From 2d2b862b19cb96c1a209480840e17daf9175e5f2 Mon Sep 17 00:00:00 2001 From: uidk3112 Date: Tue, 22 Nov 2022 19:28:08 +0100 Subject: [PATCH 01/60] understand gaussian with python --- .../Understanding_Gaussian_Distribution.ipynb | 781 ++++++++++++++++++ python/examples/images/gaussian_01.png | Bin 0 -> 15797 bytes python/examples/images/gaussian_02.png | Bin 0 -> 46762 bytes python/examples/images/gaussian_03.png | Bin 0 -> 98343 bytes python/examples/images/gaussian_04.png | Bin 0 -> 15772 bytes python/examples/images/gaussian_05.png | Bin 0 -> 17101 bytes python/examples/images/gaussian_06.png | Bin 0 -> 52294 bytes python/examples/images/gaussian_07.png | Bin 0 -> 107847 bytes python/examples/images/gaussian_08.png | Bin 0 -> 42286 bytes python/examples/images/gaussian_09.png | Bin 0 -> 42597 bytes python/examples/images/gaussian_10.png | Bin 0 -> 43842 bytes 11 files changed, 781 insertions(+) create mode 100644 python/examples/Understanding_Gaussian_Distribution.ipynb create mode 100644 python/examples/images/gaussian_01.png create mode 100644 python/examples/images/gaussian_02.png create mode 100644 python/examples/images/gaussian_03.png create mode 100644 python/examples/images/gaussian_04.png create mode 100644 python/examples/images/gaussian_05.png create mode 100644 python/examples/images/gaussian_06.png create mode 100644 python/examples/images/gaussian_07.png create mode 100644 python/examples/images/gaussian_08.png create mode 100644 python/examples/images/gaussian_09.png create mode 100644 python/examples/images/gaussian_10.png diff --git a/python/examples/Understanding_Gaussian_Distribution.ipynb b/python/examples/Understanding_Gaussian_Distribution.ipynb new file mode 100644 index 0000000..442f41d --- /dev/null +++ b/python/examples/Understanding_Gaussian_Distribution.ipynb @@ -0,0 +1,781 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5485bc75", + "metadata": {}, + "source": [ + "# Gaussian Distribution" + ] + }, + { + "cell_type": "markdown", + "id": "50b44158", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "id": "79b2af07", + "metadata": {}, + "source": [ + "In real world we are not 100% accurate in states that we measure via sensors or predict via system models. There are always degree of uncertainty in what we estimate. Assuming 100% confidence in what we estimate could lead to critical problems.\n", + "\n", + "In order to model the real belief in the state estimate, an uncertainty model must be used. This uncertainty means that we are not assuming an exact value for the state but instead a range of values where we think that the actual state value lies within.\n", + "\n", + "**Example:** \n", + "\n", + "**Instead of saying that I predict a value to be exact $2$, I say that its $2 \\pm 0.5$ which means that I think that the predicted or measured value lies in the range of values $[1.5, 2.5]$.**" + ] + }, + { + "cell_type": "markdown", + "id": "25f1b62c", + "metadata": {}, + "source": [ + "## Exact Values" + ] + }, + { + "cell_type": "markdown", + "id": "6ec3741e", + "metadata": {}, + "source": [ + "Here we plot an exact value that we assume we measured to get the feeling of how things look like visually." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "0a537bf6", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "29bfbb48", + "metadata": {}, + "outputs": [], + "source": [ + "def make_figure(xlims=None):\n", + " figure, ax = plt.subplots(figsize=(30, 10))\n", + "\n", + " ax.axvline(c='grey', lw=2)\n", + " ax.axhline(c='grey', lw=2)\n", + "\n", + " ax.grid(visible=True)\n", + "\n", + " ax.set_xlabel('position x (m)', fontsize=30)\n", + " ax.set_ylabel('p(x)', fontsize=30)\n", + "\n", + " if (xlims != None):\n", + " ax.set_xlim(xlims[0], xlims[1])\n", + "\n", + " return figure, ax\n", + "\n", + "def add_absolute_position(ax, x, p, color, set_label=True):\n", + " label = ''\n", + " if (set_label == True):\n", + " label=f'x={x}'\n", + " \n", + " ax.vlines(x, 0, p, color=color, label=label, linewidths=5)\n", + " \n", + "def update_plot():\n", + " plt.legend(prop={'size': 30})\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "53484a2b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x0 = 1\n", + "\n", + "fig, ax = make_figure(xlims=(0, 2))\n", + "add_absolute_position(ax, x0, 1, 'green')\n", + "update_plot()" + ] + }, + { + "cell_type": "markdown", + "id": "93fb5983", + "metadata": {}, + "source": [ + "where $p(x)$ in y-axis stands for the belief percentage in the state $x$. And in that case, the $p(x)$ would be $1$ because we are 100% sure that this is the correct value." + ] + }, + { + "cell_type": "markdown", + "id": "4f93e5e5", + "metadata": {}, + "source": [ + "As we explained in the overview section above, assuming an exact measurement from a sensor or a model is not realistic because all sensors which manufactured has certain degree of errorness which could be illustrated in the datasheet of sensor when you buy it or could even be variable and sensitive to to physical conditions like eg. temperature." + ] + }, + { + "cell_type": "markdown", + "id": "9952f397", + "metadata": {}, + "source": [ + "This will lead us to assume that the measurements are not exact and this belief must be modeled in a mathematical form. The Gaussian distribution or sometimes also called Normal distribution is the belief mathematical model of choice for most of the modern robotics applications because of its simplicity." + ] + }, + { + "cell_type": "markdown", + "id": "d2ce529c", + "metadata": {}, + "source": [ + "## Gaussian PDF" + ] + }, + { + "cell_type": "markdown", + "id": "7f9c3e47", + "metadata": {}, + "source": [ + "One of the most and simplest models to express the uncertainty in belief is the Gaussian distribution (Normal Distribution).\n", + "\n", + "The reason for this is that Gaussian distribution model has only two parameters which are the mean and variance. And sometimes the standard deviation term is used instead of variance which is basically its square root $\\sigma_{std} = \\sqrt{\\sigma^2_{std}}$\n", + "\n", + "The Gaussian's probability density function (pdf) is:\n", + "\n", + "$$\n", + "p(x) = \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp^{\\frac{1}{2}\\left( \\frac{(x-\\bar{x})^2}{\\sigma^2} \\right)}\n", + "$$\n", + "\n", + "where; $\\sigma^2$ is the variance, $\\bar{x}$ is mean of the distribution. $x$ is the sample of interest which lies inside the distribution.\n", + "\n", + "We can express a state which is normally (Gaussian) distributed as:\n", + "\n", + "$$\n", + "x = \\mathcal{N}(\\bar{x}, \\sigma^2)\n", + "$$\n", + "\n", + "where $\\mathcal{N}(...)$ stands for Normal distribution." + ] + }, + { + "cell_type": "markdown", + "id": "f58757b6", + "metadata": {}, + "source": [ + "Now, lets visualize the normal distribution in 1-D space and understand what does it mean." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "bab4a162", + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian_pdf(x, mu, var):\n", + " return (1. / np.sqrt(2. * np.pi * var)) * np.exp(-0.5 * (x - mu)**2 / var)\n", + "\n", + "def generate_normal_samples(mu, var, sigma_num=3, num=300):\n", + " '''\n", + " generate normally distributed 1D [samples, pdfs] such that the mean value\n", + " is included as well in the middle index of the array.\n", + " '''\n", + " sigma = np.sqrt(var)\n", + " sigma_3 = sigma_num * sigma\n", + " x = np.linspace(mu - sigma_3, mu + sigma_3, num)\n", + " middle_idx = int(num / 2)\n", + " x = np.insert(x, middle_idx, mu) # add the mean value to the samples in the correct order of points (middle)\n", + " p = gaussian_pdf(x, mu, var)\n", + " return x, p\n", + "\n", + "def add_gaussian_bel(ax, x, var, color, visualize_details=False):\n", + " p = gaussian_pdf(x, x, var)\n", + " add_absolute_position(ax, x, p, color, False)\n", + " \n", + " x_bel, p_bel = generate_normal_samples(x, var)\n", + " ax.plot(x_bel, p_bel, color=color, label=f'x={round(x, 2)}, var={round(var, 2)}')\n", + " \n", + " if visualize_details == True:\n", + " sigma = np.sqrt(var)\n", + " sigma1_range = (x - sigma, x + sigma) # sigma 1 x-range\n", + " sigma2_range = (x - sigma*2, x + sigma*2) # sigma 2 x-range\n", + " sigma3_range = (x - sigma*3, x + sigma*3) # sigma 3 x-range\n", + " \n", + " # fill sigma 1 area\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel >= sigma1_range[0]) & (x_bel <= sigma1_range[1])), color='C0', alpha=0.3)\n", + " \n", + " # fill sigma 2 areas\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel >= sigma2_range[0]) & (x_bel <= sigma1_range[0])), color='C1', alpha=0.3)\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel <= sigma2_range[1]) & (x_bel >= sigma1_range[1])), color='C1', alpha=0.3)\n", + " \n", + " # fill sigma 3 areas\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel >= sigma3_range[0]) & (x_bel <= sigma2_range[0])), color='C2', alpha=0.3)\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel <= sigma3_range[1]) & (x_bel >= sigma2_range[1])), color='C2', alpha=0.3)\n", + " \n", + " # arrow marking sigma 1 area\n", + " ax.arrow(x, -0.25, sigma1_range[0], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " ax.arrow(x, -0.25, sigma1_range[1], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " \n", + " # arrow marking sigma 2 area\n", + " ax.arrow(x, -0.5, sigma2_range[0], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " ax.arrow(x, -0.5, sigma2_range[1], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " \n", + " # arrow marking sigma 3 area\n", + " ax.arrow(x, -0.75, sigma3_range[0], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " ax.arrow(x, -0.75, sigma3_range[1], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " \n", + " # area covered by sigma 1\n", + " ax.text(x, -(0.25-0.05), \"68.27%\", fontsize=20)\n", + " \n", + " # area covered by sigma 2\n", + " ax.text(x, -(0.5-0.05), \"95.45%\", fontsize=20)\n", + " \n", + " # area covered by sigma 3\n", + " ax.text(x, -(0.75-0.05), \"99.73%\", fontsize=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "948f6f7d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = make_figure(xlims=(-3, 3))\n", + "\n", + "add_gaussian_bel(ax, 0.0, 0.5, 'green', visualize_details=True)\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "markdown", + "id": "5c802a64", + "metadata": {}, + "source": [ + "To understand more about the standard deviation ($\\sqrt{\\sigma^2} = \\sigma$), I created the above figure. It is shown there the distribution areas covered by $1\\sigma$, $2\\sigma$, and $3\\sigma$.\n", + "\n", + "The blue area of $1\\sigma$ covers 68.27% of the whole bell-shape area of the normal distribution, the orange area of $2\\sigma$ covers 95.45%, and the green area of $3\\sigma$ covers 99.73%.\n", + "\n", + "In another way, this means that $\\pm 1\\sigma$ is the area where we think that 68.27% of the randomly distributed samples or guesses lie within. And for $\\pm 2 \\sigma$ area 95.45% of the samples or guesses lies within the area from the mean to it." + ] + }, + { + "cell_type": "markdown", + "id": "78208c6e", + "metadata": {}, + "source": [ + "In the normal distribution, the mean has the highest probability $p(x)$ to be correct expectation. The far you go away from the mean the less probability you get which actually makes sense. The probability decrease exponentially which makes the model even better as the far I go away from mean I need to have more reduction in probability." + ] + }, + { + "cell_type": "markdown", + "id": "ac3424d9", + "metadata": {}, + "source": [ + "The next aspect to observe is that the more uncertainty you have (more $\\sigma^2$) the less the peak probability at the mean is.\n", + "\n", + "In the below exercise, we try to overlap several plots of gaussian curves with difference variances to observe how the peak probability $p(x)$ at the mean changes." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "412b8824", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABtMAAAJgCAYAAAD4c5xoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzde3zO9f/H8cdndrLZhs0hxxlzPhPlECFCkSLHEUkqkvTtR6lQKvXNKUuRU1gO34oKOdVQSmHOcp5RGBI7YG3X5/fHlastO9mu7bPN83677bbPdV3vz/V+Xruurjav6/V+G6ZpIiIiIiIiIiIiIiIiIiI3c7E6gIiIiIiIiIiIiIiIiEhepWKaiIiIiIiIiIiIiIiISBpUTBMRERERERERERERERFJg4ppIiIiIiIiIiIiIiIiImlQMU1EREREREREREREREQkDSqmiYiIiIiIiIiIiIiIiKTB1eoAVipatKhZpUoVq2OISAETFxeHt7e31TFEpIDRe4uIONvvv/8OQJkyZSxOIiIFjX5vEZGcoPcWEckJO3bsuGCaZomMxt3WxbRSpUqxfft2q2OISAETHh5O69atrY4hIgWM3ltExNnGjx8PwGuvvWZxEhEpaPR7i4jkBL23iEhOMAzjZGbGaZlHERERERERERERERERkTSomCYiIiIiIiIiIiIiIiKSBhXTRERERERERERERERERNKgYpqIiIiIiIiIiIiIiIhIGlRMExEREREREREREREREUmDimkiIiIiIiIiIiIiIiIiaVAxTURERERERERERERERCQNKqaJiIiIiIiIiIiIiIiIpEHFNBEREREREREREREREZE0qJgmIiIiIiIiIiIiIiIikgYV00RERERERERERERERETSoGKaiIiIiIiIiIiIiIiISBpUTBMRERERERERERERERFJg6vVAURERERERERERERuZ0lJSVy5coWYmBiuXr2KzWazOlKe4+fnx8GDB62OISIWc3FxoXDhwvj4+ODr60uhQoVyZV4V00REREREREREREQskpCQwMmTJ/Hy8qJo0aKULVsWFxcXDMOwOlqeEhMTg4+Pj9UxRMRCpmlis9mIi4sjJiaGCxcuULFiRdzd3XN8bhXTRERERERERERERCyQlJTEyZMnCQgIoFixYlbHERHJ0wzDoFChQvj6+uLr68ulS5c4efIkQUFBOd6hpj3TRERERERERERERCxw5coVvLy8VEgTEcmCYsWK4eXlxZUrV3J8LhXTRERERERERERERCygpQtFRLLHx8eHmJiYHJ9HxTQRERERERERERERC1y9ehVvb2+rY4iI5Fve3t5cvXo1x+dRMU1ERERERERERETEAjabDRcX/ROtiEhWubi4YLPZcn6eHJ9BRERERERERERERFJlGIbVEURE8q3ceg9VMU1EREREREREREREREQkDa5WBxAREREREZEc8FcsXN4HMccg7gTERcFff9qvT4xhSPmjuBqJsPozcC0C7sXsX4XLQpFK4F0J/GqCVznQJ+ZFREREROQ2pmKaiIiIiIhIfmeaEHsMzm6E6M1waSdcOQSY/4zxLAXuxe2Fs+vncXP5C5tpQNJf8NdZsCXA5YNw9Tf78Q0eAVCsIQTcBaXa2L8X8sj1hygiIiIiImIVFdNERERERETyI1uivXB26jP47SuIP2W/vvAd4N8EKvaGYvXBJxi8A8G18D/nhhkEuP99HHPB/r3rcft30wZXf4fY4/DnPnth7o8dsP8N2DcBChWGUvdC+YehbFfwDMilBywiIiIiImINFdNERERERETykz8i4PhcOPkpXL9oL27d0QFqjYFSbe3Fs+wsy2i42Jd29CoHJe/55/qEP+3Fu7Mb4bcv4ffVYDxp71YLGgTlH4JCntl9dCIiIiIiInmOi9UBREREREREJANJ1+DYHFjTEL5pCEdnQ6l20PIzeOQ83PMFBD8FvlVzbn8z96JQrgs0ngZdjsP9O6HmaIg5DFt7wxdlYMdIiD2RM/OLiIiISApxcXFMnjyZ5s2bU7JkSTw9PalYsSI9e/Zk7dq1OTLnyZMnGT16NHXq1MHPz48iRYpQvXp1hg8fzv79+3NkTsm+yMhIPvvsM8aMGUP79u3x9/fHMAwMw6B169Y5Nq9pmixdupQHHniAcuXK4eHhwR133EHbtm35+OOPSUxMzLG5nU2daSIiIiIiInnV9T/gcCgcmQHXoqFoHWj0PgT2AY/i1uUyDCjewP5Vd4K9W+3YHDg8Aw5Ph3IPQ43/QEAT6zKKiIiIFGARERF0796d48ePp7g+KiqKqKgoli1bRp8+fZg3bx7u7u5p3MutWbx4MUOHDiU2NjbF9YcOHeLQoUPMmjWLt99+m5EjRzplPnGO999/n2effTbX57106RLdu3fn22+/TXH92bNnOXv2LN9++y0zZ87kiy++oEKFCrme71apmCYiIiIiIpLXJFyGXyfDr1MgMQbuuB9qvGBfUjGnOs+yynCBO+6zf8WfhkPvw9GP4NT/oExne7GteEOrU4qIiIgUGCdPnqRjx46cO3cOgCZNmtCvXz8CAgLYu3cvs2bN4uLFi4SFheHi4sLChQuzPeeqVasYMGAASUlJGIZB9+7d6dChA25ubmzatImFCxeSkJDA888/j4+PD4MHD872nOIcSUlJKS4XLlyY4OBg9uzZk2NzJiQk0LVrV7Zs2QJA+fLlGTJkCFWqVOH06dPMnTuXgwcPsnPnTjp27MiPP/6Ir69vjuVxBhXTRERERERE8oqk63BoOhx4CxIuQbluUGccFKtrdbLM8SoHDSZB7bH2LrWD78I3jaD8w1B/EvhUsTqhiIiISL733HPPOQppgwYNYvbs2bi42Hd06t27N0OHDqVly5ZERUWxaNEievXqRefOnbM8X3x8PEOGDHEUZebNm8eAAQMct/fv359evXrRqVMnEhMTGTlyJA8++CClSpXKxqMUZwkMDOSZZ56hUaNGNGrUiJo1a3L69GkqVaqUY3POnDnTUUhr2LAhGzZsoFixYo7bhw0bxkMPPcTatWs5cOAAr7/+Ou+++26O5XEG7ZkmIiIiIiJiNdOEUytgVS3Y9SL43wX374B7Ps8/hbTk3Hyg1hjocgJqvwZn1sKqmhDxIvx1xep0IiIiIvnW7t27WbFiBQAVKlQgNDTUUUi7oUKFCsycOdNxedy4cdmac/bs2fz+++8A9OjRI0Uh7Yb77rvPsbxjbGws//3vf7M1pzjPQw89xIwZMxg4cCB169bF1TVne6wSExOZOHEiAIZh8Mknn6QopAF4enryySef4O3tDdiXorx48WKO5souFdNERERERESsFHscvrsftnQDF3do/Q3cu7pgLI3o7gd1x8GDRyCwr71T7auqELnEXkAUERERsdimTZsoVKgQhmFQoUIF/vzzzzTHnjhxAj8/PwzDwNvbm0OHDuVe0L8tXbrUcTxkyBA8PT1THdexY0eqVLGvCrB9+3aOHTvmlDlHjBiR5rjhw4dj/L0k+bJly7I8X0a+/PJLDMPAMAxGjRqVqXOef/55xzlfffVVittM02TLli28/PLLtGnThjJlyuDh4YG3tzeVKlWiV69efPXVV5gZ/P46btw4xxzh4eEAbNy4kd69e1OpUiU8PT0xDIPIyMisPOx849tvv+X8+fMAtG3bllq1aqU6rmTJkvTq1QuA69evs3LlylzLmBUqpomIiIiIiFjBlggH/wurasOFrdBwKnTaDWU6WJ3M+QrfAXfNgw6/gFd52NobNj0IcVFWJxMREZHbXKtWrRg9ejQAp06dYsiQIamOS0xMpE+fPly5Yu+ynzZtGtWqVcu1nDesW7fOcXz//fenOc4wDDp0+Of3yrVr12ZpvitXrvDTTz8B4Ofnx913353m2PLly1OzZk0AoqKiOHDgQJbmzEjHjh0JCAgA4NNPP8Vms6U7PikpiSVLlgAQEBBw089t0KBB3HPPPbz55pt89913nDlzhoSEBOLj44mMjGTp0qV06dKFTp06OZ7/jJimybBhw2jXrh1LliwhMjKS69evZ+HR5j+ZfY3++/ZvvvkmxzI5g4ppIiIiIiIiue3KIVh3N0T8B0q3g84HoPoIcHGzOlnO8m8M7X+ChpPh3Hf2ZS2PfqwuNREREbHU+PHjadq0KQDLly9n7ty5qY65UVR65JFHGDx4cK5mBLDZbBw8eBAAV1dX6tWrl+74xo0bO4737duXpTkPHDjg6MiqX7/+TUtK5sScGXFzc6Nnz54AnDlzho0bN6Y7fuPGjZw5cwaAXr164eaW8nfuq1ev4uHhQfv27Rk7dizz5s1j2bJlhIaGMmLECIoXLw7Yiz39+/fPVMZ3332X0NBQSpcuzejRo1m0aBHz58/n6aefxsPD41Yfcr6S/Hlv1KhRumNz4/XiLDm7OKaIiIiIiIj8wzThyAf2IlqhwtB8KVToAX8vh3NbcCkE1UdCuW6w7XH4+Qn47StoOhs8S1qdTkRERG5Drq6uhIWFUb9+fWJiYnj22Wdp2bIlwcHBAHz//fe89dZbgL37avbs2aneT3x8fIqunOyoUKECDRumXPb79OnTxMfHA1C2bNkM976qWLGi4/jw4cNZypH8vMDAwAzHO2POzOjXrx+hoaEALFq0iPvuuy/NsYsWLUpx3r8988wzfPjhhxQtWjTV8ydOnMjAgQNZvnw5K1euZNOmTbRq1SrdfGvWrKFFixasWrUKX19fx/X/3m9u586dREU5Z7WG9u3b4+Xl5ZT7yo5bec2UK1eOQoUKkZSUxJEjRzBN07FUaF6jYpqIiIiIiEhuuHYBfhoAv6+GOzrCXXPsyx/erooEQpv1cGg67BoNq+vA3QvhjvZWJxMREZHbUFBQEKGhofTv35+4uDj69OnD1q1biYuLo2/fviQlJeHi4sLChQspVqxYqvcRHR1Nt27dnJJnwIABzJ8/P8V1yfdzu7HMYXr8/f1TPfdWWDFnZtx1110EBwdz5MgRPv/8c2bOnJlqISk+Pp4vvvgCgODgYEcHYnItW7ZMdy5vb2/mzJnD6tWriYuLY+HChRkW07y9vVm6dGmKQlpqpk+fzoIFC9Idk1knTpzIVMEzp93Ka8bV1RVfX18uXbpEYmIicXFxFClSJIcTZo2WeRQREREREclp57fCNw3g7EZoPANar7q9C2k3GC5Q/Tm4fwd4lITv7oc9r4ItyepkIiIichsKCQmhb9++AGzfvp1XXnmFJ5980tE5NGbMmAyLKDkpNjbWcezp6Znh+MKFCzuOY2Ji8s2cmXWjyyw2NpaVK1emOmbFihWOxxASEpLluXx8fKhTpw4A27Zty3D8I488QpkyZbI8X36Wl18z2aHONBERERERkZximvDrFNj1f+BdEdr/CMUbWJ0q7ylaCzpsg+3DYN/rcP57aL5Eyz6KiIgk89w3z7Hr7C6rY+Sq+qXrM/X+qbk65wcffMDWrVs5ceIEkyZNclzftGlTxo0bl+65gYGBjv3FcpoVS+HlteX3+vXrx2uvvQbYl3Ls3bv3TWOSL/F4o1CamuvXr7Ns2TJWrlzJ7t27OXfuHLGxsak+n6dPn84wW0bdbjfMnz//pg5EyZvyTWeaYRj3G4ZxyDCMo4ZhjE7l9v8YhrHr7699hmEkGYZR3IqsIiIiIiIiJF6FH0MgYhSUfdDefaVCWtpcveCuudB0Llz4Eb65E/6IsDqViIiI3GZ8fX0JCwtLsR+Zj4/PTddZIfnyd1evXs1wfPIxPj4++WbOzAoKCqJZs2YArFu3jvPnz6e4PTo6mvXr1wPQvHlzgoKCUr2fvXv3UqdOHfr3789nn33G0aNHiYmJSbMweuXKlQyzlS1b9lYeSoGS/DVz7dq1DMfn5msmO/JFZ5phGIWAUOA+4DTwi2EYX5qmeeDGGNM03wXe/Xv8g8BI0zT/sCKviIiIiIjc5uJPw+Zu8Md2qPsG1HoJ8tgnefOsygOhWF3Y/BCsbw53zYOKPa1OJSIiYrnc7tC6nZUtWxZvb28uX74MQKNGjdIsxOSmokWLOo4vXryY4fjkY5Kfm9fnvBUhISFs3bqVxMRElixZwvDhwx23LVmyhMTERMe41Pzxxx+0a9eO6OhoAMqXL88DDzxA9erVKVGiBJ6eno6OvLFjx7J//35sNluGuZIvXXi7KVq0KJcuXQLsr4f09kBLTEx0FCddXV3x9vbOlYxZkS+KaUAT4KhpmscBDMNYAnQFDqQxvjfwaS5lExERERER+ccfOyD8AUiMhXtWQrkuVifKf4o3gg7b4ftH4IdecOVXqP2qCpIiIiKS42w2GyEhIY5CGkB4eDgzZ87kqaeeSvfc+Ph41q1b55QcFSpUoGHDhimuK1euHF5eXsTHx3P69GkSExPT7ZY7efKk47hq1apZypH8vMjIyAzHO2POW/Hoo48yYsQIEhISWLRoUYpi2o0lHt3d3Xn00UdTPX/GjBmOQtqAAQP4+OOP0/yZTpw40cnpYefOnY49+bKrffv2eHl5OeW+sqNq1aqcOHECsL9mKlasmObY06dPk5Rk3y85ODg4zy0lmlx+KaaVBU4lu3waaJraQMMwvID7gWG5kEtEREREROQfv62GHx4Fd3/7/mhFa1udKP8qXArabISfh8DecRAXCU1mgYub1clERESkAHvrrbfYtGkTAG3btmX79u1cvnyZUaNG0apVK2rWrJnmudHR0XTr1s0pOQYMGHDTXlouLi7UqFGDHTt2kJiYyO7du2nUqFGa97F9+3bHce3aWfu9tGbNmri4uGCz2YiIiMBms+HikvbuUc6Y81YUL16cTp06sWLFCn7++WeOHDlCcHAwhw8f5pdffgGgc+fOFCtWLNXzN2zYANi7oqZOnZrp4qSzTJ8+nQULFjjlvk6cOEFgYKBT7is7ateuzdq1awH766FVq1Zpjs3t10t25JdiWmrlyLR2cnwQ+CGtJR4NwxgCDAEoUaIE4eHhTgkoInJDbGys3ltExOn03iKS990R9xVVL08l1q0ye33eImHXBSDc6lipap3KdXn2PcZ8jMAiBoHH5/PH6b3sLz6eJJe8u/yLiOj3FpFb4efnR0xMjNUx8oWkpKQc/1n98ssvjBs3DoA77riDjz/+mG+//ZbHH3+cq1ev0qtXL7799ls8PDxSPT82NtZpWf76669UH++9997Ljh07APjyyy/T7P4yTZM1a9Y4Ljdv3jxLPz/DMLjzzjvZtm0bly9f5ttvv6Vp01T7XDh9+jQHDtgXkytfvjzly5fPldd39+7dWbFiBQBz5szh5ZdfZs6cOSluTyvHmTNnAHtRrlChQmmO2717d4o92VIbd/36dcdxfHx8ph77X3/9leGYzIqNjc30zzv5a9XZ/221bNmS9957D4BVq1YxZMiQNMd+9dVXjuPWrVtnOce1a9dy/HcPI61N9PISwzDuBsaZptnh78tjAEzTfCuVsV8Ay03TDMvofqtVq2YeOnTI2XFF5DYXHh5O69atrY4hIgWM3ltE8jDThP0TYc8rUKYTNF8KbmnvC5AnhKXyecU+efxvw+PzYdsTULQu3PsNeJawOpGIpEG/t4hk3sGDB6lRo4bVMfKFmJgYfHx8cvT+GzRowLFjxzAMg3Xr1tGuXTsA+vfvz8KFCwF47rnnmDJlSo7lyMju3bupX78+YF8K8tChQ3h6et40bvXq1XTu3BmAxo0bO7q0smL69OmMGDECsC+ruHTp0lTHvfjii7z77rsAvPDCC47jnJaQkEDp0qW5dOkSlStX5siRI1SpUoXjx49TrFgxzp49i7u7e6rnNmjQgF27dmEYBpcvX07zNdatWzdHwQ7sxcp/GzduHOPHjwfgu+++y9P/L4yMjKRSpUoAtGrVyqmFqMTERMqUKcP58+cxDIO9e/dSq1atm8ZFR0cTFBREXFwcnp6enD59Gn9//yzNmZ33UsMwdpim2TijcWn3Y+YtvwDBhmFUMgzDHegFfPnvQYZh+AGtgJW5nE9ERERERG5Hpg12Pm8vpFXqb98jLa8X0vKroMfsP98rB2FDS4hzzt4SIiIiIgDPPPMMx44dA2DUqFGOQhpAaGgoQUFBAEybNs2xhJ0V6tWrx0MPPQRAVFQUw4YNw2azpRgTFRWVYn+3G912qQkMDMQwDAzDSLOgMnjwYMqUKQPAsmXLUl2WcMOGDY4iY5EiRXjhhRdu4VFlj7u7Oz169ADg2LFjTJ48mePHjwP24l9ahTSAO++8E7AXx8aOHXvT7aZp8uqrr6YopN3O5s+f73i9pFUsdHV15eWXXwbsP7/+/ftz6dKlFGOuXbvGgAEDiIuLA2DYsGFZLqTllnyxzKNpmomGYQwD1gKFgLmmae43DGPo37d/+PfQbsA60zTjLIoqIiIiIiK3C1sS/DzY3jFV9VloNAWM/PJ5xXyqbCe4dx1segDWt4A2G8A35ze2FxERkYLt008/dXSeNWjQgIkTJ6a43cfHh7CwMFq0aEFiYiKPPfYYe/bsoUQJazrlp06dyo8//si5c+eYM2cO+/btIyQkBH9/f/bu3ctHH33ExYsXAejbt6+jQy2rvLy8mDVrFl27diUpKYmBAweyatUqOnbsiKurK5s2beKTTz4hMTERgClTplCqVKk07y8wMNCx/5izOrhCQkKYNWsWAC+99FKK69Pz9NNPM3fuXJKSkpg+fTq7du3i4YcfpnTp0pw6dYqwsDAiIiKoWbMmhQsXdiyxmd/8u1B4+fJlx/GJEyduur1hw4Y8/PDDWZ7vqaee4rPPPmPLli3s3LmTevXq8eSTT1KlShVOnz7NnDlzOHjwIGDfly+1QmZeky+KaQCmaa4GVv/rug//dXk+MD/3UomIiIiIyG3Jlgg/9oeTn0KdcVD7VTBS2+pZnK5kC2gXDt+2hw2toO234KflsURERCRrIiMjHV1cXl5ehIWFpdrJ1LRpU8aNG8fYsWM5e/YsAwcO5Ouvv87tuABUrFiRNWvW0L17d44fP862bdvYtm3bTeP69OnD3LlznTJn586dWbBgAUOHDiU2Npbly5ezfPnyFGPc3NyYNGkSgwcPdsqct6J58+ZUqlSJEydOkJCQAEBQUBDNmzdP97z69evz/vvvOzr8Nm/ezObNm1OMqVGjBitXrrTkcTnLvwvEyUVFRd10+4ABA7JVTHN3d2flypV0796db7/9llOnTqVaMGvYsCFffPEFfn5+WZ4rt+hjkyIiIiIiIrfC9hds7WsvpNV/G+q8pkJabitW315Qw4SN98Kf+y0OJCIiIvlRUlIS/fr1c3TpTJ48merVq6c5fsyYMdxzzz0ArFq1ihkzZuRKztQ0aNCAPXv28N5773H33XcTEBCAh4cH5cuXp0ePHqxZs4bFixenu8Threrbty/79u3jxRdfpFatWvj4+ODt7U3VqlV55plniIiIYOTIkRnez9WrVx3HAQEBTslmGAb9+vW7KW9mPPXUU/zwww/06NGD0qVL4+bmRsmSJWnWrBmTJ09m+/btVKlSxSk5byfFihVjw4YNLFmyhM6dO1OmTBnc3d0pVaoUbdq0YdasWWzbto0KFSpYHTVTjNQ2yrtdVKtWzTx06JDVMUSkgNFm2yKSE/TeIpJH2P6CH/rAqf9Bg/9CjVFWJ8qasFSKf33y4d+Gl3+Fb9vYOwXbfgtFa1udSETQ7y0it+LgwYPUqKEO68yIiYnBx8fH6hiSTYcOHXIULLt06cLKlSstTiQFQXbeSw3D2GGaZuOMxqkzTUREREREJDNMG/w0yF5Iazg5/xbSChK/6tA2HFzc4Nu2cEUflhQRERHJyzZs2ACAi4sLb775psVpRDJPxTQREREREZGMmCZsfxYiF0G9iVA94+VrJJf4VoU2G+3HG9tC7HFr84iIiIhImm4U00JCQqhVq5bFaUQyT8U0ERERERGRjOx5BY6EQo3/QM0xVqeRf/OrDveuh6Sr9oJa3CmrE4mIiIjIv9hsNsLDw/Hw8GD8+PFWxxG5JSqmiYiIiIiIpOfAu7B/IlR+AupPAiOV/cbEesXqQpt1kPAHfNcBrv9hdSIRERERScbFxYVLly5x7do1KlasaHUckVuiYpqIiIiIiEhajs6GXS9ChZ5w50wV0vK64o3gni8h9hhs7gKJV61OJCIiIiIiBYCKaSIiIiIiIqk5uRR+fhLKdIK7PwGXQlYnkswo1QruXgjnt8LWvmBLsjqRiIiIiIjkcyqmiYiIiIiI/NuZ9bC1H5RsCS2WQyF3qxPJraj4KDScAqe/gB3PgmlanUhERERERPIxV6sDiIiIiIiI5CmXD8D33cGvhn3JQFcvqxNJVlQfAVd/g4Pvglc5qDXG6kQiIiIiIpJPqZgmIiIiIiJyw9VzEN4ZCnlBq6/B3c/qRJId9d+Gq7/D7pegcBkIGmB1IhERERERyYdUTBMREREREQFIvAqbH4Jr56DdJvCuYHUiyS7DBZrOhatnYdvj4FkKytxvdSoREREREclntGeaiIiIiIiIaYOfBsLFbdBsEfjfaXUicZZC7nDP5+BXG75/FC4ftDqRiIiIiIjkMyqmiYiIiIiI7HkVopZC/UlQ/mGr04izuflCq6/AtTBs6gIJl6xOJCIiIiIi+YiKaSIiIiIicns7vgD2T4TKg6HGC1ankZziXR5afg7xJ+H7nmBLtDqRiIiIiIjkEyqmiYiIiIjI7St6C/z8BJRqC3d+AIZhdSLJSSWaw50z4ex6iPiP1WlERERERCSfcLU6gIiIiIiIiCXif4Pvu4N3JWj5P3BxszqR5IbKj8OlPXBoKhStC5UHWp1IRERERETyOHWmiYiIiIjI7SfpOmzpDolxcM8X4F7U6kSSmxq+Z+9G/GUonP/R6jQiIiIiIpLHqZgmIiIiIiK3n50j4eJPcNc88KtpdRrJbS6u0GIpeJWHLd0g/rTViUREREREJA9TMU1ERERERG4vx+fDkZlQ4z9QoYfVacQqHv5wz0p7d+LmbvZuRRERERERkVSomCYiIiIiIrePP3bCz0Oh1L1Q702r04jVitaCuxfCH9th5yir04iIiIiISB6lYpqIiIiIiNwerl+ELQ+DZ0lovtS+1J9I+Yeg+ig4Egonl1qdRkRERERE8iAV00REREREpOCzJcEPveHqGWj5GXiWsDqR5CX134KAZrBtMFw5ZHUaERERERHJY1RMExERERGRgm/feDi7HhqHgv+dVqeRvMbFDVoshUIe8H0PSIy3OpGIiIhIhuLi4pg8eTLNmzenZMmSeHp6UrFiRXr27MnatWtzZM6TJ08yevRo6tSpg5+fH0WKFKF69eoMHz6c/fv358ic4jw//vgjgwYNonLlynh5eVG8eHEaNWrEG2+8wYULF5w+365duxg+fDgNGjSgaNGiuLq6UrRoUerWrcuQIUP4/vvvnT5nTtG6JiIiIiIiUrCd/Rb2vQFBj0GVwVankbzKqxzcvQjCO8H24XDXHKsTiYiIiKQpIiKC7t27c/z48RTXR0VFERUVxbJly+jTpw/z5s3D3d3dKXMuXryYoUOHEhsbm+L6Q4cOcejQIWbNmsXbb7/NyJEjnTKfOI9pmowaNYqpU6dimqbj+qtXr3Lp0iV27tzJjBkzCAsLo02bNtmez2azMXLkSN5///0U8wFcvnyZvXv3snfvXmbPnk2vXr2YN28enp6e2Z43J6mYJiIiIiIiBde18/BjP/CtCo1nWJ1G8roy90Otl2H/G1Cypb0AKyIiIpLHnDx5ko4dO3Lu3DkAmjRpQr9+/QgICGDv3r3MmjWLixcvEhYWhouLCwsXLsz2nKtWrWLAgAEkJSVhGAbdu3enQ4cOuLm5sWnTJhYuXEhCQgLPP/88Pj4+DB6sD7HlJWPGjGHKlCkAeHt78/jjj9OkSRNiY2P57LPPWL9+PefOnaNr165s2bKF+vXrZ2u+559/nunTpzsuP/jgg7Ru3ZoyZcoQHR3Njz/+yPLly0lKSmLJkiUkJSWxbNmybM2Z04x/VwVvJ9WqVTMPHdJ6+CLiXOHh4bRu3drqGCJSwOi9RSQLTBtsehDOboQO26BYPasT5R1hxs3X9bl9/zZMwZYE390HF36CDj9D0dpWJxLJd/R7i0jmHTx4kBo1algdI1+IiYnBx8fH6hh5Qrdu3VixYgUAgwYNYvbs2bi4/LOjU1RUFC1btiQqKgqAr7/+ms6dO2d5vvj4eIKDg/n9998BmD9/PgMGDEgxZv369XTq1InExESKFCnC0aNHKVWqVJbnFOeJiIigUaNGmKaJn58fmzdvpm7duinGjBs3jvHjxwNw5513sm3bNgwjlb8ZMiEyMpLKlStjs9koVKgQq1evpn379jeN27lzJ61atXJ0OkZERGS5iJed91LDMHaYptk4o3HaM01ERERERAqmQ9Pg99XQ8D0V0iTzXApBszBw84Pvu0NinNWJRERERBx2797tKKRVqFCB0NDQFIW0G9fPnDnTcXncuHHZmnP27NmOQlqPHj1uKqQB3HfffY7lHWNjY/nvf/+brTnFeSZMmOBYavHNN9+8qZAG8Nprr9GkSRMAfvnlF1avXp3l+TZs2IDNZgPg4YcfTrWQBtCwYUOefPJJx+UtW7Zkec7coGKaiIiIiIgUPH/sgF3/B+UeguCnrU4j+U3h0tA8DK4chp3PW51GREREctCmTZsoVKgQhmFQoUIF/vzzzzTHnjhxAj8/PwzDwNvbGytWPVu6dKnjeMiQIWnuM9WxY0eqVKkCwPbt2zl27JhT5hwxYkSa44YPH+7oZsrJJfu+/PJLDMPAMAxGjRqVqXOef/55xzlfffVVittM02TLli28/PLLtGnThjJlyuDh4YG3tzeVKlWiV69efPXVVzft/fVv48aNc8wRHh4OwMaNG+nduzeVKlXC09MTwzCIjIzMysPOkpiYGNasWQOAr68vjz32WKrjDMNg+PDhjsvJn/NbFR0d7TgODg5Od2zVqlUdx3FxeftDbCqmiYiIiIhIwfLXFfi+J3iWhqZzIIvLk8htrtS9UPNFODoLTq2wOo2IiIjkkFatWjF69GgATp06xZAhQ1Idl5iYSJ8+fbhy5QoA06ZNo1q1armW84Z169Y5ju+///40xxmGQYcOHRyX165dm6X5rly5wk8//QSAn58fd999d5pjy5cvT82aNQH7UpMHDhzI0pwZ6dixIwEBAQB8+umnji6otNzYlwsgICDgpp/boEGDuOeee3jzzTf57rvvOHPmDAkJCcTHxxMZGcnSpUvp0qULnTp1cjz/GTFNk2HDhtGuXTuWLFlCZGQk169fz8KjzZ5NmzY55r3nnnvw8vJKc2zy18uNAlxWJF/e88iRI+mOTX57Xl/yVsU0EREREREpOEwTfnka4k5As8XgUdzqRJKf1ZkAxRrCz4Ph6hmr04iIiEgOGT9+PE2bNgVg+fLlzJ07N9UxN4pKjzzyCIMHD87VjAA2m42DBw8C4OrqSr166S9l3rjxP9tA7du3L0tzHjhwwNGRVb9+/ZuWlMyJOTPi5uZGz549AThz5gwbN25Md/zGjRs5c8b+u1yvXr1wc3NLcfvVq1fx8PCgffv2jB07lnnz5rFs2TJCQ0MZMWIExYvb/6b45ptv6N+/f6Yyvvvuu4SGhlK6dGlGjx7NokWLmD9/Pk8//TQeHh63+pCzLPlz0KhRo3THlihRgooVKwJw4cKFFB1mt6Jjx464u7sD8Pnnn7N+/fpUx+3cuZOPPvoIsHewderUKUvz5RZXqwOIiIiIiIg4zYlPIHKxvQhSsqXVaSS/K+RuX+5xTQP48TG4dw0Y+kyqiIhIQePq6kpYWBj169cnJiaGZ599lpYtWzqWqPv+++956623AHv31ezZs1O9n/j4+BSdY9lRoUIFGjZsmOK606dPEx8fD0DZsmVxdU3/n/dvFEYADh8+nKUcyc8LDAzMcLwz5syMfv36ERoaCsCiRYu477770hy7aNGiFOf92zPPPMOHH35I0aJFUz1/4sSJDBw4kOXLl7Ny5Uo2bdpEq1at0s23Zs0aWrRowapVq/D19XVc/+/95nbu3ElUVFS695VZ7du3v6nzLCvP38mTJx3nlixZ8pZzlClThnfeeYfnnnuOpKQk2rdvz4MPPsi9995LmTJliI6OZuvWrSxfvpykpCRq1qzJihUrbipy5jUqpomIiIiISMEQewK2D4OSraDWS1ankYLCtxo0nAK/DIVD06H6c1YnEhERkRwQFBREaGgo/fv3Jy4ujj59+rB161bi4uLo27cvSUlJuLi4sHDhQooVK5bqfURHR9OtWzen5BkwYADz589PcV3y/dxuLHOYHn9//1TPvRVWzJkZd911F8HBwRw5coTPP/+cmTNnprqEYXx8PF988QVg73660YGYXMuW6X8Iz9vbmzlz5rB69Wri4uJYuHBhhsU0b29vli5dmqKQlprp06ezYMGCdMdk1okTJ24qmFn1/I0YMYJSpUrxf//3f0RFRfHVV1/dtFddiRIlmDhxIn379k13+cm8Qh+pExERERGR/M+WBD8OAAy4ewG4FLI6kRQkVYZA2S6w6//g0h6r04iIiEgOCQkJoW/fvgBs376dV155hSeffNLROTRmzJgMiyg5KTY21nHs6emZ4fjChQs7jmNiYvLNnJl1o8ssNjaWlStXpjpmxYoVjscQEhKS5bl8fHyoU6cOANu2bctw/COPPEKZMmWyPJ+zWPn8PfLII0yZMoWyZcumevv58+d55513WLp0abbmyS3qTBMRERERkfzv0BQ4vwXumgfeFTMeL3IrDAOafgyr68LWvtDhZ3AtnPF5IiIiTvTcc7Brl9Upclf9+jB1au7O+cEHH7B161ZOnDjBpEmTHNc3bdqUcePGpXtuYGCgY3+xnGYYRq7MY/Wc6enXrx+vvfYaYF/KsXfv3jeNSb7E441CaWquX7/OsmXLWLlyJbt37+bcuXPExsam+nyePn06w2wZdbvdMH/+/Js6EHNKbj5/x44do0uXLhw4cIBKlSrxySefcN999+Hv78/FixdZv349r732GkePHmXQoEEcPnzYsZRqXqXONBERERERyd/+3Ae7X4ZyD0GlARkOF8kSzxL2Yu3lfbBrtNVpREREJIf4+voSFhaWYj8yHx+fm66zQpEiRRzHV69ezXB88jE+Pj75Zs7MCgoKolmzZgCsW7eO8+fPp7g9Ojqa9evXA9C8eXOCgoJSvZ+9e/dSp04d+vfvz2effcbRo0eJiYlJszB65cqVDLOl1Y2V26x4/n7//XfuuusuDhw4QJUqVdi+fTshISGULl0aNzc3SpcuTUhICNu3b6dy5coAvP3226xatSpL8+UWdaaJiIiIiEj+lZQAW/uBe1Fo8pG9g0gkp5S5H6qNgEPToOwDcEfaG92LiIg4W253aN3OypYti7e3N5cvXwagUaNGaRZiclPRokUdxxcvXsxwfPIxyc/N63PeipCQELZu3UpiYiJLlixh+PDhjtuWLFlCYmKiY1xq/vjjD9q1a0d0dDQA5cuX54EHHqB69eqUKFECT09PR0fX2LFj2b9/PzabLcNcyZdLtJIVz98bb7zBhQsXHMfFixdPdVzx4sV54403HB2F77//Pp07d87SnLlBxTQREREREcm/9o2HP3fDPSvAs6TVaeR2UO8tOPMNbHscOu8Dt/Q3lRcREZH8xWazERIS4iikAYSHhzNz5kyeeuqpdM+Nj49n3bp1TslRoUIFGjZsmOK6cuXK4eXlRXx8PKdPnyYxMTHdbrmTJ086jqtWrZqlHMnPi4yMzHC8M+a8FY8++igjRowgISGBRYsWpSim3Vji0d3dnUcffTTV82fMmOEopA0YMICPP/44zZ/pxIkTnZwedu7c6diTL7vat2+Pl5dXiuuseP6Sd5i1a9cu3bHJb//555+zNF9uUTFNRERERETyp/Nb4cDbEDQQynW1Oo3cLlwLw13zYX1z2PkCNJ1ldSIRERFxorfeeotNmzYB0LZtW7Zv387ly5cZNWoUrVq1ombNmmmeGx0dTbdu3ZySY8CAATftpeXi4kKNGjXYsWMHiYmJ7N69m0aNGqV5H9u3b3cc165dO0s5atasiYuLCzabjYiICGw2Gy4uae8e5Yw5b0Xx4sXp1KkTK1as4Oeff+bIkSMEBwdz+PBhfvnlFwA6d+5MsWLFUj1/w4YNALi6ujJ16tRMFyedZfr06SxYsMAp93XixAkCAwNTXJf8OUj+3KTm/PnzjscYEBBAyZJZ+7Di77//7jj29U3/g2d+fn6O47i4uCzNl1u0Z5qIiIiIiOQ/f8XCj/3Bqzw0mmp1GrndBNwF1V+AY7Ph97VWpxEREREn2bZtG+PGjQOgTJkyLF26lJkzZwL2vaT69OnD9evXLUwIHTp0cByvXZv27yGmaaa4Pfl5t8LX15e77roLgMuXL/PTTz+lOfbUqVMcOHAAsHfWpVd4dKbkSzje6Ea78f3ft//buXPnAPD39093WcOIiIib9mTLD1q3bo2HhwcAmzdvTnfftOSvl44dO2Z5zuQFtFOnTqU7NnmB0t/fP8tz5gYV00REREREJP/Z9SLEHoe7FmiZPbFG3fHgWwN+HgwJlzMeLyIiInlaTEwMffv2JTExEcMwWLBgAf7+/vTu3dtRjNm9ezejR49O8z4CAwMxTdMpX//uSrsh+XKFH330EdeuXUt13Jo1azh69CgAjRs3pnLlyln8yUDPnj0dx9OmTUtz3Pvvv49pmjflzGkPPPCAo/Ns8eLFmKbJ4sWLAShWrFi6+3DdWBYxOjqamJiYNMdNmDDBiYn/MX/+fKe9Zv7dlQZQpEgROnXqBMCVK1fSfF2ZpsmMGTMcl5M/57cqeTfckiVL0h2b/PbGjRtnec7coGKaiIiIiIjkL+fC4chMqPYclGpldRq5XRXytC/3ePV32Pm81WlEREQkm5555hmOHTsGwKhRo1Ls5RQaGkpQUBBgLyal1xGW0+rVq8dDDz0EQFRUFMOGDcNms6UYExUVlWJ/txvddqkJDAzEMAwMwyA8PDzVMYMHD6ZMmTIALFu2LNVlCTds2MCUKVMAewHnhRdeuIVHlT3u7u706NEDgGPHjjF58mSOHz8O2It67u7uaZ575513AvZi0tixY2+63TRNXn31VVasWOH84LnklVdewTAMAMaMGcOePXtuGjNhwgS2bdsG2H8mNwpw/zZ//nzH66V169apjundu7fj+PXXX2fjxo2pjtu4cWOKfejS6yDMC7RnmoiIiIiI5B+J8bBtMBSpAvXesDqN3O4CmkCN/4MDb0GF7lAm68vhiIiIiHU+/fRTFi5cCECDBg1S/AM/gI+PD2FhYbRo0YLExEQee+wx9uzZQ4kSJayIy9SpU/nxxx85d+4cc+bMYd++fYSEhODv78/evXv56KOPuHjxIgB9+/ZNtzMrM7y8vJg1axZdu3YlKSmJgQMHsmrVKjp27IirqyubNm3ik08+ITExEYApU6ZQqlSpNO8vMDDQsbzfd999l2ZR5laEhIQwa5Z9L9uXXnopxfXpefrpp5k7dy5JSUlMnz6dXbt28fDDD1O6dGlOnTpFWFgYERER1KxZk8KFC7Njx45sZ81tDRo04MUXX2TSpElcvnyZZs2aMXjwYJo0aUJsbCyfffYZ69atA+yF0FmzZjmKb1nx+OOPM3fuXH755ReuXbtG+/bteeihh2jfvj3+/v5cvHiRdevWsWLFCkch+P7776d79+5Oebw5RcU0ERERERHJP/a8ArHHoG04uHpZnUYE6rwGv31pL/J23g/uRa1OJCIiIrcgMjLS0cXl5eVFWFhYqp1MTZs2Zdy4cYwdO5azZ88ycOBAvv7669yOC0DFihVZs2YN3bt35/jx42zbts3RVZRcnz59mDt3rlPm7Ny5MwsWLGDo0KHExsayfPlyli9fnmKMm5sbkyZNYvDgwU6Z81Y0b96cSpUqceLECRISEgAICgqiefPm6Z5Xv3593n//fUeH3+bNm9m8eXOKMTVq1GDlypWWPC5neeutt0hISGDq1KnExcWlulxnyZIl+fTTT6lfv3625nJzc2PNmjX07duXtWvXYrPZ+Pzzz/n8889THd+jRw/mzp2brQJebtAyjyIiIiIikj9c2AaHpkKVoVreUfKOQh725R6vnYOdI61OIyIiIrcgKSmJfv36cfmyff/TyZMnU7169TTHjxkzhnvuuQeAVatWpdhjKrc1aNCAPXv28N5773H33XcTEBCAh4cH5cuXp0ePHqxZs4bFixenu8Threrbty/79u3jxRdfpFatWvj4+ODt7U3VqlV55plniIiIYOTIjH8funr1quM4ICDAKdkMw6Bfv3435c2Mp556ih9++IEePXpQunRp3NzcKFmyJM2aNWPy5Mls376dKlWqOCWnVQzDYPLkyfzwww889thjBAUF4enpSdGiRWnYsCETJkxg//79tGnTxinz+fv7880337B+/XoGDhxIzZo18fX1pVChQvj6+lK7dm2eeOIJvv/+e5YtW0aRIkWcMm9OMm5sCHg7qlatmnno0CGrY4hIARMeHu6U9nQRkeT03iK3vaTr8E1D+CsGOu8DN1+rE+VvYal86rPP7fu3oVPsHgv7J0Lr1VruUW57+r1FJPMOHjxIjRo1rI6RL8TExODj42N1DMmmQ4cOOQqWXbp0YeXKlRYnkoIgO++lhmHsME2zcUbj1JkmIiIiIiJ53/6JcPkANPlIhTTJm2q/An414eeh8Fes1WlERERE8qQNGzYA4OLiwptvvmlxGpHMUzFNRERERETytku7Yf9bEBiijh/Juwp5QJNZEB9l39tPRERERG5yo5gWEhJCrVq1LE4jknkqpomIiIiISN5lS4Rtj4NHcWg0xeo0Iukr0RyCn4bD0+HiL1anEREREclTbDYb4eHheHh4MH78eKvjiNwSFdNERERERCTv+vU9+GMHNA4FD3+r04hkrP5b4HkHbBsMtr+sTiMiIiKSZ7i4uHDp0iWuXbtGxYoVrY4jcktUTBMRERERkbwp5ijsHQflH4YK3a1OI5I5br5wZyj8uQcOvmd1GhERERERcQIV00REREREJO8xTfjlaXBxh0bvW51G5NaU6wrlH4F94+1FYRERERERyddUTBMRERERkbzn5BI4ux7qTgSvMlanEbl1jd8HFw/4+Ul7cVhERERERPItFdNERERERCRvSbgEO5+D4ndC8FNWpxHJmsJ3QIN34Ny3cHy+1WlERERERCQbVEwTEREREZG8ZdcYuH4BmnwELoWsTiOSdZUHQ4mWEDEKrp6zOo2IiIiIiGSRimkiIiIiIpJ3nP8Rjn4EVUdA8QZWpxHJHsMFmsyCxDiIeMHqNCIiIiIikkUqpomIiIiISN5g+wt+HgJe5aHuBKvTiDiHX3Wo+X8QuQjOhVudRkREREREskDFNBERERERyRt+nQKX90Hj98GtiNVpRJyn5hjwrgS/PA1JCVanERERERGRW6RimoiIiIiIWC/2BOwdB+W62r9EChLXwtB4Blw5CIemWJ1GRERERERuUb4pphmGcb9hGIcMwzhqGMboNMa0Ngxjl2EY+w3D2JTbGUVEREREJAtME7YPs+8v1eh9q9OI5IyynaBcN9g7AeJOWp1GRERERERuQb4ophmGUQgIBToCNYHehmHU/NeYosAHQBfTNGsBPXI7p4iIiIiIZMHpFfD7aqgzAbzLW51GJOc0mmr/vuM5K1OIiIiIiMgtyhfFNKAJcNQ0zeOmaSYAS4B/r/3SB/jcNM0oANM0o3M5o4iIiIiI3KrEeHthwa82VHvW6jQiOcu7AtR5zV5A/u1rq9OIiIiIiEgm5ZdiWlngVLLLp/++LrmqQDHDMMINw9hhGEb/XEsnIiIiIiJZs/8tiI+CO0PBxdXqNCI5r9pz4FcTtg+3F5NFRERERCTPyy9/rRqpXGf+67Ir0AhoCxQGfjQM4yfTNA+nuCPDGAIMAShRogTh4eHOTysit7XY2Fi9t4iI0+m9RQqiwom/cWf0JM4XbsvBAzY4EG51pNtG61Su03tM7vFzfYIGl0cSuXookb6DrI4j4nT6vUUk8/z8/IiJibE6Rr6QlJSkn5WIpOratWs5/rtHfimmnQaSb55QDvg9lTEXTNOMA+IMw9gM1ANSFNNM05wFzAKoVq2a2bp165zKLCK3qfDwcPTeIiLOpvcWKXBMEzY9AK4elOrwCaW8ylid6PYSdvNVeo/JTa1h604Co5YS2Ppl8K1mdSARp9LvLSKZd/DgQXx8fKyOkS/ExMToZyUiqfL09KRBgwY5Okd+WebxFyDYMIxKhmG4A72AL/81ZiXQ0jAMV8MwvICmwMFczikiIiIiIpnx21fw+2qoMw5USJPbUYN3oVBh2P6svbgsIiIiIiJ5Vr4oppmmmQgMA9ZiL5AtM01zv2EYQw3DGPr3mIPAN8Ae4GfgY9M091mVWURERERE0pB4FXaMsO8bVe1Zq9OIWKNwKag7Ac6ug9/+/VlRERERERHJS/JFMQ3ANM3VpmlWNU2zsmmaE/++7kPTND9MNuZd0zRrmqZZ2zTNqZaFFRERERGRtB2YBHGR0HgGuLhZnUbEOsFPgV8t2DESkq5ZnUZERETymbi4OCZPnkzz5s0pWbIknp6eVKxYkZ49e7J27docmfPkyZOMHj2aOnXq4OfnR5EiRahevTrDhw9n//79OTKnOM+PP/7IoEGDqFy5Ml5eXhQvXpxGjRrxxhtvcOHChRyb94cffmDYsGHUrl2b4sWLU7hwYSpWrEiLFi146aWX+P7773NsbmfJL3umiYiIiIhIQRB7HA68DRV6Qql7rU4jYi0XN2g0Db5tBwffg9ovW51IRERE8omIiAi6d+/O8ePHU1wfFRVFVFQUy5Yto0+fPsybNw93d3enzLl48WKGDh1KbGxsiusPHTrEoUOHmDVrFm+//TYjR450ynziPKZpMmrUKKZOnYqZbInxq1evcunSJXbu3MmMGTMICwujTZs2Tpv3woULPPXUU/zvf/+76bYbr9UffviB1atXs2vXLqfNmxNUTBMRERERkdyzYyS4uELD/1qdRCRvKN0Wyj8C+9+ESv3Bu7zViURERCSPO3nyJB07duTcuXMANGnShH79+hEQEMDevXuZNWsWFy9eJCwsDBcXFxYuXJjtOVetWsWAAQNISkrCMAy6d+9Ohw4dcHNzY9OmTSxcuJCEhASef/55fHx8GDx4cLbnFOcZM2YMU6ZMAcDb25vHH3+cJk2aEBsby2effcb69es5d+4cXbt2ZcuWLdSvXz/bc547d462bds6OhYrVqxI9+7dqVWrFl5eXvz222+cOHGCb775Jttz5QYV00REREREJHf8/o19b6j6k8CrnNVpRPKOBv+F31fBrheh+adWpxEREZE87rnnnnMU0gYNGsTs2bNxcbHv6NS7d2+GDh1Ky5YtiYqKYtGiRfTq1YvOnTtneb74+HiGDBlCUlISAPPmzWPAgAGO2/v370+vXr3o1KkTiYmJjBw5kgcffJBSpUpl41GKs0RERPDOO+8A4Ofnx+bNm6lbt67j9ieffJJx48Yxfvx4YmNjGTJkCNu2bcMwjCzPaZomjz76qKOQ9uKLL/L666+n2SV56tSpLM+VW/LNnmkiIiIiIpKP2f6Cnc+BTzBUe87qNCJ5S5FAqPF/cHIJnNtkdRoRERHJw3bv3s2KFSsAqFChAqGhoY5C2g0VKlRg5syZjsvjxo3L1pyzZ8/m999/B6BHjx4pCmk33HfffY7lHWNjY/nvf7USRV4xYcIEx9KOb775ZopC2g2vvfYaTZo0AeCXX35h9erV2Zrzo48+YvPmzQAMHTqUSZMmpbvcaPnyeX91BhXTREREREQk5x0OhSuHoOFkKOScPRtECpSaL4JXBdjxLNgSrU4jIiJy29i0aROFChXCMAwqVKjAn3/+mebYEydO4Ofnh2EYeHt7c+jQodwL+relS5c6jocMGYKnp2eq4zp27EiVKlUA2L59O8eOHXPKnCNGjEhz3PDhwx3dTMuWLcvyfBn58ssvMQwDwzAYNWpUps55/vnnHed89dVXKW4zTZMtW7bw8ssv06ZNG8qUKYOHhwfe3t5UqlSJXr168dVXX6XYayw148aNc8wRHh4OwMaNG+nduzeVKlXC09MTwzCIjIzMysPOkpiYGNasWQOAr68vjz32WKrjDMNg+PDhjsvJn/NbZZom7733HgBFihRh0qRJWb6vvETFNBERERERyVnXzsPecXBHByiT9eVlRAo0Vy97sfnPPXB0ltVpREREbhutWrVi9OjRgH2puSFDhqQ6LjExkT59+nDlyhUApk2bRrVq1XIt5w3r1q1zHN9///1pjjMMgw4dOjgur127NkvzXblyhZ9++gmwLxF49913pzm2fPny1KxZE4CoqCgOHDiQpTkz0rFjRwICAgD49NNPsdls6Y5PSkpiyZIlAAQEBNz0cxs0aBD33HMPb775Jt999x1nzpwhISGB+Ph4IiMjWbp0KV26dKFTp06O5z8jpmkybNgw2rVrx5IlS4iMjOT69etZeLTZs2nTJse899xzD15eXmmOTf56uVGAy4otW7Zw9OhRAB599FF8fX2zfF95iYppIiIiIiKSs/a8Comx0HAKZGPdfZECr/zDUKoN7BkL1y9anUZEROS2MX78eJo2bQrA8uXLmTt3bqpjbhSVHnnkEQYPHpyrGQFsNhsHDx4EwNXVlXr16qU7vnHjxo7jffv2ZWnOAwcOODqy6tevf9OSkjkxZ0bc3Nzo2bMnAGfOnGHjxo3pjt+4cSNnzpwBoFevXri5uaW4/erVq3h4eNC+fXvGjh3LvHnzWLZsGaGhoYwYMYLixYsD8M0339C/f/9MZXz33XcJDQ2ldOnSjB49mkWLFjF//nyefvppPDw8bvUhZ1ny56BRo0bpji1RogQVK1YE4MKFC0RHR2dpzhvLOwK0adOGxMREPvroI1q0aIG/vz+FCxcmMDCQvn37smHDhizNYQVXqwOIiIiIiEgBdmkPHJsFwcPAr4bVaUTyNsOARtNgTX3Y8wrc+YHViURERG4Lrq6uhIWFUb9+fWJiYnj22Wdp2bIlwcHBAHz//fe89dZbgL37avbs2aneT3x8fIrOseyoUKECDRs2THHd6dOniY+PB6Bs2bK4uqb/z/s3CiMAhw8fzlKO5OcFBgZmON4Zc2ZGv379CA0NBWDRokXcd999aY5dtGhRivP+7ZlnnuHDDz+kaNGiqZ4/ceJEBg4cyPLly1m5ciWbNm2iVatW6eZbs2YNLVq0YNWqVSk6s/6939zOnTuJiopK974yq3379jd1nmXl+Tt58qTj3JIlS95yju3btzuOAwICaNasGb/88kuKMSdPnuTkyZOEhYXRs2dP5s2bR+HChW95rtykYpqIiIiIiOQM04Sdz4F7Mag7zuo0IvlD0doQ/BQc+QCCn7ZfFhERkRwXFBREaGgo/fv3Jy4ujj59+rB161bi4uLo27cvSUlJuLi4sHDhQooVK5bqfURHR9OtWzen5BkwYADz589PcV3y/dxuLHOYHn9//1TPvRVWzJkZd911F8HBwRw5coTPP/+cmTNnprqEYXx8PF988QUAwcHBjg7E5Fq2bJnuXN7e3syZM4fVq1cTFxfHwoULMyymeXt7s3Tp0gyXOJw+fToLFixId0xmnThx4qaCmRXP39mzZx3Hw4YN4+jRo/j6+jJ48GAaNWpEYmIiW7ZsYcGCBfz1118sXbqUhIQEPv/88yzNl1u0zKOIiIiIiOSM01/Aue+gzgR7QU1EMqfOOHD1hZ3P24vSIiIikitCQkLo27cvYO+ueeWVV3jyyScdnUNjxozJsIiSk2JjYx3Hnp6eGY5P3ukTExOTb+bMrBtdZrGxsaxcuTLVMStWrHA8hpCQkCzP5ePjQ506dQDYtm1bhuMfeeQRypQpk+X5nMWK5y95Ee7o0aMEBgayZ88e3nvvPfr06UP//v2ZPXs2P/zwg6PY+MUXX7Bs2bIszZdb1JkmIiIiIiLOl3QNdr4AfrWhSuqbuItIGjz8oc5rsHMk/L4ayna2OpGIiOQFzz0Hu3ZZnSJ31a8PU6fm6pQffPABW7du5cSJE0yaNMlxfdOmTRk3bly65wYGBjr2F8tphgV7EVsxZ3r69evHa6+9BtiXcuzdu/dNY5Iv8XijUJqa69evs2zZMlauXMnu3bs5d+4csbGxqT6fp0+fzjBbRt1uN8yfP/+mDsScklvPn81mS3F51qxZKZb/vOHOO+9k4sSJDB8+HIBp06bx6KOP5krGrFBnmoiIiIiION+vUyDuBDSaCi76DJ/ILQt+GnyCIWIU2P6yOo2IiMhtw9fXl7CwsBT7kfn4+Nx0nRWKFCniOL569WqG45OP8fHxyTdzZlZQUBDNmjUDYN26dZw/fz7F7dHR0axfvx6A5s2bExQUlOr97N27lzp16tC/f38+++wzjh49SkxMTJqF0StXrmSYrWzZsrfyUHKMFc9f8vMqVqyY7n52AwcOxM3NDbB3/CXvpMtr9FetiIiIiIg419UzsH8ilHsISre1Oo1I/lTIHRq8B5u7wJEPodpwqxOJiIjVcrlD63ZWtmxZvL29uXz5MgCNGjVKsxCTm4oWLeo4vnjxYobjk49Jfm5en/NWhISEsHXrVhITE1myZImjywlgyZIlJCYmOsal5o8//qBdu3ZER0cDUL58eR544AGqV69OiRIl8PT0dHR0jR07lv3799/UeZWa5MslWsnq10zDhg3THevt7U21atXYt28fSUlJREZGUrt23twzWMU0ERERERFxrt1jwZYADf5rdRKR/K3sA1CqLewdB4F9waO41YlEREQKPJvNRkhIiKOQBhAeHs7MmTN56qmn0j03Pj6edevWOSVHhQoVbipElCtXDi8vL+Lj4zl9+jSJiYnpdsudPHnScVy1atUs5Uh+XmRkZIbjnTHnrXj00UcZMWIECQkJLFq0KEUx7cYSj+7u7mkuHzhjxgxHIW3AgAF8/PHHaf5MJ06c6OT0sHPnTseefNnVvn17vLy8UlxnxfNXrVo1vv32WwD8/PwyHJ98TPL/7vIaFdNERERERMR5Lu2B4/Og+kjwqWx1GpH8zTCg4WT4pgHsm2BfNlVERERy1FtvvcWmTZsAaNu2Ldu3b+fy5cuMGjWKVq1aUbNmzTTPjY6Oplu3bk7JMWDAgJv20nJxcaFGjRrs2LGDxMREdu/eTaNGjdK8j+3btzuOs9rtU7NmTVxcXLDZbERERGCz2XBxSXv3KGfMeSuKFy9Op06dWLFiBT///DNHjhwhODiYw4cP88svvwDQuXNnihUrlur5GzZsAMDV1ZWpU6dmujjpLNOnT2fBggVOua8TJ04QGBiY4rrkz0Hy5yY158+fdzzGgIAASpYsmaUcdevWdRxnZknM5AW0zBTfrKI900RERERExHki/gPuRaH2WKuTiBQMxepC5cFwOBSuHLI6jYiISIG2bds2xo0bB0CZMmVYunQpM2fOBOx7SfXp04fr169bmBA6dOjgOF67dm2a40zTTHF78vNuha+vL3fddRdgL3r89NNPaY49deoUBw4cAOyddekVHp0p+RKON7rRbnz/9+3/du7cOQD8/f3TXdYwIiLipj3Z8oPWrVvj4eEBwObNm9PdNy3566Vjx45ZnjP5uTt37kx3bFxcHIcO2X/HdXNzo1KlSlmeN6epmCYiIiIiIs7x+zdwdh3UfhXcU//kp4hkQZ0JUKiwvVgtIiIiOSImJoa+ffuSmJiIYRgsWLAAf39/evfu7SjG7N69m9GjR6d5H4GBgZim6ZSvf3el3ZB8ucKPPvqIa9eupTpuzZo1HD16FIDGjRtTuXLWV43o2bOn43jatGlpjnv//fcxTfOmnDntgQcecHSeLV68GNM0Wbx4MQDFihWjc+fOaZ57Y1nE6OhoYmJi0hw3YcIEJyb+x/z58532mvl3VxpAkSJF6NSpE2DvEkvrdWWaJjNmzHBcTv6c36qKFSty9913A/alJdevX5/m2Hnz5vHXX38B0KJFC7y9vbM8b05TMU1ERERERLLPlggRL0CRyhD8tNVpRAqWwqXs3Z6/fQVnN1idRkREpEB65plnOHbsGACjRo2iXbt2jttCQ0MJCgoC7MWk9DrCclq9evV46KGHAIiKimLYsGHYbLYUY6KiolLs73aj2y41gYGBGIaBYRiEh4enOmbw4MGUKVMGgGXLlqW6LOGGDRuYMmUKYC/gvPDCC7fwqLLH3d2dHj16AHDs2DEmT57M8ePHAXtRz93dPc1z77zzTsBeTBo79ubVNUzT5NVXX2XFihXOD55LXnnlFQzDAGDMmDHs2bPnpjETJkxg27ZtgP1ncqMA92/z5893vF5at26d5pxvvPGG43jIkCGpLpG5fft2Xn75Zcfl//wnb39wTHumiYiIiIhI9h2fD5f3Q4v/QaG0/1gVkSyqNgKOfAg7n4f7I8ClkNWJRERECoxPP/2UhQsXAtCgQQMmTpyY4nYfHx/CwsJo0aIFiYmJPPbYY+zZs4cSJUpYEZepU6fy448/cu7cOebMmcO+ffsICQnB39+fvXv38tFHH3Hx4kUA+vbtm25nVmZ4eXkxa9YsunbtSlJSEgMHDmTVqlV07NgRV1dXNm3axCeffEJiYiIAU6ZMoVSpUmneX2BgoKO48t1336VblMmskJAQZs2aBcBLL72U4vr0PP3008ydO5ekpCSmT5/Orl27ePjhhyldujSnTp0iLCyMiIgIatasSeHChdmxY0e2s+a2Bg0a8OKLLzJp0iQuX75Ms2bNGDx4ME2aNCE2NpbPPvuMdevWAfZC6KxZsxzFt6xq06YNTz31FDNnziQyMpK6desyePBgGjduTGJiIlu2bGHBggUkJCQA8MQTT2RracncoGKaiIiIiIhkz1+xsOcVCGgG5R+2Oo1IwVTIA+q/DT/0hMiFEPSY1YlEREQKhMjISEcXl5eXF2FhYal2MjVt2pRx48YxduxYzp49y8CBA/n6669zOy5gX0ZvzZo1dO/enePHj7Nt2zZHV1Fyffr0Ye7cuU6Zs3PnzixYsIChQ4cSGxvL8uXLWb58eYoxbm5uTJo0icGDBztlzlvRvHlzKlWqxIkTJxwFmqCgIJo3b57uefXr1+f99993dPht3ryZzZs3pxhTo0YNVq5cacnjcpa33nqLhIQEpk6dSlxcXKrLdZYsWZJPP/2U+vXrO2XOGTNm4OrqyowZM7hy5QqTJ09OddywYcMcXY15mZZ5FBERERGR7Dn4Llw7Cw3fg2x+glFE0lGhB/g3gd1jITHe6jQiIiL5XlJSEv369ePy5csATJ48merVq6c5fsyYMdxzzz0ArFq1KsUeU7mtQYMG7Nmzh/fee4+7776bgIAAPDw8KF++PD169GDNmjUsXrw43SUOb1Xfvn3Zt28fL774IrVq1cLHxwdvb2+qVq3KM888Q0REBCNHjszwfq5eveo4DggIcEo2wzDo16/fTXkz46mnnuKHH36gR48elC5dGjc3N0qWLEmzZs2YPHky27dvp0qVKk7JaRXDMJg8eTI//PADjz32GEFBQXh6elK0aFEaNmzIhAkT2L9/P23atHHanC4uLkyfPp2tW7cyePBgqlSpgpeXF15eXgQHBzN48GB27NjB+++/j6tr3u/7Mm5sCHg7qlatmnno0CGrY4hIARMeHu6U9nQRkeT03iJ5Vvxv8FUwlO0CLZZYnUYyKyyVomef2/dvw3wlegtsuAfqTYRaL2U8XsQC+r1FJPMOHjxIjRo1rI6RL8TExODj42N1DMmmQ4cOOQqWXbp0YeXKlRYnkoIgO++lhmHsME2zcUbj1JkmIiIiIiJZt+cVMJOg/ltWJxG5PZRsCeW6wv634dp5q9OIiIiI3JINGzYA9q6lN9980+I0IpmnYpqIiIiIiGTNpd1wfD5UHQ5FKlmdRuT2Ue9tSIqHfROsTiIiIiJyS24U00JCQqhVq5bFaUQyT8U0ERERERG5daYJES+AezGo/bLVaURuL37VofITcORDuHLE6jQiIiIimWKz2QgPD8fDw4Px48dbHUfklqiYJiIiIiIit+7MN3B2A9R+1V5QE5HcVec1KOQBu8dYnUREREQkU1xcXLh06RLXrl2jYsWKVscRuSUqpomIiIiIyK2xJdq70opUgeCnrE4jcnsqXBpqvAinPoPzP1qdRkRERESkQFMxTUREREREbs3xeXD5ADSYBIXcrU4jcvuq/jx4lrYXt03T6jQiIiIiIgWWimkiIiIiIpJ5f8XAnlegRHMo183qNCK3N7ciUHcCXNgKp1dYnUZEREREpMBSMU1ERERERDLv4H/h2jlo8B4YhtVpRCRoIPjWgF3/B7a/rE4jIiIiIlIgqZgmIiIiIiKZc/Us/PoeVOgBAU2tTiMiAC6u0OAdiDkCR2dZnUZEREREpEBSMU1ERERERDJn3+uQdB3qTrQ6iYgkV6YzlGwFe8fDX1esTiMiIiIiUuComCYiIiIiIhmLOWrveqnyBPgGW51GRJIzDGjwLlw/DwfesTqNiIiIiEiBo2KaiIiIiIhkbM8r4OIOtV+1OomIpMb/TqjYC36dDPG/WZ1GRERERKRAUTFNRERERETS98cOOLkEqo+EwqWtTiMiaan3JpiJsEdFbxERERERZ1IxTURERERE0rdrDHj4Q43/WJ1ERNJTpBIED4Pj8+DP/VanEREREREpMFRMExERERGRtJ3dAGfXQ62Xwd3P6jQikpHaL4ObD+wZa3USEREREZECQ8U0ERERERFJnWmDXaPBuyIEP211GhHJjBtdpKdXwIWfrE4jIiIiIlIgqJgmIiIiIiKpi/qffb+0OhOgkIfVaUQks6o9B54l7cVw07Q6jYiIiIhIvqdimoiIiIiI3Mz2F+x+GfxqQ2Bfq9OIyK1wKwK1XoHoTXBmrdVpRERERETyPRXTRERERETkZsc+htijUP9tcClkdRoRuVVVhoB3Jdg9xr5kq4iIiIiIZJmKaSIiIiIiktJfsbB3PJRoCWU6WZ1GRLKikDvUfR0u7YKTy6xOIyIiIiKSr6mYJiIiIiIiKR2aCtfOQf1JYBhWpxGRrArsDUXrwp6x9qVbRUREREQkS1RMExERERGRf1w7DwfegXIPQYm7rU4jItlhuEC9NyH2GBybY3UaERERcbK4uDgmT55M8+bNKVmyJJ6enlSsWJGePXuydm3O7Jt68uRJRo8eTZ06dfDz86NIkSJUr16d4cOHs3///hyZU5znxx9/ZNCgQVSuXBkvLy+KFy9Oo0aNeOONN7hw4YJT5jBNkx9++IGpU6fSt29fGjZsSPny5SlcuDBeXl6UK1eOjh07MmPGDP7880+nzJkbDNM0rc5gmWrVqpmHDh2yOoaIFDDh4eG0bt3a6hgiUsDovUVyzY6RcHg6dNoHfjWsTiM5JSyVjsM+t+/fhgWaacKGeyDmKHQ5Bq5eVieS24B+bxHJvIMHD1Kjhn7nyoyYmBh8fHysjpFnRERE0L17d44fP57mmD59+jBv3jzc3d2dMufixYsZOnQosbGxqd7u7u7O22+/zciRI50ynziPaZqMGjWKqVOnklZNqFSpUoSFhdGmTZtszXXt2jUKFy6cqbElSpRg9uzZdO3aNVtzZue91DCMHaZpNs5onGuW7l1ERERERAqe2Eg48gEEDVQhTaSgMAyo9xZsaAmHpkGtMVYnEhERkWw6efIkHTt25Ny5cwA0adKEfv36ERAQwN69e5k1axYXL14kLCwMFxcXFi5cmO05V61axYABA0hKSsIwDLp3706HDh1wc3Nj06ZNLFy4kISEBJ5//nl8fHwYPHhwtucU5xkzZgxTpkwBwNvbm8cff5wmTZoQGxvLZ599xvr16zl37hxdu3Zly5Yt1K9fP9tzli1blqZNm1KjRg1Kly5NyZIluX79Or/++ivLly/nyJEjnD9/nkceeYQ1a9Zw3333ZXvOnKTONHWmiYiT6VOYIpIT9N4iueLHARC1DB48Al7lrE4jOUmdabef8Afh/Bbochw8iludRgo4/d4iknnqTMs8dab9o1u3bqxYsQKAQYMGMXv2bFxc/tnRKSoqipYtWxIVFQXA119/TefOnbM8X3x8PMHBwfz+++8AzJ8/nwEDBqQYs379ejp16kRiYiJFihTh6NGjlCpVKstzivNERETQqFEjTNPEz8+PzZs3U7du3RRjxo0bx/jx4wG488472bZtG0YW98+22Wz8+uuv1KxZM80xSUlJDB8+nJkzZwJQvXp1Dh48mKX5IHc607RnmoiIiIiIwOWDcGIhBD+jQppIQVT/TfjrChyYZHUSERERyYbdu3c7CmkVKlQgNDQ0RSHtxvU3ihRgL5Rkx+zZsx2FtB49etxUSAO47777HMs7xsbG8t///jdbc4rzTJgwwbG045tvvnlTIQ3gtddeo0mTJgD88ssvrF69Osvzubi4pFtIAyhUqBDTpk3D398fgF9//TXdJUvzAhXTREREREQE9o4DV2+o+X9WJxGRnFC0DgT2s++JGP+b1WlERETyjE2bNlGoUCEMw6BChQr8+eefaY49ceIEfn5+GIaBt7c3Vqx6tnTpUsfxkCFD8PT0THVcx44dqVKlCgDbt2/n2LFjTplzxIgRaY4bPny4o5tp2bJlWZ4vI19++SWGYWAYBqNGjcrUOc8//7zjnK+++irFbaZpsmXLFl5++WXatGlDmTJl8PDwwNvbm0qVKtGrVy+++uqrNPcau2HcuHGOOcLDwwHYuHEjvXv3plKlSnh6emIYBpGRkVl52FkSExPDmjVrAPD19eWxxx5LdZxhGAwfPtxxOflznlPc3NwIDg52XD579myOz5kdKqaJiIiIiNzuLu22L+9Y7TnwLGF1GhHJKXXHg5kE+yZYnURERCTPaNWqFaNHjwbg1KlTDBkyJNVxiYmJ9OnThytXrgAwbdo0qlWrlms5b1i3bp3j+P77709znGEYdOjQwXF57dq1WZrvypUr/PTTTwD4+flx9913pzm2fPnyjo6kqKgoDhw4kKU5M9KxY0cCAgIA+PTTT7HZbOmOT0pKYsmSJQAEBATc9HMbNGgQ99xzD2+++SbfffcdZ86cISEhgfj4eCIjI1m6dCldunShU6dOjuc/I6ZpMmzYMNq1a8eSJUuIjIzk+vXrWXi02bNp0ybHvPfccw9eXl5pjk3+erlRgMtJNpstRWGxdOnSOT5ndqiYJiIiIiJyu9vzKrj5QY3nrU4iIjmpSCWoMhSOzYErh61OIyIikmeMHz+epk2bArB8+XLmzp2b6pgbRaVHHnmEwYMH52pGsBcfbuwr5erqSr169dId37jxP9tA7du3L0tzHjhwwNGRVb9+/ZuWlMyJOTPi5uZGz549AThz5gwbN25Md/zGjRs5c+YMAL169cLNzS3F7VevXsXDw4P27dszduxY5s2bx7JlywgNDWXEiBEUL27fb/abb76hf//+mcr47rvvEhoaSunSpRk9ejSLFi1i/vz5PP3003h4eNzqQ86y5M9Bo0aN0h1bokQJKlasCMCFCxeIjo7OsVymaTJ27FhHN1r9+vUJCgrKsfmcwdXqACIiIiIiYqELP8NvX0Ld18G9mNVpJKclJUFCQuq3/fUXuLpCFjcal3yi1stwfC7sGQstcm75JRERkfzE1dWVsLAw6tevT0xMDM8++ywtW7Z0LEH3/fff89ZbbwH27qvZs2enej/x8fEpOseyo0KFCjRs2DDFdadPnyY+Ph6AsmXL4uqa/j/v3yiMABw+nLUP0iQ/LzAwMMPxzpgzM/r160doaCgAixYt4r777ktz7KJFi1Kc92/PPPMMH374IUWLFk31/IkTJzJw4ECWL1/OypUr2bRpE61atUo335o1a2jRogWrVq3C19fXcf2/95vbuXMnUVFR6d5XZrVv3/6mzrOsPH8nT550nFuyZMls5/rmm2+4du0aYP9v5OjRo3z++efs3r0bAH9/f+bMmZPteXKaimkiIiIiIrezva+Chz9US3vvA8mjYmLgxAk4dQrOnIGzZ+3fz52DS5fsX3/+af+6etVeRLuxBM7iVO7P3f2f7+7u4OsLxYpB0aL27wEBcMcd9q/SpaFMGahUyX6cwSeUJQ8pXAqqPw/7Xoc/dkDx9D+hLCIicrsICgoiNDSU/v37ExcXR58+fdi6dStxcXH07duXpKQkXFxcWLhwIcWKpf4htOjoaLp16+aUPAMGDGD+/Pkprku+n9uNZQ7T4+/vn+q5t8KKOTPjrrvuIjg4mCNHjvD5558zc+bMVJcwjI+P54svvgAgODjY0YGYXMuWLdOdy9vbmzlz5rB69Wri4uJYuHBhhsU0b29vli5dmqKQlprp06ezYMGCdMdk1okTJ24qmOWF5++xxx7j3LlzN13v7u5Oly5deOedd6hUqZJT5spJKqaJiIiIiNyuorfAmbXQ4F1w87E6jaTm+nU4fBgOHvzn69gxexHt4sWbxxcrBqVKQfHi9mJXrVrg5wdeXvYCmYfH30Wz0Tef+8Yb9oJbQgJcuwZXrtgLcZcuwenTEBFhL9QlJqY8z8MDAgMhKAiqVoUaNaBmTfv3TPzBLhaoPgoOh8LuV+De1VanERERyTNCQkJYu3YtixcvZvv27bzyyiucOHHC0Tk0ZsyYDIsoOSk2NtZx7OnpmeH4woULO45jYmLyzZyZ1a9fP1577TViY2NZuXIlvXv3vmnMihUrHI8hJCQky3P5+PhQp04dfvrpJ7Zt25bh+EceeYQyZcpkeT5nycvPX/Xq1WnXrp1Tut9yg4ppIiIiIiK3I9OEPa+AZ2kIftrqNAL24lVEBOzcaf+KiIBff7UvzQj25RcrVYIqVaBRI/txpUpQocI/3WKZ3X8hLJVi2ssvZ3yezWYv4p05A7/9Zi/q3fg6fhw2bYK/lx4C7IW9hg2hQQP794YN7YU3LSVpLXc/qPki7BoN53+AEs2tTiQiIpmx4zm4tMvqFLmrWH1oNDVXp/zggw/YunUrJ06cYNKkSY7rmzZtyrhx49I9NzAw0LG/WE4zLPh9yoo503OjmAb2pRxTK6YlX+Kxb9++ad7X9evXWbZsGStXrmT37t2cO3eO2NjYVJ/P06dPZ5gto263G+bPn39TB2JOser5u7EvmmmaxMTEsG/fPhYtWsSsWbMYOnQo77//PitXrqRy5cqW5MssFdNERERERG5H576F6E3QaDq43rwciuQw07R3mG3dav/68UfYu9d+Pdi7yho2hG7d7F1eNWvau76SfVLUEi4uUKKE/atu3Ztvt9nsy04ePAgHDtgf086dsG7dP0XBUqXg7ruhWTP79zvvzHwRUJyn6jD4dQrsfhnafqcCp4iIyN98fX0JCwujZcuWJP7dke/j40NYWFiGe5TltCJFijiOr169muH45GN8fLK2EoUVc2ZWUFAQzZo1Y+vWraxbt47z589TokQJx+3R0dGsX78egObNmxMUFJTq/ezdu5dHHnmEI0eOZGreK1euZDimbNmymbqvnJaXnj/DMPD19aVZs2Y0a9aMrl270rlzZ/bv3899993H3r178fb2duqczqRimoiIiIjI7cY0YfdY8CoPVYZYneb2cfIkfPstfPed/evGJ1p9fe1FpYcfhiZN7EW0UqWszZpVLi5QsaL96/77/7n+2jXYtw9++QV++sleQFyxwn6bpyc0bw733gtt2kDjxuDmZkn824qrN9R6GXY8C2c3wB33WZ1IREQykssdWrezsmXL4u3tzeXLlwFo1KhRmoWY3FS0aFHH8cXUlvz+l+Rjkp+b1+e8FSEhIWzdupXExESWLFnC8OHDHbctWbLEURBNa4nHP/74g3bt2hEdHQ1A+fLleeCBB6hevTolSpTA09PT0dE1duxY9u/fj+3GPsTpKGz1h+D+lpefvw4dOvDYY48xZ84cTpw4wSeffMJTTz2Vo3Nmh4ppIiIiIiK3m99Xw8WfoMlHUEgdQTnm+nXYvBlWr7Z/HT5sv75ECXvh6N57oWVL+95iLi7WZs1pnp72IlnjxnDjD+ToaHtHXni4vcg4dqz9el9fuO8+6NTJXpDLA3tNFFhVhsDB/9q700q3U3eaiIgIYLPZCAkJcRTSAMLDw5k5c2aG/9AfHx/PunXrnJKjQoUKNGzYMMV15cqVw8vLi/j4eE6fPk1iYmK63XInT550HFetWjVLOZKfFxkZmeF4Z8x5Kx599FFGjBhBQkICixYtSlFMu7HEo7u7O48++miq58+YMcNRSBswYAAff/xxmj/TiRMnOjk97Ny507EnX3a1b98eL6+Uq47k9efv/vvvZ86cOYD9vzMV00REREREJG+4sVdakSAIGmh1moLnjz/gq6/sXVfr1tn3D/PwgNat7UWkdu2gVi0VLQBKloSuXe1fABcu2Atr69bZi4+ffWa/vn59eOgh+5KXderoZ+dMhTygzquwbTD89iWU62p1IhEREcu99dZbbNq0CYC2bduyfft2Ll++zKhRo2jVqhU1a9ZM89zo6Gi6devmlBwDBgy4aS8tFxcXatSowY4dO0hMTGT37t00atQozfvYvn2747h27dpZylGzZk1cXFyw2WxERERgs9lwSeeDYM6Y81YUL16cTp06sWLFCn7++WeOHDlCcHAwhw8f5pdffgGgc+fOFCtWLNXzN2zYAICrqytTp07NdHHSWaZPn86CBQuccl8nTpwgMDAwxXXJn4Pkz01qzp8/73iMAQEBlCxZ0im50pN8Kck///wzx+fLjnzz8UfDMO43DOOQYRhHDcO4abdswzBaG4Zx2TCMXX9/vWpFThERERGRPO30F3ApAmq/Bi5aSs8poqPhgw/shbKSJeGxx2D7dvv3r7+2F9i++Qaeew5q11YxKC0BAdC9O8yaZd93bc8eePttKFIExo+HevUgOBj+8x/4+ed/9peT7KnUH4pUsRfZzYyXLBIRESnItm3bxrhx4wAoU6YMS5cuZebMmYB9L6k+ffpw/fp1CxPal8a7Ye3atWmOM00zxe3Jz7sVvr6+3HXXXQBcvnyZn376Kc2xp06d4sCBA4C9sy69wqMzJV/C8UY32o3v/779386dOweAv79/ussaRkREcP78+WwmzX2tW7fG4+/9iTdv3pzuvmnJXy8dO3bM8WwAR48edRwHBATkypxZlS+KaYZhFAJCgY5ATaC3YRip/Ze4xTTN+n9/TcjVkCIiIiIieZ0tCfa8Cr7VIbCv1Wnyt8uXYf586NDBvgzhM8/Y90B78UV7oScqCkJDoXNn+NdSK5IJhmHvQvu//4MtW+DMGfjoI3sxbdo0aNrUfvzKK/D3P9hIFrm4Qd3x8OdeOLnM6jQiIiKWiYmJoW/fviQmJmIYBgsWLMDf35/evXs7ijG7d+9m9Oib+jwcAgMDMU3TKV//7kq7IflyhR999BHXrl1LddyaNWschYrGjRtTuXLlLP5koGfPno7jadOmpTnu/fffx/z7A09pLauYEx544AFH59nixYsxTZPFixcDUKxYMTp37pzmuTeWRYyOjiYmJibNcRMm5Ey5Yf78+U57zfy7Kw2gSJEidOrUCYArV66k+boyTZMZM2Y4Lid/znOKzWZzLPEI0KxZsxyfMzvyRTENaAIcNU3zuGmaCcASQOtPiIiIiIjciqilcHk/1BkHLoWsTpP/JCXZO8x69oRSpWDgQPs+aC++aO+i+vVXePNNuPNOdZ85W6lSMGQIrFkD587BnDlQqZL9512rFjRoANOn25eKlFtXsRf41Ya9r4Et0eo0IiIilnjmmWc4duwYAKNGjaJdu3aO20JDQwkKCgLsxaT0OsJyWr169XjooYcAiIqKYtiwYdhsKbvLo6KiUuw9daPbLjWBgYEYhoFhGISHh6c6ZvDgwZT5ex/bZcuWpbos4YYNG5gyZQpgL+C88MILt/Cossfd3Z0ePXoAcOzYMSZPnszx48cBe1HP3d09zXPvvPNOwF5MGntjD99kTNPk1VdfZcWKFc4PnkteeeUVjL//PhkzZgx79uy5acyECRPYtm0bYP+Z3CjA/dv8+fMdr5fWrVunOmbq1KnpdjCCvXjdr18/IiIiAPtynb169crsQ7JEftkzrSxwKtnl00DTVMbdbRjGbuB34AXTNPfnRjgRERERkTzPlgh7x0HROlChh9Vp8pejR2HuXPjkE/jtNyheHJ54Avr2tXdIqXCWu4oVg0GD7F9nz8KyZfbnZsQIeOEFePBB+2333w+FVDTOFMMF6r4OW7rBiU+g8iCrE4mIiOSqTz/9lIULFwLQoEEDJk6cmOJ2Hx8fwsLCaNGiBYmJiTz22GPs2bOHEiVKWBGXqVOn8uOPP3Lu3DnmzJnDvn37CAkJwd/fn7179/LRRx9x8eJFAPr27ZtuZ1ZmeHl5MWvWLLp27UpSUhIDBw5k1apVdOzYEVdXVzZt2sQnn3xCYqL9QzlTpkyhVKlSad5fYGCgY2+u7777Ls2izK0ICQlh1qxZALz00ksprk/P008/zdy5c0lKSmL69Ons2rWLhx9+mNKlS3Pq1CnCwsKIiIigZs2aFC5cmB07dmQ7a25r0KABL774IpMmTeLy5cs0a9aMwYMH06RJE2JjY/nss89Yt24dYC+Ezpo1y1F8y4rw8HBGjhxJcHAwbdu2pXbt2vj7+1OoUCHOnz/Pzp07+eKLL/jjjz8A+351H3/8Mf7+/k55vDklvxTTUnvm/r1A/k6gommasYZhdAJWAME33ZFhDAGGAJQoUSLNaruISFbFxsbqvUVEnE7vLZJdpePXUD3mCHuLvc7FTZutjpPnGYmJ+G/dSpkvv6T4jh2YLi780aQJZ554got3343p7g7XrsHfm9PnN61TuS7fvsfUrQv//S/ex45R+ptvKLVhA+6ff861kiU588ADnOnUiYQ8/od5nmD60dCtOu7bX2JbVDlMI+1PcItkRL+3iGSen59fukvLyT+SkpJy5Gd18uRJRxeXl5cXs2fP5vr16zftjVazZk3GjBnD66+/ztmzZwkJCWH58uVOz5MZxYsX53//+x8hISFERkaybds2R1dRcj169GDatGnp/txuLMsIEB8fn+bYe+65hw8//JCRI0cSGxvL8uXLb3r8bm5ujB8/np49ezplzltRt25dAgMDiYyMJCEhAbAX7erWrZvu/VeuXJl3332XF154AZvNxubNm9m8OeXfS9WqVWPx4sUMHz7ccV1q95n8NeOsx+UsL730ErGxsXzwwQfExcWlulxniRIlmDt3LpUrV04ze/JlRdP6b/JGUfXIkSMcOXIk3VyBgYFMmzaNe++9N1s/r2vXruX47x75pZh2Giif7HI57N1nDqZpXkl2vNowjA8MwwgwTfPCv8bNAmYBVKtWzXRG1VtEJLnw8HCnfKJGRCQ5vbdItiQlwNePQfHG1Onwsjqp0vP77/Dhh/Dxx/Z9usqXh9dfxxg0CP8yZSgwJZmwm6/K9+8xrVvD449DQgJ89RWeH35IpblzqfTJJ9C1KwwbBq1a6fWfnjPT4LsOtCpzGKoNszqN5GP6vUUk8w4ePIiPj4/VMfKFmJgYp/+skpKSGDp0KJcvXwZg8uTJNGrUKM3x48aNY9OmTWzevJm1a9eyYMEChg2z5v+ZLVq0YN++fXz00Uf873//48iRI8TExFCyZEnuuusuBg0axP3335/h/STvQPLy8kr3Zzx48GDuu+8+PvjgA1atWkVUVBQ2m42yZcty33338dRTT1GrVq0M50xekKlQoYLTnteQkBBef/31FJczc98jR47k7rvvZvLkyWzZsoWLFy9SrFgxqlSpQvfu3XnyySfx8vKiULJVD1K7Xw8PD8dxRj9LK8yYMYO+ffsya9YsNm/ezO+//46npydBQUE89NBDPPXUUwQEBKR7H56eno7jQoUKpfoYFy9ezJYtWwgPD+fnn3/mzJkzREdHEx8fj4+PD+XLl6dBgwZ06dKFBx54IN1lODPL09OTBg0aZPt+0mMkrwLnVYZhuAKHgbbAb8AvQJ/kyzgahlEaOGeapmkYRhPgf9g71dJ8gNWqVTMPHTqUs+FF5LajPxxFJCfovUWy5ciH8MtT0HoNlMn4D+rb0vbtMHWqfcnAxETo2BGeesr+vSAuFRiWSkGpT97/2/CWHTkCs2bZl+n84w+oVw+eew569YJk/xAgfzNN2NAKYo5Al2Pg6mV1Ismn9HuLSOYdPHiQGjVqWB0jX8iJYprkvkOHDlG9enUAunTpwsqVKy1OJAVBdt5LDcPYYZpm44zGuWTp3nOZaZqJwDBgLXAQWGaa5n7DMIYahjH072HdgX1/75k2HeiVXiFNREREROS2kHgV9r0OJZrDHR2sTpO32GzwxRfQogXceSd8+SU8/bS9ALNqFTzwQMEspN1OgoPh3Xfh9GmYPdteKB04ECpUgPHj7QU2+YdhQL2JcO0sHA61Oo2IiIgUQBs2bADAxcWFN9980+I0IpmXL4ppYF+60TTNqqZpVjZNc+Lf131omuaHfx/PME2zlmma9UzTvMs0za3WJhYRERERyQOOfgRXf4e6b2h5uxuuX4c5c6BmTXj4YfvSjlOm2AsuU6dC5cpWJxRnK1wYBg+GvXthwwZo0gTGjYOKFeHFF+HsWasT5h0lW9oL7wfehr+uZDxeRERE5BbcKKaFhIRkaklIkbwi3xTTRERERETkFiXGwYG3oFQbKNXa6jTWi4+HyZMhKMheWClcGD79FA4fti/95+trdULJaYYBbdvC11/Dnj3QpQu89x4EBsIzz8DJk1YnzBvqvgEJf8CvU6xOIiIiIgWIzWYjPDwcDw8Pxo8fb3UckVuiYpqIiIiISEF1eAZci4a6r2c8tiC7etXecRYUBKNGQbVqsHYt7Nxp3zvL1dXqhGKFOnVg8WI4dAhCQuzLQFapAo89Br/+anU6a/k3hnLd4OB7cP2i1WlERESkgHBxceHSpUtcu3aNihUrWh1H5JaomCYiIiIiUhAlXIYDk6BMJyjRzOo01rh2DWbMsC/bOHKkfVnHzZvh22+hfXsteyl2VarYC2nHj9u705Yts79WevSAffusTmeduhMgMRYOvGN1EhERERERy6mYJiIiIiJSEB2aCgmX7P8gfru5fh1mzoTgYBg+3F4s+fZb+1fLllank7yqXDl7B2NkJIwZA+vWQd26MGCA/brbTdHaULE3HH4frp6xOo2IiIiIiKVUTBMRERERKWiu/wG/TrYv01a8kdVpcs9ff9k7jKpWhaefhgoVYMMG2LQJ7r3X6nSSX5QsCRMnwokT8MIL9k61atXs++qdP291utxVdzzYEmD/W1YnERERERGxlIppIiIiIiIFzcH/wl8x9n8Ivx2YJnz5pX0PrCFD4I474Jtv4PvvoW1bLecoWVO8OLzzDhw5Av37w/vv2/fdGz8eYmKsTpc7fKpA0EA4+hHERVmdRkRERETEMiqmiYiIiIgUJNei4dA0qNgLitaxOk3Oi4iwF8y6drVfXrkSfvwROnRQEU2co1w5e8fj/v32vfbGjbPvwzd9un1J0YKu9iv27/tuwyVjRURERET+pmKaiIiIiEhBsv9tsF2DOq9ZnSRn/fYbPPYYNGoEe/bAjBmwdy906aIimuSM6tXhs89g2zaoXRtGjPjnOtO0Ol3O8a4AVZ6E4/PhyhGr04iIiIiIWELFNBERERGRgiL+Nzg6Eyr1B99qVqfJGbGx8NprEBwMn35q39Pq6FF45hlwc7M6ndwOmjSBjRth7Vrw8YHu3aFdO3vnWkFV6yVw8YC946xOIiIiIiJiCRXTREREREQKiv1vgi0Rar9qdRLns9lg7lyoWhUmTIAHH4Rff7XvaVW0qNXp5HZjGPYlH3futHdFRkRAvXr2brVLl6xO53yFS0PVYXDyU/izABcNRUQsYhbkDmcRkRyWW++hKqaJiIiIiBQEcSfh2Gyo/DgUqWR1GueKiIBmzeDxx6FiRfjhB1i6FCoVsMcp+Y+rq70r8vBheOIJeP99e8H3448hKcnqdM5V4z/g6g17C/gSsiIiuczFxQWbzWZ1DBGRfMtms+HikvOlLhXTREREREQKgn2vAy5Qe6zVSZznyhV47jlo3BiOH4cFC2DrVnthTSQvCQiAmTNhxw77PmpPPAFNm9pfrwWFZwBUHwmnPoM/IqxOIyJSYBQuXJi4uDirY4iI5FtxcXEULlw4x+dRMU1EREREJL+7cgSOz4fgoeBVzuo02Wea9s6z6tVh+nQYMgQOHYL+/e3L64nkVQ0awObNEBYGZ89C8+YwYABcuGB1Mueo/jy4FYU9BXApWRERi/j4+BATE2N1DBGRfCsmJgYfH58cn0fFNBERERGR/G7feHDxgJqjrU6SfYcPQ4cO0KsX3HEH/PSTveOnWDGrk4lkjmFA7972Pf3GjLEX1qpXh4UL7YXi/My9KNR4AX7/Gi5sszqNiEiB4OvrS3x8PJcK4p6bIiI57NKlS8THx+Pr65vjc6mYJiIiIiKSn10+AJFhUHUYFC5tdZqsu3oVXn0V6tSBbdvse0/9/DM0aWJ1MpGsKVIE3nzTvudf1ar2zsoOHexLluZn1Z4FD3/Y84rVSURECoRChQpRsWJFLly4wG+//caVK1dISkrCzO8fwBARyQGmaZKUlMSVK1f47bffuHDhAhUrVqRQoUI5Prdrjs8gIiIiIiI5Z89r4FoEar5odZKs27IFHn8cjhyBPn3gvfegdD4uDIokV7s2fP+9vcNyzBj75fHjYeRIcM2Hf5K7+di7YCP+A9GboeQ9VicSEcn33N3dCQoK4sqVK/z555+cOXMGm81mdaw859q1a3h6elodQ0Qs5uLiQuHChfHx8aF06dK5UkgDFdNERERERPKvPyLg1P+g9qv2TpH8JjbWXlyYMQMqVYING6BtW6tTiTifiws88wx07QrDhsGLL9qXf/z4Y2jUyOp0ty74aTj4nr07rW249jIUEXGCQoUKUaxYMYppaes0hYeH06BBA6tjiMhtSss8ioiIiIjkV3teBbeiUH2k1Ulu3caN9iUdQ0Ph2Wdh714V0qTgK1cOvvgCPvsMzp2zL2M6ahTExVmd7Na4ekGtl+ydaec2Wp1GRERERCTHqZgmIiIiIpIfXdgGv38NNf8D7kWtTpN5V67Ak09Cu3bg5gabN8O0aeDtbXUykdxhGPDww3DgADzxBEyeDPXqwQ8/WJ3s1lR5ArzKwe6xoH19RERERKSAUzFNRERERCQ/2vMKeARA1WetTpJ533xj3y/q44/hhRdg925o0cLqVCLWKFoUPvwQwsMhKQlatoT/+z+4ds3qZJlTyBNqvwIXt8Hvq61OIyIiIiKSo1RMExERERHJb6I3w9n1UHMMuBWxOk3G/vwTBg6Ejh2hSBHYuhXefRcKF7Y6mYj1WrWCPXvsXWrvvAONG8POnVanypyggeBdyV7cV3eaiIiIiBRgKqaJiIiIiOQnpmlfVq3wHRD8lNVpMhYeDnXrwsKF8NJL9iJB06ZWpxLJW3x84KOPYPVq+OMP+38jEybAX39ZnSx9Lm5Q5zW4FAGnv7A6jYiIiIhIjlExTUREREQkPzm7Ac5vgVovg2se7uxKSLAvWdemDXh42LvRJk4ET0+rk4nkXR07wr598Oij8Npr0KyZfW+1vCywL/hUhT2vgi3J6jQiIiIiIjlCxTQRERERkfzCNGHPWPCqAJUHW50mbQcO2Dtr3nnHvnRdRAQ0aWJ1KpH8oXhxWLwYli+HEyegYUOYPBlsNquTpc7FFeqMh8v7IWqZ1WlERERERHKEimkiIiIiIvnFb1/DxZ+h9itQyMPqNDczTZgxAxo1gtOnYeVK+9J1RfLBvm4ieU337rB/P3ToAKNG2b+fOWN1qtRVfBT8asPecWBLtDqNiIiIiIjTqZgmIiIiIpIfmDbY+yoUqQxBA6xOc7OzZ6FTJxg+HO69F/buhS5drE4lkr+VKgUrVsCsWfDDD/b9B1evtjrVzQwXqDsBYg5D5CKr04iIiIiIOJ2KaSIiIiIi+cGpz+HSLqgzDlzcrE6T0sqVUKcOhIdDaCisWgWlS1udSqRgMAz7cqk7dkCZMtC5M4wcCdevW50spXIPQbGGsHcCJCVYnUZERERExKlUTBMRERERyetsSbDnVfCtARV7W53mH9euwbBh8NBDUL487NwJTz9t/8d/EXGuGjVg2zZ79+fUqXDXXXDokNWp/mEYUPd1iDsBx+dZnUZERERExKlUTBMRERERyetOLoErB6HueHApZHUau6NHoVkzeyfayJHw00/2f+wXkZzj6QnTp8OXX8KpU9CwIcybZ9+vMC8o0xH874L9b0DSNavTiIiIiIg4jYppIiIiIiJ5me0v2DsOitaD8o9YncZu6VL7P+JHRtqXeJw8GdzdrU4lcvt48EHYvRuaNoVBg6BPH7h82epU9u60em9A/Gk4OsvqNCIiIiIiTuNqdQAREREREUnHiU/g/9m76/Aori6O49+J4e6uwQnuFtyKS1vc3alAW5xSrLiWAoXixYsVt+LuLsXdNTLvH5cKL052swn8Ps+zT8juzL1naLtN5uw55/4JKLgQLBd/Fu7RI1OFNnasaTE3YwYkSeLamOQFtg0PH8L9++bx5An4+4Ofn3n4+0P+l5y3eTN4eICn579fI0SAiBHNw0O/PYYsCRLAihXQrx907WpaQM6ebRLdrhSnCMQuBAf7QIpG4BHetfGIiIiIiDiAfh0SEREREQmpAp7A/p4QIyck+MS1sRw9CtWrw7598OWX8P33JtsiTvfwIVy8CJcuweXL/369dg1u3oQbN8zj5k24d88k0N7U9c+e+uJzefO+/pywYU1SLVo0iBEDokc3X2PEgDhxIF48iBvXfI0XD2LG1Pg8p3N3h2++gcKF4dNPzT/EYcOgcWPX/eX/PTttZUE4NhLSfemaOEREREREHEjJNBERERGRkOrkeHj4F+Qa59qsxNSp0LSpyaYsWgRly7oulg+Qn5/pmHn8uBlFd+YMnD377+P69RfP8fD4N5EVIwakSAE5ckCUKCbhFSnSvxVlYcI8X23m6QlcfXHNZcuer157+vTfCre/k3T37sGtWyZ5d+kSHDxo4nvw4MX1woaFxIlN8WKSJJA0KSRPDqlSgbc3RI7s2L/Hj1qePLBrF9Ssaf5b3bgRRo82pYWuELsAxC0Bh/uBdzPwjOSaOEREREREHETJNBERERGRkMj/ERzsDbEKQNzironh8WNo0wbGjYN8+Uxbx4QJXRPLB+DBAzh82CSg/n4cO2aSZ/7+/x4XPvy/Cajs2U1CKkGCfyu+4sY1CTS3oHT9nPbiUyVLvv9yDx48Xzl38SKcO/dvQnDvXrj6fwm82LFNUi1NGsiQAdKnN4948VTR9l5ixoQlS0zVaPfusHu3afuYOrVr4vHpBctzwdGhkOE718QgIiIiIuIgSqaJiIiIiIREx0fDo0uQb4ZrMgt//QVVqsCOHfD119C7t4ZmvYNLl0wu4+/Hnj1w6tS/7Re9vEyOI3Nm0z3T2/vfR6xYoS+ZFCECpExpHq/y6BGcPGkq8I4fN4nEY8dg/nwYP/7f46JFAx8fyJLFPLJmNQk3/ev3Ftzdzfy0PHmgRg2TjR0/3vxLFtxi5oQE5eDwQEjVEryiBX8MIiIiIiIOol9HRERERERCGr/7cKgvxC0GsQsG//4rV8Jnn5l+f/PmQcWKwR9DKHL3rsk5btkCW7fCtm2mQutvKVKYpFCdOv9WX6VM+fElh8KFMxVoGTI8/7xtm6q1/1bs7dkDY8eaBByYlpFZskCuXOaRO7ep3AttScdgU7y4afv46afm8eefMGCAyeIGJ5+esDQLHB4EmXoF794iIiIiIg70kf36JiIiIiISChwbDk+umTZpwcm2oV8/+PZbUwo0b54ZcCXPOXcONmwwj40bTfLn74ozb28oVgyyZTMVVZkymTlm8mqWBXHimEeRIv8+7+8PR4+ayr5du0yScswYGDLEvB47NuTPD76+5pE+fRBbX35oEiWCtWtNZemQIeYvcNYs83xwiZYZElWFo0MgdVsIGzP49hYRERERcSAl00REREREQpKnd+DwAIj/CcTMHXz73r0L9eqZBFr16qY1XMSIwbd/CHbpEqxYYQr21q83M8AAIkWCvHmhalVTLZUzJ0SP7tpYPyQeHv9W8tWqZZ7z84P9+00F4JYt5p/H3LnmtRgxoFAhJdee4+UFgwebmYcNGpgs7+zZUDAYK14zdodzc8z7WpZ+wbeviIiIiIgDKZkmIiIiIhKSHBkMT2+Z9mjB5fBhqFQJTpyAH3+E9u0/6v55jx6ZqrPly81j/37zfMyYJlnTvj0UKGDmen1srRpdzdPTVPxlzQrNm5vnzpyBdetMEdbatS9PrhUvbmbUfbT/WletavprVqwIRYuaBFvLlsHzFxI1PSStYSpu07SHcHGdv6eIiIiIiIPpVz8RERERkZDiyQ04MggSVYHoWYJnz9mzoX59CB/elF75+gbPviGIbcO+ff8mzzZsgCdPTFFP/vzQty+UKGFaNn70lU4hUNKk5lG3rvn+Vcm1FCmgbFn45BNTmBUmjEvCdZ00aUxJX61a0Lq16Z05apQZSOdsGbrB2RlmFmS2Ic7fT0RERETEwZRMExEREREJKQ4PAP/7kLGH8/cKCDCz0fr1g9y54bffIGFC5+8bQjx5AqtXm66Wv/8Oly+b59OnhxYtTPKsYEGTY5TQ5f+Ta6dPw7JlsGgR/PQTDBtmOpgWL26Sa2XKQLx4row4GEWJAgsWQPfu0KuXGfg3dy4kSODcfSN7Q7K6cHw0pP0Cwn887zUiIiIi8mFQMk1EREREJCR4dAWODjft0KKmd+5ed+9CjRqweDE0aQLDh5syrA/c/fuwdKlJoC1ebP4aIkY0yZQyZaBYMefnFCT4JUtmWkI2bw4PH5ok6uLFJrk2b545Jls2k1irVMlUIH7Q7SDd3KBnT8iSBerUMRc/Z46Zq+ZMGbrAmV/hwPeQc7Rz9xIRERERcTA1KRERERERCQkO9YXAJ6YdmjOdOGEq0ZYtMy3exo79oBNp16/DhAlQrpyZeVa9uulmWa2aSaZcuwYzZ5oqJiXSPnzhw5s2j6NHw19/wd690KePafnYu7fJL6VJA126wIEDro7WySpVgi1bIFIkKFzYvBc4U8SkkKIRnPwZ7p927l4iIiIiIg6mZJqIiIiIiKs9PG/anyWra9qhOcvKlZAzJ1y5AitWmFKdD9CtWzBunMkPxIkDDRvC/v3mctetg0uX4OefTSVScIyLkpDJssDHBzp3hj//NK0+x46FRIlMgi1jRtP2s0cPOHzY1dE6Sfr0sG2bKcts1sxUqj596sT9vgXLHQ70ct4eIiIiIiJOoGSaiIiIiIirHfgeCDRt0JzBts2gqFKlTPnV9u0m0/QBefLEjH6qXBnixjU5gUuXzFi4XbvM3KzBg80cNHd3V0crIVGsWObfm5Ur4eJFGDnSVDP26AHp0pnEW+/ecPy4qyN1sGjRzODAzp1NFrpYMVPS6QzhE4B3czg9Ce4ec84eIiIiIiJOoGSaiIiIiIgr3T8Np8ab9mcRkzp+/SdPoHFjaNvWlGJt2gTJkzt+HxcIDIT1600CJG5cqFLFXF6LFrBjh6km+ns01Ac9A0scLk4c8+/RunVw/jwMHQqRI5v2j6lSmQLP0aPh9m1XR+og7u6mHG/aNFOpljMnHDrknL3SdQK3sLC/h3PWFxERERFxAiXTRERERERc6UAvwM20P3O0q1ehaFEYP96UaM2bZ+YjhXKHDsE330CyZFCokLn//8knZgzc+fOmAi1bNiXQxDHix4c2bWDjRjNnbeBAePzYJNvixYMaNUzX1MBAV0fqAJ9/bjKIDx9CnjzmPypHCxcHUreGs9Ph9oc+mE5EREREPhRKpomIiIiIuMrdY6bdmXcL0/7Mkfbtgxw5TI/DGTNMfzq30Pvj/8OHMGkS5M1rxjz162da702dakbA/forlCwJHh6ujlQ+ZIkSQceOsHev6ZbaoAEsXQolSkDSpNC1K5w65eoogyhXLnNxyZKZatZhw0yrWEdK+yV4RIT93R27roiIiIiIk4Te36ZFREREREK7/d1Nu7P0nRy77pIlkC8f+PvDhg3w6aeOXT8YHTgArVub6qB69eDGDVMZdPGiSWLUqAERIrg6SvnYWBZkz27mql26ZPLVadOanHWKFODra5K/Dx+6OtL3lCiRKcUrX960iG3eHPz8HLd+mBiQpj2cmwM3dztuXRERERERJ1EyTURERETEFW4fgLMzIHUbCBvbceuOGAHlyoG3t5l9lC2b49YOJn9XoeXLBxkzwk8/QZkysHYtHDliKoPixHF1lCJG2LAmX/3HH3D2rEmonT9vkr8JEph/X0+ccHWU7yFiRJgzBzp3hrFjoVQpuHnTceunaQ+eUWFfV8etKSIiIiLiJEqmiYiIiIi4wv5u4BnJtDtzhIAAM9ipdWszQGz9enMnPxQ5eNBcQoIEJhFx/bqpQrtwwcxFK1RIc9AkZEuUyIwnPH7cJH9LljRdElOlMgnhJUtC2Ww1Nzfo0wcmTzaVarlzw9GjjlnbKyqk+xIuLoLrWxyzpoiIiIiIkyiZJiIiIiIS3G7ugnNzIU0HCBM96OvduwcVKsDw4dChA8yda6pKQoHAQPj9dyhSBDJkMAUwpUs/X4UWM6aroxR5N5Zlkr8zZphqtW7dYPduM4LM2xt+/NGxRV5OV7s2rF4Nt2+bhNratY5ZN1UbCBNT1WkiIiIiEuIpmSYiIiIiEtz2dQWv6JC6XdDXOncO8ueHZctg9Ghzl97dPejrOtn9+6YjZerUZizT8ePQt6+q0OTDEz++SaadPWuSawkSwBdfQMKE0KiRSbKFCvnymdax8eJBiRIwZUrQ1/SMCOk6weUVcHV90NcTEREREXESJdNERERERILTtc1wcbFp7+gVJWhr7dgBOXPCmTOmf1yzZg4J0Zn++gu++sq0w2vdGmLEMAmGU6fg669VhSYfLi8vM1tt/XrYu9cUe02fDlmzmuTxokWhoAVk0qTw558mgV+7NvTqBbYdtDW9m0PYuLCvS9DXEhERERFxEiXTRERERESC074uEDY2pG4dtHXmz4eCBSFMGNi0yVSKhGCbN5tEQvLkMGiQCXfzZtiyxTzv6enqCEWCj4+PaWl64YL57+HMGShXzrQ6nTABnjxxdYSvES2aqYStUwe6doUGDeDp0/dfzyM8pP/WVKZdWeW4OEVEREREHEjJNBERERGR4HJlrblZnK4zeER4/3WGDYPKlc0d+a1bIX16h4XoSIGBMG+eGbGUNy/88YcZ6XbqFMycaZ4X+ZhFjQrt28OJEzB1qqlea9gQkiWDfv3MiLIQycsLfvkFunc3X8uUCVqwKRtD+ESw9ztVp4mIiIhIiKRkmoiIiIhIcLBtU5UWLj54v2c7xsBA6NgR2raFChVg9WqIE8excTqAnx/8+itkzGhyfteumflo589D//6QOLGrIxQJWTw9oUYNMz9t+XKTH+/Uyfy30rGjGY0Y4liWGQb3yy+wbp1p/Xj27Put5R4GMnwHN7bCxSUODVNERERExBGUTBMRERERCQ6XlsO1jeaGsXvYdz//8WP4/HPTE65VK5g9G8KHd3ycQfD4MYweDalSmQ5wbm4wbRocPQotW0LEiK6OUCRksywoXhxWrIBdu0zrx6FDTXvUOnXgwAFXR/gSdeuastPz50256Y4d77dO8voQMblmp4mIiIhIiKRkmoiIiIiIs9k27PsOIiSB5A3f/fybN82QsVmzYMAA0+bR3d3xcb6ne/dMWMmSQYsWEDcuLFwIe/ea/J+Hh6sjFAl9smQxrR9PnDDJ6LlzTbVntWqwb5+ro/s/RYqY2Y1hwkChQrBo0buv4eYJGbrCrd1wfp7jYxQRERERCYJQk0yzLKuUZVlHLcs6YVlWp9ccl8OyrADLsqoGZ3wiIiIiIq904Xe4uQMydAN3r3c798wZyJfPzEabMQO++MKUr4QAN26YLm9JksBXX5kb/WvWmHvq5cqZyjQRCZqkSWHIENNB8dtvTRFYpkymheru3a6O7j/SpYMtWyBtWtOG9uef332NpDUhcmrY1xUCAxwfo4iIiIjIewoVv95aluUOjARKA+mAzy3LSveK4/oBfwRvhCIiIiIir2AHmrZlkbwhWe13O3fXLsiTBy5fNn3fPv3UOTG+oxs3oHNnk0Tr2RN8fWHbNjPrydc3xOT6RD4oMWJA794mqda1qxmZmDWryVvt3Onq6J6JGxfWrjWVtI0bQ48e79ay0c0DMnSHOwfhr1nOilJERERE5J2FimQakBM4Ydv2Kdu2nwIzgAovOa41MAe4GpzBiYiIiIi80l+z4fY+yNjd3Ch+W0uXQsGC4OUFf/5p/uxit2+bSrRkyaBfPyhf3sxwmjsXcuRwdXQiH4do0UyO6swZ83X9esieHT75xCS1XS5iRNPntW5d6N4dmjYFf/+3Pz9JdYiSAfZ3g8B3OE9ERERExIlCy/SCBMC5/3x/Hsj13wMsy0oAVAKKAPpVXkRERERcLzDA3BCOkg4Sv0NV2cSJpqojY0ZYvBjix3dejG/h3j0zpm3gQJNQq1LF3CPPkMGlYcl/BNqBPPF/wpOAJzz2f8wT/2dfX/L904CnVH7JGguOLCCMRxjCeoQljPuzr6/43uNdEsPiFFGjmgq1du1g+HAYNAhy5YJSpUySLWdOFwbn6WnexxIkgD59THXtjBkQPvybz7XcwKcnbKgMZ6ZA8npOD1dERERE5E0s+11aLrxqEcuKjake8wGSANGAcMAj4CZwFtgHbLNt+9p7rF8NKGnbdqNn39cGctq23fo/x/wG/Gjb9hbLsn4BFtm2PfslazUBmgDEihUr26xZah0hIo51//59IkaM6OowROQDo/eW0CnOw2Wkvd2PA9F6cD3cW1SW2TaJp00j+c8/czN7dg726EHA29x8dpLHj92YPz8B06cn5u5dT/LmvU69emfw9r7vspg+dLZtc8fvDtefXufW01vc87/Hff/73PW7y33/+9zzv2cefvf+/bP/PR4FPHq3fbxffM46/vbne1geRPKIRCTPSETyiEREj4hE9ohMRM+I5vn/PCJ7RiZmmJjE8IqBp5vnO8Upb+/hQ3fmz0/AzJmJuHvXkwIFrtGgwWmSJn3o0rjiz5uH9/Dh3E2blgN9+uAXJcqbT7Jtsl1vikfgPbbFnoxt6d+b0EY/t4iIM+i9RUScoXDhwjtt287+puPeO5lmWVYKoBam3WKmdzh1DzAfmGLb9um33CsP0N227ZLPvu8MYNv2D/855jTw93SGmMBDoIlt2/NftW7q1Knto0ePvkPoIiJvtnbtWnx9fV0dhoh8YPTeEgoFPIVFqSFMDCi5/c2DxAIDoX17UwJWo4ap6vDyCp5Y/8/jxzB2LPzwA1y5AiVLmtloLq10+QD4Bfhx8d5Fzt89z4V7F7hw9wIX7l147vuL9y7yJODJS88P6xGW6OGiEy1sNKKFi/bvn8NGI3KYyITzDPfGirIw7mHwcvci0+rML6y/q/DO11a0/ff7B34PuPXoFrce3+Lmo5v/fn10iztP7rzy7yB2hNgkiJSAhJETkiBSAhJETvDv95HN18hhIjvqr/yjdO8eDB5sKkkfPIDatU0ladKkLgxq7lzzvpY0KSxb9nbBXFgC68pCjjHg3dTZEYqD6ecWEXEGvbeIiDNYlvVWybR37s1hWVYJoANQ/L9Pv8MSmZ89uluWtRwYZNv2ijecsx3wtiwrGXAB+Ayo8d8DbNtO9p8Yf8FUps1/h7hERERERBzn1Hh4cAZyjH5zIu3JEzNfaOZM07Ptxx/BLfjHG/v7w6RJZi7ahQtQuDDMng358wd7KKGWf6A/Z26f4fiN4xy/efzfrzePc+b2GQLtwOeOD+sR9p/EUp5EeUyC6VlyKXaE2CZhFs4kzMJ5hnNq7FnjZXXIOgGBAdx+fJtbj29x69Etrj28xsV7F/9JHl64d4Gzd86y6dwmbjy68cL5McLFwDuGN97Rnz1i/PtVibY3ixTJtH9s0QL69oURI2DaNGjWDL79FuLEcUFQlSvDihVm0GKePGYmZObMrz8nfmmImQcO9obkdcE9bLCEKiIiIiLyMm+dTLMsKz/QF8jz91PPvt4AtgFbgcPArWfP3QWiANGfPdJi5pzlfPY9QAmghGVZm4BOtm3/+bK9bdv2tyyrFfAH4A5MsG37oGVZzZ69PuZtr0NERERExOn8H8GB3hArP8Qr+fpj790zN5pXroR+/eDLL9+cfHMw24ZFi6BTJzh0CHLnhsmToUiRYA0jVLnz+A77ruxj/9X9HLtx7J/E2enbp/EP9P/nuEhekfCO4U2O+DmokaEGSaImea4qK1rYaFjB/M/b2dzd3IkRPgYxwsd447GP/R//W6139wLn7p7j5M2THL95nDVn1vDrvl+fOz52hNjPJdjSx0qPTxwfkkZN+sH9PQZVzJimOq1tW1NZOmoUTJhgCmC/+ALeptuiQxUoABs3mqFuBQvC/Pmvf5OxLPDpBauLwYmfIHWbYAtVREREROT/vVUyzbKsqZhqsL9/OzkPTAem2ra97103tSzLB1NZ9jmQCMgHrLcsa7pt27Vedo5t20uAJf/33EuTaLZt13vXmEREREREHOb4KHh0EfJOe31i7OpVKF0a9u6FX34x1WnBbOtWk7/bsAG8vU0lWuXKwZ7PC7ECAgM4eeskey/vZd+Vfey7uo+9l/dy9s7Zf46J4BkB7xjeZIqbiarpqj6X7IkdIbaSPK8R1iMsyaMlJ3m05C99/aHfw3+Sa/+t8vvjxB/8cv+Xf46L5BUJnzg++MTxIVOcTPjE8SFjnIxE9NJclUSJYNw48995ly7Qu7dJrHXqBK1aQTjnFjw+L3162LzZJNRKl4YZM6BSpVcfH6cIxPaFg30gRSPwcN0MSRERERH5uL3VzDTLsv7uRbIa6GPb9mqHBWBZRYBvgCKAbdu2u6PWfhPNTBMRZ1APbxFxBr23hCJ+92BhcoiWBYosf/Vxp06ZYWQXLsBvv0HZssEXI3D8OHzzjUmexY5tZio1agSensEaRojyxP8Jey7vYfvF7SZ5dnUfB64e4KHfQwDcLXdSx0z9XMLGJ44PCSIlCH0Js2kvibfG+83TdpV7T+5x6Noh9l4xic6/v959cvefY1JES0GmuJnwie1D1nhZyZUwF7EjxHZh1K63a5dp97hsGSRMaGYj1qgRzJ1lb94073nbtplMX4MGrz726kZYWQAy94d0XwZfjBIk+rlFRJxB7y0i4gyOnpm2Guj2qjaMQfEsMbfasqx8QHdHry8iIiIiEqyODoUn18Gn96uP2bPHVGb4+cGqVWaGUDC5etW0fBs7FsKEMfPROnY0c5Y+JrZtc/bOWbae38qW81vYcmELuy7t4mnAUwCih4tOpjiZaJK1iUmexc1EuljpCOuhuU0hRaQwkciVMBe5Eub657m//7nuu7Lvn4To3st7mXd4HjYmWZg8WnJyJ8xN7gS5yZUwF5njZsbL3ctVlxHssmY1I8vWrjXtHmvXhqFDzajGggWDKYjo0U1r2ypVoGFDuH4dvvrq5cfGftYu93A/8G4Gnh/Zm5WIiIiIhAhvlUyzbbuYswN5lqgr7ux9RERERESc5uktODwQElaAmDlffsy6dVCuHESNCmvWQNq0wRLaw4fmZnn//vDoETRpAl27Qty4wbK9y91/ep8dF3eYxNmzx5UHVwAI5xGO7PGz0yZnG3InzE3OBDlJGDlh6Ks2EyzLImnUpCSNmpTyqcv/8/yDpw/YfXn3P//s151Zx7T90wAI4x6GrPGymgTbs0eiyIk++H/+vr6mMGzqVFOlWqiQ6bjYr59p+ep0ESLAwoVQpw58/bVJqPXr9/Iesxl7wvJc5sMKGb4LhuBERERERJ73tpVpIiIiIiLyJocGgN9d8On18tcXLYJq1SBZMli+3PRYczLbhunTzb3q8+fNPLQ+fSB1aqdv7VL3ntxjw18bWHN6DWvOrGH35d0E2qZ7faoYqSiZsuQ/lUkZY2fE0/0j7m/5EYjgFYH8ifOTP3H+f547f/f8c5WJo3eMZvCWwQDEjxQf36S+FE5amMJJC5M8WvIPMrnm5mYq06pUgcGDTcvHRYugZUszXy16dCcH4OVlsnkxYsCAAXDjhimb9fi/WxUxc0KC8ubDCqlaglc0JwcmIiIiIvI8JdNERERERBzh0RVTNZHkM4ia8cXXp06FunUhSxbTYy1mTKeHtH07tG0LmzdDtmwmqZY//5vPC43uP73Pn3/9yZozJnm28+JOAuwAvNy9yJ0wN98W+JY8CfOQM0FOYoSP4epwJQRIGDkhCdMlpEq6KgD4Bfix/+p+tpzfwoa/NrDq1Kp/qtcSRU70b3ItWWGSRk3qwsgdL3x4M0etYUNTsTpsGEyaZBJqLVuanJfTuLvDiBHmPbFnT7h1C6ZNg7D/11LVpycszQyHB0GmV3xgQURERETESYKUTLMsK7pt2zeDcH4Z27aXBCUGEREREZEQ4dAPEPgEMnZ/8bWRI6FVK9NXbcECiBzZqaFcvAidO8PkyRAnDkyYYPJ4bm5O3TZYPfJ7xJ/n/mTN6TWsPbuWbRe24R/oj4ebB7kS5KJz/s4UTlaYPAnzEM4znKvDlVDA092TrPGykjVeVlrkaIFt2xy9cfSf6sZlJ5bx675fAUgaNSmFkxbGN6kvRZIVIWFk51eZBoe4ceGnn6B1azNPrUMH8/Y1cCBUqPDyDowOYVnQo4epUGvbFsqUgfnzn3+vjJYJEleDo0MgdVsI6/wPJIiIiIiI/C2olWn7Lcuqbdv26nc5ybIsL+BHoAXgHsQYRERERERc68E5OD4aktWFyKn+fd624fvvTXlH+fIwc+aL1RYO9OgRDBpkWrX5+UGnTmYWUqRITtsyWJ28eZIlx5ew9MRS1pxZw2P/x7hb7mSPn50v8nxB4WSFyZcoHxG8Irg6VPkAWJZFmphpSBMzDc1zNMe2bQ5eO/hPcm3B0QVM3DMRgPSx0lPGuwylU5YmX+J8eLk7s5TL+TJmhD/+gGXLTFKtUiUoUQKGDoU0aZy4cZs2JqFWrx4ULmyqeGPH/k9g3eGv2XC4P2Tp78RARERERESeF9RkWjxguWVZPwLf2rbt/6YTLMvKAEwD0gdxbxERERGRkOFAL8CGjF3/fS4w0NyFHjzYDCWaMOHFOUAOYtswezZ8+SWcPWtufA8cCMmTO2W7YPPY/zHrz65nyfElLDm+hOM3jwPgHd2bptmaUiJFCQokLkCkMB9ItlBCNMuyyBA7AxliZ6B1rtYE2oHsu7KPladWsvTEUoZsGcKATQOI5BWJ4imKUzplaUqnLE2CyAlcHfp7K1UKihWDUaNM+8eMGU3hWNeuTiywrVkTokWDqlWhQAEzXzJJEvNalHSQtCYcGwFpOkC4uE4KQkRERETkeUH9bT4AcAO+AIpYlvW5bdsnXnWwZVmtgX5AGMACjgRxfxERERER17p3Ak5NAO/mEOHZDV9/f2jcGH75xfRLGzLEaT0W9+0zW6xfDz4+sHq1KegIrc7cPsPS40tZcmIJq0+v5qHfQ8J6hKVw0sK0ztma0t6lSRk9pavDFMHNciNz3MxkjpuZL/J+wb0n91h1etU///7OPTwXgExxMlE6ZWnKeJchT6I8eLiFrtHlHh6mYOyzz8xctUGDYMoU6NfPfE7AKW9tZcrAihXwySeQL59JqKVLZ17L2A3OToeDP0D2oU7YXERERETkRUH9Kb4AMBVIBmQFdluW1ca27Yn/PciyrFjARKA0JokG8DPQLoj7i4iIiIi41v4e4OYF6b813z9+DDVqwLx50L27KeFwwqChO3egWzcYMQKiRoUxY6BRI3APZU3Ubdtmz+U9zD08l7lH5nLo2iEAkkdLToPMDSjtXRrfpL6E9wzv4khFXi9SmEhUTFORimkqYts2B64eYOmJpSw5voSBmwfS98++RA0blbLeZamctjIlU5QMVS1JY8eGceOgSROTwK9Xz7zvDB8O2bM7YcN8+WDdOihZ0lSoLVkCuXJBpJSQvB6cGANpv4AIiZywuYiIiIjI84KUTLNte4tlWZmA0UBNIALws2VZpYAmtm3fefbniUBsTCLtFtDYtu25QQtdRERERMTFbh+EM1Mh7Zem3di9e6bH4qpVphqtbVuHb2nbMHWq6SB59So0bWrGskWP7vCtnCbQDmTzuc3/JNDO3D6Dm+VGoSSFaJy1MWW8y+Ad3RvLCUlIkeBgWRYZ42QkY5yMfJXvK+48vsPKUytZfHwxC48uZOr+qYTzCEeplKWonLYyn6T6hKhho7o67LeSIwds2gS//gpffw05c0LDhtCnD8SK5eDNfHzgzz+heHEoWhQWLDBfM3SB05Ph4PeQc4yDNxUREREReVGQ+0vYtn0fqG1Z1hJgFBAFqArksixrFVCPf6vR1gK1bdu+ENR9RURERERcbn9X8IgI6b6CmzehdGnYuRMmTYI6dRy+3YED0LKlaemYIwcsWuSkihAn8AvwY+2Ztcw9PJf5R+dz+f5lvNy9KJ68OF0KdqF86vLEDB/T1WGKOEWUsFGokq4KVdJVwT/Qnw1nN/yTTJ53ZB4ebh4UTVaUymkrUyF1BeJEjOPqkF/LzQ3q1oWKFaFnTxg2zMxt7NULmjd3cIVs8uQmoVaiBJQtC7/9BuXKQYpGcGIcpPsaIiZz4IYiIiIiIi9yWHdz27anA1mATZjkWWL+TaQ9Bb4BiiqRJiIiIiIfhJs74dxcSNMBbjyBggVh716YM8fhibS7d6FjR8ic2STUfvoJtmwJ+Ym0J/5PWHBkAXXn1yX2wNiUmFKCX/f9SoHEBZheZTrXvrzGohqLaJClgRJp8tHwcPOgcLLCDC8znHPtz7G54Wba527PiZsnaLqoKfF+jEfBiQUZsmUI5++ed3W4rxUlCvz4o5ndmD27af+YKxfs2OHgjeLGhbVrIVMmqFwZZswwrXUtdzjQy8GbiYiIiIi8yKGTj23bPmNZ1nQgL2D//TSwDPjRtm37lSeLiIiIiIQme78Dr+gQpiLkzw/XrsHSpVC4sMO2sG1zz7hjR7h82cxE69MHYobgvFNAYADrzq5j2v5pzD40mztP7hAtbDQqpK5A5bSVKZ68OOE8w7k6TJEQwc1yI3fC3OROmJt+xfqx/+p+U7F2eC7t/2hPhz86UDBJQWpkrEHVdFWJHi5k9nNNmxaWL4eZM6F9e9P6sWVL6N3bJNwcInp0WLnSVKXVqGE+VZClORwbBuk6QeRUDtpIRERERORFDqtMsywrmmVZc4FhmASaBQQ8+1oO2GZZVhpH7SciIiIi4jJXN8KlZRC9LviWhjt3YPVqhybSjhwxo4Fq1ID48WHzZnPvOCQm0mzbZsfFHXT4owOJBiei6OSizDw4kwppKrC05lKufHGFXyr+QvnU5ZVIE3kFy7LwieNDd9/u7Gu+j2OtjtHDtweX71+m6aKmxB0Yl/LTyzPjwAwePH3g6nBfYFnw2WfmvatlSxg5EtKkMR8IcNjHaiNFgiVLoFQpaNwYNkYHt7Cwv4eDNhAREREReTmHJNMsyyoM7AMqYJJnt4HqQC7g2LPnfICdlmU1c8SeIiIiIiIuYduw71twjwE1J5k7yH8PMXOAx4+he3fTzWz3bhg1CrZuNa3TQpqj14/SfW13Uo9ITY5xORi5fSS5EuZiVtVZXP3iKpMqTqJUylJ4unu6OlSRUMc7hjddCnXhcMvD7Gqyi7a52rLr0i4+n/M5cQbGodbcWiw5vgS/AD9Xh/qcKFFg+HDYtg0SJIDPPzfjzo4fd9AG4cPD/PlQpQq06wrXs8LZ6XD7gIM2EBERERF5UZDaPFqW5QH0Br7AJMwsYD1Qy7bt88+OyYKpVmsIhANGWpZVGmhg2/aNoOwvIiIiIhLsLq+Eq+thRlgIEwdWrYIUKRyy9Nq10LQpHDtmbkAPHgxx4jhkaYe5fP8y0/ZPY9r+aey8tBMLi8LJCvN1vq+pnLYy0cJFc3WIIh8Uy7LIEi8LWeJloV/xfqw/u/6fNqpT908lRrgYVE9fnVo+tciTMA+WZbk6ZMDMUNu6FcaMgW++gYwZoXNn+PprCBs2iIt7eZmSt0aNoNMkGOUF+7tDgdmOCF1ERERE5AVBrUzbDHz5bJ0AoCtQ+O9EGoBt249s224MVAVuYhJunwD7LcsqHsT9RURERESCj23DhtZww4LjCWDDBock0m7cgAYNTJdIPz8zem3atJCTSPML8GP+kfmUn16ehIMS0nF5RyzLYlCJQZzvcJ5VdVbRMGtDJdJEnMzNcsM3qS8/lfuJSx0vseCzBRRPUZxf9vxCvgn5SDsyLf029uPSvUuuDhUAd3fT8vHIEahUyVTdZsxoRp8FmYcHTJgAdVvCgqdwbg5c3+GAhUVEREREXhTUZFo2THLsNFDAtu3etv3ybui2bc8FMgPrnp0TF1gSxP1FRERERILPgu/A/yhsiQ9rNkKiREFazrZhyhQzV2jyZFOxceCAGQcUEhy4eoCOf3QkwaAEVJpZie0Xt/NF3i843PIw2xtvp32e9sSPFN/VYYp8lMJ4hKF86vJMrzKdK19cYUL5CcSKEItOqzqRaHAiPpn2CXMPz+VpwFNXh0q8eDB9Oixfbr4vXhzq1TMfJAgSNzfTUzJ1O7gHTK0A/v5BXFRERERE5EWOmJk2Bchs2/bWNx34rGKtCPAt4Oeg/UVEREREnG/WDDjeB26EhSE7IW7cIC134oSZI1S7tilu27UL+vY144Bc6fbj24zZMYac43KScXRGhm8bToEkBVj0+SLOtT9H32J9SRMzjWuDFJHnRAoTifpZ6rOh/gaOtjrKV/m+Yvfl3VSZVYUEgxLQfll79l/Z7+owKV4c9u0zbR+nToW0aU23xpd/JPctWRZ8Pxj8S0Gsi9CiCDx54rCYRUREREQg6MmsOrZt17Ft+97bnmAbPwD5gZNB3F9ERERExPkmT4ZRNSABUPwniPX+/RefPoU+fUyrs23bYORI+PNP8PFxXLjvKtAOZNWpVdScW5N4P8aj+eLmPPZ/zOCSg7nQ4QJzqs+hbKqyeLgFaeSyiASDVDFS0adoH862O8uSGkvwTerLyO0j8RnjQ45xORi1fRS3Ht1yWXzhwsH338POnZA0qZkP+ckn8NdfQVy46VwIjALxN0D5cvDwoSPCFREREREBgphMs217ShDO3Q5kCcr+IiIiIiJON3o0NKoLNbwgajZIXeu9l9qxA3LkgG+/NTePDx+GFi3MXCFXuPbgGv3/7I/3cG+K/VqMJceX0CBzA3Y03sHeZntpl7sdsSLEck1wIhIkHm4elPYuzW/VfuNix4sMLTUUvwA/Wi5pSfxB8am/oD7bLmzjFZManM7HBzZvhsGDYe1aSJfOdGwMCHjPBT3CQe4BkAq4sRJKloQ7dxwYsYiIiIh8zFzaZtG27Qeu3F9ERERE5LV+/NFku9qkg4hPIGs/01LsHT16BF99BblywfXrMH8+/PYbxHfBuDHbttn410Zqza1FwsEJ+Xrl1ySMnJBpladxqeMlRpYdSbb42bDe4zpFJGSKGT4mbXK1YU+zPexsspN6meox+9Bscv2ci2w/ZWPcznE8eBr8v567u0O7dnDwIBQoAG3aQL58Znbke0leHyKlgg4JYetmKFrUAYPZREREREQ0s0xERERE5EW2DT16wBdfQI1KkPsqxC0GcYu+81Lr10OmTDBgADRoYG4aV6jghJjf4O6Tu4zaPopMYzJRYGIBfj/2O02yNuFA8wOsq7eOzzN+TliPsMEfmIgEq6zxsjL6k9Fc6HCBUWVG4R/oT5NFTYg/KD6tl7Tm4NWDwR5T0qSwZImZo3byJGTJAl27wuPH77iQmwf49ALOway25g23cGG4csUJUYuIiIjIx+StkmmWZQVLO0bLsrIGxz4iIiIiIq9k26aMrHt3qFcPvsoAT69Dpj7vtMzdu6aorVAh8PeHlSth3DiIGtUZQb/a3st7abaoGQkGJaDlkpZ4unsyrtw4Lna4yPAyw0kfO33wBiQiIULkMJFpnqM5e5vtZWP9jZRLVY6fdv1EhtEZKDixINP3T+eJ/5Ngi8eyoEYN0/7288+hVy+TVNuy5R0XSlwVomUFaw78Ptdk53x94eJFZ4QtIiIiIh+Jt61M22FZ1jzLsjI5IwjLsrJYlrUA2OaM9UVERERE3kpgILRsCQMHmq8j+8LRwZCoKsTI8dbLLFkCGTLAmDGmhdn+/abbWHB5GvCUKfumkHd8XjKPzcykvZOomq4qWxttZUfjHTTK2ogIXhGCLyARCbEsyyJf4nxMqTyF8+3P079Yfy7cu0CNuTVINDgRnVd25tydc8EWT8yYMHkyLFsGDx6Yto9ffGHa5b4Vyw0y/wAPzkKiE2ah8+ehYEH46y+nxi4iIiIiH653afNYHthlWdYiy7I+tSwrSD1gLMsKa1nWZ5ZlLQV2AOUA10w+FhERERHx9zd9GEePNpVpw4fD4b4Q8PBZ27A3u3EDateGsmUhUiTYtAkGD4YIwZS3uvrgKr3W9SLJkCTUnlebG49uMKjEIC50uMDEChPJmSCnZqGJyCvFihCLL/N9yfHWx1lWcxl5E+Wl/6b+JBuajE9nf8qmc5uw7eD5tb1kSTM7rXFjM74yUybYuPEtT45bHOIUhgO9IHdmWLHCDKwsWBBOnXJm2CIiIiLygXrbZFoOTNWYBZQGpgFXLMv6xbKsupZlpX2bRSzLSmdZVj3Lsn4BrgBTgRLP1t0M5HzH+EVEREREgs7Pz2TBJk0ys9L69oWHf8HxUZC8PkRJ88Yl5syBdOlgxgzo0gV27YLcuYMhdkwrxwYLGpB4cGK6ru1K5riZWVpzKYdbHqZ9nvZEDxc9eAIRkQ+Cm+VGyZQlmf/ZfE62OUn73O1ZfnI5+SbkI9fPuZi6bypPA546PY7IkU2F76pV5m26YEFo29ZUrL2WZZnWvE+uwZEh5s149Wq4d88scuyY02MXERERkQ/LWyXTbNveZdt2HqAqcBCT/IoE1AYmAAcsy7ptWdZ2y7L+sCxrumVZP1mWNcOyrOWWZe2wLOs2sB8Y/+y8SM/W2Q9Utm07n23bux1+hSIiIiIir/P0qRnQM2MG9O8PXbuaG7H7uwMWZOj22tOvX4fPPoOqVSFhQtixA3r2hDBhnBt2QGAA84/Mp/CkwmQem5mZB2fSIEsDDrc8zNKaSymVshRu1rs0ohAReVHSqEkZUGIA59qfY2SZkdx9cpda82qRdEhSeq/vzbUH15weQ5Eipl1uy5YwbBj4+MDatW84KWZuSFgRDg+Ax9cha1Zz0tOnJqF28KDT4xYRERGRD8c7/XZt2/Zc27Z9gFLAAsAfkxCzgMhAVqAYUB1oCFQDigJZnr3+97F+wHyghG3bmW3bnu+AaxEREREReTdPnpgs2Jw5MGQIfPmlef7OITg9GVK1ggiJXnn6vHmQPj3MnQu9esGWLaYVmTPdeXyHwZsH4z3cm0ozK3Hq1ikGFB/A+fbnGVV2FGlivrmKTkTkXUX0ikiLHC041PIQS2suxSeOD13WdCHR4EQ0XNCQfVf2OXf/iKb77rp15vMOhQtDixam2OyVfHpDwAM41Nd8nzGjWcDNDXx9Yc8ep8YsIiIiIh+O9/qoqm3by23brgTEA+oAvwJ/90mwXvKwgaPAZExVWjzbtivbtr0yaOGLiIiIiLynR4+gYkX4/XcYOdL0Dvvb3u/AIyKk7/zSU2/cgJo1oXJliB/fVKN99x14ejov3DO3z9B2aVsSDk5Ih+UdSBA5AbOrzeZkm5N8kfcLooWL5rzNRUSecbPcKJWyFMtqLeNQi0PUz1yfGQdnkGlMJopMKsLiY4sJtAOdtn/BgrBvH7Rvb1pAZswIK191ZyFqekhWB46NgAfnzHNp08L69RAunCl5277dabGKiIiIyIcjSH1fbNu+adv2FNu269q2nQYIB3gDuYCCz756A+Fs205r23Y927an2rZ9K8iRi4iIiIi8r4cPoXx5+OMPGDfOlDf87fpWOD8P0nwBYWK8cOrChZAhA8yaZcarbdtmWo45y+5Lu6kxpwYph6Vk9I7RVEpTiR2Nd7Ch/gaqpKuCh5uH8zYXEXmNtLHSMvqT0Zxrf45+xfpx4uYJPpn+CT6jfZi0Z5LT5qqFDw+DBsHGjRA2LBQvDq1avWKWWsbugA0Hevz7XMqUJqEWNSoUKwabNjklThERERH5cDh0iIJt209t2z5p2/Z227Y3Pvt60rZtP0fuIyIiIiLy3u7fh7JlYfVq+OUXaNTo39dsG/Z0gjCxIE375067dQvq1IEKFSB2bFPM0LWrc6rRbNtmxckVFP+1OFl/ysqiY4vokKcDp9ueZnKlyWSLn83xm4qIvKfo4aLzVb6vONnmJL9W+hU3y416C+qRfGhyBm4ayN0nd52yb968sHs3tGtnCowzZ4bNm//voAhJwLs5nJoId478+3zSpCahFjculCjxFkPYRERERORjponkIiIiIvLxuHsXSpWCDRvg119Nduy/Lq+Aq2shQxfwjPjP04sWmdlo06aZBNr27eamraP5B/ozbf80sv6UlRJTSnDw6kH6FevHufbn6F+8PwkiJ3D8piIiDuLp7kktn1rsbbaXZTWXkTpmar5c8SWJBifi6xVfc/HeRYfvGS4cDB4Ma9aAnx/kzw+dO5uRmP9I/w24h4d93z1/csKEZoZakiRQujQsX+7w+ERERETkw+DwZJplWbEtyyprWVZjy7LaP/ta1rKs2I7eS0RERETkrd2+baoPtm6FGTOgRo3nX7cDYe83ECEppGwCwL17pnCtXDmIGdO0dOzRA7y8HBva/af3GbplKCmHpaTm3Jo88X/ChPITON32NF/l+4ooYaM4dkMRESeyLIuSKUuyqs4qdjTeQemUpRm4eSBJhySl4YKGHL522OF7+vqaWWr160PfvpAjB+zZ8+zFsLEhTUc4Nwdu/N+MtLhxTVVa6tTmzX7RIofHJiIiIiKhn8OSaZZlVbIs60/gErAQGAMMfPZ1IXDJsqyNlmVVdNSeIiIiIiJv5eZNMxdn1y6YPRuqVn3xmL9+g5s7IWMPcA/Dhg1mFtrEiabKYccOyJrVsWFdf3idLqu7kHhwYtr90Y7EURLz++e/c6DFAepnqU8YjzCO3VBEJJhli5+NGVVncLz1cZpka8L0A9NJNyod5aeXZ9M5x84qixwZfv4Zfv8drl2DnDnh++/B3x9I2wHCxIQ9X5uWvv8VK5Zp/ZspE1SuDHPnOjQuEREREQn9gpxMsyzLy7KsWcBsIDdgveaRB5hjWdYsy7Ic/HleEREREZGXuHYNihSBAwdg/nwz9Oz/BTw1VWlRfXgSvyZffQWFCoGbm+kI2aePY6vRLt67SIc/OpBkSBK+3/A9vkl92dRgE+vrr+eTVJ/gZqkbu4h8WJJHS86IMiP4q/1fdC/UnU3nNpFvQj4KTyrMqlOrsP8/wRUEn3xi3vIrVYLvvjOtH4+eimxa+F5ZA5eWvXhS9OiwYoUpaateHaZPd1g8IiIiIhL6OeK39DlAFf5NmB0CRgDtgMbPvo4ADv7nmCqY5JuIiIiIiPNcuQKFC8PRo6ZUoUyZlx93YgzcP8WpKP3IkdOdAQOgSRPYuxfy5nVcOGdun6H5ouYkG5qMYVuHUTVdVQ62OMjcT+eSJ1Eex20kIhJCxQwfk26+3Tjb7iyDSgzi2I1jFPu1GHnG52HRsUUOS6rFiAEzZ5quvsePQ5YsMOKPZtgRkpvqtMCAF0+KEgX++AMKFICaNeGXXxwSi4iIiIiEfkFKplmW9RlQ9tm3F4HStm1nsG27jW3bw2zbHv/saxvbtjMCpYALmIRaWcuyPg1S9CIiIiIir3Lxohmic/o0LFkCxYu//Di/u9gHenHmcRHSFC7JtWuweDGMGQMRIzomlKPXj1Jvfj1SDkvJhD0TqJ+5PsdaH2NSxUmkjZXWMZuIiIQiEbwi0D5Pe061OcWYsmO48uAK5aaXI8vYLMw6OIuAlyW73sOnn5oqtcKFoXVbL3r//j3c3g9nprz8hIgRzf8Eihc3A9jGjnVIHCIiIiISugW1Mq3hs68PgEK2bf/xuoNt214O+AL3nz3VKIj7i4iIiIi86Nw506fx/HlYtszcRX2FW5v6Yz25TpVe/Slf3mL//lcXsL2rvZf38unsT0k7Mi2zDs6idc7W5sbxJ2NIHi25YzYREQnFwniEoWn2phxrZT5g8CTgCZ/O/pT0o9Izac8k/AL8grxHvHiwaBGMGwcDZlVn15ns3N/cBdv/8ctPCB8eFiww/SKbNYNhw4Icg4iIiIiEbkFNpmUCbGC8bdsn3+aEZ8eNx1SnZQ7i/iIiIiIizztzxiTSrl41828KFHjpYbYN08ZfJMzpQfy2/XPa98rGb79BzJhBD2Hr+a2Um16OzGMzs/T4Ujrl78SZdmcYXGowCSInCPoGIiIfGE93T+pkqsOB5geYVXUWYT3CUm9BPVKNSMWYHWN4/KrE11uyLGjUCPbudWPy/v5EtM4xsfNwLl9+xQlhw8KcOVC5MrRtCwMGBGl/EREREQndgppM+7vxzfZ3PO/v48MHcX8RERERkX+dPGkSabduwapVkDv3Sw+7cgUqVIAHW7rh6e5PvhbfU6uWudkaFFvOb6HUlFLkHp+bTec20dO3J2fbnaVP0T7EjhA7aIuLiHwE3N3cqZa+Grub7mbR54uIGzEuzRc3J+WwlIzcNpIn/k+CtH6yZDBoamFOPylNpVR9KJDrJgsWvOJgLy8zeO2zz+Crr+D774O0t4iIiIiEXkFNpl189tX9Hc/7+/iLrz1KRERERORtHT0KBQvCgwewZg1kz/7Sw+bNgwwZ4NyBQzT0nYBH2hbE904WpK23nN9C6amlyTM+Dzsv7aRfsX6cbXeWLoW6EC1ctCCtLSLyMbIsi7KpyrKpwSZW1l5J8mjJabW0FSmHp2TU9lFBSqq5uUGyin2JGuEOXSr3oWJFaNwY7t9/ycEeHjBlCtSuDd99B926mdJmEREREfmoBDWZtvrZ15f3znm1Apj2kKvfdKCIiIiIyBsdOmQq0vz9Ye1ayJz5hUPu3IF69UzHrsSJYf2wzrh5RcTK8N17b7v1/NZ/kmg7Lu6gX7F+nG57mq/yfUVEr4hvXkBERF7LsiyKJi/KunrrWFl7JUmiJKHlkpakHJ6S0dtHv39SLZoPVvK61M41nB++O8v48ZAlC2zb9pJj3d1h4kRo2BB69oRvvlFCTUREROQjE9Rk2jDgKVDHsqwcb3OCZVnZgbrAk2fni4iIiIi8v337wNfXlBqsXWvKzv7P+vXg42OKC7p0gS0LNxDp7kJI1wnCvvuQtG0XtlFmahlyj8/N9gvb6Vu0r5JoIiJO9HdSbUP9DayovYLEURLTYkkLvId7M2bHmPdLqmXsiWW50al0F9asgSdPIG9e6NXLfDbjOe7u8NNP0Lw59O0LHTsqoSYiIiLyEQlSMs227QNAY8ACVliW1ciyLI+XHWtZlodlWQ2BFZiqtEa2bR8Myv4iIiIi8pHbtQsKF4YwYWDdOkib9rmX/fzg229Nrs3LCzZuhJ49bDwPfAXhEkDqtu+03fYL2yk7rSy5fs7Ftgvb+KHoD5xpd4av83+tJJqISDCwLItiyYuxsf5GltdaTsLICWm+uDnew70Zu2MsTwOevv1iERJBqjZwZgqFfPawbx9Urw5du5pi51On/u94NzcYORLatoXBg6F1awgMdOj1iYiIiEjI9NLE19uyLKvrsz+uAMoAY4G+lmVtAE4AD4HwQEogPxD92fFLgJT/Of8Ftm33DEpsIiIiIvKB27YNSpaEyJHNjLTkyZ97+fhxqFEDduwwnbmGDIGIEYG/5sKNLZDrZ/AI/1Zb7bq0i65rurL4+GKih4tOnyJ9aJWzFZHCRHL8dYmIyBtZlkXxFMUplrwYK06toNvabjRb3Iw+G/vwXYHvqJe5Hp7unm9eKH0nODkOdn9N1CJ/MG0afPKJKUDLnBmGD4c6dcCy/tnYJNK8vGDAAHj6FMaMMYk2EREREflgBSmZBnTHVJnxn6/RgfIvOdb6zzFlnj1eR8k0EREREXm5TZugVCmIFQtWr4YkSf55ybZh/HhTOBA2LMyZY+akARDoB3s7Q5T0kKzuG7c5dO0QXdd0Zc7hOUQLG43vi3xP65ytlUQTEQkhLMuiRIoSFE9enOUnl9NtbTeaLGpCvz/70cO3B59l+Ax3N/dXL+AVDdJ/B7s7wuWVELcYNWpAvnwmiVavHixaBGPHQvTo/2wK/fqZhNr335uE2vjxphWkiIiIiHyQHPHRKev/Hi977nXPv+pYEREREZEXrV9vKtLixjWtHf+TSLtxA6pUgcaNIU8eM07tn0QawMmf4d5xyNwX3F79ubJTt05RZ14dMo7OaG7OFurG6ban+abAN0qkiYiEQJZlUTJlSTY33MyizxcR0SsitebVItOYTMw7PA/7dfPNUrWECElg91dgm7aNSZKYz2r88APMnw8ZM8LKlc9tCL17Q8+eMGmSyby9MGhNRERERD4UQa1MK+yQKERERERE3saqVVC+vLnLuWoVxIv3z0srV0LdunDtGgwcCO3b/1/XLb97sL87xC4I8cu+dPkLdy/Qe31vft79Mx5uHnTM05Gv8n1FzPAxnXtdIiLiEJZlUTZVWUp7l2b2odl0XdOVyrMqkz1+dnoX7k2JFCWwrP/7DK97GPDpDZtrw5npkKymedodOnWCEiVM2+DixaFDB1OMFjbss3O7dAFPT+jc2QzqnDrVfC8iIiIiH5QgJdNs217nqEBERERERF7rjz+gYkXw9jaZs9ixAXjyBL79Fn78EdKkMe24smR5yfmHf4THV6Hgwv8MvzGuPbhG3419GbVjFAGBATTJ2oRvC35L/EjxnX9dIiLicG6WG9XTV6dy2spM2TeF7mu7U2pqKQomKcj3Rb4nf+L8z5+QtAYc+RH2fQeJq5oE2zNZs8KuXfDllzBoEKxYAdOmQYYMzw7o1AnChDGZtqdPYeZM872IiIiIfDA0IVdEREREQr5Fi0xFWpo0pu/Ws0TaoUOQK5dJpDVvDjt3viKR9ugyHBkIiatBzFz/PH3n8R26rulK8mHJGbJ1CJ9l+IxjrY8xsuxIJdJERD4AHm4e1Mtcz7y3lxnJ8RvHKTCxAKWnlmbnxZ3/Hmi5Qeb+8OAMHB/1wjrhw8PIkeZ/R1euQPbsMHSomdMJmHLoESNgwQLTX/jx42C5PhEREREJHkqmiYiIiEjINm+euTHp42NaO8aMiW3DqFGQLRtcuAALF5rvw4d/xRr7u0HAE/D5HoCHfg/pt7EfyYYmo9f6XpROWZqDLQ4yscJEkkZNGmyXJiIiwcPL3YsWOVpwos0JBhQfwLYL28g+LjtVZ1Xl6PWj5qB4xSFuCTjQC57cfOk6ZcvC/v2m5WO7dvDJJ3D16rMXW7aEsWNh6VLzAZCHD4Pl2kRERETE+ZRMExEREZGQa9YsqFbNlACsXAnRo3P1KpQrZ+5ZFipkbmqWK/eaNW4fgJM/Q6qW+EdMxrid4/Ae7k2nVZ3Imygvu5rsYla1WaSJmSbYLktERFwjvGd4vsj7BafbnqZ7oe4sP7mc9KPS0/T3ply8dxGyDgS/Oyah9gqxY5sPcQwfbj7j4eMDy5c/e7FJE5gwwfw/65NP4MGD4LkwEREREXEqJdNEREREJGSaOhU+/xzy5DHz0qJEYelSyJjR3KMcOhSWLIG4cd+wzu4vsD2j8LtXFjKMykCTRU1IEiUJ6+utZ1GNRWSJ97K+kCIi8iGLHCYy3Xy7cbLNSVrlbMXEPRNJOSwl3+6cwdMkteD4SLh7/JXnWxa0agXbtkGMGFCypJmp9vQpUK8e/PorrFsHpUrBvXvBdl0iIiIi4hxKpomIiIhIyPPLL1C7tik9W7aMJ16RaNcOypQxFQHbt0ObNuD2pp9mLy6DS38w5H4kys+th7ubO/M/nc+fDf6kQJICwXAhIiISksWKEIshpYZwpNURKqWtRJ+Nfci86Xee2hYBu7984/k+Pub/Sc2awcCBkDcvHD8O1KwJM2bA5s1QogTcvu30axERERER51EyTURERERClnHjoH59M5Bm0SKOXYhAnjymEq11a3PTMmPGNy+z9+JOzq6pxvGnMPxWABPKT2Bfs31USFMBy7Kcfx0iIhJqJI+WnKmVp7KryS4Sxc1Bj2tPcb+wgOWbvyXQDnztueHDw+jRMHcunD4NWbKYz4TYVavB7NmwcycUKwY3Xz6HTURERERCPiXTRERERCTkGDnSzJspUwYWLGDy7PBkzQpnz8KCBTBsGIQN+/olTt86Ta25tRgzKztJrPscTFCHg62OUz9Lfdzd3IPnOkREJFTKEi8Lf9T6g6Klf+dyoCfRD/ch29gsLDuxDNu2X3tupUqwd68Z81m/PtSoAXcKV4R588yAzyJF4Pr14LkQEREREXEoJdNEREREJGQYPNgMoKlYkXuT51G7cVjq1oVs2czNyfLlX3/69YfXabu0LalHpGbFkTkMiBMe/5h5qVjsF8J5hgueaxARkQ9CEe9PiJ33Z7KHhSLWJUpPLU3RyUXZfmH7a89LmBBWrYLeveG33yBzZtgcvSz8/jscPQq+vnDlSrBcg4iIiIg4TqhJplmWVcqyrKOWZZ2wLKvTS16vYFnWPsuy9liWtcOyrPyuiFNERERE3kO/ftChA1Srxs5Os8ia24tp06BHD1i92tycfJXH/o/p/2d/UgxLwYjtI6iXuR4nijUiov0Qj2xDQS0dRUTkPbglqwXRszMwthejS/7IgasHyPlzTqr/Vp3jN46/8jx3d/j2W9iwwXxfoAD03laCgIWLTR9IX1+4eDF4LkJEREREHCJUJNMsy3IHRgKlgXTA55Zlpfu/w1YBmWzbzgw0AH4O1iBFRERE5P306gWdOmF/XoPBOaaRp4Anjx/DmjXQtau5KfkygXYgU/dNJfWI1Hy98msKJinI/ub7+anwN0Q6NQ6S1oYY2YP3WkRE5MNhuUHWQViPLtAs4kNOtjlJt0LdWHJ8CelGpaPl4pZcuf/qKrM8eWDPHqheHbp0gaLfF+Hq5GVw/jwUKgTnzgXftYiIiIhIkISKZBqQEzhh2/Yp27afAjOACv89wLbt+/a/DcwjAK9vZi4iIiIirmXb5u5i1648rl6H8rcn0+ErD8qUMTcfCxZ89alrTq8hx7gc1JpXi5jhY7K6zmp+//x30sVKB3u/MTdAM30fbJciIiIfqNgFIFFlONSXSIH36e7bnZNtTtIkaxN+2vUTKYaloNuabtx/ev+lp0eJAlOnwi+/wI4dkKZxAdZ9uxyuXjUJtTNngvVyREREROT9hJZkWgLgvx/ZOv/suedYllXJsqwjwGJMdZqIiIiIhES2DZ06Qe/eXCzTiBTrJ7JitTsjRsC8eRAjxstPO3ztMOWml6PI5CJcf3idXyv9yvbG2ymcrLA54PoWODsd0nSECImC73pEROTDlbkfBD6FfV0AiBMxDiPLjuRQi0OU8S5Dz/U98R7uzfhd4wkIDHjhdMuCunVh925Inhx8O+ehb7GV2LdumYTayZPBfUUiIiIi8o6sf4u5Qi7LsqoBJW3bbvTs+9pATtu2W7/i+IJAV9u2i73ktSZAE4BYsWJlmzVrlvMCF5GP0v3794kYMaKrwxCRD8wH9d5i26QYNYpEs2ezwrs2pY5PJEGiJ3TtepCUKR+89JSbT2/yy5lfWHxpMeHcw1EzcU0qJ6hMGPcwz62b5XprwgZcYlvsKQS4hQumCxIJfXwvFn7hubXx17ggEpHQIcWdUSR8MJsdsX7igWfK5147dPcQo06O4uDdgySPkJzmyZuTPfrL2wz7+VmMH5+MmTMTUybeJubcK4MV1pM9P/7Io8SJg+NSgsUH9XOLiIQYem8REWcoXLjwTtu23zgjIrQk0/IA3W3bLvns+84Atm3/8JpzTgM5bNu+/qpjUqdObR89etTR4YrIR27t2rX4+vq6OgwR+cB8MO8tgYHQujWMGsWseG359NJgGjSwGDYMIkR48fAHTx8waPMg+m/qz2P/xzTP3pyuhboSM3zMFw8+Owv+/BRy/QwpGjr/WkRCs2nWi8/VCPm/G4q4zNNbsDAlRM8KhZebcrP/sG2b2Ydm8/XKrzl9+zSlU5ZmQPEBpI+d/qXLrVgBdepA/Bv72RC2GOHCW1irV0O6/x8PHzp9MD+3iEiIovcWEXEGy7LeKpkWWto8bge8LctKZlmWF/AZsPC/B1iWldKyzE+zlmVlBbyAG8EeqYiIiIi8XGAgNG0Ko0YxLMyXNLo3mGnTLMaPfzGRFhAYwMTdE0k1IhVd13alRIoSHGpxiGGlh708kRbwGPZ0gqg+kKxesFyOiIh8RLyiQcZucHklXFz6wsuWZVEtfTUOtzzMwOID2XRuEz5jfGi2qBlX7l954fjixWHfPohXIiPZ7q3l1m2LwEK+5kkRERERCXFCRTLNtm1/oBXwB3AYmGXb9kHLsppZltXs2WFVgAOWZe0BRgKf2qGh7E5ERETkYxAQgH/dBvDzz/TiO6Zk7MfuPRaff/7ioctPLifL2Cw0WNiARJETsbH+RuZUn4N3DO9Xr390ODw4DVl/BDd3512HiIh8vLybQ6RUsLsjBPq99JAwHmHomLcjJ9ucpFWOVozfPZ6Uw1PSZ0MfHvk9eu7YWLHg99+h+dC0FAxcx+WbXvjlLwy7dgXH1YiIiIjIOwgVyTQA27aX2LadyrbtFLZtf//suTG2bY959ud+tm2nt207s23beWzb3ujaiEVEREQEAH9/bleog8eUSXShJ/e+7MXGPy1SpHj+sH1X9lFySklKTinJA78HzKo6i80NN5Mvcb7Xr//4GhzsDfHLQtwXRuaKiIg4hpsnZBkAd4/AiXGvPTRG+BgMLT2Ugy0OUix5Mb5d/S2pR6Rmyr4pBNqB/xxnWdCmDUzdnoq6Sddz8V5EHuUriv+mbc6+GhERERF5B6EmmSYiIiIioY/91I+TuWsQdfE0ekf4gfzLutC/P3h5/XvM1QdXafp7U7KMzcL2C9sZVGIQh1ocolr6aljWS+Y6/b/93cD/gbnBKSIi4kwJykGcwub/PU9vvfHwVDFSMe/Teaytu5ZYEWJRe15tco7Lyboz6547LlMmmL8vOSOrr+fi4+g8KViMS7P/dNZViIiIiMg7UjJNRERERJzi9pUnbE9WnRQ7f2OM9480OtGJkiX/ff2J/xP6/9mflMNSMmHPBNrkbMOJNidon6c9YTzCvN0mt/bCibHg3QKipHXOhYiIiPzNsiDrYHh6E/b3eOvTCiUtxPbG25lccTJXHlzBd5IvlWZW4tiNY/8cEyEC9J+ZhAMj1nHJjkukaiVZ22PdqxcVERERkWCjZJqIiIiIONyWtY/ZmawKOS/OZ3m54TQ50oG4cc1rtm0z59Ac0o1Kx9crv8Y3qS8Hmh9gcKnBRA8X/e03sW3Y2Ra8ooHP29/QFBERCZJomSBFEzg2Au4ceuvT3Cw3ameqzdFWR+lduDcrT60k/aj0tF3alhsPb/xzXIWWCfH8cx3XwiYmZ/fSDP5kFQ8fOuNCRERERORtKZkmIiIiIg4TGAgDej7ibuEKFH20mFNfj6XEwla4Pfupc9elXfhO8qXqb1UJ7xme5bWWs/DzhaSOmfrdNzs3G66uA5/eJqEmIiISXHx6gUck86EO236nU8N7hufbgt9yvPVxGmRuwIjtI0g5PCVDtwzFL8APgCS545HwxFruxEpJs8Wf0D7tMg4ccMaFiIiIiMjbUDJNRERERBzi0iUoX/QB2bqVpRgreDhiAsn7NjGv3btEgwUNyP5Tdg5dO8SYsmPY3XQ3xVMUf7/N/B/Cri8gaiZI0diBVyEiIvIWwsYEn55weSWcX/BeS8SNGJex5cayt9lessfPTrs/2pFxdEaWHF8CgGeC2MQ7tBq/FGkY9lcFumX9nTFj3jl3JyIiIiIOoGSaiIiIiATZsmWQN+M9Oq0vja+1DmvyZMK3rM8jv0f02dAH7+HeTNk3hY55OnKi9QmaZm+Kh5vH+294qD88/AuyDwM3d8ddiIiIyNvybg5R0sOuDhDw+L2XyRA7g6nU/mwhgXYgZaeVpfTU0hy+dhhixiTy9tW4Zc7ETP/KLG8+l2rV4NYtB16HiIiIiLyRkmkiIiIi8t6ePoUvvoBPS99h3sOS5LM24TZ9GtSqycwDM0kzMg3frv6WEilKcKjlIQaUGECUsFGCtumDs3C4HySuDrELOuZCRERE3pWbB2QbCg9Ow5FBQVrKsizKpS7HgRYH+LHEj2w+t5mMozPSdmlbboa18Vy7AvfcOZjtVp0w82aQOTP8+adjLkNERERE3kzJNBERERF5LydOQL58MP7HW+yNVZxM/juwfvuNbfmTkX9ifj6b8xnRwkZjdZ3VzP10Limjp3TMxru/BCzIMsAx64mIiLyvuEUhYSU42AceXgjycl7uXnTI04HjrY/TKGsjRmwfgfdwb0Yc/ZWApYtxy5+PKdSk6qNfKVQIeveGgAAHXIeIiIiIvJaSaSIiIiLyzqZNg6xZ4eax65xKVpSkd/Zy49ex1GEeuX7OxcmbJ/m53M/sbLKTwskKO27jK2vhr98gXSeIkNhx64qIiLyvrD9CoD/s+dphS8aKEIsxn5j5opniZKL10tZkmpqfVSM6Yvn6MvB6XUZln0CXLlCsGFwIeh5PRERERF5DyTQREREReWv370P9+lCzJhRIfZXD8YsQ9eIhpvaqTuITLZl1cBad8nXiWOtjNMzaEHdHzjML9IedbSFCEkj7pePWFRERCYqIySDtF3BmKlxzbO9Fnzg+rKqzinmfzuOJ/xOKza1AlTpheOibjyZbG7Kpzhi2bYNMmWDRIoduLSIiIiL/oWSaiIiIiLyVPXsge3aYNAn6tr7AorsFcTtzlFr1o1Dr0RTKpirL4ZaH+aHYD0QOE9nxAZwcB7f3QZaB4BHO8euLiIi8r/SdIVwC2NEGAh3bd9GyLCqmqcjBFgfpX6w/Ky5uJE7+zRzMlYw8k5tzqt0wEiWCcuWgbVt48sSh24uIiIgISqaJiIiIyBvYNgwfDrlywd27sHHKGdovzM3Dv05Q+POn7POJzeo6q/mt2m8ki5bMOUE8uQl7v4PYvpCoinP2EBEReV8eESBLf7i1C05NdMoWYTzC8GW+Lzne+jifZ69P1uKnWZTeizh92rKlen/atoVhwyB3bjh61CkhiIiIiHy0lEwTERERkVe6cQMqVoQ2bcxMlk3TdpC2bUYeXDlPhYbh+bTZcHY33e3YuWgvs78b+N2GbEPBspy7l4iIyPtI8jnEygd7v4Gnt522TZyIcRhXfhxbWuxiULuczEwPYb75mtYeDfn9dzh3DrJlg19+MR+IEREREZGgUzJNRERERF5q3Tozg2XpUhj4YyD1ancnfLmc+D28z8j+VZnR/xStcrbCw83DuYHcPgDHR0PKZhDNx7l7iYiIvC/LgmzD4Ml12N/T6dtliZeFVQ3X4zltJvOyRyDFjxN4+EtaFq37ixw5zIzTWrVMVbmIiIiIBI2SaSIiIiLyHH9/6N4dihSBcOFg9Lw97LqRnsINemB5eHJ96Wy+a/0bMcPHdH4wtg0724JnZPBx/o1JERGRIImeFVI0hGPD4c5hp29nWRaVfapTasNl9pTOSvU5R9jQIjn5v+lG1+5PmTEDsmaF7dudHoqIiIjIB03JNBERERH5x7lzJonWowdUqv6QrN0bMX5uFkYPOkrYaDGJuf0g6QoG48yyc3Phymrw6QVhYgTfviIiIu8r0/dmhtrOdsHWZzFc2IhkXrSd+/Vr8uX6AKJ17cnESCno9ssq/Pxs8uaFgQMhMDBYwhERERH54CiZJiIiIiIALFgAmTPDrl021b5dxLKMsbm9ahJrpnkSMUFyIm7eiZUyZfAF5P8QdneEqBkhZdPg21dERCQowsaGjN3h8nI4vyD49nVzI+L4X6F1azpsgf4LH9H9RDESflWOQiXv8OWXUKYMXLkSfCGJiIiIfCiUTBMRERH5yD1+DK1bQ8WKEDXuHaK3K85vnuX46m5Glk53J0xyb9w2bIDEiYM3sIN94MFZyD4SnD2XTURExJFStYQoGUyrYv+HwbevZcHQodCxI5+tu8GBffk5dm8zq3NEp2CL6axbZ5MpE6xYEXwhiYiIiHwIlEwTERER+YgdOQK5c8OIEZCk1DxOVY5NhHgX2B2rC10H7cQtbTpYtw7ixQvewO4eg8MDIGltiF0gePcWEREJKjdPyDESHv4FB78P3r0tCwYMgM6dSTd/I+f3F6NNtub8Gac2Xs3zY4W/SYkS0KkT+PkFb2giIiIioZWSaSIiIiIfIduGiRMhWzabY6cf4FazArcK1WNQmb7sj9KZzG36QPbssHo1xIwZ/MHtaA3uYSHLgODdW0RExFFiFzQfCjk8wHxIJDhZFnz/PfTqRZhpsxgy8RJ76m0lW6YwXP48IdHz/0a/flCgAJw+HbyhiYiIiIRGSqaJiIiIfGTu3oUaNW0aNAC/eJt41CgV9arF5FirY7Q/GAmPOvXM3bXlyyFq1OAP8NwcM2fGpzeEixP8+4uIiDhKlv7gHs58SMS2g3dvy4LvvoPBg2HuXDI0/Y5VVX9nds1fiVjlC6hWjV37H5ApcyAzZgRvaCIiIiKhjZJpIiIiIh+R7dshnc9jZswIhMLfkeWrL9nWYT7jK4wnzoSZ0LgxlCwJS5ZAxIjBH6DffdjVHqJlBu/mwb+/iIiII4WLaz4ccnm5+bCIK7RrB+PGwR9/YJUpQ5WExTnc8jDdW2TAap6VB1G28fnnULe+Pw8euCZEERERkZBOyTQRERGRj0BgIHT7/h658vhz4dZVoreozKTBqdjceCM5EuSAvn2hbVuoVAnmz4dw4VwT6IFe8PA8ZB8Fbh6uiUFERMSRvJubD4nsam8+NOIKjRrBtGmwaRMUK0b4e4/p5tuNY98tp1K/oVDgeyZPciO1z1327AnmCjoRERGRUEDJNBEREZEP3LmLT0mX9ww9v4sEqRbRasJ4Tv/4K3Uy1cENC7p0gc6d4fPPYeZMCBPGNYHeOQxHBkHyBhArj2tiEBERcTQ3D8g+0nxY5EAv18Xx2WcwZw7s3Qu+vnDlCkmiJmH259NZMzkfydo04cLV+2TL6cc3P1wM9q6UIiIiIiGZkmkiIiIiH7AfftlBsjR3OLojLunqjeDw+nQMr9KDyGEim9ktHTtC797QsCH8+it4eromUNuGHS3BMxJk7uuaGERERJwlVl5IXt98aOTOYdfFUb48LF4MJ0+a+ah//QWAb1Jfjg0aww+zl+KWfC0/fBOfFHn3cfL8bdfFKiIiIhKCKJkmIiIi8gE6cuUk3hVm8039rLiFv8Pwuds4OLEVqWOmMgcEBkKLFjB4MLRuDT/9BO7urgv47Ey4sgYy9YGwsVwXh4iIiLNk7mc+NLKjFS4t+ypWDFasgKtXTULtxAkAPNw86FSyIZd2ZiNv4984vT0NqTI84IufFhIQGOC6eEVERERCACXTRERERD4g95/ep+WUgaTLcY0TC6uS45P9XD6aiFblC/57kL8/1KsHY8bA11/D0KHg5sIfC5/egd0dIHp2SNHYdXGIiIg4U9hY5kMjV1bD2emujSVvXli9Gh48MAm1Awf+eSlmhBj8+VM1pi85Q5iwgfzYrCwJyo9j7amNLgxYRERExLWUTBMRERH5ANi2zbT900jcuCOjGjXC44YPoybeZNvvmYge5T8z0B4/hqpVTUvHXr3ghx/AslwXOMDeb+HxFcgxGtxcWB0nIiLibCkaQ/QcsKs9PL3l2liyZoX1683PAYUKwc6dz738WYlUXD6WkILl/uLK4mYULhxIhbGtOH/3vIsCFhEREXEdJdNEREREQrndl3aTb2wJatZ9yK3JY0mXzp2jB8LTvF705w+8dw/KloUFC2D4cPjuO9cn0q5vg+OjwLsVxMju2lhERESczc0dcv0ET27Ans6ujgbSpYONGyFyZChSxPz5PyJHtli3IBk/T3yM17VcLGzfkxQtOvD9+u957P/YRUGLiIiIBD8l00RERERCqesPr9NsUTOy9mjAtq6jsPY05OtOgezZGolkyf7v4Js3zYyUdetg0iRo1colMT8n0B+2N4Vw8SBTL1dHIyIiEjyiZYbUbeHEWLi22dXRQPLksGEDxIsHJUqYeWr/p2G9sBzYG4YMqSPwdOosvvsiCmmGZGb+kfnYrpz/JiIiIhJMlEwTERERCWX8A/0ZvnU4KYd589OosLiP304s9xSsXGnR9wc3PD3/74RLl0z7pj17YM4cqFPHFWG/6OgwuLUHsg0Dz8iujkZERCT4ZOwB4RPBtiYQ6OfqaCBhQtPyMVUq+OQTmDfvhUO8vWHn1jB06ABsb8XlwQuoNKIzJaeU5PC1w8Efs4iIiEgwUjJNREREJBRZfXo1WcZmoc2cnnjMWIq9dAilS3mwf78bRYq85ITTpyF/fvN16VKoUCHYY36pB3/B/q4QvywkquzqaERERIKXZ0TIPhzuHIAjg10djRE7NqxZY2apVa0KEye+cIiXF/z4IyxeDJH9UuH58z42zk9NxtE+dPijA3ce33FB4CIiIiLOp2SaiIiISChw+fFlqv1WjaKTi3LtgA/RfvmLe4dzMWwYLFwIMWO+5KSDByFfPrh1C1at4uXZNhfZ2QZsG7KPcP3cNhEREVdIWAESVoT93eH+GRcH80y0aLBypWkN3aABDBr00sPKlIG9ey0K5vfk0dzhJFm5icFrJ5BqRCom7J5AoB0YzIGLiIiIOJeSaSIiIiIh2EO/h3Rf25262+uy6PAfFDy+kaujpxAnRji2bbNo3foVuajt26FgQfPn9eshV65gjfu1zs2H8wsgY3eImNTFwYiIiLhQtmFgucOOluZDJiFBhAjmkzrVqkHHjvDddy+NLV48WL4c+vSBs5tyEH/qFWLfLE/DhQ1pubslW85vcUHwIiIiIs6hZJqIiIhICGTbNrMPzSbtyLT0WNeDrHZV0v5+jfVT89GwocWOHZAp0ytOXrvWVKFFiQIbNkCGDMEZ+uv53YOdrSFqRkjTztXRiIiIuFaERODTEy4ugXNzXB3Nv8KEgenToXFj+P57aNECAgJeOMzNDTp3Nj9ueLqF4ciAn6h+cxdXH10nz/g81Jtfj8v3L7vgAkREREQcS8k0ERERkRBm/5X9FJ1clGq/VSNq2Kh0iXaQff0mcep4GGbOhHHjzIfGX+r336FUKUicGDZuhBQpgjX2N9rXDR5egBxjwc3T1dGIiIi4XqrWEC2zaYH8NATNHHN3h7FjoVMnGDMGataEp09femiePLBnD1SqZDFrWBYSzz1Mq7S9mbZ/GqmGp2LgpoE8DXj5uSIiIiKhgZJpIiIiIiHEzUc3ab2kNVnGZmHvlb0M8v2JzFt206ttOpIle8CePVC9+msWmDoVKlUCHx/T2jF+/OAK/e3c2AHHhkLKJhArj6ujERERCRncPCDnT/DoMuz9xtXRPM+y4IcfoH9/mDkTKlSAhw9femjUqOaQn36CwwejMbPVt4xOfZpCSQvx5YovyTg6I0uPLw3e+EVEREQcRMk0ERERERcLCAxg7I6xpBqeilE7RtE0W1N+y3eS0Y0b8+tkN7p0gaFD95A06WsWGTUKatc2c9JWrYIYMYIr/LcT6AdbG0LYOJC5r6ujERERCVli5IDUbeD4KLi60dXRvOjLL01p/PLlULw43Lr10sMsy3SGHDNmJ3HiQKNPE5B65+/Mr7oE27YpM60M5aaX48TNE8F8ASIiIiJBo2SaiIiIiAtt/Gsj2cdlp9niZqSPnZ4djXaR8thIShWOysOHsHo19OwJ7u72yxewbTPLpGVLKFcOliyBSJGC9yLexuGBcHsfZB8FXlFdHY2IiEjI49MbIiSBbY0h4LGro3lRo0Ywaxbs2AG+vnD51bPQkiZ9yLZtZtTajz9C73qlmV/iAP2L9WftmbWkH5Wezis7c//p/eCLX0RERCQIlEwTERERcYHzd89TY04NCkwswPWH15lZdSazSq/l20aZ6NABypSBvXvNvapXCgyEtm3hu++gVi2YPRvChg2uS3h7d4/C/h6QqCokqujqaEREREImz4hmpujdI3Dge1dH83JVqsDixXDyJOTPD6dPv/LQcOFg5EiYO9ccniu7F/HPfMmxVsf4LMNn9P2zL6lHpGbqvqnY9is+NCQiIiISQiiZJiIiIhKMHvs/ps+GPqQekZq5h+fSpWAXjrQ8QrSL1cmUyWL1anPjad68N3RqfPoUataE4cOhQweYNAk8PYPtOt6aHQjbmoB7OMg+3NXRiIiIhGzxS0LS2nCoL9ze7+poXq5YMdNS+uZNyJcPDhx47eGVKsGePZA5s/nsT+fW8RhZbBKbGmwiXsR41JpXiwITC7Dr0q5gCV9ERETkfSiZJiIiIhIMbNtm4dGFpB+Vnm9Xf0vJFCU53PIw3+XrSc8uEShRwiTPtm83LZEs6zWL3bsHn3wCM2ZA//6mf5JbCP2x7sQ4uLoesv4I4eK6OhoREZGQL9tg8IoGWxtBYICro3m5XLlgwwbzA0vBgrBly2sPT5wY1qyBrl3h118hWzYIez0P2xpv4+dyP3PsxjGy/5Sdpr835dqDa8F0ESIiIiJvL4TedRERERH5cBy+dphSU0tRYUYFwnqEZUXtFcz9dC5+15KRN6/JhzVrZhJpGTO+YbFr16BIETNMbeJE+PLLYLmG9/LwAuz5CuIUgeT1XR2NiIhI6BAmBmQbBje2wbEQXNWdPj1s3AjRo5tqteXLX3u4hwf06GF+hHnwAHLnhmFD3WiQpSHHWh+jXe52TNgzgVQjUjF863D8A/2D6UJERERE3kzJNBEREREnufP4Dh3/6IjPGB+2nt/KkJJD2NN0D0WTFePnnyFLFjNqZM4cGD0awod/w4Jnzpj5JAcPwvz5UK+e8y/ifdk27GgJgX6Q86c3lNqJiIjIc5J8CvHLwt5v4f6r55K5XLJkJqGWMiWULQtTprzxlEKFTNvHkiWhfXsoVw787kVlUMlB7G22l+zxs9NmWRsyj8nM6tOrnX8NIiIiIm9ByTQRERERBwu0A5mw23yyevCWwdTLVI9jrY/RNndb7t72pEoVaNwY8uSBffugcuU3rxnh1CnImxeuXoWVK02bx5Ds3Gw4vwB8ekKkFK6ORkREJHSxLMgxGix32NbUfEglpIobF9atgwIFoHZtGDjwjafEjAkLFsCwYbBiBWTKZNpApouVjuW1ljPv03k88HtA0clFqTqrKmdun3H+dYiIiIi8hpJpIiIiIg605fwWcv+cm4YLG5IiWgq2N97OuPLjiB0hNqtWgY8PLFpk7jMtXw4JErzFohs3krltW3NjbcMGk1QLyZ7chB2tIXo2SN3O1dGIiIiEThESQea+cHkFnJ7s6mheL0oUWLoUqleHL78kxahREBj42lMsC1q3hq1bIXJkKFoUvv0W/P0tKqapyKEWh+hVuBdLji8h7ci0dF/bnYd+D4PpgkRERESep2SaiIiIiANcvHeR2vNqk2d8Hs7fPc/kipP5s8GfZIufjSdPzGizYsXMzaKtW6FjR3B7m5/EFi6E4sXxixYNNm2CDBmcfi1BtrMtPLkBuX4GNw9XRyMiIhJ6eTeDWPlhZzt4eNHV0bxemDAwfTq0aUOi336DWrXg6dM3npY5M+zcabpX9+kD+fLB8eMQzjMc3xX8jqOtjlIxTUV6rOtB2pFpmX1oNnZIrtQTERGRD5KSaSIiIiJB8Nj/MT9s+IFUw1Mx6+AsOufvzLHWx6idqTaWZXHkiGnnOHAgNGtmbhZlyfKWi0+YAJUqgY8Pu4cPhyRJnHotDnF+IZyZAum/hWiZXR2NiIhI6Ga5Qa4JEPgEtjUJ2e0ewXxSaMgQTjVubBJrZcvCvXtvPC1CBPNjz2+/wYkTJsE2bpy53ERREjG9ynTW1VtH1LBRqfZbNYpOLsqBqwecfz0iIiIizyiZJiIiIvIebNtm/pH5pB+Vnm9Wf0Ox5MU41OIQfYr2IaJXRGwbxoyBrFnh3DkzF2T0aAgf/q0Wh759oWFDKF4cVq3CL0oUp19TkD25aea6RM0E6b9xdTQiIiIfhsjekKkPXFwMp391dTRvZln8VaMGTJxoBqH5+sKVK291atWqZp5s7tzQpImZK3v9unmtYJKC7Gyyk1FlRrH3yl4yj8lMm6VtuPXolvOuRUREROQZJdNERERE3tGha4coMaUElWZWIqxHWJbXWs78z+aTInoKAK5dg4oVoXlzKFDA3BQqX/4tFw8MhA4doHNnqFHDtHmMGNFp1+JQO9vCk+uQ5xdw93J1NCIiIh+O1G2etXtsG/LbPf6tXj3zc8yRI2be64kTb3VawoSwYoWp6l+yBDJmhD/+MK95uHnQPEdzjrU6RtNsTRm5fSTew735aedPBAQGOO9aRERE5KOnZJqIiIjIW7r16BZtl7bFZ7QPOy7uYGipoexpuofiKYr/c8zy5eDjA8uWweDBsHQpxIv3lhs8eWLmiwwZAu3awa+/glcoSUqpvaOIiIjzhLZ2j38rUwZWr4Y7d0xCbceOtzrNzc3Ml922DaJHh1KloG1bePzYvB4jfAxGlh3Jria7SB87PU0XNSXHuBz8+defTrwYERER+ZgpmSYiIiLyBgGBAYzZMQbv4d6M2D6Cxlkbc6zVMdrkaoOnuydgbu60bw8lS5qbPtu3m3yY29v+tHX7tjl5+nTT4nHQoHc42cXU3lFERMT5Qlu7x7/lygV//ml6Xfv6mk8evaVMmUz+rXVrGDYMcuQwFf//vB43E2vrrmVGlRlce3iN/BPzU3NuTS7cveD46xAREZGPWii5QyMiIiLiGuvOrCPrT1lpvrg56WOnZ2eTnYz+ZDSxIsT655iDB819oiFDoFUrc9PHx+cdNvnrL8iXDzZtgqlT4euvwbIcfi1Oo/aOIiIiwSNVa4iVL3S1ewRIndr8nJMiBZQta37eeUvhwplE2tKlppV2jhym+j8w0LxuWRafZviUIy2P0KVgF+YcmkPqEan5YcMPPPF/4qQLEhERkY+NkmkiIiIiL3H29lmq/1Yd30m+3H58m1lVZ7G27loyx838zzGBgeZmTrZscOkSLFoEw4ebmz5vbc8eyJ0bLlwwA0Fq1HDwlTiZ2juKiIgEHzd3yDUx9LV7BIgfH9avh/z5TVvrH398p9NLlYL9+83XDh1MQf/F/+QTI3hFoGfhnhxueZgSKUrwzepvSD8qPb8f/R07NP09iYiISIikZJqIiIjIfzz0e0j3td1JMzINi44tonuh7hxueZhq6ath/ada7Nw5KF7835s5Bw6YD1q/k+XLoUAB8PCAjRuhcGHHXoyzqb2jiIhI8Huu3eNkV0fzbqJEMSVmVavCF1+YQWgBAW99eqxYMH8+jB1rCt0yZoS5c58/Jlm0ZMz9dC7Lay3Hy92L8jPKU2ZaGY5eP+rYaxEREZGPipJpIiIiIoBt28w8MJM0I9LQY10PKqSuwJFWR+jm243wnuH/cxxMm2Zu3mzdCj//bG7qxI79jhv+8ovJviVPDps3Q4YMjryc4LG9hWnvmHui2juKiIgEp1StIVZ+2NkGHvzl6mjeTdiwMGOGSaQNG2YSaw8fvvXplgVNmsDu3ebHqCpVoGFDuH//+eOKpyjO3mZ7GVxyMJvObSLD6Ax0+KMDtx/fduz1iIiIyEdByTQRERH56O2+tJtCvxTiszmfESN8DNbVW8eMqjNIHCXxc8fdvAmffw41a0L69LB3r7l5807jzWwbevaE+vVNJdqGDZAggWMvKDicmQ5/zQSfHhA9i6ujERER+bi4uUOeSWAHwpZ65mto4u5uhs0OGQILFpifia5ceaclUqUy1WnffAMTJ0LmzOb7//J096Rd7nYcb32cepnqMWTLELyHezN6+2j8A/0ddTUiIiLyEVAyTURERD5a1x5co+nvTcn2UzYOXz/M2E/GsqPxDgomKfjCscuXm2q0OXOgTx8z8iNFinfc0M8PGjeGbt2gbl1YvBgiR3bMxQSnh+dNVVrMPJD2K1dHIyIi8nGKmByyDoYra+DoMFdH837atjV9Gvfvhzx54MiRdzrd0xO+/x7WrTPdIgsUgM6d4enT54+LHSE248qPY1fTXaSPlZ4WS1qQZWwWVp5a6cCLERERkQ9ZqEmmWZZVyrKso5ZlnbAsq9NLXq9pWda+Z49NlmVlckWcIiIiEvI9DXjKkC1DSDUiFeN3j6dNrjYca3WMJtma4O7m/tyxDx9C69ZmLlqUKKa1Y+fO5gPV7+TePShfHsaPhy5dzEeoPT0dd1HBxQ6ELQ3A9oM8k8HNw9URiYiIfLxSNIQE5WBPJ7hzyNXRvJ+KFWHtWnjwAPLmNZ9YekcFCpiOAfXrQ9++kDOnyc/9v8xxM7Om7hrmVp/LQ7+HFP+1OOWnl+f4jeNBvgwRERH5sIWKZJplWe7ASKA0kA743LKsdP932GmgkG3bPkAv4KfgjVJERERCOtu2WXRsERlHZ6T9H+3JmSAn+5rvY0ipIUQLF+2F43fsgGzZYMQI88HpnTsha9b32PjSJShUCFasgHHjTJvHd+oNGYIcGwWXV0CWHyFSSldHIyIi8nGzLMg5DjwjwabaEPD0zeeERDlzmhmysWND8eJmQO07ihzZzLJduND86JU9OwwYYCrW/suyLCqlrcShFofoV6wfa8+sJf2o9HT8o6PmqYmIiMgrhYpkGpATOGHb9inbtp8CM4AK/z3Atu1Ntm3fevbtFiBhMMcoIiIiIdiBqwcoOaUk5aaXw8JicY3FLKu5jHSx/v/zOeDvD717m25D9+6ZHNiQIRAu3HtsfPiwWejYMfj9d2jUKMjX4jJ3jsCeryB+GUjZxNXRiIiICEC4OJDzJ7i1Cw70cnU07y95cjP0LHduM6C2Tx8za/YdlSsHBw5A2bLw1VdmHNvp0y8eF8YjDF/l+4rjrY9TN1NdBm8ZrHlqIiIi8kqhJZmWADj3n+/PP3vuVRoCS50akYiIiIQK1x5co/mi5mQak4kdF3cwtNRQ9jffTxnvMlgvqQ47ccK0CurSBapVMy2CihV7z83Xr4d8+eDxYzPMo3TpoF2MKwX6weba4BEecv0ceivrREREPkSJKkGyunCoD1zb7Opo3l/06GZQbY0a8O230KSJmTn7jmLFMnNuJ00y7R99fEyn7Zfl5uJEjKN5aiIiIvJGlv0en/IJbpZlVQNK2rbd6Nn3tYGctm23fsmxhYFRQH7btm+85PUmQBOAWLFiZZs1a5ZTYxeRj8/9+/eJGDGiq8MQ+ej5Bfox78I8Jp+dzKOAR1RMUJG6SeoS2TPyS4+3bVi0KB6jRqXEwyOQdu2OU7To1ffeP87y5aQeMIBH8eOzv18/HseN+95rgevfW5Le/YWk9ydxMFp3roUr5LI4RMQxfC8WfuG5tfHXuCASEXEU98D75LjWiEA82BFrHIFu71NS7xhB/rnFtkk2YQJJpkzhZo4cHOzWjYAIEd5rqStXwtCvXxp2745G3rzX6djxKNGjvzxBZ9s2G65vYMypMVx6fIm8MfLSPHlzEoZX8yORkMDVvxOJyIepcOHCO23bzv6m40JLMi0P0N227ZLPvu8MYNv2D/93nA8wDyht2/axN62bOnVq++jRo06IWEQ+ZmvXrsXX19fVYYh8tGzbZuHRhXyx4gtO3DxBGe8yDCw+kLSx0r7ynIsXoXFjWLIEihaFX36BhO97z8S2oVs36NXL9BWaMweivTiP7V259L3l+jZYkReSfA55f3VNDCLiWNNeUl1aI+T/bigib3BlLawqYtox5xzjsjAc9nPLzz9Ds2aQPj0sXvzeP6AFBsLw4dCpE0SMCGPHQuXKrz7+sf9jhm4Zyvcbvuex/2Na52xNl0JdiBo26vtdh4g4hO63iIgzWJb1Vsm00NLmcTvgbVlWMsuyvIDPgIX/PcCyrMTAXKD22yTSRERE5MOz9/Jeik4uSsWZFfF082RpzaUsrrH4lYk024apUyFDBlizBoYONZ2F3juR9vixaUvUqxc0bAjLljkkkeZSfvdgUw0IFx+yD3d1NCIiIvI6cXwhbUc4MRbOL3B1NEHXqJFJop0+bWap7d37Xsu4uUHbtrBrFyRJAlWqQJ06cOfOy48P6xGWr/N/zbHWx56bpzZmxxjNUxMREflIhYpkmm3b/kAr4A/gMDDLtu2DlmU1syyr2bPDugIxgFGWZe2xLGuHi8IVERGRYHbl/hWa/N6ELGOzsO/KPkaUHsG+5vsolbLUq8+5Ym6k1KoFadLAnj3Qpo252fJerl2DIkVgxgzo1w/GjQMvr/dcLATZ0QoenIa808ArqqujERERkTfx6Q3RssCWBvDwgqujCbqSJWHDBvPnAgVg6dL3XiptWti82TQRmDYNMmaE1atffXzciHGfm6fWfHFzsozNwqpTq947BhEREQmdQkUyDcC27SW2baeybTuFbdvfP3tujG3bY579uZFt29Fs28787PHGsjwREREJ3Z74P6H/n/3xHu7NxD0TaZe7HcdbH6dlzpZ4uHm88rzffjPVaEuWQP/+5v5MqlRBCOTQIciVC3bvhtmz4auvwHpJC7XQ5sw0OD0Z0neB2PldHY2IiIi8DfcwkG86BDyGzbUhMMDVEQVdpkywZQskTw6ffALDhpkWA+/B0xO6d4dNmyBcONPiu107ePjw1edkjpuZNXXXMKf6HB48fUCxX4tRYUYFjt84/l4xiIiISOgTapJpIiIiIn+zbZu5h+eSblQ6vl75Nb5JfTnY4iCDSg4iWrhXt1W8cQM++wyqV4ekSU2rny+/BHf3IASzciXkzWvuwKxbZ8rdPgT3T8P25hAzL2T4ztXRiIiIyLuInBqyD4Mra+DIQFdH4xgJE8LGjVCunOnZ2KIF+Pm993I5c5rPQbVubVp9Z85sln8Vy7KonLYyh1oeom/Rvqw5vYb0o9LT8Y+O3H58+73jEBERkdBByTQREREJVbZf2E6hXwpRZVYVwnuGZ0XtFSz8fCGpYry+tGzhQjO7fu5cM9Js82ZIly6IwYwbB6VKQaJEsHWruSvzIQj0h001AQvyToXXVPmJiIhICJW8ASSqCnu/g+vbXB2NY0SMaH6Y++orGDMGypSBW7fee7nw4U2R25o14O8PBQtC+/avr1J72Ty1lMNSMnzrcPwC3j+5JyIiIiGbkmkiIiISKpy9fZaac2uS8+ecHL1xlDFlx7C76W6KJS/22vNu34a6daFCBYgbF7Zvh+++A4+g5IcCAqBjR2jSBIoXhz//NNPsPxQHesL1zZBjDERM6upoRERE5H1YFuT6CcLFg001wO+eqyNyDDc3M592wgTTFSBPHjhxIkhL+vrCvn2m2G3IEFOl9uefrz/nv/PUMsXNRJtlbUg/Kj3zj8zHfs8WlCIiIhJyKZkmIiIiIdqdx3f4esXXpB6RmnmH5/Fdge840foETbM3fe1cNIBly8xstKlToUsX2LbNjNwIWkB3THuhQYNMX6Dff4fIkYO4aAhydT0c/B6S14Okn7k6GhEREQkKr2imyvzBadjRytXROFb9+qbd9rVrZnbtunVBWi5iRBgxAlavNt0jCxQwn516XZUamHlqK2uvZNHni/Bw86DSzEr4TvJlx8UdQYpHREREQhYl00RERCRE8gvwY8S2EaQcnpIBmwbwWYbPONb6GL2K9CJSmEivPffePVM0Vro0RIli5tX37AleXkEM6sQJ8+nnFStg7FjTFyhIJW4hzNNbpr1jhOSQbZiroxERERFHiF0A0n8LpyfDmWmujsaxChY0n5aKHdt0C5gwIchLFi78P/buOzyqam3j8G+lkYRA6J0AofciVZCuUhRQQcWCir33fs6xHNvxsxw92HuliFJEmoAoSO899N5LSEgIafv7Y6WTQICZ7Eny3Ne1r5nMTGa/iTjZez9rvQtWr4Z77rFjp1q1gnnzzvw9xhj6N+jPqntX8VH/j1h/aD3tPmvHTb/cxI7oHRdck4iIiLhPYZqIiIj4FMdxmLBhAs0+asaDUx6kReUWLL1rKV8P+poapWuc9ftnzYLmzeGLL+xyGkuXQtu2Hijsjz/sqOcDB2yYdtddHnhTH+I4sOB2OLkfOo+EwDMHliIiIlKINPsXVOgEi+6B2Atriehz6ta1i+F27w633w5PPmlbcl+AsDD48EOYORMSE6FLFztL7eTJM39fgF8A97S9h80Pbea5Ls/x8/qfaTiiIc/OeJbjCccvqCYRERFxl8I0ERER8RlL9i6hxzc9GDR6EP7Gn0lDJzHj5hm0rtr6rN8bGwv33w+9etkZaHPn2uU0goM9UNjHH8Nll2Uuuta9uwfe1MdEvQ+7x0GrN6C8J9JHERER8Rl+AXawjPGHuddCSoLbFXlWmTIwebJd9Oytt2xL7ujoC37bnj3PfZYaQOkSpXm116tsfGAj1za9ljf+foN6/6vHh4s/JCkl6YLrEhERkYKnME1ERERct/P4Tm4edzPtPmvHukPr+Kj/R6y6dxX9G/THGHPW7586FZo2hY8+gkcegRUrbDfGC5acbNdFu/deG6bNnw+RkR54Yx9zeBGseBKqD4BGj7ldjYiIiHhDyVrQ6Rs4thyWPe52NZ4XEAAffGAPCH//HTp2hI0bL/htS5Wys9RmzIBTp+wstSeeOPssNYCa4TX59qpvWXrXUppVasb9k++n+UfNmRg1EcdxLrg2ERERKTgK00RERMQ1MadieG7mczQc0ZCx68byXJfn2PzQZu5pew8Bfmdfi+zoUbj1Vrs2WlgY/P03vPsuhIZ6oLhjx+wbjxhhr5hMnAilS3vgjX1M4jH4+zoIqQYdv4J8hJciIiJSSNUYAI0eh00fwo4xblfjHffcY/szHjkC7dvbUVce0KuXnaV2113w9tvQurUdZ5Ufbaq2YdawWUy8fiIAA0cNpOe3PVm2b5lHahMRERHvU5gmIiIiBS45NZmPFn9Evffr8frc1xnSZAhRD0Txaq9XKV0if4HVzz9Dkybw/ffw/POwfLmHZqMBrFtn10f76y/46iv4v/8Df38PvbkPcRxYcBvE74bOo6FEObcrEhEREW9r9TqU7wgL7yh666el69rVtuauXRv697fHch6YCVaqlO3+/fvvdmZaly52ibb4+LN/rzGGKxteyep7V/NBvw9Yc3ANF316EcPGDWPX8V0XXJuIiIh4l8I0ERERKTCO4zB+w3iaf9Sc+ybfR5OKTVhy5xK+vepbIsIj8vUe+/fD4MF2q1YNliyBV16BEiU8VOT48TZIi4mBWbPs1LeiKuo92D0BWr8JFTq4XY2IiIgUBL9A6DLarqNWFNdPS1e7tm1bcPXV8NRTMGxY/noz5kPv3naW2h132CXaWrSwh435EegfyH3t7mPzg5t5tsuzjFk7hgYjGvDsjGeJToj2SH0iIiLieQrTREREpED8vfNvunzVhatGXwXAhOsn8Mctf3BRtYvy9f2OA99+a2ejTZoEr70GCxfaheA9IjUVXngBrrrK7mTpUujc2UNv7oMOL4IVT0GNgdDwEberERERkYJUMgI6FuH109KVLAljxsDLL9t2Bt26wZ49Hnnr0qXhk08yQ7RevWy4duxY/r4/PDic13q9xsYHNzK4yWD+8/d/qPt+Xd6Z/w4JyUU04BQRESnEFKaJiIiIV607tI6BowbS5asubI/ezmdXfsbqe1czoOEATD7X59q5E/r1g1tugcaNYcUKePZZCAz0UJHHj8OgQfZCy223wZ9/QvXqHnpzH3TqKPx9rdZJExERKc5qXAmNn0hbP22029V4jzHwz3/CuHGwfj20bQsLFnjs7Xv0sLPUnnoKvv7ajsn65Zf8f39EeATfXfUdy+5eRrtq7Xh8+uM0HNGQ71Z+R0pqisfqFBERkQujME1ERES8YnfMbu6YeAfNP2rO7O2zea3na2x6cBN3tLmDAL+AfL1Haip89BE0bWqXL3vvPXvbqJEHC42Ksm0dp0yBESPgiy8gONiDO/AxTiosuBVO7oXOYyCorNsViYiIiFtavgYVOsHCOyEmyu1qvGvQIJg/H0JC7Jpqn37qsbcOCYH//AcWLYIqVeCaa+y2b1/+36NVlVZMvWkqM26eQcXQigwbP4w2n7Zh6uapOB5Y701EREQujMI0ERER8ajohGiemfEM9f9Xn+9WfcfDHR5m60NbefaSZwkNDM33+2zaZEf63ncfdOwIa9bAQw+Bv78Hi/31V2jfHo4cgRkz4P77i/4srbWvwZ5fofXbUKG929WIiIiIm/wCofNo8A+GOVdDUqzbFXlXs2Z2wd2ePeHuu+HOOyHBcy0V27Sxgdobb8Dkybajwuef23bl+dUrsheL7lzEqGtGEZcYR98f+tLr214s3rPYY3WKiIjIuVOYJiIiIh6RkJzA2/PeJvK9SN78+00GNxlM1ANRvHP5O5QPLZ/v90lOhv/7P7uQ+8qV9gLE9OlQp44Hi01NhX//GwYMgHr17Ppo3bp5cAc+au9UWPUvqH0jNHjA7WpERETEF5SsCZ1HQcwGWDD83JKfwqhcOfjtN3j+eXug2bUr7NrlsbcPDISnn4ZVq+zavnfeaddT27w5/+/hZ/y4rtl1rLt/HSP6jmDNwTW0/7w91/50LZuObPJYrSIiIpJ/CtNERETkgqSkpvDtym9pOKIhT/z+BB1qdGDZ3cv47qrvqF2m9jm91/LldhbaU0/BZZfBunVw++0enix2/DhcfTX8619w000wdy5ERHhwBz7qxDaYdwOUaQ7tPy36M/BEREQk/6r0hJZvwK6xsOFtt6vxPn9/eOUVu7jZhg1w0UXwxx8e3UX9+jBrFnzyiR231by5HTCWnJz/9wjyD+L+9vez5aEtvNDtBSZvmkyTD5tw/2/3c+DEAY/WKyIiImemME1ERETOi+M4TN40mdaftOaW8bdQMbQiM4fNZMqNU2hVpdU5vVdcHDzxhF0PfvduGDUKxo+HatU8XPTq1XYnkybBO+/At9/aRS6KuuSTtnWT48Alv0BA/tttioiISDHR+AmoORhWPA0HPBss+ayrrrJ9GcuXh0svtceHHpyZ5+cHd91lB4hdfrkdMNahA6xYcW7vU6pEKV7s/iJbHtrCXW3u4tNln1L3/bq88McLxJ4q4q05RUREfITCNBERETlni/Ysoue3Pen/Y3/ik+IZPXg0i+5cRM86Pc/5vSZPhqZN4e237Sy09evhuuu8MHHqhx/s1YsTJ+zI40cfLR6zsxwHFt8Lx1bAxd9DqbpuVyQiIiK+yBjo+CWUaghzr4M4z7U+9GmNGtlAbeBAePxxuOEGO9LLg6pXh3Hj4Kef7MCxtm3h2Wfh5Mlze5/KYZX5oP8HrLtvHf3q9+Plv16m7vt1GbFoBIkpiR6tWURERLJTmCYiIiL5tv7Qeob8NIQOn3dg7cG1jOg7gnX3r+PaptfiZ87tsOLAARg6FPr3h9BQ+Osv+PRTKFvWL1FT1QAAf4hJREFUw0UnJsIDD9iWjm3bwrJlcMklHt6JD9v8MWz7Bpq9ANX7u12NiIiI+LLAUnYWe0oCzB0MKafcrqhglCoFY8fC66/D6NG27/gmz65NZgwMHmwHjg0bBm+8AS1bwsyZ5/5e9cvXZ8yQMSy8YyFNKzXlwSkP0uSDJvy4+kdSnVSP1i0iIiKWwjQRERE5q23HtnHr+Ftp9lEzpm6eygvdXmDLQ1u4v/39BPkHndN7pabatd4bNbLLVLz0kl0rzSv51u7d0K0bfPABPPaYvVpRtaoXduSjDs2HpQ9DtX7Q/F9uVyMiIiKFQXgj6PQ1HFlkjyOKC2PgmWdg6lTYu9euo/bzzx7fTbly8OWX8Pvv9ri4d2+4+WY4ePDc36t99fbMGjaLKTdOISwojBt/uZGWH7dkwoYJOB5sVykiIiIK00REROQM9sXu4/7f7qfhiIaMXjuaRzs+ytaHtvJi9xcpVaLUOb/f+vXQvTvceacdibtqFfzrX1CihOdrZ9YsaNMG1qyBMWNsH8nAQC/syEfF74W510BoTdve8RxnDoqIiEgxVvNqaPI0bP4ENn/qdjUF67LL7Eivxo3tVLJHH7WdDjysd2+7nO8//mEnwzVqBJ99ZgO2c2GMoU+9Piy7exmjrhnFqeRTDBo9iI5fdGTG1hkK1URERDxEV1VERETkNEfij/DU709R9/26fLrsU25vfTubH9zMW5e9RcWSFc/5/U6ehBdegFatbLb1xRd22bKGDT1fO44D//mPXUS+QgW7BsaQIV7YkQ9LPgl/DYKkWOg6HoI83TtTREREirwWr0LVPrD4fjj4l9vVFKyICJgzBx58EP77XzsabJfn15ALCYF//xtWroTmzeGuu6BrV3u8fK78jB/XNbuOdfev44sBX7Avdh+XfncpPb/tybxd8zxeu4iISHGjME1EREQyxJyK4eU/Xyby/UjemvcWg5sMZsP9G/joio+oXrr6eb3n1Kn24sDLL9vBvRs2wPDhtpOOxx09ahePf+YZu7NFi+yo4uLEcWDhHXB0iZ2RVqa52xWJiIhIYeTnD51HQqm6MOcaOLHd7YoKVlAQvP++nTa2ejW0bg3TpnllV40bw+zZ8NVX9li5dWt49lmIjz/39wrwC2B46+FsenAT7/d5n3WH1tH5y85cOfJKVu5f6fHaRUREiguFaSIiIsLJpJO8Pe9tIt+L5IXZL9A7sjer713Nt1d9S91ydc/rPffssRPC+vaFgACYMQN++AEqVfJw8ekWLLBXHqZOhffeg1GjICzMSzvzYevfhB0/QstXoMZAt6sRERGRwiyoDHSdCKnJ8NdASDrhdkUF79prYckSu+5u377w4ouQkuLx3RgDt95qw7SbboI33oBmzWDKlPN7vxIBJXiww4NsfWgrr/V8jbk759Lqk1ZcP/Z6og5HebR2ERGR4kBhmoiISDGWmJLIR4s/ot7/6vHE709wUbWLWHTHIn6+9meaVmp6Xu+ZnAzvvGPXfZg0CV55xbau6dXLw8Wncxy7Htoll4C/P8ybBw895KWpbz5u96+w4lmodT00edbtakRERKQoKN0AuoyG42tg/jBwznFRr6KgYUNYuBCGDYOXXoI+feDQIa/sqkIFO0Nt9my7rnC/fjbP2737/N6vZFBJnr3kWbY9vI3nL3meSRsn0eTDJtw+4XZ2RO/waO0iIiJFmcI0ERGRYiglNYXvVn5HoxGNuG/yfdQpU4fZt8xm2k3TaFe93Xm/77x5cNFF8Pjjdr2HtWvh+efthQCvSG/r+MQTMGAALFsGbdt6aWc+LnotzLsByrWBDl8UzzBRREREvKPqZdD6bdg9Dla/6HY17ggNtSnX55/b9dRatYK/vLeWXLdusGKFXVPt11/tQLW33oKkpPN7vzLBZXil5ytsfXgrD7V/iO9Xf0+DEQ14aMpD7D+x36O1i4iIFEUK00RERIoRx3H4Zf0vtPi4BcPGD6NMcBkm3zCZObfNoVvtbuf9vkeOwB13QOfONt/65Rc7Ky0y0oPF55S1reP778PYsVCmjBd36MNOHYG/BkBAGHQdDwGhblckIiIiRU3DhyFyOKz5N+wY43Y17jAGbr/dHoeWLAk9etiFgb3Q9hHsgLR//MMOUOvZE5580mZ4f/xx/u9ZqWQl3u3zLpsf3MwtLW/hw8UfUvf9ujw741mOnjzqsdpFRESKGoVpIiIixYDjOPwa9SttP2vLNWOuIdVJ5achP7HkriX0rd8Xc56zmFJT4YsvbOebb76xJ/jr18NVV3lxYlTOto5//w0PPlh8Z2KlJMLcIRC/B7qOg9AablckIiIiRZEx0O5DqHAxLLgVji51uyL3tGoFS5fCDTfACy9A796wd6/XdhcZCRMn2u3kSRus3XDDhe2yZnhNPr3yU9bfv55BjQbxn7//Q5336vDi7BeJToj2WO0iIiJFhcI0ERGRIixriDZg1ACiE6L5auBXrL53NYObDMbPnP+hwKJF0LGjnZHWuDEsXw5vvglhYR78AXI6fPj0to7tzr8tZaHnOLD4bjjwB3T4DCp0dLsiERERKcr8S8Alv0BwJZh9BcTtdLsi95QqBd99B19/bQ+MW7aEKVO8ussrr7Sz1P71L9sJolEjePfd82/9CFC/fH1+uPoHVtyzgt6RvXnpz5eo/d/aCtVERERyUJgmIiJSBOUVom24fwO3trqVAL+A837vQ4dsgNahA+zaZa8h/PUXNGvmwR8gN7Nm2YsU06bBe+8V77aO6da+Clu/hmYvQJ2b3a5GREREioOQytDtN0g5CbP7Q+Jxtyty1y232Flq1apBv3520Fdiotd2FxICL70Ea9ZAly7w2GPQps2FL9/WonILfr72Z5bfvZyedXpmhGovzX5JoZqIiAgK00RERIoUx3GYtHES7T5rlxGifTngy4wQLdA/8LzfOzkZRoyABg1sS8cnnoCoKLjpJi93WExKgmefte1zSpWChQvhoYeKb1vHdNt+gFX/hNo3Q/MX3K5GREREipMyTeGSnyFmA8wdDKkXMDWqKGjUyK6jdt99th15ly6wdatXd1mvHvz2G4wfD7Gx0K0b3HzzhXebbFWlFb9c90tGqPbiny8qVBMREUFhmoiISJGQNUS7cuSVHD15NCNEu631bRcUogHMmQMXXWSXJmvbFlatgv/7Pyhd2kM/QF62bLEXI954w06HW7rUrlFR3B38CxYOh0rdbHvH4h4sioiISMGr0gvafwr7Z8Die2376eIsJAQ++MB2T9i4EVq3htGjvbpLY2wH9HXr4PnnYcwYu5bxf/4Dp05d2Hunh2rL7lpGjzo9ePHPF6nzXh1e/vNljicU89mIIiJSLClMExERKcQcx+G3jb/R/vP2GSHaFwO+IOqBKI+EaHv3wo03QteuEB1trw1Mn27XSPO677+3FyE2boSffoJPP4WSJQtgxz4uJgr+GgRhdaDrOLt2iYiIiIgb6t4GTZ+HLV/AujfcrsY3XHMNrFgBTZrA9dfbNpAxMV7dZWgovPKKDdV69oRnnrEt2CdNuvCMs3XV1oy7bhzL7lpG99rdeWH2C9R+r7ZCNRERKXYUpomIiBRCWUO0K0ZewZH4Ixkh2vDWwy84RDt1Ct58045s/fln+Oc/Yf16e23A65OgYmJs78ibb7az0FauhMGDvbzTQiLhEMzuByYAuk+GoLJuVyQiIiLFXYt/Q62hsPI52D7K7Wp8Q+3adhGzf/3LDhBr1QrmzfP6buvWhQkT7BLDAQFw5ZV2GbeoqAt/b4VqIiJS3ClMExERKURyhmiH4w/z+ZWfeyxEcxwYN84OpH36aejRA9auhZdftiNevW7hQjsbbeRIu7L6H39AREQB7Nj3+aUmwF8D4eRe6DYRwiLdLklERETEjrTq+BVU7AILboWDc9yuyDcEBtrj2Tlpv49LLoEXXrALEXvZZZfZtuzvvmszvGbN7HrHxz2QeWUN1brV6pYRqv37z38rVBMRkSJNYZqIiEghkL4mWofPO2QL0TY+sJHb29x+wSEa2AlgvXrB1VfbJR+mT4eJE+0IV69LSrIXFzp3thcY0kfy+vsXwM4LgdRkmhx7GQ4vgE7fQYWOblckIiIiksm/BHQdDyVrwZ8DKJm01e2KfMfFF9u2jzfdZEeodekCmzd7fbeBgfDII7BpE9x6K7zzDjRoAF9+CampF/7+rau2Zvz141l611K61erGv2b/K2OmWnRC9IXvQERExMcoTBMREfFhKakpjFk7htaftObKkVdyKP4Qn135GVEPRHksRDt4EO6+G9q0sSNYP/jAnu9feumF158vUVH2IsPLL9sF2latsqGaWI4Di+6iwqn50HYERKjlpYiIiPigEuWhxzQICKXFkachbofbFfmO0qXhm29g9Gh77NuqFXz11YUvaJYPlSrBZ5/B4sVQrx7cfjt06ABz53rm/dtUbZMRqnWt1ZUXZr9AxLsRPDfzOQ7FHfLMTkRERHyAwjQREREflJSSxDcrvqHph025bux1JCQn8PXAr9n4wEbuaHMHQf5BF7yPxER46y2oX9+OUH3wQTty9b777BoLXuc4MGKEbeu4dSv89JO9yBAeXgA7L0RWPgdbv2J72DBocJ/b1YiIiIjkLaw29JiKn5MAf1wOCYfdrsi3XHutHTjWrh0MHw5DhsCRIwWy64susgHa99/Dvn226+SQIfYw3BPaVG3DhOsnsOLuFfSt35c35r5Brf/W4tGpj7InZo9ndiIiIuIihWkiIiI+JCE5gY+XfEyDEQ24dcKtlAgowejBo1l731puaXWLR2aiOY5t39i0KTz5pO00s3o1/Pe/ULbshf8M+bJnD/TpYxO87t1hzRoYrBlXp9nwX1j3BtS7i+2lbnW7GhEREZGzK9OcNeVetTPTZveDpBNuV+RbataEmTPhzTftQXmzZjBpUoHs2hjbCGLjRtsUYvJkaNzYnhNER3tmHy2rtGT04NGsu38d1za9lv8t+h+R70dy9693s/WY2n+KiEjhpTBNRETEB8QlxvHu/HeJfC+Se3+7l8olK/Pr0F9ZcfcKrm16Lf5+nlk7bPly6N0bBg60s8+mTIHffoNGjTzy9vkzejQ0b26Hxn70kS2gatUCLKCQ2P4jLHsUal4NbT+0Vz9ERERECoHjJVpA59FwbCnMuQZSEt0uybf4+dkEa/Fi24fxyitt/8Xjxwtk96Gh8M9/2q4UN90Eb79tW0B+8IFdytgTGlVoxNeDvmbTg5sY3mo4X6/8mgb/a8CwccNYf2i9Z3YiIiJSgBSmiYiIuOh4wnFem/Matd+rzWPTH6NhhYbMuHkG82+fzxUNrsB4KEDZuROGDbPtXVauhPfesx1m+vTxyNvnz7Fjdijs9dfb3pLLl8M99ygkys2+6TD/FqjUDS7+ATwUpoqIiIgUmBoDoP2nsH86LLgNnFS3K/I9LVvCokXw3HPw9dfQooWdtVZAqlWDL76AZcvsrh94wN7+9pvnlnOrU7YOH13xEdse3sZDHR7i5/U/0/TDpgz5aQjL9y33zE5EREQKgMI0ERERF+yL3cfTvz9NxH8jeH7W87Sr1o65t83lj1v+oFdkL4+FaMePw7PPQoMGMGYMPPUUbN4MDz0EgRfeMTL/fv3V9pUcPRpeegn+/tsWJac7vADmXA3hTaHrBPAPdrsiERERkfNT93Zo+Rrs+BGWPuK5hKYoKVECXn0V5s2D4GDbRuLBByEursBKaNXKZngTJ0JqKlxxBVx2mR185ynVSlXjncvfYfvD23nukueYvmU6bT5tQ5/v+zB7+2wc/dsQEREfpzBNRESkAG06som7fr2L2u/V5q35b9GnXh+W3rWUyTdOpnNEZ4/tJykJRoyw7VreeMMuLh4VZe+XKeOx3ZzdsWN2StyAAVChgh15+69/2R6Tcrqjy+CPPhBcFXpMgaBwtysSERERuTBNnoFGj8HG/8HK592uxnd16GA7NzzyiD2Qb9XKBmwFxBjbbXLNGnj/fTtbrVUruPVW2+XCUyqWrMgrPV9hxyM7eK3nayzfv5we3/Sg4xcdGbd+HKmawSgiIj5KYZqIiEgBWLJ3CUN+GkLDEQ35duW3DG81nKgHohg9eDRtqrbx2H4cB8aNs5PAHnzQLk22ZAl89x3UquWx3eRP+my0H3+0izIsWQJtPPezFjnRa+GPyyAwHHrNhBCtIyciIiJFgDHQ+i2odzesex3WvOp2Rb4rNBTefRf++AOSk6FLF9ta4uTJAishMNCeR2zeDI8/DqNG2YYSTz5px8l5SpngMjx7ybNsf3g7H/X/iMPxh7l6zNU0+aAJXy7/klPJpzy3MxEREQ9QmCYiIuIljuMwY+sMen/bm3afteP3Lb/zTJdn2P7Idj664iPqlavn0f0tWACXXAJXX21PgidNsu1aLrrIo7s5u6NH4eab7Wy0ihXtbLSXX4agoAIupBCJ2QSzeoNfkA3SSka4XZGIiIiI5xgD7T6E2jfDqn/Ahnfdrsi3de9ueyzecQf83//ZKWJz5xZoCWXL2l1v3GiXPH77bYiMtI8lJHhuPyGBIdzT9h6iHohi1DWjCA0M5faJtxP5fiRvzXuL2FOxntuZiIjIBVCYJiIi4mEpqSmMWTuGtp+15dLvLmXdoXW82ftNdj66k9d6vUaVsCoe3d/atXDVVdCpkx1B+umnsHIl9O9vr1sUqIkT7Wy0UaNsO8fFizUb7WzidsCsXuAkQ88ZUMqzIauIiIiITzB+0PFLqDkYlj0Gmz5xuyLfVqqUPbCfPh0SE+2ouQcegNiCDZciIuDrr2HFCnu+8dRTdqbaN99ASorn9hPgF8B1za5j6V1LmXbTNBpVaMSTvz9p15ie+TwHThzw3M5ERETOg8I0ERERD4lLjGPEohE0HNGQ68Zex4nEE3x25Wdse3gbT3Z+ktIlSnt0fzt2wG23QYsWMGsWvPKKDdPuvNOFJckOH7az0QYOhEqV7Gy0l17SbLSzid8LM3tCUiz0/B3Cm7hdkYiIiIj3+AXAxT9Atf6w+F7Y9p3bFfm+Sy+F1avhoYfgww+hWTOYNq3Ay2jRAiZPtucdVarYtdRat7aPOY7n9mOM4bK6lzFz2EwW3bGIXnV68frc16n9Xm3u/vVuog5HeW5nIiIi50BhmoiIyAXaF7uP52c+T813a/LglAepWLIiY4eMZd1967ijzR2UCCjh0f0dOgSPPmpHhI4cCY89Blu3wvPPQ1iYR3d1do4D338PjRtnn43WunUBF1IIJRy0rR0TDkKPqVC2ldsViYiIiHiffxBcMhYq94QFt8LOn9yuyPeFhcF779lWj6Gh0KePTbOOHi3wUnr0gIULYfRoiI+33TB69IB58zy/r3bV2zH22rFseGADN7e4mW9WfkOjDxoxYOQA/tz+J44nUzwREZGzUJgmIiJyntYcXMPwCcOp/V5tXp/7Ot1rd+fv4X8z//b5XNPkGvz9/D26v9hYO9krMhLefx+GDYNNm+y6BeXLe3RX+bNtG/Tta2ek1asHy5drNlp+nTwAM3tA3Hbo/htU6OB2RSIiIiIFxz8Yuk2ACp3g76EK1PLr4ovtMfdzz9kBbU2awC+/FHgZxsC118K6dTBiBKxfD507wxVX2HaQntagfAM+vfJTdj66kxe6vcD83fPp/k132n3WjpGrR5KUkuT5nYqIiOSgME1EROQcOI7DjK0z6PN9H5p/1JzRa0dzZ5s72fjgRn657hcurnmxx/d56pQdiBoZCS++aAeirl0Ln30GNWt6fHdnl5xsVyBv1gz+/hv+9z87SrZZMxeKKYRO7oOZ3eHEdug+GSp1dbsiERERkYIXUBK6T8kM1LaPcruiwiE4GF591XaDqFoVrrnGbnv2FHgpQUFw//22S8brr9tTg9at4brrYMMGz++vUslKvNj9RXY+spOP+39MbGIsN/xyA/X+V4935r9DzKkYz+9UREQkjcI0ERGRfEhMSeTbld/S6pNWXPrdpazYv4JXerzCzkd2MqLfCOqVq+fxfSYl2TXH69eHRx6BVq3sUmQ//QSNGnl8d/mzfDl07AhPPAG9etnhqA88AP6enYVXZMXvhRndIX4X9JgClbu7XZGIiIiIewJL2UCtYmeYfyNs+8HtigqP1q3tycHrr9uFyxo3tu0rUlIKvJSSJeGZZ2zjin/8A377DZo2tes7b9/u+f2FBIZwd9u7WX//eiZeP5E6Zerw+PTHqfluTZ6c/iS7ju/y/E5FRKTYU5gmIiJyBofiDvHqX69S57063DL+FlJSU/hywJfseGQHz3d9nvKhnu+vmJwMX30FDRvC3XdD9erw++92a9fO47vLn/h4eOopW8Du3TBmDEyY4NLUuEIqfo+dkXZyL3SfqhlpIiIiIgCBYWmz9bvBgmGw7Tu3Kyo8AgNtirVmjW0B+fDDduDbsmWulFOmDPz733am2sMP2/WdGzSws9f27fP8/vyMH1c2vJLZt85m8Z2L6Ve/H+8ueJfI9yMZ+vNQFuxe4PmdiohIsaUwTUREJBerDqzi9gm3U/Pdmvzjj3/QrFIzptw4hdX3rua21rdRIqCEx/eZkmKXPmjcGIYPt+ugTZ5sF/Pu3dvju8u/X3+1Q0v/7//s8NL162HIELtYguRP3C6Y0Q1O7oce06BSF7crEhEREfEdASWh2ySo1APm3wJbv3a7osKlbl2YMsWmV7t22QFwjzxiF112QaVK8M47sHmzPX349FNb4lNPwaFD3tln22ptGXnNSLY8tIWH2j/E5E2T6fRFJzp83oEfVv1AYkqid3YsIiLFhsI0ERGRNCmpKYzfMJ4e3/Sg5cctGbV2FLe1uo21961l2k3T6FOvD8YLAVJqqp3o1bw53HyzbZMyYYLt2tK3r4uZ1fbtMHAgDBgAoaEwe7ZdqK1sWZcKKqTidtgZaacOQc/pUNHz6+qJiIiIFHoBodDtV6jSGxYMhy1fuF1R4WIMXH+9Xazs7rtty8fGjeGXX8BxXCmpRg345BNb0tVXw1tvQe3a8PTT3gvVapWpxduXv82ex/Ywou8IohOiuWncTdT+b23+/ee/ORh30Ds7FhGRIk9hmoiIFHvRCdG8M/8d6v+vPleNvoqtx7byZu832f3obj664iOaVGzilf06DowbZ9dCu+468PODsWNtV5YBA1wM0U6dgtdegyZNYMYMePNNWLECunVzqaBC7PgG+L0LnDoCPX6HCh3drkhERETEdwWEQNcJUPVyWHgHbPiv2xUVPmXKwIcf2vYW5cvDNdfYkwtvLF6WT3Xr2g4ca9fCoEG24YW3Q7WwoDDub38/6+9fz+QbJtOicgv+NftfRLwbwW0TbmPF/hXe2bGIiBRZCtNERKTYijocxf2/3U+Nd2rw+PTHqVG6BmOHjGXLQ1t4svOTlA3xzgys1FT4+Wdo08aO0Dx1Cn78EVautOe6fm7+dZ45E1q2hOefh3797DDSJ5+06zHIuTm6DGZcAqmJ0PtPqNDe7YpEREREfF9ACHQdDzWvgWWPwqoXXJtZVah17AhLltjkatYsO0vt5Zfh5EnXSmrcGH744fRQ7amn4KCXJoz5GT/61u/L1Jumsu6+dQxvPZwxa8fQ+pPWdPu6G7+s/4Xk1GTv7FxERIoUhWkiIlKsJKcmM2HDBC777jIafdCIz5d/zuAmg1l21zL+uu0vrmlyDQF+AV7Zd0qKDc2aN4fBgyE+Hr75xp5MDh0K/v5e2W3+7N1ri+jdG5KT7ZoLY8dCzZouFlWIHfwLZvYA/1DoPRfKtnS7IhEREZHCw78EdB4FkcNhzcuw9GFwUt2uqvAJDIQnnrAD5AYMgBdesGshT5zoakCZHqqtWwdXXQVvvw116ng3VANoXLExH/b/kN2P7ub/Lv0/dkTv4Jox11D3/bq8Pud1tYAUEZEzUpgmIiLFwsG4g7w25zXqvl+XQaMHse7QOl7u/jI7H9nJ14O+pnXV1l7bd1ISfP21PWm88UbbvnHkSHvyOGwYBHgnu8ufxES7eEGjRrbn5Isvwpo10KePi0UVcnsmwx+XQ0g1uOxvKF3f7YpERERECh+/AOjwOTR6DDb+D+bfCppBdH5q1oTRo20XipAQuy5y//6waZOrZTVqlNn+MWuo9uSTsH+/9/ZbNqQsT1z8BJsf2szP1/5MvXL1eG7Wc9R8tyY3/XIT83bNw9FsSBERyaHQhGnGmD7GmChjzGZjzDO5PN/IGDPfGHPKGPOEGzWKiIhvcRyHebvmceMvN1LjnRo8P+t56pWrx8/X/sz2R7bzz27/pHJYZa/tPzERPv0UGjaE226DkiXtZK9Vq+za4K7ORHMcmDQJmjWzZ6tdu9qz2BdegOBgFwsr5LaPgr8GQnhT6P0XhNZwuyIRERGRwssYaP0WtHgFtn8HcwdDSoLbVRVePXvatZDfeQfmzrXnAs89B3FxrpaVHqqtW2fb4L/zjm3/eP/9sGOH9/Yb4BfA1Y2vZuawmay7bx13tbmLiVET6fxlZ9p82obPl31OXKK7vxsREfEdhSJMM8b4Ax8AfYEmwFBjTJMcLzsKPAS8VcDliYiIj4lLjOOzpZ/R5tM2dP6yM5M2TuKetvew7r51zBw2k6sbX+21Vo4ACQkwYoRdaPvuu6FCBdtJZdkyH1gTDWD9eujbF6680hYzebIN1urWdbmwQm7TRzDvBqh4MfSaBcEV3a5IREREpPAzBpo9D21HwO4JMLsfJB53u6rCKzAQHn0UNm60bd5ff92mWaNHu742XcOG8N13tivlzTfDZ59BvXpw6632FMabGldszP/6/Y+9j+/lo/4fkZyazJ2/3kn1d6rz6NRH2Xhko3cLEBERn+f25bz8ag9sdhxnq+M4icAoYGDWFziOc9BxnMVAkhsFioiI+zYc3sCjUx+l+jvVuWvSXaSkpvBx/4/Z89ge3u/7Po0rNvbq/qOj7blo7drw4INQqxZMnQoLF9rcyhiv7j5/BT76KLRoAQsW2CGfq1fbYE3On5MKK56FxfdB9Sug+1QILO12VSIiIiJFS4P7odP3cHAOzLgE4ne7XVHhVqWK7UX/999QsaJtnXHJJbBokduVUb++DdK2boUHHoAxY+xSb4MHw9Kl3t13WFAY97S9h1X3rOKvW/+iT70+jFg8goYjGnLZd5cxfsN4ktVuVESkWCosYVp1YFeWr3enPSYiIsVcQnICP67+kW5fd6PxB40ZsXgEfev3Zc5tc1h5z0rubns3YUFhXq1h7167WHZEhO2S0rIlzJoFc+bA5Zf7QIiWkgKffGLPSt97D4YPtyNRH33UjkyV85dyCubdDOvegHr3wCW/QECI21WJiIiIFE11boTuk+HEdpjWEaJXu11R4XfxxbB4sU2vNm+GDh3gpptg166zf6+X1agB775rWz0+9xzMmAFt29rlnefM8e6+jTFcUusSRg0exa5Hd/Fy95dZd2gdV42+ilr/rcU/Z/2THdFe7EEpIiI+xxSGBTWNMUOAyx3HuSPt65uB9o7jPJjLa18ETjiOk2u7R2PMXcBdABUrVrxozJgxXqtbRIqnEydOEBbm3fBGYEfcDibtm8T0A9OJSY6hWnA1rqh6BZdXuZxyQeUKpIZdu0IYPbom06dXISXF0K3bIa6/ficNGpwokP3nR9klS6j78ceEbdlCdIsWbH7gAU7Ur+92WUVCQOoJmh79J2UTV7C11J3sDBvq1eRUny0i4knd9/Y47bHZ1f5woRIRKYq8fdxSMmkLLY48g79zkjXlXiK6xEVe21dx4h8fT8SPP1JzzBgcY9h13XXsGjqUlBDfGCx24oQ/EydW56efahAdHUSzZse5/vqddOp0pEBa6ac4Kcw/Mp9J+yax6Kidwde+XHuuqHoFHct19OpSAmLpnEhEvKFHjx5LHcdpe7bXFZYwrRPwouM4l6d9/SyA4ziv5/LaFzlDmJZVw4YNnaioKA9XKyLF3ezZs+nevbvbZRRJCckJ/LzuZz5Z+glzds4hwC+AqxpdxV0X3UXPOj3xMwUz4XrxYvjPf+CXXyAoCG67DZ54wseWHFu1yk6XmzbN9p184w249lofmCZXRMTthNl9IXYTdPjKjpL2Mn22iIhH/ZjL34MbfP/cUEQKhwI5bonfDX/0hZgN0PFLqHOzd/dXnOzYAc8+CyNH2naQr74Kt9wC/v5uVwZAfDx88QW89Rbs3GmXfHv8cTuhLji4YGrYEb2DL5d/yefLP2dv7F6qhlVleOvh3NHmDmqXqV0wRRRDOicSEW8wxuQrTCssbR4XA/WNMXWMMUHA9cBEl2sSEZECsv7Q+oy10G4adxN7Y/fyRq832P3obsYMGUPvyN5eD9Icx+ZSvXpB+/a2xcgzz9jzzI8+8qEgbc8e28axVSu73sHbb9sVvK+7TkGapxxbAdM72gs43acWSJAmIiIiIjmE1oBL50KlrjB/GKx51R60y4WrVQt+/BHmz4c6deD2221/xVmz3K4MgNBQu0b15s3www82QLvzTjuG8NVX4ehR79dQq0wtXurxEjse2cGE6yfQpmobXpvzGpHvRdL3h76MWz+OpJQk7xciIiIFplCEaY7jJAMPANOA9cAYx3HWGmPuMcbcA2CMqWKM2Q08BvzDGLPbGFPavapFRORCxJ6K5cvlX3LJV5fQ5MMmfLD4A3pH9mbGzTPY+OBGnu7yNJXDKnu9joQE+PJLaN7c9uZfvx7efNOOgHztNajs/RLyJyYGnn/erov2ww/w2GP27PKxx6BECberKzp2jYffu4DxtxdvqvR0uyIRERGR4isoHLpPgdo3wap/wPxbICXB7aqKjo4d4e+/YdQoOHbMjiy8/HJYvtztygC7/PMNN8CyZXawY+vW8I9/2LWsH34Ytm3zfg0BfgEMaDiASTdMYvsj2/ln13+y+sBqrh5zNRH/jeCZGc8QdVhdsUREioJCEaYBOI4z2XGcBo7j1HUc59W0xz52HOfjtPv7Hcep4ThOacdxyqTdj3G3ahEROReO4zBnxxyGTxhO1bercvvE2zkUd4j/9P4Pux/bzejBo+kV2atA2jkePAgvvWQHZd5+u+1o8vXX9oTsySehtK8M10hKgg8+gHr1bLo3aJCdifbWW1CuYNaOKxYcB9a+BnOugtJN4LKFUKa521WJiIiIiH8QdPoWmr8M27+DGT3g5H63qyo6jLFdLjZssF0vliyBNm1sirVli9vVAbbEXr1gyhTb7f6aa+DDD+0p0vXX25ILQkR4BC/1eIntj2xn4vUTaVetHW/Ne4tGHzSi85ed+WLZF8Seii2YYkRExOMKTZgmIiJF156YPbw+53UajmhI16+78tO6n7i+2fX8Pfxv1t+/nqc6P0WlkpUKpJZ16+Cuu+xoxhdftN1MZsyAFSvsMgE+M8krNdWuYdCkCTzwADRtahdz+/FH24pFPCf5JMy7EVY+D7VugN5/Qmg1t6sSERERkXTGQPN/QpexEL0KprWDo74xe6rICA62XS+2boXnnoPx4+1iZQ88AAcOuF1dhubN4Ztv7CDIxx+3AVu7dnDJJTB2LCQne7+GAL8Armx4JROHTmT3Y7t5s/ebHD15lDt+vYMqb1fh1vG38teOv3DUllREpFBRmCYiIq44lXyKsevG0v/H/kT8N4LnZj1H1VJV+Xrg1+x7fB+fD/ici2tejCmAdb4cxwZm/frZTOq77+DWW21Lx99+s6McfWa5MceBiRPtmmg33GAXDPj1V7t+QduzrpUq5yp+L8zoBjtGQsvX4OLvISDE7apEREREJDcR19hW3Bj4vTPsHOt2RUVPeLhdmGzLFrjjDvj4Y7uA9Asv2NbzPqJGjcz2/O+8Y5eWHjLElvrmmwWzrhpAlbAqPNn5Sdbdt455w+dxY/Mb+WX9L3T7uhsNRjTgtTmvsTtmd8EUIyIiF0RhmoiIFBjHcViydwkPT3mY6u9UZ8hPQ1i5fyXPdH6GjQ9s5M9b/+SWVrcQFhRWIPWcOAGffAItWsCll9pe+//+N+zaZc8JGzUqkDLyb+ZMu27BwIF2MbeRI+16BVdc4UNpXxFyZIkd1RyzDrqOh6bP6vcsIiIi4uvKtYbLF0GZljB3CKx+CZxUt6sqeqpWhY8+sq09+vWDl1+2SdU770B8vNvVZQgPh0cfhU2b7GS6unXh6aehZk249147gLIgGGPoVLMTn175Kfse38c3g76hRukaPD/reWr9txZ9f+jLqDWjOJl0smAKEhGRc6YwTUREvG7n8Z28Pud1mn7YlHaftePjpR/To04Pptw4hR2P7ODVXq9Sv3z9Aqtn0yZ7QlWjBtxzj124+quvYMcOu2B1hQoFVkr+LFhgp8f17g379sHnn9uT1uuvBz/9KfeKLV/A713ALxAunQc1BrpdkYiIiIjkV0gV6P0H1BkGq1+Ev66CxGi3qyqaGjSAMWNg0SLbPePxx21i9f77dgCgj/D3t2MSZ82ClSvtqdRXX9mu+ZdfDpMn2076BaFkUEmGtRzGH7f8weYHN/Ncl+dYe3AtQ38eSuW3KjN8wnBmb59NqkJgERGfoitwIiLiFTGnYvhq+Vf0/KYntf9bm+dmPUe5kHJ8csUn7H98Pz8N+Yk+9frg7+dfIPWkptoTpH797PneiBH2/t9/w9Kltq2jz6yHlm75chgwADp1gjVr4L33YONGuP12CAhwu7qiKSUBFt5ht0qXwOWLoWwLt6sSERERkXPlHwwdv4Y2/4W9k2FqOzi2yu2qiq527eD33+HPP6FhQ3j4YahXDz78EE6dcru6bFq0gC++sB1JXnnFnmr17w+NG8N//wvHjhVcLXXL1eXfPf/N9ke2M2vYLAY3GcxP636ixzc9qPNeHZ6b+RzrDxXQ9DkRETkjhWkiIuIxyanJTNk0hRt+voEqb1Vh+MTh7Dy+kxe7v8iWh7Ywd/hc7rroLsqGlC2wmqKj4d13bYDWv7/Np1580fbO//FHuPhiH+zct2SJDdHatIE5c+C11+yaBA89ZBf+Fu84sR2md7az0po+D92nQnBFt6sSERERkfNlDDR6GHr9ASlxML0jbPve7aqKtq5dYfZsOwWsdm24/36oXx8+/RQSE92uLpuKFeH552HbNntuWL687WBSvbodv7h0acHV4mf86FGnB18O/JIDTxzgx6t/pEnFJvzn7//Q5MMmtPusHe8vfJ+DcQcLrigREclGYZqIiFwQx3FYvGcxj017jBrv1KDfj/2Yunkqt7a6lXnD57HpwU38q9u/iCwbWaB1LV0Kd91lT4QeewyqVLFLjO3YYdfGrlq1QMvJn4ULbeLXrh3MnWsXcNu+HZ59FsIKZh25YmvvFJjaBk5sga4ToeUrUECzJkVERETEyyp1gT7LoHx7mH8zLL4PUnxrtlSR06OHHRg4fbo9Kbv7bjtj7csvISnJ7eqyCQqCoUNh3jw7+PLmm2HUKGjbFtq3h6+/hpMFuJRZaGAoQ5sPZcqNU9jz2B7euewdklOTeXjqw1R7uxpXjrySkatHEpcYV3BFiYiIwjQRETk/6w6t45+z/kmDEQ1o/3l7RiwawcU1L+aXa39h3+P7+LD/h3Sq2QlTgNO+TpyAzz6zJz1t28L338N119lgbe5c2xc/KKjAysm/efOgTx/o2NEGaq+9ZkO0f/zDrpgt3pOaAqtehNn9ITQC+iyFGle6XZWIiIiIeFpIFeg5Axo/AZs+ghndIG6n21UVbcbApZfa853Jk+3i1Lffbts/fvBBwSZU+dSqFXzyCezda5d9O3ECbrvN5oGPP27X3y5IVcKq8GinR1l+93JW37uaxzs9zvJ9y7nhlxuo9FYlhv48lIlRE0lM8a1ZfyIiRZFxHMftGlzTsGFDJyoqyu0yRKSImT17Nt27d3e7DK/YHr2dUWtGMXLNSFYdWIWf8aNnnZ4MbTaUqxpdVaDtG7NascKe8PzwA8TGQrNmduDjTTdBmTKulJQ/c+bAyy/DjBm2x8gTT8B992kWWkGJ3w3zboKDf0KdW6DdhxAQ6nZVeSrKny0i4oIfcxnsckPxPTcUEc/y+eOWXb/A/FvB+EPHL6Dm1W5XVDw4DkyZAq++agO2ypVtQnXPPVCqlNvV5cpx7DJwH34I48ZBcrLNB++8EwYOdGewZqqTypwdcxi5ZiRj143lyMkjlAkuwzWNr2Fos6F0r929wNYmL2g+/9kiIoWSMWap4zhtz/o6hWkK00TEs4rawd2BEwcYs3YMI9eMZP7u+QB0qtGJoc2GMqTpEKqEVXGlrrg423rj009h0SK7lNi119oQrVMnH1wHLV1qKvz2G7zxhj2BrFQJnnrKnkCWLOl2dcXH7gmwYDiknoK2H0LkMLcrOqui9tkiIi5TmCYiXlQojltit8DfQ+HoYqh3D7R5BwJC3K6qeEhPqF591Q4sLFsWHn4YHnwQypVzu7o87dsHn39uz0F377YT7W65xU62a9zYnZqSUpL4fevvjFwzkvEbxnMi8QRVwqpwbZNrGdp8KB2qdyjQbjHeVig+W0Sk0FGYlg8K00TEG4rCwd2huEOM2zCOn9b9xKxts0h1UmlZuSVDmw3lumbXUbtMbVfqchxYsgS++srOQouJgSZNbIB28832HMxnJSXZRdv+8x9Ytw5q1bIz0YYPh1DfnQ1V5KQkwPInYeMIKNsGOo+E0g3cripfisJni4j4EIVpIuJFhea4JSURVv0T1r8J4U2h8ygo08ztqoqXRYtsm/sJE2yHjnvvzVz02kelpNil4D7/HCZOtLPVOneGO+6AIUPcGyN5Mukkv236jZFrRvLbxt84lXKKOmXqcG3TaxnSZAhtqrYp9MFaoflsEZFCRWFaPihMExFvKKwHdwdOHOCX9b8wdv1YZm+fTaqTSv1y9bm+2fVc3+x6mlRs4lpthw7Z9c++/BLWrLGz0AYPtiFa584+PAsN7BS6zz+Ht9+GXbugeXN4+mk7jS4w0O3qipfj6+Dv6yF6NTR6DFq+Bv4l3K4q3wrrZ4uI+CiFaSLiRYXuuGXfdJg/DJKO2xlq9e7x8ZOMImj1anj9dRg9GgICYNgwG6q5NeUrnw4cgG+/tad8GzdC6dJwww02WGvTxr1/RscTjjN+w3hGrhnJzG0zSU5Npk6ZOgxuMpjBTQbTrlq7QhmsFbrPFhEpFBSm5YPCNBHxhsJ0cLcvdl9GgPbXjr9IdVJpWL4hQ5oMYUjTITSv1Ny1A+zkZNtO/6uv4Ndf7dft29uJXNdd5+NroQEcPgwjRsD//gdHj0LXrjZE69tXJ+YFzUmFjR/AiqchIAw6fQPV+rpd1TkrTJ8tIlIIKEwTES8qlMctJw/Agltg3zSofiW0/xRCfHd2VJG1eTO88449EUxIgCuusB09unb16fMox4G5c22oNmaMLb1VK7j1Vhg61Hb3d8uR+CNMiJrA2HVj+X3r7ySnJhMRHsHgxoMZ0nQI7au3x8/4uVfgOSiUny0i4vMUpuWDwjQR8QZfP7jbE7OHn9f/zNh1Y5m7cy4ODk0qNsk4kG5asamrI9TWr7fnTd99B/v325OOm2+G226Dpk1dKyv/1q2D//7X/gAJCXZV6qeftgu5ScGL22HXRjswC6r2tQvMh1R1u6rz4uufLSJSyChMExEvKrTHLU4qRL0HK56FwDBo9xFEDHG7quLp0CH46CM7QPHQIWjb1oZq11xjZ675sOho2+H/iy9g6VJbbt++dn21K66AEi42xzh28hgToyby07qfmL5lOkmpSdQoXYPBje2MtU41O/l0sFZoP1tExKcpTMsHhWki4g2+eHAXdTiK8RvGMz5qPAt2LwCgWaVmGQGamy0cwZ4bjR5tWzkuXAj+/tC/v52F1q9fIeiG6DgwbRq8+65tnh8cbBPARx6xi7pJwXMc2PoVLH0EcKDNu1D3dp8ezXo2vvjZIiKFmMI0EfGiQn/ccnw9zL8Fji6GWtdD2w+gRDm3qyqeTp60AxXfftv2UaxVCx591J4slirldnVntXYtfPONPdfdtw/KlYPrr7fBWrt27p6eRCdE82vUr4xdP5apm6eSmJJI1bCqDGw4kKsaX0X32t0J8g9yr8BcFPrPFhHxSQrT8kFhmoh4gy8c3KU6qSzZu4TxG8YzbsM4NhzeAMBFVS9iUKNBDG4ymEYVGrla48mTdrHm77+HqVNtG8cWLWwGddNNPr3edKb4eHti9957dkpd1apw//12MbcKFdyurvg6uQ8W3gV7J0GlbtDxKwir43ZVF8wXPltEpAhRmCYiXlQkjltSk2HdG7D6JQiuCO0/h+r93K6q+EpNhUmT4K23YM4cG6Tddhs88ADUr+92dWeVnAwzZ9pgbdw428SkUSO7NNzNN0ONGu7WF3Mqhl+jfmXchnFM2TyF+KR4SpcoTf/6/RnUaBB96/WlVAn3w8si8dkiIj5HYVo+KEwTEW9w6+AuMSWR2dtnM37DeCZETWBv7F78jT/da3dnUKNBDGg4gIjwiAKvK6uUFPjzTxugjR0LsbFQvTrceKPdWrRwtbz8270bPvwQPvnErofWpo0dHXnttRDkWyP3ihXHge3f29loKfHQ8g1o+CD4cJuSc6ETRxHxKIVpIuJFReq45ehymD8Mjq+ByNug9Vuapea2RYvs2tSjR0NSEvTpAw89BJdfDn6+f+x//Dj89JMN1ubOtbPTunWDG26wXSzLufzP62TSSWZum8n4DeOZGDWRQ/GHCPIPondkbwY1HMSVDa+kSpg7o1+L1GeLiPgMhWn5oDBNRLyhIA/uohOimbZ5GhM3TuS3jb9x/NRxQgND6VuvL4MaDaJf/X6UC3H3SNxxYNUq+OEH+PFH2LPHDiIcPNjOQOvWzbZ19HmpqXYo4Ycf2il1jgODBtkQrUuXQt0+sEg4sRUW3QP7f4fyHe1stHB3Z196mk4cRcSjFKaJiBcVueOWlFN2htr6N6FEeWjzHtS6TucAbtu/Hz79FD7+2PZQrF/fdgq59VYID3e7unzZssUONh05EqKi7BIHffrA0KEwYACULOlufSmpKczbNS9j2Yitx7ZiMHSq2YmBDQdyZYMraVShUYGtu17kPltExCcoTMsHhWki4g3ePLhzHIeNRzYyaeMkJm2axJwdc0hxUqgQWoEBDQYwqNEgekf2JiQwxCv7Pxfr1tmBgqNH25OC9EWXb7oJrrwSQtwvMX+OHYOvv7aLX2/aZNs33nGHbeVYu7bb1UlqMmx4F1a/ACYAWr0O9e8tMrPRstKJo4h4lMI0EfGiInvccmwlLLzTrqVWrR+0+xBK1nK7KklMhF9+sbPV5s2DsDDbP/Gee6B5c7eryxfHgeXLbag2cqQdhBoaasdvDh0Kl13mfhMUx3FYc3BNRrC2bN8yACLLRnJF/Su4osEVdK3VlRIBJbxWQ5H9bBERVylMyweFaSLiDZ4+uEtMSeSvHX/x28bfmLRpEpuPbgagReUWGQes7au3x9/P/eldmzZlBmhr1tiBmt27w3XXwdVXQ8WKbld4DpYutbPQRo60C7xdfDHcd5+dUlfCeycHcg6OLrUXM44thxoDoe0ICHV5sQEv0omjiHiUwjQR8aIifdySmgIb/wer/mG/bvEKNHgQfOB8TLDncf/7H4waBadOQadOcNddtiV/aKjb1eVLaqpdFm7kSNsO8uhR2/px8GD7Y3TrZgerum3X8V1M3jSZSZsmMWPrDBKSEwgLCuOyupfRv35/+tXv5/F2kEX6s0VEXKMwLR8UpomIN3ji4O7AiQNM2TyFSRsnMX3LdGITYynhX4Jekb24ov4V9G/Q3/X1z9Jt2wZjxtgAbfly+1iXLjZAGzwYqrjTSv38xMTYH+Szz2DxYnuyddNNcO+90KqV29VJusRoWPUv2PQBBFe2IVqNq4p8mx2dOIqIRylMExEvKhbHLXE7YPF9sHcylLvIHpNW6Oh2VZLuyBH49lu7znVUFJQpAzffbDuMNG3qdnX5lpgI06fbYG38eIiPt81SrrrKnm/36GFbQ7otPimeP7b9kdFFZ3fMbgDaVWvHFQ3sIOBWVVrhd4EdRIrFZ4uIFDiFafmgME1EvOF8Du6SUpKYv3s+UzdPZdqWaRntEqqVqpYx+6xnnZ6UDHK5YXqajRth3Dj4+WebOQG0b28DtCFDoGZNd+s7J45jW4F88YUN0uLjoUkT2xJk2LBC02u/WHBSYevXsOIZSDwC9e6Glq9BUBm3KysQOnEUEY9SmCYiXlRsjlscB3aOgWWPwcm9EHkbtHwdQiq7XZmkcxz46y8bqv38s02nLr7YhmpDhhSi9QfsqerUqXa22qRJcOKEnbE2aJD9UXr2dL8VJNh2kKsOrMoI1hbuXoiDQ6WSlbi87uX0qdeHSyMvpWLJc29dU2w+W0SkQClMyweFaSLiDfk9uNsevZ1pm6cxdctUZm6dSWxiLP7Gn4trXkyfen3oU68Prau0LrCFfM/EcWDlShug/fKLbeEI0K4dXHONbTVRp467NZ6zgwftSMUvvoANG2xf/euvh9tvhw4divwsp0LnyGJY8gAcWQQVO9uRv2VbuV1VgdKJo4h4lMI0EfGiYnfckhQLa16BqHfBPwSavwwN7gc/H+jFJ5kOH4ZvvoFPP7UjRMPD7TngrbcWunPAkydh2jQYOxYmToTYWDv5btAgO2OtVy8IDna7Sutg3MGMgcPTNk/jyMkjGAwXVbsoI1zrWKMjAfn4/6XYfbaISIFQmJYPCtNExBvyOriLT4rnz+1/Mm3LNKZunkrUEfv5ExEeQZ+6NjzrWacn4cG+MRMqNRUWLLDh2S+/2HaOfn5wySV2/bNBgyDCNzpN5l9Skj3j+Oore8aRnGxHJd5+u00Ew8LcrlBySjgIK5+HLV/Ylo6t/w9q31ioTnQ9RSeOIuJRCtNExIuK7XFLTBQsfRj2TYPwZtD2fajcw+2qJCfHgdmz7Xnh2LE2mWrUyIZqN98M1aq5XeE5SUiA33+3P8qECXD8uD217dPHnrf36wdly7pdpZWSmsKyfcsyrovM3z2fVCeV8BLh9IrsRZ+6fbi83uV5LmtRbD9bRMSrFKblg8I0EfGG9IO75NRklu5dysxtM5mxdQZ/7/qbxJREggOC6V67e8YIrIblG/rE7DOwB+GzZsGvv9qD8H37bP/1Sy+1AdqAAVDx3DsxuMtx7CLU331nG80fOmR/iGHDbIjWuLHbFUpukuNhw7uw7j+QchIaPgzN/wWBpd2uzDU6cRQRj1KYJiJeVKyPWxwH9kyEpY9A3HaofiW0egPCm7hdmeQmJsb2Tfz6a5g7144gvfxyG6wNGOA707vy6dQpe04/YYLd9u+HgADo2tUGawMH+tag2OiEaGZuncnUzVOZumVqxlprDco3oHed3vSO7E332t0pG2LTwGL92SIiXqMwLR8UpomIJzmOw4bDG/h4+sfs8N/B7O2zOX7qOAAtK7ekV51eXFb3MrrW6kpIoO/0Zd+/H377zQZov/9u+7CXLGlHsV1zjR3FViiXDdu5E374wbZy3LDBNo8fMMCONOzTxzeaycvpUlNg27ew6p9wcg/UGGQvPpRu6HZlrtOJo4h4lMI0EfEiHbcAySdh4/uw9jVIPgF174DmL0FIFbcrk7xs2mTbQH7zDezebadzDRkCN9xgW7T4+bld4TlJTbVrnI8fb4O19evt461b21Bt4EBo2dJ3mn44jsP6w+uZunkqM7fN5M/tfxKXFIef8eOiqhfRq04vKsRW4P4r7yc4oHCFnCLi2xSm5YPCNBG5UHti9jBz28yM2Wd7Y/cCULtM7YxRVD3q9KBSyUouV5opff2zSZNsgLZokX08IgKuvNJu3btDiRKulnl+jh+3PSm/+8627XAc6NLFBmhDhvhObwvJ3d5psOIpiF4F5TvYlo6VLnG7Kp+hi1Ii4lEK00TEi3TckkXCYVjzb9j0IfiXgMZPQqPHIVAt5n1WSgr88YedrTZ+PMTFQY0aMHSoDdZ8KYE6Bxs32lBt/HiYP9+eLteoYQfQ9utn11nzpZUPElMSWbRnETO2zmDG1hks3LOQ5NRkSviXoEtEF3rV6UXvyN60qdoGfz9/t8sVkUJMYVo+KEwTkXO1O2Y3f27/kz93/Mns7bPZdHQTABVCK9CzTk961+lNyYMluaHvDS5Xmt2JE7bVw9SpNkTbtcs+3r69nax15ZXQvHmhPB+wP9yvv8KoUfYHTEyEevVsgHbTTRAZ6XaFcjaH5tmZaAdmQVgktHwdIoYU0n+Q3qOLUiLiUQrTRMSLdNySi9jNsOJZ2DXWrgXc9Dmodxf4a4aNT4uLs+ebP/xgzzeTk+1SATfcYMO1unXdrvC8HDhgrw1MngzTp9vT6qAgO7C2Xz/o39+eVvuS2FOxjJg0gkNhh5ixdQarD64GILxEOJfUuoRutbrRvXZ3WlVpRYBfgMvVikhhojAtHxSmicjZ7Dq+i9nbZ2eEZ1uObQHswVrXWl3pVqsbvSJ70aJyC/yMbfngCyeOjgNr1thj/alTYc4cSEqy7Rt797bhWf/+UKWwdhiJj7dH/aNH2x6VJ09C9ep29tl110GHDgpiCoMji2HVv2DfVAiuBE2eg/r32BG7chpf+GwRkSJEYZqIeJGOW87g0HxY+RwcnA2hNaDp8xA5HPzVht7nHTkCY8faYG3OHPtY+/Zw7bUweDDUquVufecpMdEuF/fbb3ZLv1Rav769btCvn+1y6QvLx2X9bDlw4gCzts1i9vbZzN4xm41HNgJQKqhUtnCtTdU2CtdE5IwUpuWDwjQRycpxHLZHb2fOzjkZAdrWY1sBKBNchq61utK9Vne61+5Oi8ot8mwj4NaJY3S0XfMsPUDbaztO0ry5XSKsTx/o3LmQtm8EG5hNn24DtIkT7QjBSpUyA7TOnQtdD/ti69gKWPWCXZi9RHlo/BQ0uB8CSrpdmU/TRSkR8SiFaSLiRTpuyYf9s2x3hsPzoGQtaPZPqDMM/ALdrkzyY+dO2x1l5EhYscI+1q6dDdUGDy7UHVK2bLFjV3/7za6ecOoUhIRA165w2WV2a9rUnfGrZ/ps2Re7L2Mg9J87/mTD4Q0AhAWF0SWiC91qdaNbrW5cVO0ighRei0gWCtPyQWGaSPGWnJrMqgOrmLtzbsa278Q+AMoGl6Vb7W4ZI5maV2qe7x7cBXXimJgICxbAjBkwcyYsXGhbu4eHw6WX2vDs8sttD/RC6/hxewT/yy82IYyLg3Ll7MnJdddBt27gr97ohcbRpXYB9l2/QGAZaPw4NHwYAku5XVmhoItSIuJRCtNExIt03JJPjgP7ptlQ7egSCKsLTZ6BOjerW0NhsmUL/Pwz/PQTLFliH2vTJjNYq1/f3fouQFycXT7u99/t2NYNNp+iatXMYK13bzvOtSCcy2fL/hP7+WvHX3bm2vbZrD+8HoDggGDaV29P55qd6RLRhU41OlE2ROurixRnCtPyQWGaSPFyIvEEC3cvtMHZrrks2L2AE4knAIgIj8g4kOoS0YVmlZpltG08V946cUxNhdWrbXg2Ywb89ZftdujnB23b2gCtb1/b4TCgMHcwOHDAroo8bpxNCZOSbD/KQYPgqqugRw8I1GjNQsNxbAubta/D/t8hMNwGaI0ehaAybldXqOiilIh4lMI0EfEiHbecI8eBPZNg9YtwbBmEVIdGj9k11QLD3K5OzsX27TZYGzvWjn4F2y5m4EC7YPlFFxXqjio7d2YGazNmwNGj9vHWre01iV69bNOYkl5qOnIhny0HThzg711/ZwymXr5/OcmpyRgMTSs1pUvNLhnXhCLCIzBaOkKk2FCYlg8K00SKLsdx2Ba9jQW7F7Bg9wLm7ZrHiv0rSHFSMBhaVG5Bl4gudK7Zmc4RnYkIj/DYvj114ug49jh85kx7kDprFhw6ZJ9r2NCO/urd2y4QXKbMBe/OPY4DGzfa1Y/Hj4e//7aP1a1rw7OrroKOHQv1CUex5KTCnl9tiHZkoV1kvdFjdk20wNJuV1co6aKUiHiUwjQR8SIdt5wnx7ED0Na+bgekBZWDBg9Cwwdte3QpXHbutF1Wxo+3a6ylpkK1anYR84ED7UBRX1iI7DylpMCyZTZYmz4d5s2D5GQ79rV9e+jZ0/6InTp57sf05GdLXGIci/YsyhhwPX/XfGITYwGoXqo6nSM606lGJzrW6EjrKq0pEaDZoiJFlcK0fFCYJlJ0xJ6KZfHexRnh2YLdCzgUb5On0MBQ2ldvT5eaXTIOhsKDw71Wy/ke3DkObN4Mf/6Zue3aZZ+rWtUGZ7162a1Qt24E26Pyr79sgDZpkm2LAdCiBVx9tQ3Qmjd3pwm7XJjkeNj+PWz4L8Ssh5J1oMlTEHkr+BfeE0VfoItSIuJRCtNExIt03OIBh+bDutftALWAkhB5GzR4CEoX3paBxdqRI3YhsgkTMpcwCAuzazMMGAD9+kGFCm5XeUFOnLBjY2fNsq0hly61+WGJEnDxxTZY69nTLi0XdJ5LlnnzsyUlNYXVB1czd+dc/t71N3/v/JtdMfaiTJB/EK2rtKZjjY50qN6BjjU6UrtMbc1eEykiFKblg8I0kcIpJTWF9YfXs2jPoozgbM3BNTjYz7NGFRrRsUZHOlbvSMcaHWlaqSkBfgXX9zC/B3eOA1FR2cOzvXvtc5Uq2eXAunWzB5yNGxeBXOnAAXvyMGmS7QsRG2uPqnv1giuugP79IcJzMwSlgMXvgY0fwOZPIPEolG0NjR6HWtdBAf7/V5TpopSIeJTCNBHxIh23eFD0alj3f7BzFKQmQ/UroOEjULlHEThJLKYSEmzaNGECTJwI+/bZ/5bt2tm1G/r2tWs5FPL1wY8ft2No//jDbitX2usgoaF2ttoll9itY0f7WH4U9GfL3ti9LNy90F572rOAxXsWczL5JACVSlbKdu3pomoXUbqEurCIFEYK0/JBYZqI70t1Utl8dDNL9i5h8Z7FLNm3hGX7lhGfFA9A2eCy9uAlbWtXrZ3rC8fmdXCXlAQrVtiRWn//bbs8HDhgn6taNTM8697dtnEs9OdFiYm2z8P06TBtmu3/AFC9emZ41rOn95qpi/c5DhxZDFHvwc4x4KRAjUHQ6BGoeEkR+EfsW3RRSkQ8SmGaiHiRjlu84OQ+2PQxbPoITh2CMs1tqFZrKASEuF2dnK/UVHuuPHkyTJkCCxfa86wKFeystb597W0hn7UGdnLen3/aYG3OHFi1yv6oAQF2Kbn0cK1LFyhXLvf3cPuzJTk1mTUH12TrihR1JPPacsPyDWlbrS3tqrWjbbW2tKrSipJBuuYh4usUpuWDwjQR3+I4Dtujt7Nk7xIbnu1dzNJ9S4k5FQNASEAIrau2zjgoaVetHQ3KN/C5afXpB3fR0TB/fmZ4tmgRxNsMkIgIe5CYHp7Vq1cEcof0PpXTptntjz9s64qAADvs7LLLbIjWsmUR+GGLuaRY2DHSnswfWw4BpaDuHdDwAQiLdLu6IsvtE0cRKWIUpomIF+m4xYtSEmD7SIj6L0SvgqCyUOcWqHc3hDdyuzq5UEeO2AGpU6bYdpCHDmXOWrv0Urv+Q6dOtstLIRcdbcffzpljt8WL7ZhcgKZN7TWTiy+2P27duvbX4IufLUdPHmXRnkUZ17KW7F3Cntg9APgZP5pWbErbam0ztpaVW2r9NREfozAtHxSmibgnKSWJDYc3sGL/CrsdsLdHTx4FbD/qlpVbZhxstKvWjsYVGxdou8ZzkZoKGzfaQWRjx+5l27ZqrFtn8yV/f2jVCjp3ttvFFxeBNc/SHTxoQ7NZs+wB//bt9vHISDt67vLLbZ/K0mp1UCQcWwGbPrFroiWfsKNh690DdW6CQP039jZfPHEUkUJMYZqIeJGOWwqA48DBP+0At92/QGoSVOpmQ7WaV4O/LtYXellnrU2bZi84pKRASAh07WqXTOjd2w5Y9fNzu9oLlpBgByGnh2vz5tnVIQAqVrTtICtX3sqNN0bSrp1vN7nZF7sv20DxxXsXczj+MACBfoE0qdiEVlVaZWwtK7d0vcuSSHGmMC0fFKaJFIzjCcdZdWBVtuBszcE1JKbYIUfBAcE0r9SclpVbclG1i2hXrR3NKjXz6ZE6hw7Z49j0bfFiO6oKoGTJZLp0CcgIz9q3t+sKFwlHj9q+DOkrCq9dax8vVcq2bLzsMhug1a3rbp3iOYnHYMdo2PoVHFkE/sEQcZ09Sa/QUbMMC5AuSomIRylMExEv0nFLAUs4aI/XN38KJ7ZCiQpQZ5idsVa2hdvViafExNjz8Rkz7LZunX28fHkbrPXsadvfFIl1I2xuuG6d7fiTvqVfxvX3h+bN7ay1Tp3sxL0GDXw3U3Qch10xu+zyJXuXZAwo339if8ZraoXXyhawtarSilrhtXyuG5NIUaQwLR8Upol4luM47I7Zfdpss63Htma8pkJoBVpXaZ3t4KBB+QY+O+MMbKfCFSvsCKmFC+3ttm32OT8/ewDXoUPmtn//bHr16u5myZ5z9KjtUTl7tg3PVqzIXDG4Sxc766xnT2jTxrZzlKIhNRn2TYdt38DuCZB6CsKbQt07IXKYbSUjBU4XpUTEoxSmiYgX6bjFJU4q7J8Bmz+BPb/a2WplW9lQrfYNEFzJ7QrFk/butQNdZ8yA33+3XwNUrmxnrqUvzN6kie+mTOdo4sS5BAZ2yQjXFi7MnL1WqpS9NNG2beaW3h7SV+0/sZ+V+1dmu4YWdTgKB3tMFl4i/LSArUnFJgT5B7lcuUjRojAtHxSmiZy/I/FHWHtoLWsPrrW3h9ay6sCqjDaNBkO9cvVO+6NfNayqT4+qiY62edGyZZnbhg02PwKoWTN7cNamzemtBQr1iePOnbafwty59jZ95lmJEna4V8+eNkBr3x6CdPBWpDiOXf9s+4+w/QdI2A8lykOtGyDyFijbxrfPQoqBQv3ZIiK+R2GaiHiRjlt8QMJh2DHKDpA7ugRMAFTrC3Vuhmr9ISDU7QrFkxwHNm2yM9fSt9277XPly2eGa1262LaQhXQwbM7PlpQUWL8elizJ3FasgFOn7PPh4XDRRdkDttq1ffvUNi4xjjUH17Bi/wpWHliZcRufFA/YNpGNKzamWaVmNK3Y1G6VmlKnTB38/fxdrl6kcFKYlg8K00TO7tjJY6eFZmsPruVA3IGM15QKKkXTSk1pXql5xqyz5pWbExbk270NDx3KDMyWL7e3W7ZkPl+jhg3L2rSB1q1t24CqVc/+voXmxDElxYZl6Sv+zp1rwzSwQ7o6d7YH2pdcYn/4kBB36xXviF5rT7J3jobYTfYku/oVdvRqtX6gEW8+o9B8tohI4aAwTUS8SMctPub4Otj6jV37+OReCCgJ1QdCreug6uVaX60ochzbUidruJa+xnloqB0dfPHF9ry/Y0coWzi6j+TnsyUpyV7qWLIEli61tytX2scBypXLHrC1amUDNl+evJeSmsKWY1syO0HtX8HaQ2vZeXxnxmuCA4JpXKExTSs1zRay1S5TGz/jwz+ciA9QmJYPCtNEMh1POM66Q+uyBWdrDq5h34l9Ga8JCwqjScUm2f4oN63YlBqla/j0bLPUVNixA1avzgzNli3LHKQFEBmZGZylh2eVzrMDhs+eOB44AAsWZG6LF9selgBVqtjQ7JJLbIDWooVtQi5F0/ENsGusDdGOrwXjB5V6QK3roeZVdkaa+Byf/WwRkcJJYZqIeJGOW3xUagoc+ittMN1YSDwKgeH2HCDiWqjcU8FaUbZrl13GYd48u61YYQfZgm0F2bmz7UjTvj00auST1wTO97Pl1ClYsyb7DLbVqzN//LAwu4RHy5b2ckjLltCsGZQu7dn6PS32VOxp1/LWHlrL7pjMC16hgaG5XsuLCI/w6Wt5IgVJYVo+KEyT4iY5NZltx7ax8chGoo5EZbvdG7s343WhgaHZRrOkTx2vGV7T50ezHDxoD5BWr7bbmjV2RNKJE/Z5Y+xavFmDs1atPDsIyydOHE+csMnh0qW2ifiCBZmj0AICbFrYoYMdgdaxo00TdRBVdDmpcGQR7B5vt5i0v30Vu6QFaIMhpLKbFUo++MRni4gUHQrTRMSLdNxSCKQmwf6ZNljbPQ6SYiCglO1OUfMq2xIy0MeTBLkwcXF2Ufj0cG3ePLv2Bdj1LNq0sV1q0jcfuG7gyc+Wkydh1ars28qVcPx45mvq1MkM2NJDtshI357FBpkD5tccXJOty1TWAfMlA0vSoHwDGlZoSINyDTLvl29A6RL6f1+Kl/yGaYWzQa6I5MlxHA7GHcwMyw5HsfGovd1ybAvJqckZry0fUp4G5RtwWd3LaFi+YaGaAn7ihA3J0gOz9NuDBzNfU768HVl02232tlkzexvm290nz11MTGZwtnSpnXYXFZV9obeOHeHBB+1t69Zq2VgcJMfBgdl24fHdE+waaCYAKneHBg9BjQEQWsPtKkVERERExA1+gVCtj91SPob9s2yotmeibQHvFwiVe0GNgTZgKxnhdsXiaSVL2jXRe/SwX6em2msJS5bYTjaLF8MHH2QuQFa2rO2L2K5d5m316q4HbOcrJMSOMe7QIfMxx7ET+NKDtfSQbeJE++sB+2tr3tyGa02aQOPGdqtRw3d+FeHB4XSq2YlONTtlezzrUi7rD68n6kgUi/YsYszaMaQ6qRmvqxJWxYZr5Rtmu40sG0mgf2BB/zgiPkNhmkgh5DgOh+MPs+XYFrYe28qWo1uyzTSLORWT8doS/iWoX74+TSs15erGV2f7I1g+1PdbuR0+bI/lNmzIvF2zxrb+ThcaCk2bwhVXZAZmzZpB5cq+cyDjMdHR2YOzpUvtIsPpqle3zb+HDrWjyC66KH8LvUnh5zi2ZeO+abBvKhz8C1IT7XoIVftAjaugej8IKhy98EVEREREpID4B9tzher9IPVjOLLAdrTYNQ4W32tfE97Uzlar1g8qdNbaykWRn19mMnTzzfax9AXI0sO1xYvhP//J7I9YpUrmwmPpU7fq1vXJFpH5YQxERNjtiisyH4+Ph3Xrss9gGzsWjh7NfE2pUrY7ZvqvMH2LjLQNgnxB2ZCydInoQpeILtkeP5V8ii3HttgB+Vm6WI3bMI7D8YczXudv/IksG5kxm61++frULVuXyLKRRIRHKGiTIk9tHtXmUXxUYkoiO6J32LAsLTTLev9E4olsr48IjzhtxEjDCg2pWbom/n6+fRCTlGTDsayBWfr9I0cyXxcUBPXr2+As60yzOnV8a4q9R9oOJCfbkCzr1LvVq2HLlszXRETYsCw9NGvTxiaIUnwkRsP+GTY82zsVTu6xj4c3sQFa1T5Q6RJ7ciyFntoliYhHqc2jiHiRjluKCMeBmA2wdwrsmwIH/7TtIQPCoEpvO3OtSk8o3bgIjmSVPJ08adOkxYszFyCLisoM2EJD7QWbli2z90gMD7/gXfvSZ4vjwKFDsH69DdrWr8/c9uzJfF1QEDRocHrIVr++/VX5uqMnj7LxyMaMLT1o23hkIwnJCRmv8zf+RIRHEFk2ksiykRkhW2TZSOqWq0uZ4DLu/RAiZ6E2jyI+znEcDsUfygjMcoZmu2J2ZZtiHRwQnPFHqHut7tQtl/lHqU6ZOoQE+nbbvtRU2LfPZkFbtmSfbbZ5s82O0lWubEfzXHONvW3Y0N7WqlVoBzflzXFg9+7si7ytXm2PvhIT7Wv8/OyRV5s2cPvtNjhr3RoqVnS3dil4STFw6G97EnvgTzi6GJwUu5ZBlUvTArTLoWRNtysVEREREZHCzhgIb2y3xo9BUiwcmJUWrk21s9cAgitD5R5QuafdwtxfW0u8KCQkc/31dAkJNlFK7424ciX8/DN89lnma2rXzpy9lt4jsV49mzYVQsZApUp269Yt+3MxMfaaV9aQbfly+ytJzbzUR/Xq9ldQv769Tb9ft65tJ+kLyoWUo2ONjnSs0THb46lOKntj92Z0zNp6bCtbo+398RvGcyj+ULbXlw0umxGsRZaJzLymWbYONUrXIEizXaUQUJgm4iWnkk+xO2Y3O47vYOfxnew8vpMd0TvYGWNvd8XsyjaCA6ByycpElo3kklqXZPxhSQ/NqoRV8fl1zE6dgu3bMwOzrNu2bfbYKl1goD1IaNwYrroqMzBr2BDKlHHrJ/CilBTYscOmh1n7Va5Zk3112xo17HS7yy6zt82b219MsGYWFUuJx+DgXBueHfwTji0DJ9WufVa+HTR5Gqr2hQod7JoGIiIiIiIi3hJYyq6hVmOg/frENhuu7Z8FB/+AHaPs46E104K1HlCxi8K14iA42A4AbtMm8zHHgb17bbCWNWSbNCkzUfL3z7w4lHVr1KhQL3hfujS0b2+3rBISbBOi9evt7ebN9vbXX+HAgeyvrVYt76DNF341fsaPGqVrUKN0DbrW6nra87GnYjMmDGSdQLB833LGrR9HUmpSxmsNhiphVahVphYR4RHUCre3We+XCS6D0eeIuExtHtXmUc5DqpPK4fjD7InZkxGU7Ty+M1twtu/EvtO+r2pYVfuHoEwtIkpHZPxhSB+NUTLIR4ad5MFx7B/3nTttLpQzMNu1y74mXWio/SOf21arlu/0jPao48dZ+uOPXBQWln363aZNmYv2gl24t1mzzF6VzZvb/pVltZ5VseU4cGILHF4IRxbaNc+iVwEO+AVBhY5QsStU7gYVOtm10KRY8aWWJiJSBKjNo4h4kY5biiHHgZgoG64dmAUHZ8OptHUbgitB+Y72PKbixVCuLQQUgv524h0nT2bviZi+bdqUvW1RzZqnhWzzDh3i4quvLpLhbEyMvbaWHrBlvd2/P/trK1WyE/1y22rV8v32kSmpKeyO2c2WY1vsxINcrqueSjmV7XvCgsIygrVsYVuZWlQvVZ1qpapRIqCESz+RFHb5bfOoME1hmuQQnxTPnpg97Indw56YPeyN3Wvvp329J3YP+2L3ZRtBAbYNY16jJyLCI6hRuobPf6gnJtqOgzt22C09NEu/v3Nn9jwI7B/w3MKyyEjbrrEIHt/YmWRbt9ota9/KqKjsRzj+/vYXkT7lLuv0uwoViugvR/It4RAcWWyDsyOL7JaYtnqxf6gNzyp1s1uFDlr3THRRSkQ8S2GaiHiRjlsEJxWi18Dh+XB4nr2N3WSfMwFQtqUN1yp0gnLtoFRd8PFuPOJlSUk2OcoZsm3YAPHxma8LDbXTtOrWzZyylb7VqGGXyihiYmPtpaf0cG37drtt22av2aWvEpKucuW8w7aaNX2nhWReHMfhYNzBXEO29PuH4w+f9n0VQitQrVQ1qpeqbrfSmbfpj1cIraAZbnIahWn5oDCteDmReIL9J/Zz4MQBext3IDMoSwvJ9sbuJToh+rTvLRVUKtsHb9YP5JrhNYkIj6BiaEWf/jBOSrI5z5492besgdm+fdlnlgFUrWpHtURE2Nv0LSIC6tSBUqXc+Xm8KiXF/nLSw7KswdnWrXDkSPbXly9v1zRLC8rWJCXRbPBgG6QV0t7f4mEn98OxFRC90t4eWQQnttrnjB+EN4XyHaB8e3sb3gT8iuLUTbkQuiglIh6lME1EvEjHLZKrhMNwZIEN1g7Ns+dFKWkhSUApKNcayraGsm3s/dKNdV4ktiXkrl2wYQMbJ0+mgZ+fTZQ2b7bXaLImSSVK2Gsx6eFa3brZp2z5Qn9ED0tNtdf70gO2rFt62JaUfT4AZcva3DHnVrNm5n1fv94XnxSfsaROzuu76fcPxh3EIfvxbZB/UMb13YzrvKWrUyWsCpVLVqZKWBWqhFWhfGh5n19uRzwnv2Ga/iJJoXYy6SQH4g6cFpLtP7E/2/0DJw4QlxR32vf7G3+qhFWheunqNCzfkJ61e2YPzdICs1IlfPcviOPYiVJ79thW1DnDsvTtwIHTg7LAQPuHslYtu0RX1qCsVi37XAnfnkx3fhIS7IFY+nS7rFt6spj1YCwgwP5CIiNh8ODMqXd169pEMTw829sfnj3bBmtS/KQm2dYmx1ZC9Iq025WQcDDzNaERdr2zevfY8KzcRRBY9A7oRUREREREsgmuANWvsBtAajJEr7ZrQx9dBseWw+ZPIeWkfd4/GMKbQ7k2diZbeFO7lSjv3s8gBc/PL+OC1d4SJWiQNahPHwydHq5l3WbMsC0lsypfPvPiV3rAlvV+mTKFrouQn59dX61aNbj44tOfT021g+fTA7Zdu2xXqvRt2bLT12sDu+5bzpCtalW7ValibytXdm8MeWhgKI0qNKJRhbyvvyWlJLH/xP7sQVvMHvae2MuemD2sPLCSyZsm53nNuFLJSlQOywzY0sO2jNu058oGl/XpCRbiOQrTxGc4jsOJxBMcij/E4fjDHIo7lO3+4fjDHIrPfOxg3EFiTsXk+l7lQ8pnfNB1rNGRKiUzP+CyfuBVDK2Iv59/Af+k+XPypB1ZcuBA7rdZ72ed7Z6uXDmoXt1urVpl3s+6lS9fBGe/nzqVfQpeemiWNTw7ePD076ta1aaIrVrB1VfbsCw9MKtZs4gu8CbnLfkkxG6E4+shJn3bYIO01LQg1i/InuhV6w9lWtqTvzItoEQ5d2sXERERERHxBX4BdgZaudZQ93b7WGoKxEbB0eU2ZDu2HHaMgs2fZH5fcGXbzSM9XMsI2XSuVez4+9trORER0LNn9uccx6ZI6YOmt2/PvN2wAaZNO/2CWunSNlSrUSP7BbSsX5crV6gCNz+/zNI7d879NadO2QH6WUO2rKHb6tX2UltuDe7Klz89ZMvtfqlSBf9rC/QPpGZ4TWqG18zzNY7jEHMqhgNxB06bqHHgxAH2x9kJG2sPrmX/if2nLfsDEOgXSKWSlahYsiIVQytSIbQCFUMrUrFk5v0KoRUyni8XUs5nr0fLmenqsHhFUkoSxxKOcfTkUY6dTLvN8vWRk0cywrGsYVnOxSXTBfkHZfsQqlOmDhVDK2aODMgSlFUqWYlA/8AC/onPLikJDh+226FDp98eOJA9MIvJPSekfHk78qNKFejQwd7PGZJVqwYhIQX783ldcrL9xezde+bt8Ok9kylZMnPKXZs29rZmzcwDrurVi+gUPLkgqckQvwtObIHYLba/f8x6G6DFbYeMVgEGwiKhdCOoenlacNYKSjcEP9/7LBIREREREfFZfv5pQVkTqHOjfcxxIH43HF+bfdv6NSSfyPze4MpQqj6Uqpd2m7aF1VM3kOLImMwpW506nf6849hrSFmDtvT7e/bYKVsHD56eIAUH5x6yVamSuVWubLsYFZLQrUQJ23ipTp28X5OUlHndct8+u+W8HxVlb3Ou4Qb211axIlSqlP02t8cqVSq4dd2MMYQHhxMeHE6D8g3O+FrHcYhOiD69M9qJAxyIO5BxrXvrsa0cjj/M8VPHc98nhnIh5bIFbBVCK1AhtAJlg8tSLqQcZUPSbtO+LhdSjtDAUM2Ac5nCNMlTejKfVyiW8VjC6c+dSDxxxvcuXaJ0RjhWo3QNWldpfVpKn/V+WFCYz3xYOI4duHLsmN2OHs28nzUgyxmWHc/98xOwvYrTA7I2bTL/7qbfpt+vVMm2Ziwy4uPtgcmBA7nfZr1/+PDpBzB+fvYXU62anZJ/8cWZB0rpW0REoZymLwXAcSDpOMTthLhtNjA7sSUzPIvbDk5y5uv9g6FUQ9uaMfIW27+/dCMo3cA+JyIiIiIiIp5nDJSsabdqfTIfdxw7ADI9XIvZYAdB7ptmg7asgqtkBm0la6dttSCsNoRU19psxZExmWlO2zyWSkpMtElR1nVUdu/OvL9ggf06t/SoRInMC3o5L/Sl31asCBUq2AuDPt46KjAws+3jmTiOvVaaNWjbt89eGz10yF7iO3QI1q2z9xMScn+fkJDMcK18eTshMP0265b1sTJlvNtYyhhD2ZCylA0pS+OKjc/6+sSURA7HH861A1vG/fhDbDyykb93/c3Rk0dJTk3O8/0C/QJzDdqyBm6nPRdSlrLBZX1y4klhpL8URdSp5FPEnIrh+KnjHE84nnE/5lRMtq+PJxwnJjEmz9fkXKQxqyD/oMz/UYPLEhEeQasqrU5L0HP+D1wmuAwBPnCQkpCQGYLlDMVyfp3zudz+RqYLCsr8W1yhgh3VUaFC5tc5b8uXLwIdBB0HYmPtL+rIkdy3nM8dPAgn8ghdS5e2fzErV4YGDeCSS+zXOYOySpXslH6R3DipELfDhmXxO+1JVtzOzK/jdkJybPbvCSwDperanvwRgyGsrv06rG7aCZb+vYmIiIiIiPgEY6BkhN2q9c3+XHIcxG624VrGthn2TYWT+3K8jz+E1rDhWnrIFlrTPhZaE8LqQEABTZMR3xIUlLmuWl4cx17nOtP6LNu3w8KFuc90AxuklSuXeaGwQoWzbz46880Y+yOULw9Nm575tY4DcXGnB205b48etcvgHT0K0dG5/wrThYfnHbylPx4envvm6euzQf5BVCtVjWqlquXr9elLIOWc2JKz49vRBPvY3ti9rDm4hmMJx/JcCildSEAI4cHhlC5RmvAS4dnuZ7sNDs92P+tzvjTZxS2F/RJ+keA4DvFJ8ZxIPJHnFpcUd8bnc4ZgebVLzCo4IPi0/1nqlayX7X+i8ODw0wKx9FAsJCCkwP8Hchzbxzcmxs70iok5fcvt8dweO1MgBvZDtGxZu6WvP5Z+P+vj6ffLlrV/y8LCfPJv2dmlpGT+sqKj7W1u96Ojcw/Kkk7vGZyhdOnMv6Tly0P9+plhWc7bihWLYI9KcUVqMkysC1kHBZSoAKERdkRi5V6ZJ14la9vATD32RURERERECr+Aknbd6rItT38uJQHidtluJHE7st8emAXxe8h2HtnuQ6h/b8HULYWPMZkB19nSo+Rk23kpPWQ7fNheV0tvcZW+bd0KixbZ+3ldb/P3z0yMypTJ3MqWzf51bo+Hh9ug0GXG2OuoYWFnbjGZVUqKvUSZPmb/6NHct/Tntm3LnCSRmnrm9w4NtZcw8wrb0recryldOvPnKFny/Mf9G2MoVaIUpUqUIiI84py+Nzk1meiE6Ozd5LKEcBm5QZZJNXtj92Y8HpsYe9Z9+Bk/SgWVyha4lSpRirCgMLsFhmXez7GVDCqZ6+O+MOHmXBSual2QnJrMyaSTnEw+SXxSPCeT0m5z+fpMz8UnxWcEZjmDsbjEuDPOAMvKYHL9x1g1rCoNyzfMMznOmTyXCipFiQDvrhGVmGgnHsXFee42JubMmU26wMDMD7P0rUaNzA+70qXtwpd5hWPeGI3guldesWuK5RWWxZ79Q5OQEPtHN/2PdcOG2UOy3LayZYtYb0opNPyDoNN3EFzJBmahNSEg1O2qRERERERExE3+wVC6vt1yk5pkZ6/F77JrtZW7qGDrk6IrICCz7WPLXILenBzHXhTNGbZl3Y4dyxz4vnlz5kD45LzbBQI2OcoatqVfQE2/cDp8ODRpcqE/scf5+2fOMqtXL//fl5pqrysfOZJ5KTR9TsGZtl27Mu/Hx+dvXyEhNlgrVSozZEvfcnss5+MlS9otNDTzNiTkzJM3AvwCMtZdOx+pTiqxp2Lz7G6X69enjnP05FF2Ht+ZLetITDnLDJYsSviXyDN8CwkIITQwlJCAEEICM++HBobm+nVezwX5B3lsQlChiQuMMX2A9wB/4HPHcd7I8bxJe74fEA/c6jjOsjO9596Te+nzfZ8zBmVJqflIbnIR5B+U63/gUkGlqBBawaaxZ0hrz/SPqDBMp1y6NO92w7nx88v8sMh6W66cXfIq/UMkZ0CW9TM+61aiRCGdHeZN33xj/8CGh2eOQqlXL/N+1sfzuu8Do1ZEzkn6gtUiIiIiIiIi+eEXmNnFRMRNxtiUpVSp/E/dgrT1BOMzg7X0wC3rlvOx9Blx6S29LrvMJ8O08+Xnl5kbnq+kJDsXIWfgFhtrM8+8tvTv2bMn++Onzt5YLsNdd8Enn5x/7WfjZ/zsjLPgcGpS84LeKzElkbjEuHx33MutQ9+R40dyzWryOyEpK4M5axiXX4UiTDPG+AMfAJcCu4HFxpiJjuOsy/KyvkD9tK0D8FHabZ4SnUSOnjxKaGAoFUIrZP+FniHlzE8K6l/M19WpWdNOhMoZjuV1q/CrAGzcqF+yiIiIiIiIiIhIUWZM5syE6tXdrqbICAzMnBXnCUlJuQdv8fG2Q1v6bVxc/iYy+oog/yCCQoIoG1LWo+/rOA6nUk6dtTvgWb/O8fiRk0fyXUOhCNOA9sBmx3G2AhhjRgEDgaxh2kDgW8dxHGCBMaaMMaaq4zj7Tn87q3ZobRbducibdRdblSrB88+7XYVkoyBNRERERERERERExHWBgZlLD8nZGWMIDggmOCDY40GduSd/180LS5hWHdiV5evdnD7rLLfXVAfyDNNiY2N56aWXPFWjiEiGP//80+0SRKQI0meLiHjKC7ksE6NzIxHxJB23iIg36LNFRNxSWMK03KLBnA0y8/MajDF3AXcBVK1a9cIrExERERERKWQWzGx4+oNaGkZERERERCRXxnZF9G3GmE7Ai47jXJ729bMAjuO8nuU1nwCzHccZmfZ1FND9TG0eGzZs6ERFRXm1dhEpfmbPnk337t3dLkNEihh9toiIp6XPRHvhhRdcrkREihodt4iIN+izRUS8wRiz1HGctmd7nV9BFOMBi4H6xpg6xpgg4HpgYo7XTASGGasjcPxMQZqIiIiIiIiIiIiIiIjI2RSKNo+O4yQbYx4ApgH+wJeO46w1xtyT9vzHwGSgH7AZiAduc6teERERERERERERERERKRoKRZgG4DjOZGxglvWxj7Pcd4D7C7ouERERERERERERERERKboKS5tHERERERERERERERERkQKnME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkDwrTRERERERERERERERERPKgME1EREREREREREREREQkD8ZxHLdrcI0xJhaIcrsOESlyKgCH3S5CRIocfbaIiDfos0VEvEGfLSLiDfpsERFvaOg4TqmzvSigICrxYVGO47R1uwgRKVqMMUv02SIinqbPFhHxBn22iIg36LNFRLxBny0i4g3GmCX5eZ3aPIqIiIiIiIiIiIiIiIjkQWGaiIiIiIiIiIiIiIiISB6Ke5j2qdsFiEiRpM8WEfEGfbaIiDfos0VEvEGfLSLiDfpsERFvyNdni3Ecx9uFiIiIiIiIiIiIiIiIiBRKxX1mmoiIiIiIiIiIiIiIiEiein2YZoz5tzFmlTFmhTFmujGmmts1iUjhZ4z5P2PMhrTPl3HGmDJu1yQihZ8xZogxZq0xJtUY09btekSkcDPG9DHGRBljNhtjnnG7HhEp/IwxXxpjDhpj1rhdi4gUHcaYmsaYP4wx69POhx52uyYRKfyMMcHGmEXGmJVpny0vnfH1xb3NozGmtOM4MWn3HwKaOI5zj8tliUghZ4y5DJjlOE6yMeY/AI7jPO1yWSJSyBljGgOpwCfAE47jLHG5JBEppIwx/sBG4FJgN7AYGOo4zjpXCxORQs0Y0xU4AXzrOE4zt+sRkaLBGFMVqOo4zjJjTClgKTBIxy0iciGMMQYo6TjOCWNMIDAXeNhxnAW5vb7Yz0xLD9LSlASKd7ooIh7hOM50x3GS075cANRwsx4RKRocx1nvOE6U23WISJHQHtjsOM5Wx3ESgVHAQJdrEpFCznGcv4CjbtchIkWL4zj7HMdZlnY/FlgPVHe3KhEp7BzrRNqXgWlbnvlQsQ/TAIwxrxpjdgE3Av9yux4RKXKGA1PcLkJEREQki+rArixf70YXpURERMTHGWNqA62BhS6XIiJFgDHG3xizAjgI/O44Tp6fLcUiTDPGzDDGrMllGwjgOM7zjuPUBH4AHnC3WhEpLM722ZL2mueBZOzni4jIWeXns0VExANMLo+pS4eIiIj4LGNMGPAz8EiObmMiIufFcZwUx3FaYbuKtTfG5NmmOqDAqnKR4zi98/nSH4HfgBe8WI6IFBFn+2wxxtwCXAH0cor7ApUikm/ncNwiInIhdgM1s3xdA9jrUi0iIiIiZ5S2ntHPwA+O4/zidj0iUrQ4jhNtjJkN9AHW5PaaYjEz7UyMMfWzfDkA2OBWLSJSdBhj+gBPAwMcx4l3ux4RERGRHBYD9Y0xdYwxQcD1wESXaxIRERE5jTHGAF8A6x3HecftekSkaDDGVDTGlEm7HwL05gz5kCnukyWMMT8DDYFUYAdwj+M4e9ytSkQKO2PMZqAEcCTtoQWO49zjYkkiUgQYY64C/gdUBKKBFY7jXO5qUSJSaBlj+gH/BfyBLx3HedXdikSksDPGjAS6AxWAA8ALjuN84WpRIlLoGWO6AHOA1dhruADPOY4z2b2qRKSwM8a0AL7Bng/5AWMcx3k5z9cX9zBNREREREREREREREREJC/Fvs2jiIiIiIiIiIiIiIiISF4UpomIiIiIiIiIiIiIiIjkQWGaiIiIiIiIiIiIiIiISB4UpomIiIiIiIiIiIiIiIjkQWGaiIiIiIiIiIiIiIiISB4UpomIiIiIiJwnY4yTts320PvNTn9PT7yfWMaYq9J+rwnGmOpu1wNgjLk5raZoY0wlt+sREREREZG8KUwTERERERHxEmPMIGPMi2lbGbfrKY6MMcHAO2lffuo4zh4368niR2AjEA687nItIiIiIiJyBgrTREREREREvGcQ8ELaVsbVSoqv+4DaQALwhrulZHIcJwV4Je3LW40xjd2sR0RERERE8qYwTURERERE5Dw5jmPStu4eer/u6e/pifcr7owxIcAzaV9+7TjOXjfrycWPwA7sufkLLtciIiIiIiJ5UJgmIiIiIiIiRdUwoGLa/W/dLCQ3abPTfkj7crAxJsLNekREREREJHcK00RERERERKSoujftdovjOPNdrSRv36fd+gN3uVmIiIiIiIjkTmGaiIiIiIh4nTGmuzHGSdteTHusuTHmU2PMFmPMSWPMIWPMDGPM0HN435rGmDeMMcuMMUeNMaeMMXuMMb8aY241xvjn4z3qG2PeNsYsNcZEG2OSjDFHjDFRxpjpxpinjDFN8/je9J9pdo7HvzbGOMAtWR7eluX16dvXOb5vdvpz+ai7Q9rvL8oYE2uMiUv7XX5jjOmZj+/PVrsxJtQY84QxZokx5lja+601xrxujCl7tvc7y77+mWV/E8/y2muyvHa1MSb4PPfZHGiZ9uWPZ3nti1n22T3tsV7GmJ+NMbuMMQlpv9tPjTG1cnxvsDHmbmPMvLR/w/FpdT9jjClxtjodx1kPrEj78kZjjFp8ioiIiIj4mAC3CxARERERkeLHGHMz8BmQNWwIBnoBvYwxNwKDHcdJOMN73A28C4TkeKpa2nYF8JgxZoDjONvzeI87gA+AoBxPlUvbGgCXAjcArfLzs3mbMSYA+BC4M5enI9O2YcaYn4BbHMc5mY/3jAR+BZrkeKpJ2jbUGNM9r99jPrwK9Aa6AlcaY+5zHOfDXOqogf13AZAADD3Tv4GzGJTl/h/n8o3GmDeAp3M8nP67HWyM6eU4znJjTBXs761tjtc2A14H+hljLs/Hf4M/sP++amMDwBXnUq+IiIiIiHiXwjQRERERESlo7YDn0u5/CfwFpKQ9fjtQEuiPbX83OLc3SAvSPs7y0K/Ab0A0NgC7DagDNAfmGmNaO45zKMd7tAY+wXbsSAZ+TqvlIBAIVAVaA5edx8/4PjAeeAjokfbY3WnvndXO83jvb4H02XsJwDfAPOzvsC32d1gKGAKEG2P6OI5zpplupbG/u0bARGAKcBQbHN0LRAC10vbb9TzqxXGcVGPMTcBKoCzwljHmT8dx1qa/xhjjh/1vnj4L7knHcdacz/7SXJp2mwosOYfvux/7724b8BWwESgD3Ax0TqtvrDGmGfb31gaYDEwCjmB/jw8B5YFLgOeBf5xlnwuy3L8chWkiIiIiIj7FnPmcSkRERERE5MKltc7LOjsoFrjMcZwFOV5XH5iNnVkGdnbazzleUxtYh52RlgLc4DjOmByvCQF+woZyAGMdxxmS4zUjsMEJwHU53yPL6/yBDo7jzMvlufQTqj8dx+mey/Nfk9nqsc7ZZnaltVzsBuA4zmnt/owx1wGj0r48APR0HGddjtfUwv6u66Q99IDjOB+coXaAROAax3Em5XhNeWBxlvfq4DjOojP9DGdijBmM/e8CsApo7zjOqbTnnsPOYAOY5DjOlRewH38gBggF1jqO0+wsr38ReCHLQ5OAIVlnxaWFfb8BfdIeWooNW292HCdbG0ljTANsIBaCDXirpP+ceey/FrA97ctxjuNcfcYfUERERERECpTWTBMRERERETc8mTNIA3AcZxN2ZlW6J3L53ofIbO34dm4hWFpbvRuAfWkPXZMWcGRVL+32OJkBz2kcx0nJLUhzSdbWg7flDNIAHMfZAVwPpIdlT+Zj7bhXcgZpae91BHgty0OXn2O9Od9vLHY2IkAL4E0AY0x74KW0x/cDwy9kP9hZdaFp96PO8XsPAjflbC/pOE4q8HKWhy4CPskZpKW9diN2lh3YWW3tz7TDtP9m6a0gW5xjvSIiIiIi4mUK00REREREpKAdw7bPy5XjOFOxM88AOqatS5VV+qydZODtM7xPDHZtMQBD9jW0AOLTbkthWxn6tLQZea3TvlztOM6UvF6bNntsVtqXtbDBT15SgBFneH5Wlvs511Q7Hw9hWycCPGiMuRb4EbsMgYNd5+1QXt+cT7Wy3D96jt/7neM4x/N4bjGQlOXr02b8ZTE3y/38/N6Opd3WNMacNitRRERERETcozBNREREREQK2hzHcRLP8pqsAU679DvGmEpkBiUrHcfJuQZZTtOz3O+Q47nf0279gD+MMXcYYyqc5f3clHV20/Q8X5X7a3L+7FltdBzn2Bme35Plftk8X5VPjuPEYdd8S8SGnKOBumlPv+M4Tn5+trMpl+X+uYZpC/N6wnGcZOy6aABxZIa+uTmQ5X5+fm/p7xuEXTdQRERERER8hMI0EREREREpaJvP8TXVstyvmuX+Rs4u62uq5njuC+z6bGDXBPsMOGiMWW2M+cQYM9QYE56PfRQUT/7sWR0+05vkWOsrOB/7PSvHcZYB/8jx8HLgOU+8P1Aiy/3Yc/zeI2d5Pv33cdQ58yLk5/p7i8lyPyTPV4mIiIiISIFTmCYiIiIiIgUt/uwvIS7L/bAs90vl8Zq8nMjje0mbHXc58CSwPe1hAzQD7sK2HjxgjPnAGFM6H/vyNo/97Dmknl85FyznWmYT8jFjMb+yBlnn+t8uv78PT//esga3J/N8lYiIiIiIFDiFaSIiIiIiUtBC8/GarG3usoZCsXm8Ji9Zg7jTZig5jpPoOM5bjuPUAZpiQ7RvgN1pLykB3Af8ZYxxe7aQR392N6Wtg/d5joefM8a08tAusrZ2LJfnq3xLep2J5C8sFRERERGRAqIwTUREREREClq9c3zN3iz392W5Xz8f75P1NXvzfBXgOM46x3E+cxznVsdxagI9yZyx1hK4PR/78yav/ewFyRhjsIFlxbSHfkm7DQJ+9FBouT3L/cIWpu08S/tIEREREREpYArTRERERESkoHUxxgSd5TU9stxfnH7HcZyDwI60L1sZYypyZpdlub8o/yWC4zh/AA9keajLuXx/mqytAM15fH9WWeu/NB+vP++f3cseI7O2acBg4NO0rxsD73pgH9vInN3V0APv51XGmNpkrqu2ysVSREREREQkFwrTRERERESkoJUDbsnrSWPMZdiWiwDzHcfZn+MlP6fdBgCPnOF9SmFbNAI4wLjzqHV7lvsB5/H9WVtU5qc1Y54cx9kOLEv7smXa7ylXxpi22Jl1YMPHpReyb09Ja+P4WtqXh4Bb02ZhPQpsSHv8bmPMwAvZj+M4KWT+zI18ZM27M+mQ5f5C16oQEREREZFcKUwTERERERE3vGWMaZfzQWNMXeDLLA+9ncv3/g84mXb/KWPMNbm8TzDwPVAt7aGfHcfZlOM1bxtjOp6lznuz3F95ltfmZluW+23O4/tz+k+W+18bYxrlfIExJgIYReb53v+lhUuuMsaEAiOx7RwBhqcHpY7jxANDseuFAXxhjKl2+ruck9/Tbv2Athf4Xt6WNUyb5loVIiIiIiKSq/MZWSkiIiIiInIhJmPbFP5tjPkGmAOkAO2w65KFpb3uF8dxfs75zY7jbDfGPAp8jD2nGWuMmZD2vtHYtcKGA5Fp37IHuD+XOq4BHjPGbANmYNvrHQRKADWBIUCrtNceIbMV4bmYmeX+m2ltKaOA5PTaHMdZnd83cxxnjDFmEDZ4qgosM8Z8DczH/g7bYn+H6TOxpgMfnkfd3vAukB7+feA4zqSsTzqOs8IY8xzwFlAe+MYYc9kFrB82Dvh32v3uwKz/b+/eQeyqojAA/xubsbNS0EYRlHRip5WgYCEiEQST6KiQ8dEqFoKIKQQrW18JKIxIIIWVrdYKEsRgI0pAEUUEq0SNLou9x8fknkmcceYM1++Dw2XDZt3FueV/197brLMXNo41/aqqthPaAgAAu0iYBgAA7LWP0yeUjic5Op7N3k9yZKpAVb3eWmvpAc1KkvvGs9lnSe4dd61ttnGf2Q1J1rbo92yS+6vquy32TPX5aWvt3fTw65r0oOjv3k7y6L8su5p+H9jRJFemT889tWDfqSSrOwij/jOttYNJHh/LM0mendj6SpK708PWu5I8k4vf2WWpqjOttdPpgejhJC9sp85ua60dyF+h7TsztgIAAExwzCMAALDnqmo9fRLteJIvk5xP8mP69NCRqrqnqs5fosZrSW5KP/rwdPpU2i9Jvk0P4x5Lcsu4a2yRW5McTD828qMkPyT5NcnPSb4eNZ5McqCqPpmocTkeTg+7PhzfcWHL3ZdQVReqai3JbUlOJPkiPVw7l36s5HqSO6vqgao6N11pb7TWrkv/nZP+bg9P9TWCv0fS31OSvNRa28nxmBtTeTe21m7fQZ3d9ND4/C3Jm3M2AgAALNb2wZ8UAQCAJddauyPJB2N5rKpenK0Z/jfG3Xlnk1yd5I2qemLmlv6htXZFehh6fZKTVfXgvB0BAACLmEwDAABgKY3pxpfHcrW1du2c/SxwKD1I+z3JsXlbAQAApgjTAAAAWGavph9/uZLkuZl7+dOYSnt+LN+qqs/n7AcAAJgmTAMAAGBpjem0p8dybdzhth8cSnJzkp+yj0I+AADgYsI0AAAAllpVvVdVrapWquqbuftJkqpaHz1dVVXfz90PAAAwTZgGAAAAAAAAE1pVzd0DAAAAAAAA7Esm0wAAAAAAAGCCMA0AAAAAAAAmCNMAAAAAAABggjANAAAAAAAAJgjTAAAAAAAAYIIwDQAAAAAAACb8ASrWhXN9W/CBAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = make_figure(xlims=(-3, 3))\n", + "\n", + "add_gaussian_bel(ax, 0.0, 1.0, 'green')\n", + "add_gaussian_bel(ax, 0.0, 0.8, 'blue')\n", + "add_gaussian_bel(ax, 0.0, 0.6, 'red')\n", + "add_gaussian_bel(ax, 0.0, 0.3, 'orange')\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "markdown", + "id": "eabdd1cd", + "metadata": {}, + "source": [ + "As we see in the above figure, the less the variance is the more the mean probability is $p(\\mu)$ which makes totally sense, as the more certain we are in our estimate or measurement, the more confidence or probability of occurance we give to the mean value." + ] + }, + { + "cell_type": "markdown", + "id": "87e7b68f", + "metadata": {}, + "source": [ + "## Example" + ] + }, + { + "cell_type": "markdown", + "id": "f12b4e45", + "metadata": {}, + "source": [ + "Lets think of an example of having a robot moving in 1-D space.\n", + "\n", + "The model to predict the robot next position based on the current position and speed is:\n", + "\n", + "$$\n", + "x_{t} = x_{t-1} + v_{t-1} \\Delta{T}\n", + "$$\n", + "\n", + "$$\n", + "v_{t} = v_{t-1}\n", + "$$\n", + "\n", + "this is known as constant velocity model, since the velocity state is always assumed to be constant and equal to velocity at previous time.\n", + "\n", + "where; $x$ and $v$ are position and velocity, respectively. $\\Delta{T}$ is the sampling time." + ] + }, + { + "cell_type": "markdown", + "id": "eaa7c42d", + "metadata": {}, + "source": [ + "Lets assume that {$x_{t-1}=2m$}, {$v_{t-1}=2 \\frac{m}{s}$} and {$\\Delta T=1s$}.\n", + "\n", + "Then the result is:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "x_{t1} &= x_{t0} + v_{t0} \\\\\n", + " &= 2 + 2 \\\\\n", + " &= 4 m\n", + "\\end{align}\n", + "$$\n", + "\n", + "In this example we predicted the new position but we didn't consider any uncertainty in our belief. Hence, the positions are absolute and exact values without any errors." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "8f7c18e3", + "metadata": {}, + "outputs": [], + "source": [ + "inf = 100000.\n", + "\n", + "x0 = 2 # initial position\n", + "v0 = 2 # initial velocity" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "eb55d243", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = make_figure(xlims=(0, 6))\n", + "add_absolute_position(ax, x0, 1, 'green')\n", + "update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "463301d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x0 = 2 # initial position\n", + "v0 = 2 # initial velocity\n", + "\n", + "x1 = x0 + v0 # position at t1\n", + "\n", + "fig, ax = make_figure(xlims=(0, 6))\n", + "\n", + "add_absolute_position(ax, x0, 1, 'green')\n", + "add_absolute_position(ax, x1, 1, 'red')\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "markdown", + "id": "887afeb3", + "metadata": {}, + "source": [ + "In order to respect and consider the uncertainty in our system model, we represent the position state as normal distribution.\n", + "\n", + "Additionally, we also propagate the error uncertainty to the gaussian state.\n", + "\n", + "$$\n", + "x_{t1} = x_{t0} + v_{t0}\n", + "$$\n", + "\n", + "$$\n", + "\\sigma^2_{t1} = \\sigma^2_{t0} + q\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "b5dfdeb5", + "metadata": {}, + "outputs": [], + "source": [ + "noise_var = 0.1\n", + "var0 = 0.1\n", + "\n", + "x1 = x0 + v0 # position at t1\n", + "var1 = var0 + noise_var # position at t1" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "be02036f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = make_figure(xlims=(0, 6))\n", + "\n", + "add_gaussian_bel(ax, x0, var0, 'green')\n", + "add_gaussian_bel(ax, x1, var1, 'red')\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "037f2401", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABtYAAAJgCAYAAAAeWlcsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdeVzVVf7H8deXXRBQQURMRUpzF3cztzHT1NLKzJXUcsoyM7Ppp5OVOqk507ikjpNtmruOlZlLLgmapqWiuOUWuKSCO6sgl/v7g+EOJJtw4Qv6fj4ePvre+z3fc96XL13xfjjnGFarFRERERERERERERERERHJnYPZAURERERERERERERERERKAxXWRERERERERERERERERPJBhTURERERERERERERERGRfFBhTURERERERERERERERCQfVFgTERERERERERERERERyQcV1kRERERERERERERERETywcnsAGZyd3e31q1b1+wYIiKlSkJCAh4eHmbHEBEpVfTeKSJy5/TeKSJyZ/S+KSJy5/bu3XvZarVWvJNr7unCWrly5dizZ4/ZMURESpXQ0FA6dOhgdgwRkVJF750iIndO750iIndG75siInfOMIzTd3qNloIUERERERERERERERERyQcV1kRERERERERERERERETyQYU1ERERERERERERERERkXxQYU1EREREREREREREREQkH1RYExEREREREREREREREckHFdZERERERERERERERERE8kGFNREREREREREREREREZF8UGFNREREREREREREREREJB9UWBMRERERERERERERERHJBxXWRERERERERERERERERPJBhTURERERERERERERERGRfFBhTURERERERERERERERCQfVFgTERERERERERERERERyQcnswOIiIiIiIiIiIiI3MssFguxsbHExcWRlJREWlraHffh7e3N0aNHiyCdiEjJ4eDgQJkyZfD09MTLywtHR8diz6DCmoiIiIiIiIiIiIhJUlJSOH36NO7u7pQrV44qVarg4OCAYRh31E9cXByenp5FlFJExHxWq5W0tDQSEhKIi4vj8uXLVK9eHRcXl2LNocKaiIiIiIiIiIiIiAksFgunT5/G19eX8uXLmx1HRKREMwwDR0dHvLy88PLy4tq1a5w+fZqgoKBinbmmPdZERERERERERERETBAbG4u7u7uKaiIiBVC+fHnc3d2JjY0t1nFVWBMRERERERERERExgZZvFBEpHE9PT+Li4op1TBXWREREREREREREREyQlJSEh4eH2TFEREotDw8PkpKSinVMFdZERERERERERERETJCWloaDgz6iFREpKAcHB9LS0op3zGIdTURERERERERERERsDMMwO4KISKllxnuoCmsiIiIiIiIiIiIiIiIi+eBkdgARESnZbllu8c2v37Dm+BqOXznO5euXaXGlBU/Vfoonaz+Js6Oz2RFFREREREREREREioUKayIikqNtp7fx4poXOXblGB7OHvh5+JGSlsK3x75l6aGlPOjzIJ888Qltq7c1O6qIiIiIiIiIiIhIkdNSkCIikq2Zu2bypwV/IjUtla/7fE3CrQQir0fye9LvJNxKACA1LZUOCzowc9dMc8OKiIiIiIiIiIiIFAMV1kRE5DaTt0/m9e9fp8eDPQh/KZwnaz+Zbbvwl8Lp8WAPXv/+daZsn1K8IUVERERERERERESKmQprIiKSxYL9C3j7h7cZ0GAAK3uvxNPVM8e2nq6erOy9kgENBvDXH/7Kgv0LijGpiIiIiIiIiMi958yZM3z88ccMGDCA+vXr4+XlhYuLCxUrVqRNmza8++67nDlzxuyYkofTp08zZswYGjRogLe3N2XLlqV27dqMGDGCw4cP23WsqKgoVq1axdixY+ncuTM+Pj4YhoFhGHTo0MGuY90LtMeaiIjYHLl0hJfXvkzHGh35oucXODnk/deEk4MTX/T8govxF3npu5doUKkBTSo3KYa0IiIiIiIiIiL3lieffJJvv/0Wq9V627nLly9z+fJlduzYwd///nfef/993nzzTRNSSl4WL17MsGHDiI+Pz/L8sWPHOHbsGPPmzeODDz5g1KhRhR5r1qxZvPbaa4XuR/5HhTUREQHgZupN+q/qT1mXsix+ejHOjs75vtbZ0Zllzyyj8ceN6b+qP/uH7cfNya0I04qIiIiIiIiI3HsOHTpkK6o1b96cP/3pT9SqVQsvLy/OnTvHqlWr2LFjB8nJyfzlL38hOTmZt99+2+TUktnatWsZNGgQFosFwzB45pln6NKlC87OzoSFhbFw4UJSUlJ444038PT0ZOjQoYUaz2KxZHlcpkwZatasSURERKH6vZepsCYiIgC8veVtDkQfYG3/tfiX9b/j633dffmsx2d0WdSFydsnM/FPE4sgpYiIiIiIiIjIvcvNzY3hw4czYsQIHnzwwdvOjxo1ihkzZthmOo0fP57evXtTq1at4o4q2UhMTOTFF1+0Fbu++OILBg0aZDv/3HPP0bdvX7p160ZqaiqjRo3iiSeeoFKlSgUeMzAwkOHDh9O0aVOaNm1K3bp1OXfuHDVq1Cj067lXaY81ERHhUMwhZuyewbCmw+hWs1uB++l8f2cGNhzIBz9+wKGYQ3ZMKCIiIiIiIiIi27dvZ/bs2dkW1TK8/vrr9OrVC4DU1FQWL15cXPEkD5988gnnz58HoHfv3lmKahkeffRRW2E0Pj6eDz/8sFBjPvnkk8yePZshQ4bQsGFDnJw036qwVFgTEbnHWa1WRn0/Cm9Xb97v+H6h+5veZTrebt4M+25Ytut9i4iIiIiIiIiUFGFhYTg6OmIYBtWqVeP69es5to2MjMTb2xvDMPDw8ODYsWPFF/S/ypcvn692vXv3th0fPHiwqOJw5coVXFxcMAyDpk2b5uuab7/9FsMwMAyD0aNH33b+119/5R//+Ac9evQgKCgId3d3XF1dqVy5Mo899hj/+te/uHnzZq5jhIaG2sYYP348kL5/2euvv06dOnXw8vLCMAzmz59/py+5UJYvX247HjlyZI7tRowYgWEYAKxYsaLIc8mdUWFNROQe993x79j822bGdxiPj7tPofvzdfdlUsdJ7Di7g7Un1tohoYiIiIiIiIhI0Wjfvj1jxowB4OzZs7z44ovZtktNTaV///7ExsYCMHPmzFxnjZnN09PTdpyUlFRk4/j4+NC1a1cA9u3bx9GjR/O8ZtGiRbbjkJCQLOe+/PJL6tSpw1tvvcWaNWuIjIwkKSmJlJQULl68yPfff8/w4cOpX79+vsbK3G/jxo2ZOXMmv/76K3Fxcfm+1l5iY2PZtWsXAN7e3jz00EM5tq1atSp169YF4MyZMxw5cqRYMkr+qLAmInIPs6RZeHPTm9T2rc3LzV62W79Dgodwf/n7GffDONKsaXbrV0RERERERETE3iZMmEDLli0BWLlyJZ9//nm2bTKKIr169WLo0KHFmvFOHTr0vy06qlevXqRjZS6OZS6aZSc2NpY1a9YAUL9+fYKDg7OcT0xMxDAMmjVrxhtvvMHHH3/MihUr+PTTT3nnnXdse8WdOnWKrl275jrDMMOOHTt44YUXSEtL44UXXuDzzz9nyZIlvPfee/j7+9/Ziy2EI0eO2FZ3Cg4OxsEh9/JMs2bNbMeZ76eYT4tpiojcw/5z5D8cv3Kc//T+D86Oznbr19nRmfEdxhPydQj/OfIfnq33rN36FhERERERERGxJycnJ5YsWUJwcDBxcXG89tprtG3blpo1awLw448/MmXKFCB9JtEnn3ySbT+JiYls3LjRLpmqVatGkyZNCnRtamoqX3zxhe1x9+7d7ZIpJ0888QTe3t7cuHGDxYsX8/7779uWMfyj//znP7ZlHAcOHHjb+bZt23Lq1Clq1KiR7fXjx49n2rRp/OUvf+H06dPMnDmT9957L9d8mzdvxt/fny1btthmgWXnzJkz7Nu3L9e+8qtJkyZUq1Yty3PHjx+3HQcGBubZR+aCaOZrxXwqrImI3KOsViuTf5xMbd/aPFXnKbv3369+P6b8OIV3t75Lrzq9cHRwtPsYIiIiIiIiIiL2EBQUxJw5c3juuedISEigf//+7Ny5k4SEBAYMGIDFYsHBwYGFCxfmuM9ZTEwMTz1ln89YBg0aVOD9vz788EN+/fVXABo0aFDkhTVXV1d69+7Np59+yunTp/nxxx9p27Zttm0zZrQ5ODgwYMCA287Xq1cv17EcHBx48803WbNmDdu2bWPhwoV5FtYAPv7441yLagA//PADQ4YMybOv/Pjiiy8YPHhwlucyz67z9fXNsw8fn/9t2ZKfmXlSfLQUpIjIPWrdiXVEREcwts1YHAz7/3Xg6ODIu+3e5diVY9prTURERERERERKvJCQEFuxZ8+ePbzzzju89NJLnDlzBoCxY8fSvn17MyPmaevWrbzzzjtA+ky8jz/+OM8lB+0hP8tB/v7774SFhQHQoUMH7rvvvgKP17p1ayB9ScjLly/n2rZ69eo88cQTBR7LXuLj423Hbm5uebYvU6aM7diMPeEkZ5qxJiJyD8qYrVbduzr96vcrsnF61e1F1U1Vmb5rOj0e7FFk44iIiIiIiIjc7V7f8Dr7L+7P8bzFYsHR8e5aLSbYP5gZj80o1jH/9a9/sXPnTiIjI5k6dart+ZYtWzJ+/Phcrw0MDLTtoWWGX3/9ld69e5OamgrA5MmTeeihh4pl7LZt21K9enVOnz7NypUrmTVrFi4uLlnaLF68mLS0NCD7ZSAz27x5M8uWLeOXX37hzJkzxMXFYbFYsm37+++/5zoDrE2bNjkuTZnZ4MGDb5tlVlTyk0dKLs1YExG5B/1y/hd2nt3J6IdG23VvtT9ycnBiRIsRhEaF5vrDv4iIiIiIiIhISeDl5cWSJUtwcvrfnBRPT8/bnitpIiMjefTRR7ly5QoAr7/+On/5y1+KbXzDMGyz/a5du8batbevXpQxk61MmTL06tUr235u3LhBly5dePTRR/nss8+IiIjg+vXrORbVAGJjY3PNVqVKlfy+jCJVtmxZ23FSUlKe7TO38fT0LJJMUjAl951ARESKzNw9c/Fw9mBQ8KAiH+vPTf/MhLAJzNg1g/lPzi/y8URERERERETuRnnN3IqLi9OH73ZSpUoVPDw8uHHjBgBNmzYlKCjI5FQ5O3v2LB07duTcuXMADBs2jOnTpxd7jpCQECZPngykF9Ey7zd38OBBDh48CEDPnj3x8vLKto9nnnmGzZs3A+nFpCeeeILg4GAqV66Mu7u7bVnLZcuWsXz5coBci26QdUlFM5UrV852nFEAzU3mNpmvFfOpsCYico+5mnSVZYeWMajRILxcs/8hxp7KuZVjSPAQPt77MX9/9O/4efgV+ZgiIiIiIiIiIgWRlpZGSEiIragGEBoayty5c3n55ZdzvTYxMZGNGzfaJUe1atVo0qRJnu3Onz9Px44diYqKAuD555/nX//6l10y3KnatWvTrFkz9uzZw9q1a7l+/bqtILRw4UJbu8z7sWW2bds2W1GtUaNGbNq0iYoVK2bbdseOHfYND5w5c4Z9+/bZpa8mTZpQrVq1LM/VqlXLdpxxv3Jz+vTpbK8V86mwJiJyj1mwfwE3U2/ycrPcfxi0p5ebv8zsX2azKGIRbzz0RrGNKyIiIiIiIiJyJ6ZMmUJYWBgAjzzyCHv27OHGjRuMHj2a9u3bU7du3RyvjYmJyTJLqzAGDRrE/Pnzc21z8eJFOnbsyMmTJwEYMGAAn3zyian7dw0cOJA9e/aQnJzMypUr+fOf/0xaWhpLly4FoGLFinTu3DnbazOKagCTJk3KsagGWYtO9vLDDz8wZMgQu/T1xRdf3LZfW926dXFwcCAtLY3w8HDS0tJsM/Cys2fPHttx/fr17ZJL7EN7rImI3EOsViv/3vtvHrrvIRr5Nyq2cetWrEur+1rxWfhnpm7iKyIiIiIiIiKSk927dzN+/HgAAgICWL58OXPnzgXS97vq378/ycnJJib8n0uXLvHII49w7NgxAPr06cOCBQtyLdQUh379+tn2osvYUy00NNS2TGXm838UHR1tO77//vtzHCMlJYXQ0FA7JS4+Xl5etGrVCkjfS27Xrl05tj179ixHjhwB0mcv5lbQleJXKgprhmF8bhhGjGEYh3I4P8AwjIj//tlpGEbxfVosIlKKbD+zneNXjjOs2bBiH/v54Oc5cukIP//+c7GPLSIiIiIiIiKSm7i4OAYMGEBqaiqGYbBgwQJ8fHzo16+fbenCAwcOMGbMmBz7CAwMxGq12uVPbrPVrl69SqdOnWyFl6effppFixbh6Oho169JQfj5+dlmpG3fvp0zZ87YCmyQ8zKQAO7u7rbjU6dO5dhu7ty5XLp0yQ5psxo8eLDd7t8fZ6tl6NOnj+145syZOWaZNWuW7ZfTn332Wbu+Tim8UlFYA+YDj+VyPhJob7VaGwJ/A+YVRygRkdJm4YGFeDh70KtOr2Ifu0/9Prg7u/N5+OfFPraIiIiIiIiISG6GDx9uK+aMHj2aTp062c7NmTOHoKAgIL0Y8v3335uSEdJnOnXu3JmIiAgAevTowbJly3KcBWaGgQMHAukrJ3322WesWrUKgAcffJBmzZrleF3z5s1txxMnTsx2duCaNWtyLW6WdEOHDiUgIACAFStWsGDBgtvabN68menTpwNQtmxZ3nzzzWz7ioqKwjAM2x8pPiXn/7ZcWK3WbYZhBOZyfmemh7uA+4o8lIhIKXMz9SYrj6zk6TpP4+HiUezje7l60btub5YeWsq0LtNMySAiIiIiIiIi8kdLly5l4cKFADRu3JhJkyZlOe/p6cmSJUto06YNqampDB48mIiIiFz3ACsqXbt2Ze/evUD6cpUDBgxg7dq1uV7j7u6e475mgwcPthV33nvvPdtSmIXx5JNP4unpSVxcHB988AEpKSlA7rPVAJ566imqVKnC77//zs8//0zdunV54YUXCAoK4vr166xbt441a9bg7u7O008/zVdffVXorMXN3d2defPm0bNnTywWC0OGDGHt2rV07doVJycnwsLC+PLLL0lNTQVg+vTpVKpUqdDjjhs3LsvjGzdu2I4jIyNvO9+kSROefvrpQo97tyoVhbU79AKw3uwQIiIlzXfHv+NG8g1CGub+Q0xRGhI8hAUHFvDtsW/p16CfaTlERERERERERCB91s/LL78MpBc9lixZgouLy23tWrZsyfjx4xk3bhwXL15kyJAhfPfdd8Udl59++sl2fP78+SxLC+akevXqREVFFWGqrMqUKUOvXr2YP3++rahmGAYDBgzI87r//Oc/dOvWjWvXrvHbb7/x9ttvZ2lTrlw5Fi9ezM8//1wqC2sA3bt3Z8GCBQwbNoz4+HhWrlzJypUrs7RxdnZm6tSpDB061C5j/rFYnNmZM2duOz9o0CAV1nJxVxXWDMP4E+mFtTa5tHkReBGgcuXKpXKTQxGRgph+aDo+Lj44nHEg9GyoXfq80/fQNGsavi6+zAmbQ+Urle2SQUSkNIiPj9fPnSIid0jvnSJyL/D29iYuLs4ufVksFrv1da+wWCz069fPNntn8uTJVKlSJcev46uvvsr69evZsWMHa9eu5cMPP+Sll14qzsgFYrVac3xNsbGxtuOMWWb2kFFYy/DQQw/h4+OTZ//16tVjx44dzJgxg02bNvH7779TpkwZqlSpQpcuXRg6dChVq1Zl+/bttmsSExNv6zcxMdF2nJycXOL+3+jRowfBwcF8+umnfP/995w7d460tDQqV67Mn/70J4YOHUqdOnVyzR0fH5/lsT1f461bt0rc1yw3N2/eLNafG42MDfBKuv8uBfmd1Wqtn8P5hsDXQFer1Xo8P30GBARYz58/b7+QIiIl1OXEy1T+Z2VGthzJh50/LFAfxoTb12q2vnfnf4eM2jCKf+35F9FvRlPOrVyBsoiIlDahoaF06NDB7BgiIqWK3jtF5F5w9OhR6tSpY5e+4uLi8PT0tEtfcu8ICAjgwoULVK5cmZMnT+Lu7m52JJE7Vpj3UsMw9lqt1pw3/8uGQ4FGKmEMw6gGfAWE5LeoJiJyL/nq6FekpqXSv0F/s6PQp34fUiwprP51tdlRRERERERERETuWYcPH+bChQsAvPvuuyqqieRTqSisGYaxFPgJeNAwjHOGYbxgGMYwwzCG/bfJu4AP8C/DMPYbhrHHtLAiIiXQV0e/Iqh8EI39G5sdhZZVWlLduzrLDi8zO4qIiIiIiIiIyD1r8+bNADzwwAN228tL5F5QKvZYs1qt/fI4PxTQ//kiItm4lnSNLZFbGNVqFIZx+3KOxc0wDPrU68O0XdO4nHgZX3dfsyOJiIiIiIiIiNxztmzZAsDf/vY3nJxKRalApEQoFTPWRESk4NYcX0NqWirP1H3G7Cg2fer3ITUtlW9+/cbsKCIiIiIiIiIi96Rvv/0Wq9VK3759zY4iUqqosCYicpdbdXQVVb2q0jygudlRbBr7N6a6d3VWH9M+ayIiIiIiIiIiIlJ6qLAmInIXi0uO4/uT3/N0nadLxDKQGQzDoMeDPdj822YSUhLMjiMiIiIiIiIiIiKSLyqsiYjcxdafXE+yJZledXqZHeU2T9Z+kpupN9l4aqPZUURERERERERERETyRYU1EZG72Jrja/B196V11dZmR7lN22ptKedWTstBioiIiIiIiIiISKmhwpqIyF3KkmZh3Yl1dKvZDUcHR7Pj3MbZ0ZnuNbvz3fHvSE1LNTuOiIiIiIiIiIiISJ5UWBMRuUvtOreLq0lX6V6zu9lRctTzwZ5cSbrCzrM7zY4iIiIiIiIiIiIikicV1kRE7lLfHf8OJwcnOt/f2ewoOXrsgcdwcXRhzbE1ZkcRERERERERERERyZMKayIid6m1J9ba9jErqTxdPWlbrS0bTm0wO4qIiIiIiIiIiIhInlRYExG5C52+fpqDMQdL9DKQGR574DEOxRzi7I2zZkcRERERERERERERyZUKayIid6G1J9YC8Hitx01OkreuD3QF4PtT35ucRERERERERERERCR3KqyJiNyFNpzcQI1yNajlU8vsKHmqW7Eu93ndx/qT682OIiIiIiIiIiIiIpIrFdZERO4ytyy32Bq1lS73d8EwDLPj5MkwDB67/zE2/7aZW5ZbZscRERERERERERERyZEKayIid5ld53YRnxLPo/c/anaUfOtasyuxybH8dO4ns6OIiIiIiIiIiIiI5EiFNRGRu8zGUxtxMBzoWKOj2VHy7ZEaj+Dk4MSGkxvMjiIiIiIiIiIiIiKSIxXWRETuMpt+20TLKi0p51bO7Cj55u3mTcsqLdkSucXsKCIiIiIiIiIiIiI5UmFNROQuci3pGr+c/4XO93c2O8od61ijI3vO7+HGzRtmRxERERERERERERHJlgprIiJ3kR8ifyDNmlZqC2tp1jS2nd5mdhQRERERERERERGRbKmwJiJyF9l4aiNerl60qNLC7Ch3rNV9rXBzctNykCIiIiIiIiIiOUhMTGTDhg387W9/o0ePHtSvXx9/f39cXFzw9PSkZs2a9OnTh5UrV2KxWOw+/unTpxkzZgwNGjTA29ubsmXLUrt2bUaMGMHhw4ftPp7Y108//cTzzz/P/fffj7u7OxUqVKBp06a8//77XL582W7j3LhxgxUrVvDyyy/TsmVLfHx8cHZ2pnz58jRq1IhXXnmFX375xW7jFTcnswOIiIj9hJ4OpX319jg5lL63dzcnN9pUa8MPkT+YHUVEREREREREpETatm0bXbt2zfbcrVu3OHnyJCdPnmTFihU0bNiQ5cuXU7t2bbuMvXjxYoYNG0Z8fHyW548dO8axY8eYN28eH3zwAaNGjbLLeGI/VquV0aNHM2PGDKxWq+35pKQkrl27xr59+5g9ezZLliyhY8eOhRrr73//O++++y7Jycm3nbt+/TrXr18nIiKCuXPnMnDgQD7++GPc3d0LNWZxK32fvIqISLbOx53n+JXjvNT0JbOjFFjHwI789Ye/EpMQg5+Hn9lxRERERERERERKpLp169KiRQsCAwOpXLkyFSpU4MaNG+zbt49ly5Zx9epVIiIiaN++PQcOHMDf379Q461du5ZBgwZhsVgwDINnnnmGLl264OzsTFhYGAsXLiQlJYU33ngDT09Phg4daqdXKvYwduxYpk+fDoCHhwcvvPACLVq0ID4+nlWrVrFp0yaio6Pp2bMn27dvJzg4uMBjHT9+3FZUCwoKolOnTgQHB+Pr68u1a9fYsmULq1atwmKxsGjRImJiYli/fj0ODqVngUUjc3XyXhMQEGA9f/682TFEROxi6cGl9P+qP3tf3EuTyk3s3r8xwbjtOet79v07ZPe53bT6rBXLn1nOs/WetWvfIiJmCg0NpUOHDmbHEBEpVfTeKSL3gqNHj1KnTh279BUXF4enp6dd+pKS68qVK6SkpFC5cuUc21y9epVu3bqxe/duAIYNG8bcuXMLPGZiYiI1a9Yk47P0+fPnM2jQoCxtNm3aRLdu3UhNTaVs2bKcPHmSSpUqFXhMsZ/w8HCaNm2K1WrF29ubbdu20bBhwyxtxo8fz4QJEwBo3rw5u3fvxjBu/ywwP/785z9z4cIF/vKXv9CuXbts+9m+fTvdunWzzX78/PPPGTJkSIHGg8K9lxqGsddqtTa7k2tKTwlQRERyFRoVirerN40qNTI7SoE1DWiKp4unloMUEREREREREcmGj49PrkU1gAoVKmQppK1du7ZQY37yySe2olrv3r1vK6oBPProo7YlIOPj4/nwww8LNabYz8SJE23LP06ePPm2ohrAe++9R4sWLQD45ZdfWLduXYHH+/vf/853331H+/btcyzOtW3blilTptgez58/v8DjmUGFNRGRu0To6VDaVW+Ho4Oj2VEKzMnBifaB7VVYExEREREREZFiERYWhqOjI4ZhUK1aNa5fv55j28jISLy9vTEMAw8PD44dO1Z8Qe9Q3bp1bcfR0dGF6mv58uW245EjR+bYbsSIEbZCyooVKwo1Zm6+/fZbDMPAMAxGjx6dr2veeOMN2zVr1qzJcs5qtbJ9+3befvttOnbsSEBAAK6urnh4eFCjRg369u3LmjVryGv1v/Hjx9vGCA0NBWDLli3069ePGjVq4ObmhmEYREVFFeRlF0hcXBzr168HwMvLi8GDB2fbzjAMRowYYXuc+Z7fqfLly+erXe/evW3HBw8eLPB4ZlBhTUTkLpCxv1qHwA5mRym0joEdOXH1BGdvnDU7ioiIiIiIiIjc5dq3b8+YMWMAOHv2LC+++GK27VJTU+nfvz+xsbEAzJw5kwcffLDYct6pU6dO2Y4LsyRjbGwsu3btAsDb25uHHnoox7ZVq1a1FfTOnDnDkSNHCjxubrp27Yqvry8AS5cuJS0tLdf2FouFZcuWAeDr68tjjz2W5fzzzz9Pu3btmDx5Mlu3buXChQukpKSQmJhIVFQUy5cvp0ePHnTr1s12//NitVp59dVX6dSpE8uWLSMqKsq271hxCgsLs43brl073N3dc2zbpUsX23FGMa4oZV66NikpqcjHsycV1kRE7gJhUWEAd0dhrUZHALZGbTU5iYiIiIiIiIjcCyZMmEDLli0BWLlyJZ9//nm2bTIKTL169WLo0KHFmvFOJCQk8Nprr9keP/300wXu68iRI7aZWsHBwTg45F5SaNbsf1tVHTp0qMDj5sbZ2Zk+ffoAcOHCBbZs2ZJr+y1btnDhwgUA+vbti7Ozc5bzSUlJuLq60rlzZ8aNG8cXX3zBihUrmDNnDiNHjqRChQoAbNiwgeeeey5fGf/xj38wZ84c/P39GTNmDIsWLWL+/Pm88soruLq63ulLLrDM96Bp06a5tq1YsSLVq1cH4PLly8TExBRbtoxxSwsnswOIiEjh3Q37q2VoUKkBvu6+bIncwnON8vfDioiIiIiIiIhIQTk5ObFkyRKCg4OJi4vjtddeo23bttSsWROAH3/80bYfVNWqVfnkk0+y7ScxMZGNGzfaJVO1atVo0qRJrm3i4+PZvHkzkD5DKjY2loiICJYuXWorJAUHBzN+/PgC5zh+/LjtODAwMM/2mQskma+1t4EDBzJnzhwAFi1axKOPPppj20WLFmW57o+GDx/Ov//9b8qVK5ft9ZMmTWLIkCGsXLmS1atXExYWRvv27XPNt379etq0acPatWvx8vKyPf/H/en27dvHmTNncu0rvzp37nzbjLSC3L/Tp0/brvXz87NLtuzMmzfPdty9e/ciG6coqLAmInIXuBv2V8vgYDjQvnp72yw8EREREREREZGiFhQUxJw5c3juuedISEigf//+7Ny5k4SEBAYMGIDFYsHBwYGFCxfmuIdUTEwMTz31lF3yDBo0iPnz5+fa5ty5czmOV6FCBQYNGsT777+f6/J/ecm851zG8ou58fHxyfZae2vVqhU1a9bkxIkTfPXVV8ydOzfb15mYmMjXX38NQM2aNW0zEzNr27ZtrmN5eHjw2WefsW7dOhISEli4cGGehTUPDw+WL1+epaiWnY8++ogFCxbk2ia/IiMjbyueldT7t3PnTr744gsA3NzceP3114tsrKKgpSBFREq5u2l/tQxtq7Xl9I3T2mdNRERERERERIpNSEgIAwYMAGDPnj288847vPTSS7YZRWPHjs2zoFJStG7dmvbt21OmTJlC9RMfH287dnNzy7N95vHi4uIKNXZeMmafxcfHs3r16mzbfPPNN7bXEBISUuCxPD09adCgAQC7d+/Os32vXr0ICAgo8Hj2UhLv38WLF3n22Wdte+P97W9/o2rVqkUyVlHRjDURkVLubtpfLUObam0A2HF2B329+5qcRkRERERERMR8C+adJ+q3pBzPWywWHB2Ldk+k4hYYVIZBLxZvceJf//oXO3fuJDIykqlTp9qeb9myZZ5LKgYGBtr2IysOtWvXto1nsVi4cuUKP//8M7Nnz+a7777ju+++45lnnmH+/Pl4eHgUejzDMArdhz0NHDiQ9957D0hf7rFfv363tcm8DGRG0TQ7ycnJrFixgtWrV3PgwAGio6OJj4/P9n6eO3cuz2x5zYLLMH/+/DxnJtpLSbh/CQkJ9OzZk99//x1IXwJy9OjRJqe6c5qxJiJSyt1N+6tlaOTfiLIuZdl+ervZUURERERERETkHuLl5cWSJUtwcvrfnBRPT8/bnitpHB0d8fPz4/HHH2fDhg2MGzcOgP/85z8MGTKkwP2WLVvWdpyUlHNhN7s2np6eBR43P4KCgmjdujUAGzdu5NKlS1nOx8TEsGnTJgAefvhhgoKCsu3n4MGDNGjQgOeee45Vq1Zx8uRJ4uLiciySxsbG5pmtSpUqd/JSikxJun83b96kR48e/Pzzz0D6PVm+fHmJKPjdqZL7TiAiIvkSdjqMttXb3hX7q2VwcnDiofse4sezP5odRURERERERKREyGvmVlxcXJEXMu4VVapUwcPDgxs3bgDQtGnTHIsyJdWECRNYsWIFx48fZ+XKlRw5coS6devecT/lypWzHV+5ciXP9pnbZL62qISEhLBz505SU1NZtmwZI0aMsJ1btmwZqamptnbZuXr1Kp06dSImJn22Z9WqVXn88cepXbs2FStWxM3NzVb4GTduHIcPH7YtYZibwi7BaS8l5f6lpKTw9NNP88MPPwDQokUL1q1bZ5eZlGZQYU1EpBS7lHCJY1eO8Xzj582OYndtqrVhfOh4rt+8Tjm3cmbHEREREREREZF7QFpaGiEhIbaiGkBoaChz587l5ZdfzvXaxMRENm7caJcc1apVo0mTJgW+3sHBgUcffZTjx48DEBYWVqDCWq1atWzHUVFRebY/ffp0ttcWlWeffZaRI0eSkpLCokWLshTWMpaBdHFx4dlnn832+tmzZ9uKaoMGDeLTTz/NcWbipEmT7Jwe9u3bZ9vDr7A6d+6Mu7t7ludKwv27desWvXv3Zv369QA0btyYDRs24OXlZZf+zaDCmohIKfbTuZ8AaF21tclJ7K9NtTZYsfLT2Z/oWrOr2XFERERERERE5B4wZcoUwsLS97N/5JFH2LNnDzdu3GD06NG0b98+1+JUTEwMTz31lF1yDBo0qNB7b2WewXj9+vUC9VG3bl0cHBxIS0sjPDyctLQ0HBxy3mFqz549tuP69esXaMw7UaFCBbp168Y333zDzz//zIkTJ6hZsybHjx/nl19+AdL38Spfvny212/evBkAJycnZsyYketyn5mLTvby0UcfsWDBArv0FRkZSWBgYJbnMt+DzPcmO5cuXbK9Rl9fX/z8/AqdKTU1lX79+vHtt98C0KBBAzZt2pTj/SgttMeaiEgptuPMDpwdnGkW0MzsKHbXskpLnByc2H5G+6yJiIiIiIiISNHbvXs348ePByAgIIDly5czd+5cIH3vqf79+5OcnGxiwjtz8uRJ27Gvr2+B+vDy8qJVq1YA3Lhxg127duXY9uzZsxw5cgRIn3FXkBlyBZF5mceMWWoZ//3j+T+Kjo4GwMfHJ9elD8PDw2/bw6006NChA66urgBs27Yt133Wvv/+e9tx166F/yV3i8VCSEgIq1atAtKLtJs3b8bHx6fQfZtNhTURkVJsx9kdNA1oipuTm9lR7M7DxYMmlZvw4xntsyYiIiIiIiIiRSsuLo4BAwaQmpqKYRgsWLAAHx8f+vXrZyvMHDhwgDFjxuTYR2BgIFar1S5/Cjtb7dy5c6xbt872uHXrgq921KdPH9vxzJkzc2w3a9YsrFYrQI5LLxaFxx9/3DYDavHixVitVhYvXgxA+fLl6d69e47XZiydGBMTQ1xcXI7tJk6caMfE/zN//ny7fc/8cbYaQNmyZenWrRsAsbGxOX5fWa1WZs+ebXuc+Z4XRFpaGs8//zzLli0D0peV3LJli11mwZUEKqyJiJRSyanJ7Dm/h4erPmx2lCLTpmobfv79Z5JTS89vg4mIiIiIiIhI6TN8+HBOnToFwOjRo+nUqZPt3Jw5cwgKCgLSC0uZZ/YUt//7v//Lc0nCU6dO8fjjj5OYmAhA+/btqVevXrZtAwMDMQwDwzAIDQ3Nts3QoUMJCAgAYMWKFdkuXbh582amT58OpBdz3nzzzfy+pEJzcXGhd+/eQPprnzZtGr/99huQXuBzcXHJ8drmzZsD6YWlcePG3XbearXy7rvv8s0339g/eDF55513MAwDgLFjxxIREXFbm4kTJ7J7924g/WuSUYz7o/nz59u+Xzp06JBtG6vVyksvvcSXX34JwAMPPMDWrVvx9/e3w6spGbTHmohIKbXvwj6SLcl3d2GtWhum7ZrG3gt778p95ERERERERETEfEuXLmXhwoUANG7cmEmTJmU57+npyZIlS2jTpg2pqakMHjyYiIgIKlasWOxZP/74Y/7xj3/QqlUrHn74YR588EG8vb1JTU3l/Pnz/Pjjj6xbt46UlBQA/P39+eSTTwo1pru7O/PmzaNnz55YLBaGDBnC2rVr6dq1K05OToSFhfHll1+SmpoKwPTp06lUqVKO/QUGBtqKg1u3bs2xQHMnQkJCmDdvHgB//etfszyfm1deeYXPP/8ci8XCRx99xP79+3n66afx9/fn7NmzLFmyhPDwcOrWrUuZMmXYu3dvobMWt8aNG/PWW28xdepUbty4QevWrRk6dCgtWrQgPj6eVatWsXHjRiC9KDpv3jxbIa4g3n77bT799FMAnJ2dee211/j555/zvK5z5862GYQlnQprIiKl1I6zOwDu6oJTm2ptANh+evtd/TpFRERERERExBxRUVG8/PLLQHoBacmSJdnOcGrZsiXjx49n3LhxXLx4kSFDhvDdd98Vd1wgfUbQTz/9xE8//ZRruw4dOvDpp59y//33F3rM7t27s2DBAoYNG0Z8fDwrV65k5cqVWdo4OzszdepUhg4dWujx7tTDDz9MjRo1iIyMtBUVg4KCePjh3H8hPTg4mFmzZvHqq6+SlpbGtm3b2LZtW5Y2derUYfXq1aa8LnuZMmUKKSkpzJgxg4SEhGyX9PTz82Pp0qUEBwcXaqydO3fajm/dusVrr72Wr+siIyOzXc6yJNJSkCIipdTOszu5v/z9VCqb828AlXYVPSryoM+D/HhW+6yJiIiIiIiIiH1ZLBYGDhzIjRs3AJg2bRq1a9fOsf3YsWNp164dAGvXrs2yJ1VxOXToEAsXLuSFF16gRYsWVK9enTJlyuDq6oqfnx8PPfQQr732Gj/++CNbt261S1Etw4ABAzh06BBvvfUW9erVw9PTEw8PD2rVqsXw4cMJDw9n1KhRefaTlJRkO/b19bVLNsMwGDhw4G158+Pll19mx44d9O7dG39/f5ydnfHz86N169ZMmzaNPXv28MADD9glp1kMw2DatGns2LGDwYMHExQUhJubG+XKlaNJkyZMnDiRw4cP07FjR7OjlgpGxmaC96KAgADr+fPnzY4hInLHrFYr/v/057EHHmPBk7eva10UjAm3TwG3vlf0f4cM/XYoXx39istvXcbB0O+DiEjpFBoaapflTURE7iV67xSRe8HRo0epU6eOXfqKi4vD09PTLn2JFJVjx47Zipc9evRg9erVJieSu0Fh3ksNw9hrtVqb3ck1+oRSRKQUOnXtFDEJMbS+7+5fHrF11dZcu3mNE1dOmB1FREREREREREQKYfPmzQA4ODgwefJkk9OIFIwKayIipdDOs+lrFT9cLfd1ou8GLau0BGDXuV0mJxERERERERERkcLIKKyFhIRQr149k9OIFIwKayIipdCOMzvwdvWmbsW6ZkcpcnUq1sHL1UuFNRERERERERGRUiwtLY3Q0FBcXV2ZMGGC2XFECszJ7AAiInLndpzdwUNVH7on9hxzMBxoUaUFu35XYU1EREREREREpLRycHDg2rVrZscQKbS7/xNZEZG7zPWb1zl86fA9sb9ahlZVWnEw+iAJKQlmRxEREREREREREZF7mAprIiKlzJ7zewBodV8rk5MUn1b3tcJitbD3wl6zo4iIiIiIiIiIiMg9TIU1EZFSZve53QA0r9Lc5CTFp0WVFgDaZ01ERERERERERERMpcKaiEgp8/P5n3nQ50HKuZUzO0qxqehRkfvL36/CmoiIiIiIiIiIiJhKhTURkVLEarWy+9xuWt7X0uwoxa7Vfa346dxPWK1Ws6OIiIiIiIiIiIjIPUqFNRGRUuTMjTNEJ0TTIqCF2VGKXav7WnEx/iJnY8+aHUVERERERERERETuUSqsiYiUIj///jPAPTtjDf63x5yIiIiIiIiIiIhIcVNhTUSkFNn9+25cHV1pWKmh2VGKXcNKDXF1dNU+ayIiIiIiIiIiImIaFdZEREqRn3//mcaVG+Pi6GJ2lGLn4uhC04Cm7PpdhTURERERERERERExhwprIiKlRGpaKnsv7KVllXtvGcgMraq0Yu/5vaRYUsyOIiIiIiIiIiIiIvcgFdZEREqJQzGHSLyVSIsqLcyOYpqW97Uk2ZJMRHSE2VFERERERERERETkHqTCmohIKfHz7z8D3NMz1poHNAdgz/k9JicRERERERERERGRe5EKayIipcTuc7vxKeNDUPkgs6OYJrBcID5lfPjl91/MjiIiIiIiIiIiIiL3IBXWRERKiZ/P/0yLKi0wDMPsKKYxDINmAc3Yc0Ez1kRERERERERERKT4qbAmIlIKxCXHcTjm8D29DGSG5gHNORxzmMRbiWZHERERERERERERkXuMCmsiIqXAvgv7sGKleZXmZkcxXbOAZlisFvZf3G92FBEREREREREREbnHqLAmIlIK7DmfvvRhs4BmJicxX0ZxMeNrIiIiIiIiIiIiIlJcVFgTESkF9l7YS1Wvqvh5+JkdxXQBngEEeAbwy/lfzI4iIiIiIiIiIlJiXL16FX9/fwzDsP2Jioqy6xinT59mzJgxNGjQAG9vb8qWLUvt2rUZMWIEhw8ftutYYn8//fQTzz//PPfffz/u7u5UqFCBpk2b8v7773P58mW7jGG1WtmxYwczZsxgwIABNGnShKpVq1KmTBnc3d2577776Nq1K7Nnz+b69et2GbO4OZkdQERE8rb3wl6aBjQ1O0aJ0SygmWasiYiIiIiIiIhk8sYbbxAdHV1k/S9evJhhw4YRHx+f5fljx45x7Ngx5s2bxwcffMCoUaOKLIMUjNVqZfTo0cyYMQOr1Wp7PikpiWvXrrFv3z5mz57NkiVL6NixY6HGSk5Opk2bNjme//333/n999/ZsGEDEydO5JNPPqFnz56FGrO4qbAmIlLCxSbHcvzKcUIahpgdpcRoHtCcNcfWEJsci5erl9lxRERERERERERMtWnTJhYsWICDgwMuLi7cvHnTrv2vXbuWQYMGYbFYMAyDZ555hi5duuDs7ExYWBgLFy4kJSWFN954A09PT4YOHWrX8aVwxo4dy/Tp0wHw8PDghRdeoEWLFsTHx7Nq1So2bdpEdHQ0PXv2ZPv27QQHBxd6zCpVqtCyZUvq1KmDv78/fn5+JCcn8+uvv7Jy5UpOnDjBpUuX6NWrF+vXr+fRRx8t9JjFRYU1EZESbt+FfQA0rawZaxmaBTTDipV9F/bRIbCD2XFEREREREREREyTkJDASy+9BMDw4cP59ttvOX36tN36T0xM5MUXX8RisQDwxRdfMGjQINv55557jr59+9KtWzdSU1MZNWoUTzzxBJUqVbJbBim48PBw/v73vwPg7e3Ntm3baNiwoe38Sy+9xPjx45kwYQLx8fG8+OKL7N69G8MwCjSei4sLhw8fpm7dujm2mThxIiNGjGDu3LlYLBZee+01jh49WqDxzKA91kRESri95/cCaCnITJoFNAPgl9+1z5qIiIiIiIiI3NvGjRtHZGQkVapUYdKkSXbv/5NPPuH8+fMA9O7dO0tRLcOjjz5qWwIyPj6eDz/80O45pGAmTpxoW/5x8uTJWYpqGd577z1atGgBwC+//MK6desKPJ6Dg0OuRTUAR0dHZs6ciY+PDwC//vorv/32W4HHLG4qrImIlHB7L+ylqldV/Dz8zI5SYvi6+xJYLpA9F7TPmoiIiIiIiIgUXFhYGI6OjhiGQbVq1bh+/XqObSMjI/H29sYwDDw8PDh27FjxBc3Bzz//zEcffQTArFmz8PT0tPsYy5cvtx2PHDkyx3YjRoywzXJasWKF3XNk+PbbbzEMA8MwGD16dL6ueeONN2zXrFmzJss5q9XK9u3befvtt+nYsSMBAQG4urri4eFBjRo16Nu3L2vWrMmyN1l2xo8fbxsjNDQUgC1bttCvXz9q1KiBm5sbhmEQFRVVkJddIHFxcaxfvx4ALy8vBg8enG07wzAYMWKE7XHme15UnJ2dqVmzpu3xxYsXi3xMe1FhTUSkhNt7Ya9mq2WjeUBzzVgTERERERERkUJp3749Y8aMAeDs2bO8+OKL2bZLTU2lf//+xMbGAjBz5kwefPDBYsuZnVu3bvHCCy+QlpZGz549eeqpp+w+RmxsLLt27QLSlxF86KGHcmxbtWpV20ylM2fOcOTIEbvnAejatSu+vr4ALF26lLS0tFzbWywWli1bBoCvry+PPfZYlvPPP/887dq1Y/LkyWzdupULFy6QkpJCYmIiUVFRLF++nB49etCtWzfb/c+L1Wrl1VdfpVOnTixbtoyoqCiSk5ML8GoLJywszDZuu3btcHd3z7Ftly5dbMcZxbiilJaWlqXI6O/vX+Rj2kupKKwZhvG5YRgxhmEcyuG8YRjGR4ZhnDQMI8IwjCbFnVFEpCjEJsdy/Mpx7a+WjWYBzYi8HsmVxCtmRxERERERERGRUmzChAm0bNkSgJUrV/L5559n2yajwNSrVy+GDh1arBmzM2XKFA4dOkTZsmWZPXt2kYxx5MgR20yt4OBgHBxyLyk0a9bMdnzoULYf5xeas7Mzffr0AeDChQts2bIl1/ZbtmzhwoULAPTt2xdnZ+cs55OSknB1daVz586MGzeOL774ghUrVjBnzhxGjhxJhQoVANiwYQPPPfdcvjL+4x//YM6cOfj7+zNmzBgWLVrE/PnzeeWVV3B1db3Tl1xgme9B06a5f75YsWJFqlevDsDly5eJiYkpslxWq5Vx48bZZqkFBwcTFBRUZOPZm5PZAfJpPjAb+DKH812Bmv/90xKY+9//ioiUauEXwgFUWMtG84DmAOw5v4cuD3TJo7WIiIiIiIiISPacnJxYsmQJwcHBxMXF8dprr9G2bVvbMnU//vgjU6ZMAdJnZX3yySfZ9pOYmMjGjRvtkqlatWo0aZLz/JGjR48yefJkACZNmsR9991nl3H/6Pjx47bjwMDAPNtnFGb+eK29DRw4kDlz5gCwaNEiHn300RzbLlq0KMt1fzR8+HD+/e9/U65cuWyvnzRpEkOGDGHlypWsXr2asLAw2rdvn2u+9evX06ZNG9auXYuXl5ft+T/uT7dv3z7OnDmTa1/51blz59tmpBXk/p0+fdp2rZ9f4bem2bBhAzdv3gTS/x85efIkX331FQcOHADAx8eHzz77rNDjFKdSUVizWq3bDMMIzKVJT+BLa3rpfJdhGOUMw6hstVovFE9CEZGisffCXgAtBZmNJpXTf7jcd2GfCmsiIiIiIiIiUihBQUHMmTOH5557joSEBPr378/OnTtJSEhgwIABWCwWHBwcWLhwIeXLl8+2j5iYGLstxzho0CDmz5+f7bm0tDSGDh1KcnIyzZo149VXX7XLmNnJvOdcxvKLufHx8cn2Wntr1aoVNWvW5MSJE3z11VfMnTs322UOExMT+frrrwGoWbOmbWZiZm3bts11LA8PDz777DPWrVtHQkICCxcuzLOw5uHhwfLly7MU1bLz0UcfsWDBglzb5FdkZORtxbOScP8GDx5MdHT0bc+7uLjQo0cP/v73v1OjRg27jFVcSsVSkPlQBTib6fG5/z4nIlKq7Tm/h/u87sPPo/C/HXK38Xbz5v7y97Pv4j6zo4iIiIiIiIjIXSAkJIQBAwYAsGfPHt555x1eeukl24yisWPH5llQKQ5z5sxh586dODo6Mm/evDyXZyyM+Ph427Gbm1ue7cuUKWM7jouLK5JMGTJmn8XHx7N69eps23zzzTe21xASElLgsTw9PWnQoAEAu3fvzrN9r169CAgIKPB49lKS71/t2rXp1KmTXWbFFbdSMWMtH4xsnrNm29AwXgReBKhcuTKhoaFFGEtEpHB+PPUj1d2rl9j3KrNz3ed4Hzt/22l6DhGRvMTHx+u9SkTkDum9U0TuBd7e3vn+8PrcthiSLt3MuYHVCkZ2H5OWXmUqunFfu+L90H3q1Kns2LGDqKgopk6danu+WbNmjB49Otf75ePjQ2xsrN2yZDfW2bNn+etf/wrAK6+8wgMPPHBbu4w90SD979PCFEiSk5NtxykpKXn2lbHkH8CtW7eKtDjz5JNP8t577wEwf/58Hn/88dvaZJ7117NnzxzzJCcn89VXX7Fu3ToOHjzIpUuXiI+Pz/K1zHDu3Lls+8n8tWrevHm+XvusWbOYNWtWnu3y649jpqam2o6TkpLyzHTr1q07ap8fJ06cANK/L+Pi4jh69CjLli1j/vz5DBs2jJkzZ7J06dJC7bF28+bNYv258W4prJ0DqmZ6fB9wPruGVqt1HjAPICAgwNqhQ4ciDyciUhCxybGcDTvLi61epEO7DmbHgbDbnzL7PbSLYxfCfggjuFUw5dzKmZpFRCQ3oaGhpr9nioiUNnrvFJF7wdGjR/H09MxXWxfna9xyvJXj+VSLBSdHR3tFKxFcnJ3z/fWxF09PT5YuXUrbtm1tRQlPT0+WL1+e4xKQxekvf/kL8fHxVK9enSlTpuDh4XFbGyNTgbVs2bKF+hpmXhowLS0tz74yF6IqVKhQpPevYcOGtG7dmp07d/LDDz9w8+ZNKlasaDsfExPD1q1bAXj44Ydp2LBhtv0cPHiQXr162QpAeYmNjc32dbm6utqO77///mL/3s1O5n3jDMPIM1PmQpyfn5/dX4OXlxdVqlShU6dO9O7dm+7du3P06FGeeuopDh48mO33c364ubnRuHFju2bNzd1SWPsWeNUwjGVAS+CG9lcTkdIu/EI4AE0ra3+1nGTss7b/4n46BHYwN4yIiIiIiIhIEbq/c7Vcz8fFxZWID/LvBlWqVMHDw4MbN24A0LRp00LNprGXRYsWsW7dOiB9OciCFiHuRObCzJUrV/Jsn7lN5muLSkhICDt37iQ1NZVly5YxYsQI27lly5bZCkU5LQN59epVOnXqRExMDABVq1bl8ccfp3bt2lSsWBE3NzdboXLcuHEcPnyYtLS0PHNlXlLRTCX5/nXp0oXBgwfz2WefERkZyZdffsnLL79cpGPaS6korBmGsRToAPgahnEOeA9wBrBarf8G1gHdgJNAIjDEnKQiIvaz98JeAJoGqLCWk8aV038TJfxCuAprIiIiIiIiIlJoaWlphISE2IpqkD6Leu7cuXl+6J+YmMjGjRvtkqNatWo0adIky3OfffYZAP7+/oSHhxMeHp7ttZmzz54921Yg+fOf/0ylSpXuKEetWrVsx1FRUXm2P336dLbXFpVnn32WkSNHkpKSwqJFi7IU1hYtWgSAi4sLzz77bLbXz54921ZUGzRoEJ9++ilOTtmXTSZNmmTn9LBv3z7bHn6F1blzZ9zd3bM8V9Lv32OPPWb7vg4NDVVhzZ6sVmu/PM5bgeHFFEdEpFjsvbCX+7zuw8+j9G3gWVz8PPyo4lmFfRf3mR1FRERERERERO4CU6ZMISwsfT+MRx55hD179nDjxg1Gjx5N+/btqVu3bo7XxsTE8NRTT9klx6BBg7LsDwb/W2bx4sWLvPPOO/nq55///Kft+PHHH7/jwlrdunVxcHAgLS2N8PBw0tLScHBwyLH9nj17bMf169e/o7EKokKFCnTr1o1vvvmGn3/+mRMnTlCzZk2OHz/OL7/8AkD37t1zXMZz8+bNADg5OTFjxowci2qQtehkLx999BELFiywS1+RkZEEBgZmeS7zPch8b7Jz6dIl22v09fXFz6/oP5PMPMv2+vXrRT6eveT8f4CIiJhqz/k9WgYyHxpXbsy+CyqsiYiIiIiIiEjh7N69m/HjxwMQEBDA8uXLmTt3LgBJSUn079+f5ORkExMWPy8vL1q1agWkz4TbtWtXjm3Pnj3LkSNHgPQZd7kVIe0p8zKPGbPUMv77x/N/FB0dDaTvJZfb0ofh4eFcunSpkEmLX4cOHWx7v23bto2kpKQc237//fe2465duxZ5NoCTJ0/ajn19fYtlTHtQYU1EpASKTY7l+JXjKqzlQxP/Jvx6+VcSbyWaHUVERERERERESqm4uDgGDBhAamoqhmGwYMECfHx86Nevn60wc+DAAcaMGZNjH4GBgVitVrv8+eNsNUhfKi8/11avXt12TWRkpO354ODgAn1t+vTpYzueOXNmju1mzZplm1WX09KLReHxxx+3zUhbvHgxVquVxYsXA1C+fHm6d++e47UZSyfGxMQQFxeXY7uJEyfaMfH/zJ8/327fM3+crQZQtmxZunXrBkBsbGy231eQPhty9uzZtseZ73lRSUtLsy0DCdC6desiH9NeVFgTESmBwi+kr5HdLKCZyUlKviaVm5BmTSMiOsLsKCIiIiIiIiJSSg0fPpxTp04BMHr0aDp16mQ7N2fOHIKCgoD0wlLmmT2lXWBgIIZhYBgGoaGh2bYZOnQoAQEBAKxYsSLbpQs3b97M9OnTgfRizptvvllkmf/IxcWF3r17A3Dq1CmmTZvGb7/9BqQX+FxcXHK8tnnz5kB6YWncuHG3nbdarbz77rt888039g9eTN555x0MwwBg7NixRETc/hnaxIkT2b17N5D+Nckoxv3R/Pnzbd8vHTp0yLbNjBkzcp3ZCOmF7IEDB9r2CaxQoQJ9+/bN70syXanYY01E5F6z98JeIL1oJLlrXLkxkF6MbHVfK5PTiIiIiIiIiEhps3TpUhYuXAhA48aNmTRpUpbznp6eLFmyhDZt2pCamsrgwYOJiIigYsWKZsQtdu7u7sybN4+ePXtisVgYMmQIa9eupWvXrjg5OREWFsaXX35JamoqANOnT891L7fAwEDbXl5bt27NsUBzJ0JCQpg3bx4Af/3rX7M8n5tXXnmFzz//HIvFwkcffcT+/ft5+umn8ff35+zZsyxZsoTw8HDq1q1LmTJl2Lt3b6GzFrfGjRvz1ltvMXXqVG7cuEHr1q0ZOnQoLVq0ID4+nlWrVrFx40YgvSg6b948WyGuIEJDQxk1ahQ1a9bkkUceoX79+vj4+ODo6MilS5fYt28fX3/9NVevXgXS97f79NNP8fHxscvrLQ4qrImIlED7L+4nwDOASmXvbEPZe1FVr6r4lPHRPmsiIiIiIiIicseioqJ4+eWXgfQC0pIlS7Kd4dSyZUvGjx/PuHHjuHjxIkOGDOG7774r7rim6d69OwsWLGDYsGHEx8ezcuVKVq5cmaWNs7MzU6dOZejQocWe7+GHH6ZGjRpERkaSkpICQFBQEA8//HCu1wUHBzNr1ixeffVV0tLS2LZtG9u2bcvSpk6dOqxevdqU12UvU6ZMISUlhRkzZpCQkJDtkp5+fn4sXbq0wEuG/tGJEyc4ceJErm2CgoL4+OOPs8wQLQ20FKSISAkUfjGcxv6NzY5RKhiGQZPKTdh3UYU1EREREREREck/i8XCwIEDuXHjBgDTpk2jdu3aObYfO3Ys7dq1A2Dt2rVZ9qS6FwwYMIBDhw7x1ltvUa9ePTw9PfHw8KBWrVoMHz6c8PBwRo0alWc/SUlJtmNfX1+7ZDMMg4EDB96WNz9efvllduzYQe/evfH398fZ2Rk/Pz9at27NtGnT2LNnDw888IBdcprFMAymTZvGjh07GDx4MEFBQbi5uVGuXDmaNGnCxIkTOXz4MB07diz0WAsWLGDNmjWMHj2atm3b8sADD+Dl5YWTkxPly5enYcOGDBo0iFWrVnH06NFSV1QDMDI2E7wXBQQEWM+fP292DBGRLG6m3qTs5LKMaTOG9zu+b3YcG2PC7VPAre+VjL9D/m/T/zFj9wzixsbh4pjzutkiImYJDQ21y/ImIiL3Er13isi94OjRo9SpU8cufcXFxeHp6WmXvkSKyrFjx2zFyx49erB69WqTE8ndoDDvpYZh7LVarc3u5BrNWBMRKWEOxRzCYrUQ7B9sdpRSo0nlJqRYUjhy6YjZUUREREREREREJAebN28GwMHBgcmTJ5ucRqRgVFgTESlh9l/cD6ClIO9A48rpXyvtsyYiIiIiIiIiUnJlFNZCQkKoV6+eyWlECkaFNRGREib8QjieLp7UKF/D7CilxgMVHqCsS1nCL4SbHUVERERERERERLKRlpZGaGgorq6uTJgwwew4IgXmZHYAERHJan/0foL9g3Ew9LsP+eVgONDYvzH7LmrGmoiIiIiIiIhISeTg4MC1a9fMjiFSaPrUVkSkBLGkWThw8YD2VyuAxv6N2X9xP5Y0i9lRRERERERERERE5C6lwpqISAly6topEm4laH+1AmhSuQmJtxI5cfWE2VFERERERERERETkLqXCmohICbL/4n4AzVgrgCaVmwCw74KWgxQREREREREREZGiocKaiEgJEn4hHCcHJ+pWrGt2lFKntm9tXB1dVVgTERERERERERGRIqPCmohICbI/ej/1KtbD1cnV7CiljrOjM/X96nMg+oDZUUREREREREREROQupcKaiEgJEn4hXMtAFkKjSo04cPEAVqvV7CgiIiIiIiIiIiJyF1JhTUSkhLgYf5HohGga+zc2O0qpFewfzKXES1yIv2B2FBEREREREREREbkLqbAmIlJChF8IB9CMtUJo5N8IgAMXtRykiIiIiIiIiIiI2J8KayIiJcT+i/uB/xWH5M41rNQQQPusiYiIiIiIiIiISJFQYU1EpITYH72fGuVqUM6tnNlRSq1ybuWo7l1dhTUREREREREREREpEiqsiYiUEOEXwrUMpB008m+kpSBFRERERERERESkSKiwJiJSAsQlx3Hy6kka+zc2O0qpF1wpmGNXjpF0K8nsKCIiIiIiIiIiInKXUWFNRKQEiIiOwIpVM9bsoJF/I9KsaRyKOWR2FBEREREREREREbnLqLAmIlIC7L+4H4DGlTVjrbAaVWoEoH3WRERERERERERExO5UWBMRKQHCL4bjU8aHKp5VzI5S6tUoX4OyLmW1z5qIiIiIiIiIiIjYnQprIiIlwIHoAzTyb4RhGGZHKfUcDAcaVWqkGWsiIiIiIiIiIiJidyqsiYiYzJJm4XDMYdsShlJ4GYU1q9VqdhQRERERERERERG5i6iwJiJislPXTpGUmkQDvwZmR7lrNPJvRGxyLFHXo8yOIiIiIiIiIiJiV4Zh5PvP4MGD7Tr26dOnGTNmDA0aNMDb25uyZctSu3ZtRowYweHDh+06ltjfTz/9xPPPP8/999+Pu7s7FSpUoGnTprz//vtcvny5WDJ07tw5y/fo/Pnzi2Vce3IyO4CIyL0uIjoCgIaVGpqc5O6RMfvvQPQBapSvYXIaEREREREREZHSb/HixQwbNoz4+Pgszx87doxjx44xb948PvjgA0aNGmVSQsmJ1Wpl9OjRzJgxI8sKT0lJSVy7do19+/Yxe/ZslixZQseOHYssx/z589m0aVOR9V9cVFgTETFZRHQEDoYDdSvWNTvKXaO+X30MDA5cPMCTtZ80O46IiIiIiIiIiN3Vq1eP999/P9c21apVs8tYa9euZdCgQVgsFgzD4JlnnqFLly44OzsTFhbGwoULSUlJ4Y033sDT05OhQ4faZVyxj7FjxzJ9+nQAPDw8eOGFF2jRogXx8fGsWrWKTZs2ER0dTc+ePdm+fTvBwcF2zxAdHc3o0aNtGRISEuw+RnFRYU1ExGQHYw5Sy6cWZZzLmB3lruHh4kEtn1ociD5gdhQRERERERERkSLh6+vLk08+WeTjJCYm8uKLL2KxWAD44osvGDRokO38c889R9++fenWrRupqamMGjWKJ554gkqVKhV5NslbeHg4f//73wHw9vZm27ZtNGz4v5WzXnrpJcaPH8+ECROIj4/nxRdfZPfu3RiGYdccI0aM4OrVqwQHB1O/fn0WLVpk1/6Lk/ZYExExWUR0hPZXKwKN/Bux/+J+s2OIiIiIiIiIiJRqn3zyCefPnwegd+/eWYpqGR599FHbEpDx8fF8+OGHxZpRcjZx4kTb8o+TJ0/OUlTL8N5779GiRQsAfvnlF9atW2fXDN9++y0rV67EwcGBefPm4ejoaNf+i5sKayIiJopLjuO3a79pf7Ui0KhSIyKvRxKbHGt2FBEREREREREpocLCwnB0dMQwDKpVq8b169dzbBsZGYm3tzeGYeDh4cGxY8eKL6iJli9fbjseOXJkju1GjBhhm+W0YsWKIsvz7bffYhgGhmHYlhbMyxtvvGG7Zs2aNVnOWa1Wtm/fzttvv03Hjh0JCAjA1dUVDw8PatSoQd++fVmzZk2WvcmyM378eNsYoaGhAGzZsoV+/fpRo0YN3NzcMAyDqKiogrzsAomLi2P9+vUAeHl5MXjw4GzbGYbBiBEjbI8z3/PCio2N5ZVXXgHg1VdfpXnz5nbr2ywqrImImOhQzCEAFdaKQKNKjYD0GYEiIiIiIiIiItlp3749Y8aMAeDs2bO8+OKL2bZLTU2lf//+xMam/wLvzJkzefDBB4stp1liY2PZtWsXkL6M4EMPPZRj26pVq1K3bl0Azpw5w5EjR4okU9euXfH19QVg6dKlpKWl5dreYrGwbNkyIH35zMceeyzL+eeff5527doxefJktm7dyoULF0hJSSExMZGoqCiWL19Ojx496Natm+3+58VqtfLqq6/SqVMnli1bRlRUFMnJyQV4tYUTFhZmG7ddu3a4u7vn2LZLly6244xinD385S9/4ffff+e+++7Lc0/A0kKFNREREx2MOQiosFYUgv2DAThwUfusiYiIiIiIiEjOJkyYQMuWLQFYuXIln3/+ebZtMgpMvXr1YujQocWaMTvHjh2jTZs2+Pj44OLiQqVKlWjXrh0TJkzg4sWLdhnjyJEjtplawcHBODjkXlJo1qyZ7fjQoUN2yfBHzs7O9OnTB4ALFy6wZcuWXNtv2bKFCxcuANC3b1+cnZ2znE9KSsLV1ZXOnTszbtw4vvjiC1asWMGcOXMYOXIkFSpUAGDDhg0899xz+cr4j3/8gzlz5uDv78+YMWNYtGgR8+fP55VXXsHV1fVOX3KBZb4HTZs2zbVtxYoVqV69OgCXL18mJiam0ONv27aNTz75BIBZs2bh6elZ6D5LAiezA4iI3MsioiPwdPGkund1s6PcdQI8A/Ap48OBaBXW7nZWq5WUZCs3b6bh7uGAs7N+b0hERERERETyz8nJiSVLlhAcHExcXByvvfYabdu2pWbNmgD8+OOPTJkyBUiflZVRKPijxMRENm7caJdM1apVo0mTJrm2uXjxYpYCWkxMDDExMWzfvp0pU6YwderUXJduzI/jx4/bjgMDA/Nsn1GY+eO19jZw4EDmzJkDwKJFi3j00UdzbLto0aIs1/3R8OHD+fe//025cuWyvX7SpEkMGTKElStXsnr1asLCwmjfvn2u+davX0+bNm1Yu3YtXl5etuf/uD/dvn37OHPmTK595Vfnzp1vm5FWkPt3+vRp27V+fn4FznPz5k3+/Oc/Y7Vaeeqpp3jyyScL3FdJo8KaiIiJIqIjaFCpgW39abEfwzBo5N9IhbW7UOyNVML3xHJwfzxRp5KIvpDCrVv/W+fcrYwDAVVcCapZhkZNPGnY2BNXNxXbREREREREJGdBQUHMmTOH5557joSEBPr378/OnTtJSEhgwIABWCwWHBwcWLhwIeXLl8+2j5iYGJ566im75Bk0aBDz58/P8fz9999P586dadiwIT4+PiQlJXH48GH+85//8Ntvv5GcnMzrr7/O1atXmTBhQoFzZN5zLmP5xdz4+Phke629tWrVipo1a3LixAm++uor5s6dm+0yh4mJiXz99dcA1KxZ0zYzMbO2bdvmOpaHhwefffYZ69atIyEhgYULF+ZZWPPw8GD58uVZimrZ+eijj1iwYEGubfIrMjLytuKZmfdv/PjxHD9+HE9PT2bNmlWovkoaFdZERExitVo5GHOQvvX6mh3lrtWoUiP+veffWNIsODo4mh1HCunY0QTWfn2ZvT/HYkm14l3OiQcedKeMuyOurgaOTgapt6wk30yjjLsjP4ZeZ/P6q5Rxd6BNh/J0f9IX/4DiW25BRERERERESpeQkBC+//57Fi9ezJ49e3jnnXeIjIy0zSgaO3ZsngWV4hAWFka7du2yPTd58mTGjx9v28tq4sSJPProo7Rp06ZAY8XHx9uO3dzc8mxfpkwZ23FcXFyBxsyvgQMH8t577xEfH8/q1avp16/fbW2++eYb22sICQkp8Fienp40aNCAXbt2sXv37jzb9+rVi4CAgAKPZy9m3b/9+/fzz3/+E0if8VelSpUC91USqbAmImKSc7HnuH7zuvZXK0KNKjUiKTWJE1dPUNu3ttlxpIBO/5bEos8vcHB/PGU9HXnscR8e7lCOwKAyODgY9H084rZrln3XkNRbaRw9nMD2H64Tuukqm9dfod0j5ekz0J8Kvs7ZjCQiIiIiIlJynZqWRMIJS47nU1PTcHKKz/F8aeRR05H73yiTd0M7+te//sXOnTuJjIxk6tSptudbtmzJ+PHjc702MDDQth9ZUcqpqAbg6OjI3/72N6Kjo21LVk6aNIn169cXetyStuJSRmEN0pd7zK6wlnkZyAEDBuTYV3JyMitWrGD16tUcOHCA6Oho4uPjs72f586dyzNbXrPgMsyfPz/XmYn2VFz3z2Kx8MILL5Camkrz5s0ZPnx4sYxbnFRYExExSUR0ejGgQaUGJie5ewX7BwNw4OIBFdZKoeSbaaxYdJF1317Gw8ORkKGVeeQxH9zyuayjk7MDDYI9aRDsSf8h/qz56hLfr7nC7h036DfIn0e7+eDgULL+USAiIiIiIiLm8vLyYsmSJbRt25bU1FQgfbbSkiVLcHIqPR+njx8/nk8//RSr1crWrVtJSkrKMhspv8qWLWs7TkpKyrN95jaenp53PN6dCAoKonXr1uzcuZONGzdy6dIlKlasaDsfExPDpk2bAHj44YcJCgrKtp+DBw/Sq1cvTpw4ka9xY2Nj82xTUmZomXH/PvzwQ/bt24eTkxPz5s3DweHu256j9LwTiIjcZWyFNT8V1opKnYp1cHZw5kD0AfrU72N2HLkD539PZtqkKM6dSabTYxXoO9ifsmUL/mNLufLOhLwQQOfuPnw653e++Pd59u+JY/ibVQvVr4iIiIiISHHJa+ZWXFwcnp5lc20j+VOlShU8PDy4ceMGAE2bNs2xKFNSBQQEUKtWLY4dO0ZycjJRUVHUqVPnjvspV66c7fjKlSt5ts/cJvO1RSUkJISdO3eSmprKsmXLGDFihO3csmXLbMXRnJaBvHr1Kp06dSImJgaAqlWr8vjjj1O7dm0qVqyIm5ubbabXuHHjOHz4MGlpaXnmKkgRsygU9/07efKkbU+/UaNGERwcfMd9lAb6JElExCQHYw5S3bs63m7eZke5a7k4ulCnYh0ORB8wO4rcgT27bjBn2lmcnAzGTqxBoyb2+w23Sv6u/HViDTatu8KCTy7w19dPMvqv1akeVDJ+4BURERERERFzpaWlERISYiuqAYSGhjJ37lxefvnlXK9NTExk48aNdslRrVo1mjRpUqg+fHx8bMfXrl0rUB+1atWyHUdFReXZ/vTp09leW1SeffZZRo4cSUpKCosWLcpSWMtYBtLFxYVnn3022+tnz55tK6oNGjSITz/9NMeZiZMmTbJzeti3b59tD7/C6ty5M+7u7lmeK+77t3jxYpKSkjAMAycnJ9tef38UEfG/bT3WrFljW16zc+fOtGjR4o7HLW4qrImImCQiOkLLQBaDRpUasSVyi9kxJB+sVitfL49hxaJogmqW4Y2x1fH1c7H7OIZh0Lm7L4FBZZg+5TTv/OUkr46uRovWKnKLiIiIiIjc66ZMmUJYWBgAjzzyCHv27OHGjRuMHj2a9u3bU7du3RyvjYmJ4amnnrJLjkGDBhV67y17zB6rW7cuDg4OpKWlER4eTlpaWq5L++3Zs8d2XL9+/QKNeScqVKhAt27d+Oabb/j55585ceIENWvW5Pjx4/zyyy8AdO/enfLly2d7/ebNmwFwcnJixowZuS73mbnoZC8fffQRCxYssEtfkZGRBAYGZnku8z3IfG+yc+nSJdtr9PX1xc/P744zZOxJZ7VamTJlSr6u+eqrr/jqq6+A9KUrS0Nh7e5b3FJEpBRITk3m18u/0tCvodlR7noNKzXkfNx5riZdNTuK5MJqtbJk/kVWLIqmzZ/KMX7q/UVSVMusVh0PpsysSfXAMsz44DQ/hhbst/dERERERETk7rB7927Gjx8PpC+luHz5cubOnQuk7z3Vv39/kpOTTUyYfxcuXOD48eNA+oyt6tWrF6gfLy8vWrVqBcCNGzfYtWtXjm3Pnj3LkSNHgPQZd7kVIe0p8zKPGbPUMv77x/N/FB0dDaTP7sut+BgeHs6lS5cKmbT4dejQAVdXVwC2bduW6z5r33//ve24a9euRZ6tNFNhTUTEBEcvH8VitdCwkgprRS3ja3ww+qDJSSQnaWlW5n98njWrLvFoNx9eGVUVF5fi+RGlXHln/vq3GtSu58Gcf55l60YVYEVERERERO5FcXFxDBgwgNTUVAzDYMGCBfj4+NCvXz9bYebAgQOMGTMmxz4CAwOxWq12+VPY2Wrjx4+3zR5q3749Hh4eBe6rT5//7Vs/c+bMHNvNmjXLNmZOSy8Whccff9w2I23x4sVYrVYWL14MQPny5enevXuO12YsnRgTE0NcXFyO7SZOnGjHxP8zf/58u33P/HG2GqTPAOvWrRsAsbGxOX5fWa1WZs+ebXuc+Z7fiYzvu7z+DBo0yHbNF198YXv+9ddfL9C4xU2FNRERE2QUeVRYK3oN/NKX24yIjsijpZjBak0vqn3/3RW6P+XL8y8H4OBgFGuGMu6O/N97NWjYuCwff3ROxTUREREREZF70PDhwzl16hQAo0ePplOnTrZzc+bMISgoCEgvLGWe2VPcxo4dm+ueXBaLhXfffZd58+bZnnv77bdzbB8YGIhhGBiGQWhoaLZthg4dSkBAAAArVqzIdunCzZs3M336dCC9mPPmm2/m5+XYhYuLC7179wbg1KlTTJs2jd9++w1IL/C5uOS8Ik7z5s2B9M8nxo0bd9t5q9XKu+++yzfffGP/4MXknXfewTDSP2sZO3Zslv3NMkycOJHdu3cD6V+TjGLcH82fP9/2/dKhQ4ciy1zSaY81ERETRERH4OroSk2fmmZHuev5l/XH191XhbUS6tv/XGLj2is8/rQvA4ZUtv2gV9xc3Rx4851A/jExik9mn6NcBScaN/MyJYuIiIiIiIgUr6VLl7Jw4UIAGjduzKRJk7Kc9/T0ZMmSJbRp04bU1FQGDx5MREQEFStWLPasc+fOZerUqbRu3ZqHH36YWrVq4e3tTVJSEkeOHGHFihW2ohKkF9Xat29fqDHd3d2ZN28ePXv2xGKxMGTIENauXUvXrl1xcnIiLCyML7/8ktTUVACmT59OpUqVcuwvMDDQtpfX1q1b7VKgCQkJsRUT//rXv2Z5PjevvPIKn3/+ORaLhY8++oj9+/fz9NNP4+/vz9mzZ1myZAnh4eHUrVuXMmXKsHfv3kJnLW6NGzfmrbfeYurUqdy4cYPWrVszdOhQWrRoQXx8PKtWrWLjxo1AelF03rx5pn0+U1qosCYiYoKImAjqVqyLk4PehouaYRg08GvAwRgtBVnS/Lj1GksXXKR1+3L0H2xeUS2Ds7MDo8ZWZ8KYU8z44AzjPwiixgPupmYSERERERGRohUVFcXLL78MpBeQlixZku0Mp5YtWzJ+/HjGjRvHxYsXGTJkCN99911xxwXSZ1Ht2LGDHTt25NjG3d2dqVOn8uqrr9plzO7du7NgwQKGDRtGfHw8K1euZOXKlVnaODs7M3XqVIYOHWqXMe/Eww8/TI0aNYiMjCQlJQWAoKAgHn744VyvCw4OZtasWbz66qukpaWxbds2tm3blqVNnTp1WL16tSmvy16mTJlCSkoKM2bMICEhIdslPf38/Fi6dCnBwcHFH7CU0VKQIiImiIiO0DKQxahhpYYcijlEmjXN7CjyX4cj4pk78xx1G3jw8uv3Ffvyjzkp4+7I/42vgaenIx+MjyImOsXsSCIiIiIiIlJELBYLAwcO5MaNGwBMmzaN2rVr59h+7NixtGvXDoC1a9dm2ZOquHz//ff885//5JlnnqFhw4ZUrlwZFxcXypQpw3333Ue3bt345z//ydmzZ+1WVMswYMAADh06xFtvvUW9evXw9PTEw8ODWrVqMXz4cMLDwxk1alSe/SQlJdmOfX197ZLNMAwGDhx4W978ePnll9mxYwe9e/fG398fZ2dn/Pz8aN26NdOmTWPPnj088MADdslpFsMwmDZtGjt27GDw4MEEBQXh5uZGuXLlaNKkCRMnTuTw4cN07NjR7KilgpGxmeC9KCAgwHr+/HmzY4jIPeZSwiX8PvTjn53/yRsPvWF2nHwzJtxe+LC+Vzr+Dvls32cMXTOUkyNOcn+F+82Oc8+7fCmFsSNP4OXtxMR/PIBHWcdC9df38duX+Vz2XeEK1+fO3OTdv5ykkr8rE/5xPy4u+l0kKZzQ0NB7ev15EZGC0HuniNwLjh49Sp06dezSV1xcHJ6ennbpS6SoHDt2zFa87NGjB6tXrzY5kdwNCvNeahjGXqvV2uxOrtGnRCIixSxjScIGfg1MTnLvyJgdqH3WzJd6K42ZH5zh1i0ro9+uXuiiWlG5r5obr7xRlchTSXw5T7+EIyIiIiIiImIPmzdvBsDBwYHJkyebnEakYFRYExEpZhnFHS0FWXzq+dXDwNA+ayXAos8vcOJYIsNG3kfAfW5mx8lVs5bePNGrIps3XGXbD9fMjiMiIiIiIiJS6mUU1kJCQqhXr57JaUQKRoU1EZFidjD6IH4eflQqW8nsKPcMd2d3HqjwgGasmWzXj9fZsOYKXXv40qpNObPj5Evf5/ypU9+DT+ec42zUTbPjiIiIiIiIiJRaaWlphIaG4urqyoQJE8yOI1JgKqyJiBSziJgIzVYzQYNKDTRjzURXL9/ik1m/88CD7gwY4m92nHxzdDQY+X/VKFPGkdn/PEPqrTSzI4mIiIiIiIiUSg4ODly7do2bN29SvXp1s+OIFJgKayIixciSZuFQzCHtr2aChn4NOXHlBIm3Es2Ocs+xWq18POscqalpDH+jKk7OpevHj3LlnfnziCqcjrzJqmUxZscRERERERERERETla5PtkRESrmTV09yM/WmZqyZoEGlBlixcuTSEbOj3HO2bLjKgb1x9B9SmcpVXM2OUyDNWnrTvlN5vlkZw4ljKs6KiIiIiIiIiNyrVFgTESlGGUsRqrBW/DK+5tpnrXhdvJDMws8u0CC4LI928zE7TqEM+nMAPj7O/GvaGZJvaklIEREREREREZF7kQprIiLFKCI6AgfDgboV65od5Z4TVD4Id2d3DkZrn7XiYrVamffRORwc4KWR9+HgYJgdqVDcPRwZ9npVLvyeworFF82OIyIiIiIiIiIiJlBhTUSkGEVER1DLpxZuTm5mR7nnOBgO1PerT0SMZqwVl+1br3PkYAIDhlTGt6KL2XHson6jsnTsXIH1qy9zOjLJ7DgiIiIiIiIiIlLMVFgTESlGEdERWgbSRA39GhIRHYHVajU7yl0vPi6VRZ+dp+aD7nTsUsHsOHbVf4g/HmUd+XTO76Sl6XtJREREREREROReosKaiEgxiUuOI/J6JA39VFgzS4NKDbiceJnohGizo9z1lsy/SHychaHDq5T6JSD/qKynEyEvBHDi10R+2HjV7DgiIiIiIiIiIlKMVFgTESkmh2IOAenFHTFHxmxB7bNWtI4dTeCH76/Stacv1YPKmB2nSLTtWI66DTxY+sVFblxPNTuOiIiIiIiIiIgUExXWRESKSUR0+t5eWgrSPA380ouaGfdC7C/NYuWLf/9OBV9nevevZHacImMYBi+8UoWbyWks+/KC2XFERERERERERKSYqLAmIlJMIqIj8HTxpLp3dbOj3LN83H0I8AwgIkaFtaKy7YdrRJ26yYAh/riVcTQ7TpGqUtWNxx73IXTTNaJ+SzI7joiIiIiIiIiIFAMV1kREisnBmIM0rNQQw7i79psqbRr4NdBSkEXkZpKFZV9epOaD7rRuV87sOMXi6b6VKOvpyMJPz2O1Ws2OIyIiIiIiIiIiRUyFNRGRYmC1WomIjrAtRSjmaVipIUcuHSE1Tfti2dvq/1zi+rVUnvtz5XumgOxR1pFn+lficEQCe3fHmh1HRERERERERESKmAprIiLF4GzsWW4k39D+aiVAA78GJFuSOXHlhNlR7iqXY1L47utLPNy+HDVre5gdp1h16upDlaquLPrsAqm30syOIyIiIiIiIiIiRUiFNRGRYhARnb6nlwpr5su4Bxn3ROxj2ZcXAeg3yN/kJMXP0dFg4AuVuXghhY3rrpodR0REREREREREipAKayIixSBjT6/6fvVNTiK1fWvjaDhyMEb7rNnLmagkdoRdp2sPX3z9XMyOY4rGzbyo36gs36yIJinRYnYcEREREREREREpIqWmsGYYxmOGYRwzDOOkYRhjsjnvbRjGGsMwDhiGcdgwjCFm5BQRyU5ETATVvavj7eZtdpR7nquTK7V9a2vGmh0tXxhNGXcHejxT0ewopurznD+xNyysW33Z7CgiIiIiIiIiIlJESkVhzTAMR2AO0BWoC/QzDKPuH5oNB45YrdZGQAfgn4Zh3Ju/Ni8iJU5EdISWgSxBGlRqoBlrdnL8aAJ7d8fyRC8/ypZ1MjuOqWo+6E7zVl589/Ul4mJTzY4jIiIiIiIiIiJFoFQU1oAWwEmr1fqb1WpNAZYBPf/Qxgp4GoZhAGWBq4A+1RIR0yWnJnPs8jEV1kqQhn4NiboeRWxyrNlRSjWr1cqyLy/iXc6Jrk/4mB2nRHg2xJ+bSWl8+59LZkcRERERERGRe4DFYmHlypX07duXBx54gLJly+Ll5UXNmjXp2rUrf//73zlx4oTdxjt9+jRjxoyhQYMGeHt7U7ZsWWrXrs2IESM4fPiw3caRovHTTz/x/PPPc//99+Pu7k6FChVo2rQp77//Ppcv228Fng4dOmAYRr7+BAYG2m3c4lJafrW8CnA20+NzQMs/tJkNfAucBzyBPlarNa144omI5Ozo5aNYrBYV1kqQBpUaAHAo5hCtq7Y2OU3pdehAPEcOJjD4pQDcyjiaHadEqFrdjTYdyrHhu8t07elLBR9nsyOJiIiIiIjIXSo8PJwXXniB8PDw287FxcVx8uRJNmzYwPnz55kxY0ahx1u8eDHDhg0jPj4+y/PHjh3j2LFjzJs3jw8++IBRo0YVeiyxL6vVyujRo5kxYwZWq9X2fFJSEteuXWPfvn3Mnj2bJUuW0LFjRxOTlg6lpbBmZPOc9Q+PuwD7gY7A/cAmwzC2W63WLNMRDMN4EXgRoHLlyoSGhto9rIhIZt9f/B6ApKgkQi+FmhvGzkrre2jCzQQA/rP9P6QEpJicpnSyWuGbJV6U9TRwLnMIc78VKtz2jJnfm1Xvd2BHmDdzpofTtlOiaTmkZImPjy+175kiImbRe6eI3Au8vb2Ji4uzS18Wi8VufUnJt3v3bnr16kVsbPrH302aNKFr165Ur14dgN9//51jx46xceNGUlJSCv29sWHDBgYNGoTFYsEwDJ588kkeeeQRnJyc2LFjB8uWLSMlJYU33ngDZ2dnBg0aVOjXKPbz3nvvMX36dAA8PDwICQmhadOmJCQksHr1arZu3Up0dDQ9e/Zkw4YNNGxYuAkCFovFdrxkyZJc25YpU6bQ3583b94s1p8bjczVyZLKMIyHgPFWq7XLfx+PBbBarVMytVkLfGC1Wrf/9/EPwBir1fpzTv0GBARYz58/X6TZRUTe3Pgms3+eTfxf43FyKC2/z3A7Y8Ltv+Ngfa/k/x2SHavVSvmp5RnQYABzus8xO06pFBEex+R3Ihk6vAqdupq7DGTfxyNue27Zd+bOEJ330Tm2b73GzE9ra9aaAOnF3g4dOpgdQ0SkVNF7p4jcC44ePUqdOnXs0ldcXByenp526UtKtujoaOrVq8eVK1dwc3Pjiy++oG/fvtm2tVgsxMTEULly5QKPl5iYSM2aNcn4LH3+/Pm3Fc42bdpEt27dSE1NpWzZspw8eZJKlSoVeEyxn/DwcJo2bYrVasXb25tt27bdVjgbP348EyZMAKB58+bs3r2b9F23CqZDhw6EhYUBUBw1qMK8lxqGsddqtTa7k2tKyx5rvwA1DcOoYRiGC9CX9GUfMzsDPAJgGEYl4EHgt2JNKSKSjYMxB6nnV69UF9XuNoZh0KBSAyJibi/ISN6sViurlkZTwdeZ9p3Kmx2nROr5bEUsFitrvtJeayIiIiIiImJfI0eO5MqVK0B6kSunohqAo6NjoYpqAJ988omtqNa7d+9sZ6M9+uijtiUg4+Pj+fDDDws1ptjPxIkTbcWtyZMnZzsb7b333qNFixYA/PLLL6xbt65YM5Y2paKwZrVaU4FXge+Bo8AKq9V62DCMYYZhDPtvs78BrQ3DOAhsAf7ParXab7c9EZECioiO0P5qJVADvwYcjD5YLL81c7c5cjCBY0cS6flMRZydS8WPEsWukr8rbTuWZ/P6K1y/dsvsOCIiIiIiIpKDsLAwHB0dMQyDatWqcf369RzbRkZG4u3tjWEYeHh4cOzYseIL+l+nT59m5cqVALRr144+ffoU+ZjLly+3HY8cOTLHdiNGjLDNclqxYkWR5fn2228xDAPDMBg9enS+rnnjjTds16xZsybLOavVyvbt23n77bfp2LEjAQEBuLq64uHhQY0aNejbty9r1qzJ8zOk8ePH28bIWJZwy5Yt9OvXjxo1auDm5oZhGERFRRXkZRdIXFwc69evB8DLy4vBgwdn284wDEaMGGF7nPmey+1KzadhVqt1ndVqrWW1Wu+3Wq2T/vvcv61W67//e3zearV2tlqtDaxWa32r1brI3MQiIhCTEMPF+Is08GtgdhT5g4aVGnIj+QZnY8+aHaXUWbU0mvIVnPhT59v3NpP/ebK3H6mpVr77WrPWRERERERESqr27dszZswYAM6ePcuLL76YbbvU1FT69+9v29Ns5syZPPjgg8WWM8OCBQtIS0sDYOjQoUU+XmxsLLt27QLS9wR86KGHcmxbtWpV6tatC8CZM2c4cuRIkWTq2rUrvr6+ACxdutT29ciJxWJh2bJlAPj6+vLYY49lOf/888/Trl07Jk+ezNatW7lw4QIpKSkkJiYSFRXF8uXL6dGjB926dbPd/7xYrVZeffVVOnXqxLJly4iKiiI5ObkAr7ZwwsLCbOO2a9cOd3f3HNt26dLFdpxRjJPslZrCmohIaXQw+iCAZqyVQBnFzox7JPlz9FA8Rw4m8EQvP1xc9GNEbipXceXh9uXYtPYKsTdSzY4jIiIiIiIiOZgwYQItW7YEYOXKlXz++efZtskoMPXq1atYilrZ2bZtm+24Y8eOXLlyhffee48GDRpQtmxZvLy8qFevHiNGjOD48eOFHu/IkSO2mVrBwcE4OOT+WUCzZv/bqurQoUOFHj87zs7Otpl6Fy5cYMuWLbm237JlCxcuXACgb9++ODtn3Qs9KSkJV1dXOnfuzLhx4/jiiy9YsWIFc+bMYeTIkVSokP6LxRs2bOC5557LV8Z//OMfzJkzB39/f8aMGcOiRYuYP38+r7zyCq6urnf6kgss8z1o2rRprm0rVqxI9erVAbh8+TIxMTF2ydC9e3cqV66Mi4sLPj4+BAcHM2LECPbv32+X/s2gDX9ERIrQwRgV1kqq+n71gfSlOrvX6m5ymtLjmxUxeJdz4pEumq2WH08968eO0OusW32Zvs/5mx1HREREREREsuHk5MSSJUsIDg4mLi6O1157jbZt21KzZk0AfvzxR6ZMmQKkz8r65JNPsu0nMTGRjRs32iVTtWrVaNKkyW3P79mzB0ifPXb69Gl69erFxYsXs7Q5cuQIR44cYe7cuUyZMoW//OUvBc6RuTgXGBiYZ/uMwswfr7W3gQMHMmfOHAAWLVrEo48+mmPbRYv+t7jdwIEDbzs/fPhw/v3vf1OuXLlsr580aRJDhgxh5cqVrF69mrCwMNq3b59rvvXr19OmTRvWrl2Ll5eX7fk/7k+3b98+zpw5k2tf+dW5c+fbZqQV5P6dPn3adq2fn1+hc2Xer+3q1atcvXqVAwcOMHv2bIYMGcKcOXMoU6ZMoccpTiqsiYgUoYjoCCp5VMLPo/B/CYl9ebt5U927OhExEWZHKTVO/5bEgX3x9H3OH1c3zVbLjypV3Wj+kBeb1l3hyd4VcSvjaHYkERERERERyUZQUBBz5szhueeeIyEhgf79+7Nz504SEhIYMGAAFosFBwcHFi5cSPny5bPtIyYmhqeeesoueQYNGsT8+fOzPJecnMyNGzcAcHR05PHHH+fatWsEBQXx/PPP88ADD3Dt2jVWr17Nhg0bsFgsvPXWW7i4uOS6N1puMu85l7H8Ym58fHyyvdbeWrVqRc2aNTlx4gRfffUVc+fOzXaZw8TERL7++msAatasaZuZmFnbtm1zHcvDw4PPPvuMdevWkZCQwMKFC/MsrHl4eLB8+fIsRbXsfPTRRyxYsCDXNvkVGRl5W/HMzPvn4+NDly5daNq0KQEBAVitVqKiovjuu+/YuXMnAF988QVnzpxhw4YNODmVnnKVPhUTESlCEdERNKik/dVKqoaVGmopyDuw5utLuLo50KmbZqvdiSeerkhCvIUfNl4zO4qIiIiIiIjkIiQkhAEDBgDpM8PeeecdXnrpJduMorFjx+ZZUClK167979+VV69e5dq1azz22GMcPnyYt99+mz59+jBs2DDWr1/Pv//9b1vbt956i3PnzhVozPj4eNuxm5tbnu0zzzyKi4sr0Jj5lTH7LD4+ntWrV2fb5ptvvrG9hpCQkAKP5enpSYMG6Z/x7d69O8/2vXr1IiAgoMDj2YtZ92/KlClcuHCBxYsX88Ybb9C3b1/69evH2LFj2bFjB1999ZWtELplyxamTp1a4LHMUHpKgCIipYwlzcLhS4d5pdkrZkeRHDTwa8C6E+tITk3G1an41rcujS7HpLAz7DqPPeFL2bL68eFO1KztwYN13Vn3zSU6d/fByckwO5KIiIiIiJRC8aGhpF66lON5S6qF60531yoZThUrUrZDh2Id81//+hc7d+4kMjIyy4f9LVu2ZPz48bleGxgYaNuPrCikpaVleezp6cmiRYuyLZi89NJLbNq0iVWrVpGSksLcuXOZNGlSocY3jJL179mBAwfy3nvvAenLPfbr1++2NpmXgcwommYnOTmZFStWsHr1ag4cOEB0dDTx8fHZ3s/8FCnzmgWXYf78+bfNTCwqxXn/HnrooVzPP/XUU3zyySe2e/KPf/yDN998s1j3nysMzVgTESkiJ6+e5GbqTe2vVoI1rNQQi9XCr5d/NTtKibdu9WUAuvXMe9kAud0TvSpy+dItdv143ewoIiIiIiIikgsvLy+WLFmSZVk6T0/P254zg6enZ5bHTz/9dJal+/7oxRdftB1v3ry5QGOWLVvWdpyUlJRn+8xt/pjX3oKCgmjdujUAGzdu5NIfCs8xMTFs2rQJgIcffpigoKBs+zl48CANGjTgueeeY9WqVZw8eZK4uLgci6SxsbF5ZqtSpcqdvJQiU5LvX//+/XnwwQcBuHHjBjt27CjS8exJv3IuIlJEIqLT9+7SUpAlV8a9iYiOoJF/I5PTlFzx8an8sPEqrduVw9fPxew4pVKT5l4E3OfKd19d4uH25Urcb/mJiIiIiEjJl9fMrbi4uCL/IPxeUaVKFTw8PGz7mTVt2jTHokxxKlu2LE5OTqSmpgLQpEmTXNs3bdrUdnzq1KkCjVmuXDnb8ZUrV/Jsn7lN5muLSkhICDt37iQ1NZVly5YxYsQI27lly5bZvlY5LQN59epVOnXqRExMDABVq1bl8ccfp3bt2lSsWBE3Nzfbv+HHjRvH4cOHb5s5mJ3MSyqaqaTfvw4dOnDs2DEAjh07RseOHYt8THtQYU1EpIhEREfgYDhQt2Jds6NIDmr51MLF0YWDMdpnLTeb113lZlIaTzxd0ewopZaDg8HjT1dk3kfnOLg/noaN9Y9dERERERGRkigtLY2QkBBbUQ0gNDSUuXPn8vLLL+d6bWJiIhs3brRLjmrVqt1WODMMg5o1a3L06FEAvL29c+0j8/nMr+dO1KpVy3YcFRWVZ/vTp09ne21RefbZZxk5ciQpKSksWrQoS2EtYxlIFxcXnn322Wyvnz17tq2oNmjQID799NMcZyYWdinN7Ozbt8+2h19hde7c2bZvWYaSfv8yz7jMvIdgSafCmohIETkYc5AHfR7EzSnvjUHFHE4OTtStWNc2u1Bud+tWGhvWXKZh47JUDyoZv21VWrX9UzlWLLzImq8uqbAmIiIiIiJSQk2ZMoWwsDAAHnnkEfbs2cONGzcYPXo07du3p27dnH+BOiYmhqeeesouOQYNGpTt3lsNGza0FdbyWpIwczEtryJcTurWrYuDgwNpaWmEh4eTlpaGg0POO0zt2bPHdly/fv0CjXknKlSoQLdu3fjmm2/4+eefOXHiBDVr1uT48eP88ssvAHTv3p3y5ctne33GEplOTk7MmDEj1+U+Mxed7OWjjz5iwYIFdukrMjKSwMDALM9lvgeZ7012Ll26ZHuNvr6++Pn52SVXbop7hpy9aI81EZEiEhEdof3VSoGGlRpqxloutm+9zvVrqTzRS7PVCsvZ2YHHnvDlYHg8Ub/lva65iIiIiIiIFK/du3czfvx4AAICAli+fDlz584F0vee6t+/P8nJySYmhK5du9qO9+7dm2vbzOcLOvvIy8uLVq1aAemFul27duXY9uzZsxw5cgRIn3GXWxHSnjIv85gxSy3jv388/0fR0dFA+syp3Ao74eHht+3hVhp06NABV1dXALZt25brPmvff/+97Tjz91lRyihiQ/HMkLMXFdZERIpAbHIskdcjaeCn/dVKugZ+DTgfd54riXmvM32vSUuz8t1Xlwi83436jcrmfYHkqVO3CriVceC7r0rfD+MiIiIiIiJ3s7i4OAYMGEBqaiqGYbBgwQJ8fHzo16+frTBz4MABxowZk2MfgYGBWK1Wu/zJbrYaQM+ePW3L/X399de57ps1b9482/Fjjz1WgK9Kuj59+tiOZ86cmWO7WbNmYbVaAXJcerEoPP7447YZaYsXL8ZqtbJ48WIAypcvT/fu3XO8NuNrGRMTQ1xcXI7tJk6caMfE/zN//ny7fc/8cbYapO/L161bNyB9hmNO31dWq5XZs2fbHme+50Vl6dKl/PrrrwB4enrSpk2bIh/TXlRYExEpAodiDgFoxlopkHGPNGvtdgf2xnH+XDKPP1XRtlGvFE7Zsk507FyBnduuc/XyLbPjiIiIiIiIyH8NHz6cU6dOATB69Gg6depkOzdnzhyCgoKA9MJS5pk9xa1cuXKMHj0aSC+UhISEcPPmzdvazZs3j1WrVgHg4eGR4/5wgYGBGIaBYRiEhoZm22bo0KEEBAQAsGLFimyXLty8eTPTp08H0os5b7755h2/toJycXGhd+/eAJw6dYpp06bx22+/AekFPhcXlxyvbd68OZBeWBo3btxt561WK++++y7ffPON/YMXk3feecf2uc7YsWOJiLh9S5SJEyeye/duIP1rklGM+6P58+fbvl86dOiQbZuPPvrI1ldOvvnmG4YOHWp7PHr0aNzcSs92OtpjTUSkCByMTi/SqLBW8mXco4joCDoEdjA3TAmz4bsrlK/gRKs25cyOclfp8oQP67+9zKb1V+gT4m92HBERERERkXve0qVLWbhwIQCNGzdm0qRJWc57enqyZMkS2rRpQ2pqKoMHDyYiIoKKFc3ZNmHMmDGsX7+ePXv2sH79eurXr8/zzz/PAw88wLVr11i9ejXr16+3tf/4448LldXd3Z158+bRs2dPLBYLQ4YMYe3atXTt2hUnJyfCwsL48ssvSU1NBWD69OlUqlQpx/4CAwNte3lt3bo1xwLNnQgJCbHN0PvrX/+a5fncvPLKK3z++edYLBY++ugj9u/fz9NPP42/vz9nz55lyZIlhIeHU7duXcqUKZPn8pslUePGjXnrrbeYOnUqN27coHXr1gwdOpQWLVoQHx/PqlWr2LhxI5BeFJ03b16hfsH6hx9+YOTIkTz44IM88sgj1KtXDx8fH6xWK1FRUaxZs4adO3fa2v/pT39i7NixhX6dxUmFNRGRIhARHYGXqxfVvKuZHUXyUMmjEr7uvrZiqKQ7f+4mB/bG0XtAJZycNFvNnir5u9KkuSdbNlzhqT5+uLhoAQERERERERGzREVF2WZzubu7s2TJkmxnOLVs2ZLx48czbtw4Ll68yJAhQ/juu++KOy6QnnPdunU8++yzhIaGcurUKd5+++3b2pUpU4a5c+cyYMCAQo/ZvXt3FixYwLBhw4iPj2flypWsXLkySxtnZ2emTp2aZSZScXn44YepUaMGkZGRpKSkABAUFMTDDz+c63XBwcHMmjWLV199lbS0NLZt28a2bduytKlTpw6rV6825XXZy5QpU0hJSWHGjBkkJCRku6Snn58fS5cuJTg42C5jHjt2jGPHjuV43jAM/vznPzN9+vRcZxWWRPokR0SkCETERNDAr4GWzysFDMOgYaWGRMTcPg3+XrZx7RWcnAweeayC2VHuSl2e8CX2hoVd22+YHUVEREREROSeZbFYGDhwIDdupP/bbNq0adSuXTvH9mPHjqVdu3YArF27NsueVMWtYsWK/PDDD6xYsYKePXtStWpVXFxc8Pb2pnHjxowdO5aTJ08yaNAgu405YMAADh06xFtvvUW9evXw9PTEw8ODWrVqMXz4cMLDwxk1alSe/SQlJdmOfX197ZLNMAwGDhz4/+zdZ1gc1/n38e/ZXui9g5BQFwL1LiS5d8dx747txIlTnX9ip7nEduInjpM4cRLbcWzHvUZyL5KFem+oFySE6EJ0FpYt87xAIpLVYWGAvT/XxQUss3N+aEfL7txz7nNc3jNxzz33sGzZMq6++moSEhIwm83ExcUxZcoUnnrqKdauXcugQYMCklMvSimeeuopli1bxm233UZmZiY2m42IiAjGjBnDI488wtatW5k9e3aXx/rjH//I888/zx133MG4ceNIS0vD4XBgsViIi4tj2rRp3H///ezYsYNnn322Y527vkQdWUwwGCUlJWllZWV6xxBC9DOaphH5RCQ3jLqBv1/8d73jBIx6+PgiofZg//gb8uPPfsxz65+j4f4GjAaj3nF01+Ly8d1btzN2Uhj33tf7Z11ed8nxRdE3P+rdbVg1TeO+e3Zhsxt47KlBUoQPAvn5+QFpbyKEEMFEnjuFEMFg+/btDBs2LCD7amxsJDQ0NCD7EqK77Ny5s6N4edlllzFv3jydE4n+oCvPpUqpdZqmjTub+8iMNSGECLADDQeod9fL+mp9yKj4Ubg8LvbW7tU7Sq+waEEtLS1+LrgkMFeNieMppTj/kmj27m5hz06X3nGEEEIIIYQQQogeMX/+fAAMBgOPP/64zmmE6BwprAkhRIAVVLbPnpHCWt9x5LHaXCXrrPn9Gl98fIhBQxwMGtL3puL3JTNmR2J3GPjsw0N6RxFCCCGEEEIIIXrEkcLazTffzIgRI3ROI0TnSGFNCCEC7EhhbWTcSJ2TiDM1PHY4BmXoeOyC2eYNTZSVuLngkmi9o/R7doeRvHOiWLm0jtoaj95xhBBCCCGEEEKIbuX3+8nPz8dqtfLwww/rHUeITpPCmhBCBFhBZQEZERmEWcP0jiLOkMPsYFDUICmsAZ99VE14hIlJ08L1jhIUzrs4Gp8P5n8qs9aEEEIIIYQQQvRvBoOB2tpaWltbSU9P1zuOEJ0mhTUhhAiwzVWbpQ1kH5Qdnx30rSAryt1sXNvIORdGYTLLS4SekJhsJWdsKAs+q8Hr8esdRwghhBBCCCGEEEKchpw1E0KIAGr1trKzeifZcVJY62uy47IprCmkqa1J7yi6+eKjQxgMcM6F0gayJ11wWQx1tV5WLqvXO4oQQgghhBBCCCGEOA2T3gGEEKI/2X5wOz7Nx6j4UXpHEWdpVPwoNDS2Vm1lYspEveP0uDa3n0ULapkwJZzIKLPecYJKdm4I8YkW5n9aw7S8SL3jiE7ytnppLHfRWNpEc1UL7vo22po9+Dx+/G1+DJqTVZs2YbQYsIRZsEdYccTZCU10EprkRBmU3r+CEEIIIYQQQgghzoAU1oQQIoCOtBKUVpB9z5HHbHPV5qAsrK1cVk9zk09mq+nAYFDMOT+K11+qoKS4lZQ0m96RxBlqrmrh4LYaDu2qw3WwpeN2W6QVW4SV8CgrrkOtKIOiob4Bc4gJzavh9/ip3lWHd2M1AEarkYgBYURlhhGVFYElRIrbQgghhBBCCCFEbyWFNSGECKCCygJsJhuDogbpHUWcpYyIDEIsIRRUFugdRRfzPz1EYrKF4aOcekcJSnnnRvHWq5XM//QQt307We844hQ8LV4qNhykavMhXNWtoCA8LZT0GUmEJrfPPjPZ/vcSe8ljawFQGGluai++Tf/lODRNo63JQ0NJE3V7G6gprOfQjlqUoZjowREkjIklIiMUpWQmmxBCCCGEEEII0ZtIYU0IIQKooLKA4bHDMRnk6bWvMSgDo+JGBWVh7UBRK7u2u7jpjkQ5ia+TsHATE6eEseSrOm64LRGLVZbB7W3cDW2UrqqkfMNB/B4/YSkhDDw/jZihkZ2aYaaUwhpqIXZYFLHDotA0DdfBFioLDlFZUE31jlpskVZSpyQQnx0jrSKFEEIIIYQQQoheQs78CiFEABVUFnBh1oV6xxCdNCpuFO9ufxdN04KqwDT/s0OYzYoZc2R9Lz3NuSCa5YvrWbG0jplzovSOIw7zuDwULSqjcmM1mqYROyKK1EkJOOMdAR1HKYUzzkHmOQ4y8pKp3lFL2Zoqdn+8n5IVFaTNSCZ2eGRQPTcJIYQQQgghhBC9kRTWhBAiQKqaq6hsriQ7TtZX66uy47N5bv1zlDWWkRwWHO343K1+liysZeLUcMLC5WWBnoaPcpKUYmX+pzVSWOsFNL9G2boqiheX4XX7SBwTS8rkBGzh1m4f22AyEDcymtgRUdTsrqcov5Sdc/dSssJO1oXphCaHdHsGIYQQQgghhBBCnJicQRNCiADZXLkZaC/OiL7pyGNXUFkQNIW1FUvqcDX7mXNBtN5Rgp5SijnnR/HKC+UUF7WQlmHXO1LQaixtYtfHRbgOthIxIJTMc9Nwxvb846GUInpwBFFZ4RzcWsO+BSVsfHkHyePjSZ+ZhNFi7PFMQgghhBBCCCFEsJMFPIQQIkCOrM01Kn6UzklEZ42MGwnA5qrNOifpOfM/qyE51crQEYFtayc6Z8acSMxmxfxPa/SOEpQ0v8b+xWVsfHkHPrefYd8cyMjrB+tSVDuaUoq4kdGM/fYIEnNjKV1dybrntlK7r0HXXEIIIYQQQgghRDCSwpoQQgRIQVUBcc444pxxekcRnRRpjyQ1LLWjSNrfFe1tYc9OF3MuiJZ1m3qJ0DATE6eFs2RhLa2tfr3jBJWWmlY2vbyD4iVlxI6IYsxdw4kZ0rvWNDPZTAy6MJ3sW4ZgMBnY8vou9i8qRfNrekcTQgghhBBCCCGChhTWhBAiQAoqCxgdP1rvGKKLsuOzg6awNv/TQ5gtihlzIvSOIo5yzgXRtLj8LF9cp3eUoHFoZy0bXthGS00rQ6/MZOjlmZhsvbdjenhqKLnfGkZ8djTFS8vZ8sYu2po8escSQgghhBBCCCGCghTWhBAiALx+L1urtsr6av3AqLhR7KjeQZuvTe8o3aq1xcey/DomT4sgJKT3FhCC0ZDhDlLSrCz49JDeUfo9TdPYv6SMbe8WYo+2MeauEcQOj9I71hkxmo0MvnQAWZdk0FDSzPp/baOhpEnvWEIIIYQQQgghRL8nhTUhhAiA3Yd24/a5pbDWD2THZ+Pxe9hZvVPvKN1q5dJ6Wlr8zLmgbxQRgolSijkXRFO4u4X9+1r0jtNv+dp8bH9/L8WLy4gbGUX2zUOxhln0jnXWEkbHkHP7MIwWAwWv7uTgdlmfTwghhBBCCCGE6E5SWBNCiAA40jpQWkH2fUeKo/29HeTCL2tISrEyeJhD7yjiBKblRWAyKRZ+IUWS7tDW7KHglZ0c2lnLgHNSGHzZAIzmvvuy2BlnJ+e2oYQmOtnx/l5KVlSgabLumhBCCCGEEEII0R367hkEIYToRQoqCzAZTAyNGap3FNFFg6MHYzaY2Vy1We8o3aas1M3ObS7yzolEKaV3HHECoWEmxk0OY2l+HR6PX+84/UprvZuC/+zAVd3KiKsHkTIxoV/8PzA7zIy6cTAxwyLZ91UJez4rRvNLcU0IIYQQQgghhAg0KawJIUQAFFQVMDRmKFaTVe8ooovMRjPDY4f36xlri76swWCA6bMj9Y4iTmHWuVE0NfpYu7JB7yj9RvPBFja9vIO2Zi8jb8giKitC70gBZTAZGHplJimTE6hYf5CdH+6T4poQQgghhBBCCBFgASmsKaXilFKXKKV+oZR6Vin1tlLqw8Of/6mUekApdbFSKjYQ4wkhRG9TUFkg66v1I9nx2f22sObzaSz+qpbccaFERpn1jiNOYdToEKJjzeR/Ke0gA6GpvJmCV3ag+WH0zUMITw3VO1K3UEoxYHYK6XnJHNxSw465e/H7ZNajEEIIIYQQ/UVeXh5KqbP+eOmllwIy/v79+7n//vsZNWoU4eHhhISEMHToUL7//e+zdevWgIwhus+KFSu44447GDhwIA6Hg6ioKMaOHcujjz5KdXV1t427bNky7r33XkaOHElUVBR2u5309HSmTZvGL37xC5YuXdptY3cHU2fvqJQaCNwEXA6c8aJCSqmNwFzgVU3T9nV2fCGE6C3qWusori8mO04Ka/1Fdnw2rxS8Qk1LDVH2KL3jBNSm9Y3U1njJO7d//V79kcGoyDsnkvffrKK6qo2YOIvekfqs5koXm9/YhdFsZNRNg7FH2vSO1O3SpiZiMCr2LShB82sMvTITg1GaVQghhBBCCBGsMjMzu7yP1157je985zs0NTUdc/vOnTvZuXMnzz33HL///e/58Y9/3OWxRGBpmsZ9993Hn//852PW5G5paaG2tpb169fzt7/9jddff53Zs2cHbNzq6mruuece3n333eN+VlxcTHFxMcuWLeOTTz5h48aNARu3u511YU0pdR7wE+Dco28+i13kHP54SCn1BfCUpmlfnm0OIYToLTZXtq/FJTPW+o9RcaOA9sd2ZsZMndMEVv6XNYRHmMgdH6Z3FHEGZp4TxXtvVLFoQS1XXR+vd5w+qflgC5tf34XBZGDUTUOwRwZPy96USQkoo2LvFwfY/t5ehl0lxTUhhBBCCCH6ujOdWbRs2TKefPJJAAYOHMj06dO7NO7HH3/Mrbfeis/nQynFN7/5Tc4//3zMZjOLFi3ilVdeoa2tjZ/85CeEhoZy5513dmk8EVgPPPAAf/rTnwBwOp1861vfYsKECTQ1NfHee+/x5ZdfUllZyeWXX86SJUvIycnp8piVlZXMmTOnYyZjeno63/zmNxkxYgQOh4PS0lL27dvHZ5991uWxetoZF9aUUtOA3wOTj9x0+PMhYDWwCtgO1B6+rQEIB6IOfwwDJgITDn8PcB5wnlJqOXC/pmnLuvLLCCGEHo60DJTCWv9x5LEsqCzoV4W1hnov61Y1cMFlMZhMZ3NNjNBLXLyFkaNDyJ9fw5XXxmEwyON2NlyHWtn82i5QilE3BldR7Yjk8fEopSj8vJjdH+9n8KUZKCXHkRBCCCGEEH3VtGnTzmi7N998s+Pr22+/vUvvA1wuF3fffTc+nw+AF198kVtvvbXj57fccgvXXXcdF110EV6vlx//+MdceumlxMfLBaK9wYYNG/h//+//ARAeHs7ixYvJzv7fecxvf/vbPPTQQzz88MM0NTVx9913s2rVqi4dM5qmcc0113QU1X72s5/x29/+FovlxN14Dhw40Omx9HBGl6wqpV4DFgFTaC+olQJ/AHI0TYvVNO1iTdMe0TTtHU3T5muatkHTtEJN09Yf/v5tTdMe1jTtIk3TYmifsfb/gJLD+5sKLFZKvdoNv6MQQnSrgsoCouxRJIUm6R1FBEhCSAIxjph+t87akoW1+HyQd460gexLZp0XycFKD1sLmk6/sejgbmhj82s7QdMYdeNgHNH9v/3jySSNiyN9ZhJVmw+x98sDx7T9EEIIIYQQQvQ/tbW1zJ07FwCDwXBMEawznn/+ecrKygC4+uqrT7i/c889t6MFZFNTU8dsOaG/Rx55pON94OOPP35MUe2IBx98kAkTJgCwZs0aPvnkky6N+eyzz7J48WIAvvOd7/DEE0+ctKgGkJqa2qXxetqZ9oK5nvYC2FfAOZqmpWma9nNN0zp1xlHTtAJN0+7XNC0dOOfwftXhcYQQok8pqCogOz5bZgD0I0opRsWNYnPVZr2jBIymaSz8ooZBQxykpgdvgaEvGj85HKfTyMIva/WO0md4W71seXMXvjY/I28YjDPWrnck3aVOTSR5Qjxla6ooXlqudxwhhBBCCCF6jUWLFmE0GlFKkZaWRl1d3Um33bdvH+Hh4SilcDqd7Ny5s+eCnoXXX38dt9sNtBe8UlJSurS/t956q+PrH/7whyfd7vvf/37H+bG33367S2OeygcffIBSCqUU99133xnd5yc/+UnHfT788MNjfqZpGkuWLOGXv/wls2fPJikpCavVitPpZMCAAVx33XV8+OGHp71I8aGHHuoYIz8/H4AFCxZw/fXXM2DAAGw2G0opioqKOvNrd0pjYyOffvopAGFhYdx2220n3E4pxfe///2O749+zM+Wpmn88Y9/BCAkJIQnnnii0/vqrc60sPYVMF3TtHM0TfsqkAE0TftK07RzgOmHxxFCiD7Dr/nZXLmZ7DhpA9nfZMdns7lqM37Nr3eUgNi7u4WSYjd550bqHUWcJYvFwNS8CNYsr6epyat3nF7P7/Wz7Z09tBxyM/ybAwmJd+gdqVdQSjHgnBTisqMpXlxG+fqDekcSQgghhBCiV5g5cyb3338/0N6O7u677z7hdl6vlxtuuIGGhgYA/vKXvzBkyJAey3k2/v3vf3d8fccdd3RpXw0NDaxcuRJobyM4efLkk26bmprK8OHDASguLmbbtm1dGvtkLrzwQmJiYgB444038PtPfe7G5/N1tMaMiYnhggsuOObnd9xxBzNmzODxxx9n4cKFlJeX09bWhsvloqioiLfeeovLLruMiy66qOPxPx1N07j33ns555xzePPNNykqKuoodvakRYsWdYw7Y8YMHI6Tv0c+//zzO74+UozrjCVLlrBnzx4ArrnmGsLCwjq9r97qjAprhwtq3br+maZpyzRNO7c7xxBCiEDbV7uPZk+zrK/WD2XHZ+PyuNhbu1fvKAGx8MsaLFbFlOkRekcRnTDrvCg8Ho1l+XV6R+nVNE1j54f7qC9uYvClGURk9L8X712hlGLwxRlEDQpnz2f7qd1br3ckIYQQQggheoWHH36YiRMnAvDOO+8cU5g6epsjBaarrrqKO++8s0cznqmCggLWr18PQFRUFJdffnmX9rdt27aOmVo5OTkYDKcuKYwbN67j6y1btnRp7JMxm81ce+21AJSXl7NgwYJTbr9gwQLKy9s7d1x33XWYzeZjft7S0oLVauW8887jV7/6FS+++CJvv/02zzzzDD/84Q+JimpfUuOzzz7jlltuOaOMf/jDH3jmmWdISEjg/vvv59VXX+Wll17iu9/9LlZrz63/ffRjMHbs2FNuGxsbS3p6OgDV1dVUVVV1aswjLSABZs+ejdfr5dlnn2XatGlER0djt9vJyMjgxhtvZP78+Z0aQ28mvQMIIURfdmQNLims9T+j4kYBsLlyM4OiBumcpmvcrX6WLapj4pRwHE6j3nFEJwwYaCd9gI3FC2o5/5IYveP0WkULS6neVkvG7GTiRkbrHadXUgbFkCsyKfjPDra/v5fRtw6VVplCCCGEECLomUwmXn/9dXJycmhsbOQHP/gB06dPJysrC4ClS5fyu9/9DmiflfX888+fcD8ul4svvvgiIJnS0tIYM2bMWd/v6KLgjTfe2OUizq5duzq+zsjIOO32RwozX79voN10000888wzALz66quce+7J5+y8+uqrx9zv6773ve/xz3/+k4iIiBPe/7HHHuP222/nnXfeYd68eSxatIiZM2eeMt+nn37KtGnT+Pjjj4+ZsfX19enWr19PcXHxKfd1ps4777zjZqR15vHbv39/x33j4uLOOsfatWs7vo6JiWHKlCmsWbPmmG3279/P/v37ef3117n22mt58cUXsdv7zntTKawJIUQXFFQWoFCMiBuhdxQRYCPiRqBQFFQWcOWwK/WO0yVrVtTT4vKTd26U3lFEF8yYHckrL5RTeqCV5FRZJ+/rKjcfomRFBYljYkmZlKB3nF7NZDUy/JpBbHxxB1vf2k3O7cOwOM2nv6MQQgghhBD9WGZmJs888wy33HILzc3N3HDDDSxfvpzm5mZuvPFGfD4fBoOBV155hcjIEy+zUFVVxZVXBuYcwq233spLL710VvfxeDy89tprHd93tQ0kcMyac0faL55KdPT/LnI81Xp1XTVp0iSysrLYvXs377//Pv/4xz9O2ObQ5XLx3//+F4CsrKyOmYlHmz59+inHcjqdvPDCC3zyySc0NzfzyiuvnLaw5nQ6eeutt07bBvHpp5/m5ZdfPuU2Z2rfvn3HFc/0ePwqKio6vr733nvZs2cPYWFh3HnnnYwdOxav18uSJUt4+eWX8Xg8vPXWW7S1tfH+++93ajw9nOkaayeklOrSGTql1EVdub8QQuitoKqArOgsHGZZw6e/cZgdZEVnUVBVoHeULlv4ZS1xCRaGjXTqHUV0wdS8CAwGWLygVu8ovU5jaRO7Py4iPD2UzPNSOxbLFidnC7cy4ppBeJq9bHtnD35v/1hPUgghhBBCiK64+eabufHGG4H2WTe//vWv+fa3v90xo+iBBx44bUFFTx988AHV1dUA5ObmkpOT0+V9NjU1dXxts53+Is+jZx01NjZ2efxTOTL7rKmpiXnz5p1wm7lz53b8DjfffHOnxwoNDWXUqPbuRqtWrTrt9ldddRVJSUmdHi9Q9Hj8ji7I7dmzh4yMDAoKCvjjH//IDTfcwC233MLzzz/PsmXLOgqP//3vf3n77bc7NZ4eujpjbbNS6mZN0746mzsppSzAH4HvAtKTSgjRZxVUFpCTkKN3DNFNsuOz2VSxSe8YXVJV2cbWgiauuSkeg0GKDX1ZRKSZ0WNDWbKwjmtvTsBglMcTwN3YxrZ3C7GGmhn2jUwMxi5dNxZUQpOcDLl8ANvfK6Tw82KyLs7QO5IQQgghhDiFXV8+R2PlydcB9/m8GI39q0FZaHwmg8+9u0fH/Pvf/87y5cvZt28fTzzxRMftEydO5KGHHjrlfTMyMjrWI9PDiy++2PF1IGarfV1vu4jxpptu4sEHHwTa2z1ef/31x21zdBvII0XTE3G73bz99tvMmzePTZs2UVlZSVNT0wkfz5KSktNmO90suCNeeumls56Z2Fk99fj5/cdeuPncc88d0yL0iPHjx/PYY4/x/e9/H4C//OUvXHPNNT2Ssau6euYhEfhCKfWEUuqMnrWVUiOBtbQX1YQQos9qamuisKaQ7DhZX62/GhU3ij01e2hua9Y7Sqcty2+f3TR99onbVIi+ZeacSGoOedhS0HT6jYOA3+tn+7uFeN0+hl89CLND2hmerZihkaROSaBiYzXlGw7qHUcIIYQQQgjdhYWF8frrr2My/e90d2ho6HG39Tbl5eV89tlnAFit1lMWkc5GSEhIx9ctLS2n3f7obUJDQwOS4WQyMzOZMmUKAF988QUHDx77nqaqqoovv/wSgKlTp5KZmXnC/WzevJlRo0Zxyy238N5777Fnzx4aGxtPWiRtaGg4bbbk5OSz+VW6jR6P39H3S09PP+X6d7fffjtmc/t7+VWrVh0zw6436+ozgY/24txPgdlKqes1Tdtzso2VUt8HngCsgAJ2dHF8IYTQzdaqrWhoZMdLYa2/yo7PRkNj68GtTEieoHecs6ZpGksW1jFspJPYOIvecUQAjJkQhtNpZPGCWrJzu/cNSl9Q+HkxjWXNDLtqIM44acnbWekzk2mscFH4eTEhcXZCk0NOfychhBBCCNHjTjdzq7GxsdsLGcEiOTkZp9NJfX09AGPHjj1pUaa3+M9//oPP5wPgiiuuOOk6cGcrIiKi4+tDhw6ddvujtzn6vt3l5ptvZvny5Xi9Xt58882O2U8Ab775Jl6vt2O7E6mpqeGcc86hqqoKgNTUVC655BKGDh1KbGwsNputY6bXr371K7Zu3XrcjKwTObqlop70ePyOvt+YMWNOua3T6WTIkCFs2bIFn89HUVERI0eO7NS4PamrhbXpwGvAAGAMsEEp9QNN0148eiOlVCzwInAh7QU1gH8BP+ri+EIIoZuCyva1t6Sw1n8deWw3V27uk4W1fYUtlJW4ufiK0y9OK/oGi8XA5OnhLF5Yi8vlw+EI3o7alQXVVGysJnVKAjFDZUZmVyiDYujlmWz49za2vVdI7reGY3HK7D8hhBBCCBGc/H4/N998c0dRDSA/P59//OMf3HPPPae8r8vl4osvvghIjrS0tNMWJY7WXW0gBw8e3PF1UVHRabffv3//Ce/bXa655hp++MMf0tbWxquvvnpMYe1IG0iLxXLSFoN/+9vfOopqt956K//6179OOjPxscceC3B6WL9+fccafl113nnn4XAce9GpHo/fkCFD+Oqr9tXDwsPDT7v90dsc/f+uN+tSYU3TtJVKqdHAP4AbASfwL6XUBcDdmqbVH/76RSCO9qJaLXCXpmnvdy26EELoq6CygFBLKOkRx/cIFv1DRkQGTrOzo4ja1yxdWIfJpJg47fQvYkTfMWNOJPM/q2H1snryzo3SO44umqta2PNpMeFpIaTP7B3tNfo6s8PE8KsGsuk/O9gxdy+jrh+MknUZhRBCCCFEEPrd737HokWLAJgzZw5r166lvr6e++67j5kzZzJ8+PCT3reqqoorr7wyIDluvfXWM157a/ny5ezcuRNon3F1zjnnBCQDwPDhwzEYDPj9fjZs2IDf78dgOPkKU2vXru34uidmHkVFRXHRRRcxd+5cVq9eze7du8nKymLXrl2sWbMGgIsvvvikM/jmz58PgMlk4s9//vMp230eXXQKlKeffpqXX345IPvat28fGRkZx9x29GNw9GNzIgcPHuz4HWNiYoiLi+tUjuzs/01COJO2mUcX086kENcbdHl1d03TmjRNu5n2wlo97cWzbwKblFIvAB8D8YdvzweypagmhOgPCqoKyI7PxqC6/FQqeimDMjAqfhQFVX2vsObzaSxfXEfu+FBCQnpvD3hx9rKGOkhIsrBoQa3eUXThdfvY/n4hRquBoVdkSvEngEISnQw8P536okYOLC/XO44QQgghhBA9btWqVTz00EMAJCUl8dZbb/GPf/wDaF976oYbbsDtduuY8MT+/e9/d3x92223nbLwdbbCwsKYNGkS0F4AWbly5Um3PXDgANu2bQPaZ9ydqggZSEe3eTwyS+3I56///OsqKysBiI6OPmXrww0bNhy3hltfkJeXh9VqBWDx4sWnXGft888/7/j6wgsv7PSYR993/fr1p9y2ubm5oyhsNpsZMGBAp8ftSQH7H6Zp2htALrCc9iJaGnDb4a/bgF8AczRNKw3UmEIIoRdN0yioLJA2kEEgOy6bzZWbT7pgbW+1ZVMTdbVeps+SFnn9jVKKmXMi2b6lmaqKNr3j9ChN09jz6X5aaloZemUmllBZOzDQ4kdHEzsiiv2Ly6gvbtQ7jhBCCCGEED2msbGRG2+8Ea/Xi1KKl19+mejoaK6//vqOwsymTZu4//77T7qPjIwMNE0LyMeZzlZzuVy8/fbbQPv7xdtvv73L/xZfd+2113Z8/Ze//OWk2/31r3/tOH9ystaL3eGSSy7pmJH22muvoWkar732GgCRkZFcfPHFJ73vkdaJVVVVNDae/D3QI488EsDE//PSSy8F7Jj5+mw1gJCQEC666CKgffbYyY4rTdP429/+1vH90Y/52UpPT2fy5MlAe/vJL7/88qTbvvjii3g8HgCmTZuG0+ns9Lg9KaDTLDRNKwLeOPLtUZ8/A/6o9bWzkkIIcRIlDSXUtdZJYS0IjIofxaGWQ5Q39a3ZG8vy63A4DeSMk4Wr+6NphwumSxYG16y1yk2HOLi1hvQZSUSkh+kdp19SSjHownRsEVZ2zN2Lx+XVO5IQQgghhBA94nvf+x6FhYUA3Hfffce0U3zmmWfIzMwE2gtLR8/s0ds777zTURDKy8s76xk/GRkZKKVQSpGfn3/Cbe68806SkpIAePvtt0/YunD+/Pn86U9/AtqLOT/96U/PKkdXWCwWrr76agAKCwt56qmn2Lt3L9Be4LNYTn5R5vjx44H2wtKvfvWr436uaRq/+c1vmDt3buCD95Bf//rXKNXe7eWBBx6goOD4zkyPPPIIq1atAtr/TY4U477upZde6jhe8vLyTjrmo48+2vH13XfffcI2mmvXruWXv/xlx/f/93//d0a/T28QsMKaUipSKfU+8DTtxTQF+A5/vhRYrZQaGqjxhBBCT0fW3JLCWv935DHuS+ustbb6Wb2inklTI7BYpFVpfxQbZ2FEtpPFX9X2udmUndVS00rhF8WEp4eSOjVR7zj9mslqZNiVmXhcXnZ9uC9ojjEhhBBCCBG83njjDV555RUAcnNzeeyxx475eWhoKK+//jomkwlN07jtttt6TVvAF198sePrO+64o1vGcDgcPPfccxiNRgBuv/12rrnmGl588UVeeeUV7rzzTi666CK83vYL8/70pz8RHx9/0v2dSTHvbB3d7vEXv/jFCW8/ke9+97sdv9fTTz/NzJkz+ctf/sJbb73Fk08+ydixY/ntb3/L8OHDGTt2bECy9rTc3Fx+9rOfAe3tPKdMmcKPfvQjXn/9dZ577jnOP//8jhaoISEhPPfccx2FuM6aPXs299xzD9A+ay07O5v77ruv4//a3XffzdSpUzvWYLvrrru61H6ypwVk0RWl1CzgP0AS7YW0WuDbQCHtM9gGA9nAOqXUfZqm/TMQ4wohhF6OFFlGxnX/IqxCX6PiRgGwuXIzFwy6QOc0Z2bdqnpaW/xMmxWhdxTRjWbMieQffyph13YXQ4b3jVYJneX3+dkxdy8Go2LIZQO6/AJfnF5IopMBc1LY+8UBytZWkTz+5G+KhRBCCCGE6MuKioo6CgAOh4PXX3/9hDOcJk6cyEMPPcSvfvUrKioquP322/noo496Ou4xCgsLWbx4MQDh4eFcddVV3TbWxRdfzMsvv8x3vvMdmpqaeOedd3jnnXeO2cZsNvPEE09w5513dluOk5k6dSoDBgxg3759tLW1L5uQmZnJ1KlTT3m/nJwc/vrXv3Lvvffi9/tZvHhxx7/pEcOGDWPevHm6/F6B8rvf/Y62tjb+/Oc/09zcfMKWnnFxcbzxxhvk5OQEZMy//e1vmEwm/va3v9HQ0MBTTz11wu3uvffejtmOfUWXLmNXSpmUUr8HvuR/RbXFwGhN097VNG0D7euuvXD4Z3bgGaXUPKVUdNeiCyGEfgqqChgQMYAwq7Qi6+8i7ZGkhKVQUNV3Zqwtza8jOtbM0BH9u9gS7CZOCcdqVSxa0P/bQe5fXEZTuYusizOwhsm6aj0laVwcUYPCKfqqhOaDJ1/gWgghhBBCiL7K5/Nx0003UV9fD8BTTz3F0KEnb7r2wAMPMGPGDAA+/vjjY9ak0sOR9bkArrvuOux2e7eOd+ONN7JlyxZ+9rOfMWLECEJDQ3E6nQwePJjvfe97bNiwgR//+Men3U9Ly//eX8TExAQkm1KKm2666bi8Z+Kee+5h2bJlXH311SQkJGA2m4mLi2PKlCk89dRTrF27lkGDBgUkp16UUjz11FMsW7aM2267jczMTGw2GxEREYwZM4ZHHnmErVu3Mnv27ICNaTAYePrpp1m+fDl33nkngwYNwuFw4HA4yMrK4s4772TdunX89a9/xWQKyBywHqO60tpFKbUGGEN70cwLPAI8dqK11JRS3wCeA6JobxVZCdyqadrJV67rZklJSVpZWZlewwsh+rARfx9BVlQWc6+bq3eUHqMePn6GiPZgcLQHu/j1izlQf4CCe3p/ca2h3st3bt7GJd+I5YbbgqNd3nWXHP+4vPlRcLRpfeaPxaxd1cCzrwzHYu2fbT/rihrY/NouEnJiyLo4Q+84Z23JY2uPu236L8fpkKRz2po8rHt+K9ZQCzm3D8Vg7J/HmRCid8rPzz/l2h1CCNEfbN++nWHDhgVkX42NjYSGyjrbonfbuXNnR/HysssuY968eTonEv1BV55LlVLrNE07qzfqXS0DHmkqug+4QdO0VSfbUNO095VSq4FXgJlAAvAJYO5iBiGE6FGt3lZ2Vu/kqmHdN71e9C7Zcdl8Wfglbb42LMbePVtm+eI6/H6YnhepdxTRA2bMiWTJwjrWrmxgyswIveMEnLfVy84P9mGPspJ5bqrecYKSJcRM1kXpbH+3kOLFZWTMStE7kjhLbdV+Wkr8uCv9uCv8uCs1vA0afo+G5gW/p307c5jCdPjDHK6wpxlwDDBiTVAog7RfFUIIIYQQgTF//nygfTbT448/rnMaITonEPPrXgW+p2la4+k21DStRCk1G7gfeChA4wshRI/afnA7Ps1HdnxwzIgRkJOQg8fvYfvB7YxOGK13nFNall9HWoaN1Ayb3lFEDxiRHUJUjJkl+bX9srC298sDtDV5yLl1KEaLUe84QStmSCTxo2M4sKKCyEHhhKfKVdC9ld+tUV/go3Grl6ZtPhq3+Wg7eOzs8iOFM2+TBgZQRkADfxugwNuggf9/2xts4MgwEjrCSPhYExFjjZgjZOaiEEIIIYTonCOFtZtvvpkRI0bonEaIzulqYesWTdNePZs7HG4T+Tul1HzgtS6OL4QQPW5T5SYAKawFkSPFtI0VG3t1Ya2izM3unS5uvD1B7yiihxgMiqkzI/hk7kEa6r2Ehfefa5YO7aqjsuAQqVMSCE0O0TtO0Ms8N5X6/Q3s+mAfY+4aIYXOXqStxk/NMi81Sz3UrvLiP7xchT3NQPhYE6HDjDgyDFjj2z+MjvbZZ0sm1h+3r+mrwtH87TPaXPv9tBT5ce3z0Vzop+rTNsrfa18E3pllIHKymdhzzTizDCglM9qEEEIIIcTp+f1+8vPzsVqtPPzww3rHEaLTunT25WyLal+77xqlVG5XxhdCCD0UVBZgN9kZGDlQ7yiih2RFZWE32TuKqr3V0vw6lKJfzlwSJzd9VgQfvneQFUvqOP+SwCz6rDePy8vuT4pwxtlJm56kdxwBmKxGBl82gIL/7GTfwlIGnZ+md6Sg5m/TOLTES8XcNurWeEEDS6wi7kIL0VNNhGabMId1rtilDApzhCI8wkD4UdeS+L0aTdt91K31UrfWS8lrbkr+48aeYSD2XDNx55uxp0rBVQghhBBCnJzBYKC2tlbvGEJ0ma6XNWua1qzn+EII0RkFlQWMjBuJ0SAnj4KF0WBkVPyoXl1Y0zSNpfm1DB/lJDqmd68DJwIrLcNOWoaNpQv7T2Gt8PNivC0+Rl4/GINJWs71FuGpoSSNj6NsTRWxwyIJT5OWkD2tpdhH+X/bqPzEg7dOw5qgSL3dSkyeGefg7p05ZjApwkaZCBtlIu128NT5qf7Kw8EvPRT/y03x824ip5hIvtZCxESTzGITQgghhBBC9Fv9p1+QEEL0AE3TKKgs4NLBl+odRfSw0fGjeW/7e2ia1itPFhbuaqGirI3LvxmndxShg2l5Ebz+UgUV5W4SEq16x+mSg9trOLithvSZSYTEO/SOI74mIy+Zmt117P64iNw7R2A0S+GzJzTv9lH8kpvqrzwoBVEzTCReYSFivAll1OdvkjnCQOI3rCR+w4q70k/lR22UvdvGlh+6cAwwkHStlfiLzRgsve9vphBCCCGEEEJ0xRm9E+6plo1KqTE9MY4QQnRWRVMFB10HyUnI0TuK6GE5CTnUtNRQ2liqd5QTWppfi9msmDg1XO8oQgdTZkagFCzLr9M7Spd4WrwUfl5MSIKD1CmJescRJ2C0GBl0UQYtNW6Kl5TpHaffa9zqZetPm1l/UxO1yz2k3GRlwoehDP+9k8hJZt2Kal9njTeQ9i0bE+aFMvhBO8oCe37fwtqrG6n4sA3Nq+kdUQghhBBCCCEC5kwvMV2rlPqvUmr06Tc9e0qpXKXUPGB1d+xfCCECZWPFRgAprAWh0fHtfwKPHAO9idersXxxHWMmhOFwSovSYBQTa2HYSCdLFtaiaX33BHbRVyV4XF6yLs5AGXpHwUAcL3JAGAk5MZSsrKCxTDq7d4fWcj/bf+li4x3NNGzykXaXlfHzwhjwPRuW6N47S9BgUcRfZCH35RBGPu3AHGVg96MtrLuhiYMLPGj+vvv8JIQQQgghhBBHnM27ssuA9Uqpj5RS1yqlbF0ZWCllU0pdp5T6FFgLXArIOy0hRK92pKiSHZ+tbxDR44485psqet86a5s3NtJQ72P6rAi9owgdTZsVSUVZG3t3t+gdpVPqihqo2FhNyqQEQhKkBWRvN2BOCpYQM7s+KsLv8+sdp9/wNmsU/aOVtdc0UrPEQ+odVsbPDSX9ThvmsL5TbFZKETnRTM6/nQx7woEywI5fuCj4djPNu316xxNCCCGEEEKILjnTwtp42meTKeBC4HWgUin1klLqVqXUsDPZiVJquFLqNqXUS0Al8Bpw3uH9rgAmnOK+Fyildiql9iil7j/JNnlKqY1Kqa1KqUVn+LsJIcQZ21i5kczITMJt0m4v2IRaQxkYOZCNlRv1jnKcpQvrcIYYyRkbqncUoaOJU8IxmxVLFtbqHeWs+Tx+dn+yH1uklbTp0gKyLzDZTAy6MB3XwRYOLCvXO06fp2kaBxd4WHt1IwdechMz28y4d0LJ+LYNk7PvFNS+TilFTJ6ZMa+FkPVLO65iP+tvbWLvn1vwNss1lUIIIYQQQoi+yXQmG2math6YrJT6BvAQMBIIBW4+/IFSqhHYDdQc/mgEwoCowx+DDt/niCPvEAuAhzRNm3uy8ZVSRuAZ4FygBFijlPpA07RtR20TAfwduEDTtGKlVNyZ/G5CCHE2NlZs7GgJKIJPTkJOr5ux1triY+3KeqbPisRk7r3twUT3c4YYyR0fxool9dx8ZxLGXrL20pkoXlpGa62bUTcOxmiWdqZ9RXRWBLEjoziwrIKYIZE442WmYWe0VfvZ8/9aOLTIS8hQI8P/n42wkWf0Nq3PUEZFwmUWomeaKPqnm9I32zg438PAn9iJmW3WO54QQgghhBBCnJWzOgOnadr7mqZlAxcA8wAv7QUyRXsRbQxwDnAN8C3gamAOkHv450e29QBzgfM0Tcs5VVHtsAnAHk3T9mqa1ga8CVz+tW1uAN7XNK34cNaqs/ndhBDidJrbmtl9aLesrxbERsePZk/NHpramvSO0mHNygbcbo1psyL1jiJ6gemzIqiv87J5Y+85Rk+nqcJFyYoK4rOjicgI0zuOOEsDz03DZDey+5P9sn7WWdI0jYoP21h3XSO1K70MuNdGzgvOfldUO5o53EDWz+3kvODEHKXY/oCLHQ+68DbKsSOEECK49eV1koUQQm96PId26tJ2TdO+0DTtSiARuAV4Bdh1+MfqBB8asBP4D+0z3BI1TfuGpmnzz3DIZODAUd+XHL7taIOBSKVUvlJqnVLqlrP/zYQQ4uQ2V21GQ5PCWhAbnTAaDY3NlZv1jtJh6cJaYuLMDB4mM0UE5IwLxek0srSPtIPU/Bq7PynC7DAx4JxUveOITjA7TGSek0pjWTMVGw7qHafP8NT52fZTF7sfbcEx0EjuqyGk3GxFmfrOTNOuCB1hIuffIaTdZeXglx7W3dBI7Rqv3rGEEEIIXRgMBvx+WbNWCCE6y+/3YzD0bBenLl0OqWlaDfDq4Q+UUhYglfbWj1bATXtbyGJN0zxdGOpE7zC/XoY0AWNpnyFnB1YopVZqmrbr6I2UUncDdwMkJiaSn5/fhVhCiGDyQdkHALTsayG/PF/fML1EsD2HtrS2APDOkndwJ7l1TgOuZkXBhghyJrSyeHEwLy0addwtwXZsHi1toIOVS70Myd6L2aJ3mlNTpWYM5Vb8Q1pZtmqp3nG6hZGQ427rd8enBoZwG7u/3M/OQ9vBIldcn1JhCIY306HZhHZpGbVTDrJ6L7C3Z2MYyT3uth4/NgcB9zhwv5XOlns1/FOr0C4qA5McQ6JdU1NT/3vOFEKIr3E6nVRXV+NwdP1iSZ/PR2NjYwBSCSFE3+FyuWhoaOjR140B7TNyuE1j4eGPQCqhvWB3RApQdoJtqjVNawaalVKLgdH8bybdkYzPAc8BJCUlaXl5eQGOKoTor9786E0ibZFcc/41KBUcV5Qf4wR1m2B7DtU0je9s+g6uMFev+N0/mVeNppVx462jSUmz6R1HN/98suC423rD46OX+JhmHr6/ELt5NNPyem+L0NZ6N+tWbyViUCjDrxrbb59Xlyxbe9xt/fH4dGW3sv75rcS3pDLkvEy94/RKmldj/7/cHHjJjT3NwNBnHIQM1u//6BLqj7tNr2PTd7VG0TOtlL0dR2hdIkMfd2BLkHVDRXuxtz8+ZwohxNFqa2txuVyEhoZ2eV+NjY0B2Y8QQvQlDQ0NDBo0iMjInnt/1VferawBspRSAw7PirsO+OBr28wDpiulTEopBzAR2N7DOYUQ/djGio2MThjdb0/+itNTSpGTkMOmyk16RwFgaX4tGQNtQV1UE8cbMtxBTKyZJfl1ekc5pb1fHgANBl6QJs+r/YAj2kbK5ASqttRQV9Sgd5xep63Gz+bvN3PgRTfxF5nJfSmEkMFGvWP1GkabYuB9dob93oFrn48NtzRRu7IrDU+EEEKIviMsLAyXy0Vtbd9o5y6EEL3JkYsTwsJ6ds32gBfWlFJxSqmLlVJ3KaV+fPjzxUqpuM7uU9M0L3Av8DntxbK3NU3bqpT6jlLqO4e32Q58BhQAq4F/aZq2peu/kRBCgM/vo6CygJz4HL2jCJ2Njh9NQWUBPr9P1xxlJa3s3d3C9F48I0now2BQTM2LYPOGRupqe+eJ6ZrCeg7trCN1WiK2cKvecUSApE5JxBZhZc9nxfi9sk7IEU07fGy8rYnGrT4GP2hn8G8cGB1STD6RmFlmcl8OwRKr2PIjF/ufb0XzS1tIIYQQ/ZvRaCQ9PZ3q6mpKS0tpaGjA5/OhafI3UAghvk7TNHw+Hw0NDZSWllJdXU16ejpGY89euBiwVpBKqSuBnwKTTrHNCuBJTdPmnu3+NU37BPjka7f982vf/wH4w9nuWwghTmdPzR5avC3kJOToHUXoLCchB5fHRWFtIYOjB+uWY2l+HcoAk2dE6JZB9F7TZ0Uy752DrFhSz4WXxegd5xh+r5/Cz4uxR1lJmRivdxwRQEazgYEXpLH1zd2UrKwgbVqS3pF0V/V5G7sfa8Ecoch+NoTQYTJL7XTsaUZyXghhzxMtFP/LTfMeH0MecmC0SzFSCCFE/2WxWMjMzKShoYG6ujrKy8vx+8/+QqXW1lZsNuloIoTo3wwGA3a7ndDQUBISEnq8qAYBKKwdbs34KnDVkZtOsflk4D2l1HvATYfXZBNCiF5vY8VGACmsCUbHjwbajwm9CmuaprE0v46R2SFERZt1ySB6t5Q0GxmZNpYurO11hbWSFRW01roZeX0WBlNf6UouzlTUwHBihkVyYFk5sSOisUcG54xEza9R9PdWSl5pIyzHyLDfObBEyfF+pow2xeDf2AkZYmTvX1op+HYTw590Yo2Tf0MhhBD9l9FoJDIysktrBOXn55ObmxvAVEIIIU4kEO9M3qO9qKYOf2wD/gb8CLjr8Oe/AVuP2uYq4N0AjC2EED1iY8VGzAYzw2KH6R1F6Gx47HBMBhObKvRbZ233DhdVFW1MmxWhWwbR+03Li6RwdwtlpW69o3RorXNzYHk5McMiicwM1zuO6CaZ56SiDIrCz/YHZQsjv1tjx69aKHmljYRvWBj1N6cU1TpBKUXydVZG/MFBywE/G+9oommHvm2YhRBCCCGEEAK6WFhTSl0HXHz42zLgQk3TRmqa9gNN057WNO2Fw59/oGnaKOACoJT24trFSqlru5ReCCF6yMbKjYyIG4HFaNE7itCZ1WRlWMwwNlXqV1hbml+HxaoYP1kKE+LkpsyIQClYlt97FkEv/LwYlCLznFS9o4huZA2zkD4zmdq9DRzaWad3nB7lqfez+fvNVC/wMOCHNgb9zIbBLC0MuyJqmpnRz4WgjLDp200cWtI7144UQgghhBBCBI+uXjr5rcOfm4GZmqZ9fqqNNU37AsgDmg7fdGcXxxdCiB6xsWJjRwtAIUYnjO5oD9rTvF6NFUvqGDshDIdD1uoRJxcVY2ZEdghL8+t6xayhQ7vqqNlTT/qMJKxhcpFCf5c0Lg5HrJ298w/g85z9+iB9UWuZn013N9O4zcfQR+2k3GBFKSmqBYIzy0jOv0NwZBrZ9nMXlR/JigJCCCGEEEII/XS1sDYa0IAXNE0rPJM7HN7uBdpnreV0cXwhhOh2FU0VVDRVyPpqokNOfA6ljaVUu6p7fOxN6xtpbPAxbVbn++6L4DFtVgSV5W3s2enSNYfP46Pwi2IcMTaSxsfpmkX0DGVQDDwvFXd9G6WrKvSO0+2ad/vYeGcTnkN+Rv3VSey5UjwONEu0gVF/cxIx1sSu37ZQ8mrvaXMrhBBCCCGECC5dLayFHP685izvd2R7RxfHF0KIbndkLS0prIkjRie0z17UY521pQtrCQ0zMnpMaI+PLfqeCVPCMVsUSxbW6ZqjZHkF7vo2Bl6QhsEoa00Fi4iMMGKGRXJgWQXuhv47w6hxq5eC7zajjJD9XAjhuSa9I/VbJqdixB8dxMwxs++vrez7W0uvmJErhBBCCCGECC5dPbNRdvjz2faiOrJ92Sm3EkKIXuDIWlrSClIcceRY6Ol11lwuH2tXNTB5egQmk7QXE6fncBgZOzGMFUvq8Hr1OfncWu+mZGUFscOjiEgP0yWD0M+AOSkA7F1wQOck3aN+g5fN9zZjClWMfjYEZ6a06O1uBoti6G/tJHzDQskrbez5XQuaX4prQgghhBBCiJ7T1cLaV4c/Tz/L+02nvYXkV6fbUAgh9LaxYiPp4elE2qX1nmgX64wlKTSpx9dZW7OiHk+bxrS8iB4dV/Rt0/IiaGzwsWl9oy7j71tQAigyZifrMr7Qly3cSsqUBKq31VK3X59jsLvUrvSw5YfNWOIMZD/rxJYkszF7ijIqBv3MRurtVirmedj1aAuaT4prQgghhBBCiJ7R1T4lTwM3A7copZ7XNO20LSGVUuOAWwH34fsLIUSvtrFiY0frPyGOGB0/usdnrC1dWEdcgoWsodJJWZy5nDGhhIQaWZZfy9gJPTtjrL64kerttaRNT8QWbu3RsUXvkTIpgcpN1ez9opjcbw1HGfr+jNtDiz1sf8CFY6CBkX9xYomUolpPU0qR8R0bygTFz7vRfDDk13aUzOjuEzSfD39DA/5mF35Xc8dnra0NfH40vx/8flIqymn84guUxYqyWFBWCwarFUNoKMbwcAyhoSijzBQVQgghhBA9q0uFNU3Ttiil7gJeAL5USv0UeEnTNO/Xt1VKmWgvqD1J+2y1OzVN29qV8YUQoru5PC52HtrJ1cOv1juK6GVyEnKYv3c+bb42LEZLt49Xc8jDlk1NXHltHErJSUNx5kxmA5OmhbP4q1paXD7sjp45Aan5NQq/OIAl1EzK5IQeGVP0TkazgcxzUtn+XiHl6w+SNC5O70hdcmhpe1EtZIiRkX9xYgqV52Q9pd/ZXlzb/w83+GDIQ1Jc6238Tc14ysvwVlfjO1SD79AhfHV14Pcfu6HBgLJYwGAArxeUIsTrpa15D5rPBz7f8TtXCkNoCMbwCEzxcZjiEzDFx2EIC5PXS0IIIYQQott0qbCmlPrN4S+/BC4CngV+r5RaAuwBXIADGARMA6IOb/8JMOio+x9H07RHupJNCCECYUvVFvyan5yEHL2jiF5mdPxoPH4PW6u2kpuY2+3jrVhch6YhbSBFp0zLi2T+pzWsWdnAjNk909a2clM1zZUuhlyRidEsswmCXfSQCCIyQtm/qJTY4VGYHV1tnKGPmuUett/vwpllZOTTTkwhcuK+N0i7zYYyKor+1ormh6GPSHFNT76GBjwHSvCUluIpLcVfV9fxM0N4OKboaCwDB2KMjMQQ4sTgdGJwOFB2e0cxrPpPfwbaT1hohwtq0T/6IVpbG5rbjb+hAV99Pb76Bvz19fhqamhZv6GjWKfsdsyJiZjT07FkpGOMiOjBfwEhhBBCCNHfdfUd7UO0zz7jqM9RwGUn2FYdtc1Fhz9ORQprQgjdHVlDSwpr4uuOFNM2VmzskcLakvxaMrPsJKXYun0s0f8MHuYgJs7MsvzaHimseVu9FOWXEpYSQuxwWZ9StLftyzwvjfXPb2X/olIGXZiud6SzVrvSw7afu3BkGqSo1gul3mxFGWDf063sMsPgB+39ou1oX6BpGr7qatr2FOIu3IPvYDUAymbDnJyEKXsU5qQkTDExKLO50+MopVBWK1itGMPCMKekHJvD68VbfQhvZSXeyko8JSW07d1LM+0FPUt6OpZBAzGnpqIM0r5VCCGEEEJ0XiAuFT3Ru5WTvYM503c2svK0EKJX2FSxiTBrGBkRGXpHEb3MoKhBhFhCWF++nttzb+/WsUqKWykqbOWWu5K6dRzRfxkMiqkzI/jgvYPU1XqIiOz8ic0zUby0HI/Ly4jrUqUVl+jgjLWTNDaOsnVVJI6Lwxlr1zvSGatb62Xbz1w40g2M+qsTc5gc171Ryo1W/G0a+//pxmBXDPq5TZ6DupG3pgb31q24d+3G39AAgCkpCceM6VjS0zFGR/fov78ymTAnxGNOiO+4zVdXR1vRfjz799O6fTutBQUohwPr4MFYhwzGlJgox4gQQgghhDhrXS2szQpICiGE6KU2Vm4kJyFH3nCL4xiUgZyEHDZUbOj2sZbm12EwwJQZ4d0+lui/ps+KZN47B1mxpJ4LL4vptnFch1opW1NF/OgYQhOd3TaO6JvSpidSufkQ+xYcYOR1g/WOc0YaNnvZ+tNmbCkGRv3NiTlcZrr0Zmm32/C3wIGX3RhtMOCHUlwLJH9bG227dtO6ZQve8nJQCnNGOo4JE7AMzMTgcOgd8RjGiAjsORHYc0ajeb207SvCvXMnrZs307pxI4awMGyjRmIbObLXZRdCCCGEEL1XlwprmqYtClQQIYTobfyan00Vm7gj9w69o4heakzCGF7Y8AI+vw+joXvWkPL7NZbm1zIqJ6TbZxmJ/i0lzUZGpo2l+bXdWljbN/8ABpMiIy+528YQfZfZYSZtWiL7FpRQu7eeyMzefcFAc6GPrT9xYYk+PFMtQopqfUH6PVZ8LRqlb7RhdCjS75Y2yl3lq6ujZf0GWrdtA48HY2QkjunTsA0bhsHZNy6iUCYT1qxBWLMG4Xe7aSssxL1tO65ly3GtXIU1KwtbzmhMCQlSjBVCCCGEEKfUN1cNF0KIHlBYU0izp1nWVxMnlZuYS/PqZvbU7GFIzJBuGWPnNhfVVR6uvTmhW/YvgsvUvEhe+3c55aVuEpOtAd9/7b4GavbUkzE7GUuIFILFiSWNi6N83UH2zi9hzJ1hvXYdrNYyP1t+0IzBAqP+6sQSLUW1vkIpReaPbfhaNIpfcGMKVSRfH/jnvGDgKS+nZe062vbsAYMB69Ah2EaN6vMtFA1WK7bhw7ENH463pobWTQW4t23DvWMHpvh47OPHYxk0sE//jkIIIYQQovvIu0MhhDiJIy3+pLAmTmZM4hgA1pev77YxluXXYrUqxk8K67YxRPCYOiMCpWBpfm3A9635NfbNP4A13ELy+PjT30EELYPJQMbsZFwHW6jYVK13nBNqq/az+d5m/G0w8mkntiR529TXKIMi6wE70bNM7P1zK1Wft+kdqU9pKy6m7q23qX/zLTwHDmAfP57Ib91B6PnnY05K6lcFJ1NUFCGz8oi8606cs2fhd7tp/Ogj6l55FffOnWh+v94RhRBCCCFELyPvEIUQ4iTWl6/HbDAzInaE3lFELzUsZhhWo7Xb1lnzePysWFrPuEnh2Ozd02pSBJeoGDPDRzlZll+HpmkB3XfV5kM0V7WQMSsFg0leYopTixkaSVhKCPsXleJ1+/SOcwxvk8aWHzbTVuNnxFMOnAPl+bevUkbF0IcdhI8xsuuRFmpXevSO1Ot5ysqof/ddGt57H39DA86ZM4m681s4p03FGBKid7xuZbBYsI8eTeSttxBywQWgaTR+8il1/3mF1h07Av53UwghhBBC9F1y1kMIIU5iffl6RsaNxGqS1kHixMxGM6PiR3XbjLWNaxtpbvIxbVZEt+xfBKepeZFUlLdRuKslYPv0eXwU5ZcSmuQkdnhkwPYr+i+lFJnnpOBp9lKyokLvOB38Ho1tP2/Gtc/P8N87CBslnfP7OoNVMfwPThwDDGy730XjNq/ekXol78GD1M+dR/1bb+M9VIMzbyaRt9+GfUwuymLRO16PUgYDtmFDibjlZkIvvhhMRpo+/Yy619+g7cABveMJIYQQQoheQAprQghxApqmsb58PWMTx+odRfRyuQm5bKjY0C1XMS/NryMs3Eh2bmjA9y2C18Qp4ZhMKqDtIEtXVdLW5GHAOSn9qj2Y6F6hySHEjoiidFUF7gb92/RpmsauR1uoX+sj61d2IifJOoH9hSlEMfLPTswRii0/dtFS3LtmSerJ73LRNH8+da++hresDMfUKUTdcTv23FyUKbgLy0oprIOziLjxRkIuuACtpYWGd9+jfu48vIcO6R1PCCGEEELoSAprQghxAgcaDnCo5VDHGlpCnMyYxDHUtNRQXF8c0P02N/lYv7qBKTMiMBqlUCECxxliZMyEUFYsqcfn63pBuK3Jw4HlFUQPiSA8VYrA4uxkzEoGoGhhic5JYP8/3Bz8zEP6PVbiLwquGTrBwBJjYOTTTgC2/NiFpz64183S/H5aNmyk9qWXad26DduYXCLvuB3HhAkosxSVj6aUwjZsKJG33Ypj2lS8paXUvfIqTQsX4ne79Y4nhBBCCCF0IIU1IYQ4gSOt/aSwJk4nNyEXIODrrK1aXo/HozEtT9rqicCblhdJfZ2XLRuburyv/YvL0HwaA2anBCCZCDa2cCvJE+Kp2lJDY1mzbjnK33dz4GU3CVdaSL1VWkD3V440IyP+4MBd5Wfbz1z424JzzSxPSQl1r75Gc34+pvh4Im66kZCZMzHYbHpH69WUyYRj/Hgi77gdW/YoWjduovall3Hv3CnrrwkhhBBCBBkprAkhxAmsL1+PURnJjs/WO4ro5bLjszEqY8DXWVuWX0tCkoWBg+0B3a8QALnjQ3E6jV1uB9l8sIWKjQdJHBuLPUpOyIrOSZmSiNlpYu/8A7qcnK5Z7mHPH1qJmmZi0E9t0s60nwvLNjH4V3YaNvrY/XhLUBVE/K2tNH45n/p33kXzeAi97FLCvnElpuhovaP1KQa7nZDZswm//joMISE0fvIpDf/9L766Or2jCSGEEEKIHiKFNSGEOIH15esZFjsMu1mKGuLU7GY7Q2OGBnTGWvXBNrZtbmZaXqSc4BXdwmw2MHFqOKtXNNDa2vl2aPsWlGC0GEmblhjAdCLYmKxG0mck03CgiUM763p07Oa9Pnb80oUzy8DQRx0okzznBoO48y2k322l6lMPB14MjlZ+7sJC6v7zCu6tW7GPHUvkLTdjHThQXmd0gTkhgYjrr8OZl4e3vILa/7yCa+1aNH9wtxkVQgghhAgGUlgTQogTWF++XtpAijM2JnFMQGesLV9Uh6bBtLyIgO1TiK+bmheBu9XPulX1nbp/7b4GagvrSZuWiNkh6/GIrknIicERa2ffVyX4fT1zUrqt1s+2+5ox2BUj/uDEaJcCQzBJvcNK3IVm9j/rpurzNr3jdBu/y0XDxx/T+MGHKLud8OuuwzljuqyjFiDKYMCem0PErbdgycjAtWQp9W+/g6+2azPChRBCCCFE7yaFNSGE+JryxnLKm8oZkyCFNXFmchNyKWsso7KpMiD7W5pfR9YQBwlJss6P6D7DRjqJijGzNL/urO+r+TX2zT+ANdxC0ri4wIcTQUcZFAPmpNBa66Z8/cFuH8/fprH95y7aDmmM+IMDa7y8LQo2SimyfmEnLNfIrkdbaCjw6h0p4Nr27qP2lVdpK9yLY8oUIm64HnNCvN6x+iVjSAihl15CyAUX4KupofbV12jZsCGoWo0KIYQQQgQTeQcphBBfc6Sln8xYE2fqyLESiHaQ+/e1UFzUylSZrSa6mcGgmDojgoL1jTTUn90J5arNh2iuaiFjVgoGk7ycFIERmRlGeEYoxUvL8bp93TaOpmnseaKFhk0+Bv/aTugIU7eNJXo3g0Ux/AkH1jgD237moqW0f7Tw0zwemhZ8RcO8eRgcDiJuuB7HxAkoo1HvaP2aUgrbsKFE3HIz5tQUmvMX0fDue/gaG/WOJoQQQgghAkzeRQohxNccaemXk5CjbxDRZxw5VjaUb+CCQRd0aV9L8+swGGDKjIiuBxPiNKblRfDh+wdZubSO8y6OOaP7+Dw+ivJLCU1yEjs8spsTimCilGLArBQ2vridkpUVZMxM7pZxSl9to/IjD2l3Wok919ItY4i+wxxuYMSfHGz6VjNbf9JMzgshmEL6bltQb2UljZ9+hq+2FvvYMTimTEGZ5G1/TzKGhBB2+eW4t26lKX8Rda++Rsh552EdmKl3NHEWvG4X7qYafG0thz9a8ba14PO0gna4CK8MGM02TBY7RosNo8WO0WLHGhKFyerQ9xcQQgghRLeSV9hCCPE168vXMzh6MKHWUL2jiD4i3BbOwMiBrK/o2jprfr/GskV1jB4bSli4/IkW3S9tgI3UdBtL88+8sFa2uoq2Jg9Dr8xEqb578ln0TqFJTmKGR1K6qpKkMbFYQgNb+Dq02MO+Z1qJOcdM2rek3a5o50gzMuz3DjZ/v5ldD7sY9oQDZehbz2+aptG6YQPNS5ZicDgIu+obWNLS9I4VtJRS2EaOxJycTMPHn9D4wQd4cnNwTpsmhc5eQtP8tNYfpPngfpqq9+M6VIq7sZrWhmrcjdX42lq6tH+jxY41NAZbWAzW0Bgc0cmExKTjjE3HFh6LUjLjXwghhOjL5BWdEEJ8zfry9UxOnax3DNHH5CbmsqG8a60gt29ppqbaw423JwQolRCnppRiWl4Eb7xcQVVFG3EJpy5ieFq8HFhRQVRWOOFpcvGB6B4ZM5M5tKOO/UvLybowPWD7bd7tY8dvXIQMNTL41/Y+VzgR3StirInMH9nY+8dWil9wk36XTe9IZ8zvdtP0xZe07dmDJTOTkPPPw2DrO/n7M2NkJBHXXUvzkqW0btiIp7SUsIsuwhgpM757kqZptDYcpP7AVupKttFYUUhzdfExxTOLMxJbeCzOmFSiBuS2F8RCojBZnf+bjWa2sfK57xy3//G3//l/s9rczbibajoKdO7Gapqqiigv+LJje6PFjjMmjdCEgUSkDCc8dQS2sFi5YEkIIYToQ6SwJoQQRznkOsT++v18b/z39I4i+pgxCWN4d9u71LfWE24L79Q+lubXYrMbGDexc/cXojOmzGwvrC1bVMuV18afctsDy8vxuX1k5KX0UDoRjOxRNhLGxFK+rorkCfE4orteIPDU+9n2s2ZMIYrhf3BgtMnJS3G8pKstNO/wUfwvN87BRmJmmvWOdFreqioaPv4Ef309junTsY8dIyfnexllMhEyKw9zWipNX3xJ3etvEHL+eVgHDdI7Wr/WUlfJocI11BZvob5kG+7GQ0B7USssMYvE7HMIiW2fQeaMScNsC+n0WGGJWafdxtPaRHN1cfsMuYP7aT64n4otCyld/wkA1tBowlOGE5k2kuiB47FHnPo1mRBCCCH0JYU1IYQ4yoaK9hlHYxLH6JxE9DW5ibkAbKzYyMyMmWd9/7Y2P6uW1TN+UhhWm7SGET0nNs7C0BFOliys44pr4k56Qtbd0EbZmiriRkXjjLP3cEoRbNKmJVJVUE1RfinDrxrYpX1pPo0dv27BfVAj+59OrLHyHCtOTCnFoJ/bad7nZ9dDLuwvhODMNOod66Rat2yh6auFGOx2wq++GnNykt6RxClYBw7EdGMsjR99TOOHH+GdMB7H5MkogzwnBYLf56HuwDYOFa6les8aXIcOAGANiyUidSThKcOJSB1GSGwGytDz/6/NthAiUoYTkTK84zbN76PpYBF1B7ZTX7KNupJtVG1fAvwDZ0wa0QPHET1wHBGpIzAY5fSdEEII0ZvIX2YhhDjK+vL2NbKksCbO1pFjZn35+k4V1jasacTV7GfaLGkNJHretLwI/vVMKUWFLQwY5DjhNvsXlwGQPlNO3IruZ3GaSZ6UQPHiMhpKmwhL7vxMgv3Puqlb5WXQA3bCRsrbH3FqBqti+O8dbLitiW3/5yLnxRDMYb1rBpjm89Gcv4jWggLMaWmEXngBBseJn7tF72IMCyP8mqtpWriQltVr8FZWEnrhhRjscsFKZ2h+H7X7C6jYuoiDO5fjdTejjCYi00aRnHsBMYPG44hK1jvmSSmDkdD4gYTGDyR13CUAuA6VUl24hkN71nBgzQcUr3ofk9VJ7JApJIyYSWR6ti6FQSGEEEIcS95ZCiHEUdaXr2dAxAAi7VLcEGcnzhlHSlgK68rXder+SxfWEhFpYuTozp88FqKzJk0L58Vny1iaX3fCwpqruoXKgmqSxsdhC7fqkFAEo5SJ8ZSvq2LfghKybx7SqfZ21Qs9HHjZTcLlZhKvOPUagkIcYY03MOz3DjZ/t5mdv3Ex4o8OlLF3FNf8LhcNH32Mt7QU+7ixOKZOlRlPfYwymQg991zMCQk0Lcyn7vU3CLv0EkxxcXpH6xM0TaOhbCcVWxdRtX0xbc11GC12YodMIW7wZCIH5GCy9N1CpSM6mbToZNImXIHX7aK2aBNVu1ZQtWMp5QVfYnFGEjdsOgkjZhKW1Lm/jUIIIYToOimsCSHEUdaVr5PZaqLTxiWNY23Z2rO+X1Ojlw1rGzn34miMveTEnQguIaEmcsaGsnxxHTfenojha8dhUX4pRrOB1CmJOiUUwchoMZI2PYnCz4qp3VNPVFbEWd2/ea+PXY+4CB1hZOBP++5JVqGP8NEmBv7Uzp7ft1D0TzcDvtf1tf66yltVRcMHH+J3uQi58AJsQ4fqHUl0gW3UKIyxsTR++BF1b71N6IUXyLprp+BtbaZ8y1eUrv+U5ur9GIxmogeNJ2FEHtEDx2E0978Lf0xWB7FDJhM7ZDK+C77HocK1VGzNp2zDp5Ss/QBnbDrJuReROHIWJptT77hCCCFEUJHCmhBCHFbfWs+emj3cnnO73lFEHzUucRxzd8ylwd1AmDXsjO+3clk9Xq/G9FkR3RdOiNOYlhfBulUNbN3cxKic0I7bG0qbOLSzjrQZSVicZh0TimCUkBND2epK9i0sJXJgOMpwZhcfeJs0tv/chcGqGPY7BwaLXLQgzl7ilRaadvoo+Y+bkKFGYufo9xzo3rWLxs+/wGCzEXHtNZji43XLIgLHnJBAxPXX0/DhBzR++BG+qVOxjx8ns5CO0lC+m9L1n1CxbRF+j5vQxCyGXvQD4odOC6piktFsJW7oVOKGTsXb2kzljqWUrv+EXV/8gz0L/03CiDyScy8kLDFL76hCCCFEUJDCmhBCHLaxYiMg66uJzhuXNA6AdWXrmDVg1hnfb+nCOpJSrAwYKDMqhH7GTgjDbjewLL+uo7CmaRpFC0sxO0ykTJSTuKLnGYwG0vOS2fH+Xqo2HyJ+dMxp76P5NXY+5KK11M+oZ5xY46VNnui8gffZaN7tY/ejLpyDQnCk9+zaRpqm0bJmDa5lyzElJhJ26SUYnMFTTAgGhhAn4VdfTeMXX+BatgxfTQ0h58xBmYL3dI2m+anevYr9K9+jvmQ7BrNVCkdHMdmcJOecT3LO+e2Fxw2fts9k2/g54SnDSJ90FTFZE1FK/v4JIYQQ3SV4X6kJIcTXrC9fD0BuQq7OSURfNTZpLABry9aecWHtYFUbO7Y2c81N8XJ1stCVxWpgwtRwVi2v547vJmOxGKjb20D9/kYyz0vFaOnZk8lCHBEzNJLQJCdFi0qJGR6F0XzqE4UHXnRTs8RL5k9shOfK2x3RNQazYtjjDtbf0sT2+13k/DsEo71n/l5rPh9NX32Fe8tWrEOGEHLeuUFdbOnPlMlE6IUX0hIVhWvFSnz19e1FVMfx6572Z36vh4otX7F/5fu4akqwhccz+NxvkzhqTlDNTjsbYYlZhCVmkTX7W5RvXkDx6rkUvPsojugU0iddRcKIWRhM0nFACCGECDS5fEUIIQ5bW76W5NBk4kNkVobonBhHDBkRGawtP/N11pbl1wEwNS+ie0IJcRam5UXQ4vKzfnUDmqaxb2EJ1nALiWNi9Y4mgphSiozZKbQ1eihfW3XKbWtXetj/vJu4C8wkXWPpoYSiv7PGGxj6iB3XPj97ft+CpmndPqbf7aZh7jzcW7ZinzCBkAsvkKJaP6eUwjFpEqEXXYS3spK6t97GV1end6we4fO0sn/V+yz7+x1s/+RpjGYrIy7/GZPveZ7U8ZdJUe0MmGxOUsdfxuR7nmfE5T/DaLKy/eO/sOzvd7B/1fv4PK16RxRCCCH6FXllLoQQh60pXcP45PF6xxB93LikcawtO7PCmqZpLM2vZchwB/EJ/W/BddH3jBgVQmSUiaX5dWRG+mmubGHIZQMwGOVaLKGviPRQIgeGc2B5OfE5MZjtx7+NcVf62fFgC44BBgbdb5dZwCKgIieaSb/Lyv7n3ISNNpL4je77u+1raKBh7jx8tbWEnHcuthEjum0s0ftYhwzGEBpCw7wPqHvzLcKuuBxzQoLesbqF3+uhdMOnFC1/m7bmWiIzRjPi0p8QmZEjz+GdZDAYSRgxk/jhM6gt2kjRinfYs+AFile+T8bUa0nOuUBmsAkhhBABIGdJhBACqGutY3fNbsYnSWFNdM24xHHsrd1LTUvNabfdv6+VkmI3U/MieyCZEKdnMComT49g07oG9i0swRlnJ3ZklN6xhABgwOxkvK0+SpaXH/czv1djx69caG0aw37n6LFWfSK4pN5uJXKyicKnWmnc7u2WMbzV1dS/+Rb+pkbCrrxCimpBypyURPi116DMZurfeZe2vfv0jhRQfp+X0g2fsfyfd7Hry2dxRCUz5qYnGHPD40QNyJWiWgAopYgakMuYGx5nzE1P4IhKZtcX/2T5P++idMNn+H3d8xwmhBBCBAsprAkhBLCubB2AFNZEl41LGgf875g6lSULazEaYfK08O6OJcQZmzYrgiFRPtrq28iYlSwnt0Sv4YxzEJcdTemaKlrr3cf8rOjvrTQU+Bj0gB1HhqwHKLqHMiiGPGzHEq3Y/oALT70/oPv3lJZS//Y7AIRfcw2WtLSA7l/0LaaoKCKuuxZTVBQNH3xA6+bNekfqMk3TqNq5nJXP3cOOT/+KNTSa3OsfZcxNvycybaTe8fqtyLSRjLnp9+Re/yjW0Gh2fPpXVj53D1U7l/dIa1shhBCiP5LCmhBCAGvK1gD/K4oI0VljEscAnLYdpN+nsXxRHTljQwkNk87MovdIS7UwMd1PnddE5EAp+oreJX1GEgDFi8s6bju0yEPpa20kXmUh7jxZV010L3O4gWG/c9BWrbHzwRY0f2BOSrsLC6l/730MDgfh116DKSYmIPsVfZvB6ST86m9iTk+naf4CXKtX6x2p0xrKd7P+1fvZ/N5jGIxmRl/zIONueVJmqPWQIzPYxt3yJKOvfhCD0cTm9x5j/av301C+W+94QgghRJ8jZ/KEEIL2wtrAyIFE2qUln+iaSHskg6IGsbb81IW1LQVN1NZ4mT5bjjnRu5StqcJm1PhoM0w+6CEmTgoVovewhVtJGhdH6epKkiclYGizsvMRFyFDjWT+yKZ3PBEkQoebGPgTG3ueaOXAS27S7ujasde6eQtNCxZgio8j7PLLMTgcAUoq+gNlsRB22aU0ffElrmXL0dxtOKZN7TPFqNaGagoX/YeKzQswO8IZcsG9JOWch8Egs4v1oJQiJmsCUQPHUrbxc/YufpU1L/6YxFGzycy7BVuoFPWFEEKIMyGFNSGEANaUrmFq2lS9Y4h+YlzSOJYfWH7KbZZ8VYvDaWDMhLAeSiXE6XlcXkpWVuJMC6NyRSvLFtdx+Tfj9I4lxDFSpyRSsbGaovmltH0aj1Iw7HcODJa+cZJZ9A8JV1qo3+Rj//NuwnNNhOd27q21a+06XEuWYE5PJ+ySi1EWuZhBHE8ZjYRccD7KYqFl7Vo0txvn7FkoQ+9tQuT3eShePZd9S99A8/tIn/xNMqZci8kqhePewGAwkjLmIhKGz6RoxdsUr55L5Y6lDJh2PWkTrsBgNOsdUQghhOjVeu+rMCGE6CGVTZUcaDgg66uJgBmXOI7i+mKqmqtO+PPWVj+rVzQwaWoEFov8KRa9x4Hl5fjafAy5IJWsoQ6W5dfpHUmI45gdJlImxVMz10zTTj+Df+PAliTPpaJnKaUY9DM79mQDO37twlN3duutaZqGa8VKXEuWYBmcRdjll0lRTZySUgrn7FnYx4+ndfNmmj77HM3n0zvWCdXu38zqF35A4cKXiB4whsnffpZBs26XolovZLI5GTTrdiZ/+1miBuRSuPAlVr/wA2r39/01/YQQQojuJO9AhRBB78haWFJYE4FyZK2+dWXrTvjzNSvqcbf6mT47ogdTCXFqrfVuytZWET8qGmesnWl5ERQXtbJ/X4ve0YQ4jrUxCooisOQ0ETVdmnAIfZiciqGPO/DUaex65MzXW9M0DdeSpbhWrsQ6fDihF16IMkpbPHF6Simc06bimDYV986dNHz4EZrXq3esDm3NdWz98CnWv3Y/Po+b0Vc/SPY3f4U9IkHvaOI07BEJjP7mr8m++jf4PG7Wv3Y/Wz98irbmOr2jCSGEEL2SFNaEEEFvTdkaDMpAbmKu3lFEP5GbmItCdRRtv27pwlpi4swMGe7s4WRCnFzxknIA0mYkATB5egQGAyyVWWuil2kp9VP4/9xYB/hpSymndk+93pFEEAsZbCTzhzZqlnkpfaPttNtrmkbzwoW0rFuHbXQ2Ieed26vb+YneyTF+PM45s/Hs20f9+//F73brmkfTNMo2fcGKZ++mcusiMqZcw6S7/05M1gRdc4mzF5s1kUl3/52MKddQuXURK569m7JNX6JpZ3bhgBBCCBEs5BW8ECLorSlbw7CYYYRYQvSOIvqJMGsYQ2KGsLb8+MJabY2Hgo1NTJ8VicEg6wGJ3qH5YAuVBdUkjY3DFm4FICzcxOgxoSxfXIf/DGdhCNHd/B6NHb9yoYww8slQbNFW9uWXnvFMISG6Q+I3LUTnmSh6ppXGrSefPaT5/TR98SWtmwqwjx2Lc9YslJLXAqJz7NnZhF54Ad7ychrefQ9/a6suOVrqq9j45q/Z/vFfCInNYOKdf2Vg3q0YzTZd8oiuM5ptDMy7lYl3/pWQ2Ay2f/xnNr75G1rqT9zmXgghhAhGUlgTQgQ1TdNYU7qG8cnSBlIE1rikcSecsbZ8UR2aH6blRfR8KCFOYn9+KUazgdSpx7ZqmpoXwaGDHnZsbdYpmRDHKvpHK03bfGT9woEjxUT6zGRcVS0c3FqjdzQRxJRSZP3SgSVOsf2XLryNxxd6NZ+Pxk8/w71tG45Jk3BMnyZFNdFl1qFDCbv0EryHDlH/7nv4W3qufbOm+SlZ9xGrnv8u9SXbGXL+PYy56fc4Y9J6LIPoXs6YNMbc9HsGn3cP9SXbWPX8dylZ9zGadnZrSgohhBD9kRTWhBBB7UDDAQ66Dsr6aiLgxiWOo6yxjLLGsmNuX7KwlswsO8mpchWv6B0aSps4tKuOlEkJmB3mY342blI4VptB2kGKXqFmuYfS19pIvMpCzOz2YzV2eCTOeAdFi0rxe+VEn9CPOUwx9LcO2qo0dj3mOqZtmub10vjRx7Tt2oVj+jQckydJUU0EjCUzk7DLLsVXU0P9ez1TXHPVlrP+tV+w8/N/EJ48lIl3/Z2UsZeglJxi6m+UMpA67hIm3vV3wpOGsPPzv7P+tV/gqi3XO5oQQgihK3nVI4QIamtK1wDts4uECKQjx9S6snUdtx0oaqVobyvTZ0XqFUuIY2iaRtFXJZidJpInxh/3c5vNwPjJYaxaWo/HI0ULoZ+2aj+7HmnBMcjAgB/878IEpRQDZifjrm+jfMNBHRMKAWGjTGTcY+PQQi/l77evt6Z5vTR89BFte/finDULxzh5zSkCz5KRQdjll+GrqW2fueZydcs4mqZRuvFzVv/rXpoq9zLs4h+Sc91vsUcc/xpC9C/2iHhyrn+UYRf9gMbKQla/8H3KNn4ua68JIYQIWlJYE0IEtTVlazAbzIyOH613FNHP5CTkYFCGY9pBLsmvxWCAKTMi9AsmxFFqCxuoL24ibWoSRovxhNtMy4ukudnHxrWNPZxOiHaaT2PHgy58LRrDHnVgtB070ydiQBjhGaEcWFqO1+3TKaUQ7ZJvtBA52cTeP7fSuL2Nho8+xrOviJA5c7DnyOtN0X0s6emEXX45vtruKa61NddR8O5v2fHJ04QlDWbiXc+QNPo8mX0ZRJRSJOWcz6Q7nyEsMYvtnzxNwXuP0tZcr3c0IYQQosdJYU0IEdTWlK0hOz4bq8mqdxTRzzgtTobHDmd12WoA/H6Npfl1jB4bSniESed0QhyerbawBFuElYQxMSfdblROCOERJmkHKXRz4BU39Wt9DLzPjmPA8QVgpRQDZqXgcXkpXVWhQ0Ih/kcZFIMftGOO8FP7+kd49u3DOXs2tuxRekcTQcCSnkbYFZfjq68PaHGtevdqVj7/PWr2rifrnDvJveExbGGxAdm36Hts4XHk3vAYWXPu5FDhWlY+/12q96zWO5YQQgjRo6SwJoQIWn7Nz7qyddIGUnSbCUkTWF26Gk3T2La5mZpqj7SBFL3Gwa01NFe1kD4zCYPx5C8JjUbF5OnhrF/dQHOTzAYSPat+k5f9z7mJPddM/KXmk24XmuQkZmgkpasqaWv29GBCIY5nDtMYdPViHFHFNLmmSlFN9ChL2lHFtXfexd/c3Ol9+Txudnz6DJveeRhrSCTjb/8zaROulLXUBEoZSJt4JRNu/wvWkEg2vf0wOz57Bp/HrXc0IYQQokfIqyEhRNDaU7OHenc945PG6x1F9FOTUiZR01LDnpo9LFlYi91uYNzEML1jCYHf52f/ojKccXZiR0SddvvpsyLxeDRWLK3r/nBCHOap97PzNy5sCQYG3W8/bbux9LxkfB4/B5aW91BCIY6n+Xw0fvIJ2qF9uK3TOPDBYKo+lWKv6FmW1NT24lpDQ/vMtU4U15qri1n70k8o3fAJaROvZPxtfyIkLiPwYUWfFhKXwfjb/kTaxCspXf8Ja1++j+bqYr1jCSGEEN1OCmtCiKC1pnQNAOOTpbAmusfElIkALN+3mlXL6pk4NRyLVf70Cv1VbKimtc5NxqyUM1obJTPLTnKqlcULansgnRDtrUp3P95C20GNoY/aMYWc/jh1RNtIGB1D+fqDtNTKFfOi57UX1T6lbU8hzpkzSfr2WMJyjBT+oYWWEpnxK3qWJTWV8CuvaC+uvf9f/C0tZ3Q/TdMo2/QFq1/8Ee7mWnKufZisOXdiMJ181rAIbgaTmaw5dzL62odxNx5i9Ys/omzTl2iapnc0IYQQotvI2T0hRNBaU7YGu8nO8NjhekcR/dSI2BE4zU6WLquitcXP9NnSBlLoz9fmo3hpGeFpIUQOPLMZlEopZsyJZNd2FxVlUrAQ3a/8/TYO5XvJ+J6N0OFnvi5l2vQklAGKF5d2Yzohjqf5/TR++hlte/bgnDkD+5hclFEx5GEHGGDnb1rwe+Uks+hZ5pQUwi6/HF9tbXtxrbX1lNt73S62fvAk2z/+C+FJQ5j4rb8SPVDa5oszEzNwHBPv/BvhSUPY/vGf2fbBk3jdgVnnTwghhOhtpLAmhAhaa8rWkJuYi8lw5ifshDgbRoORcUnjqCyIJTrWzLCRTr0jCUHp6ko8zV4yZp/ZbLUjpudFogyw+CuZtSa6V/NeH3v/3ErkZBPJ11vO6r7WMAtJ4+Op2lJDc6WczBM9Q/P7afr8c9p278Y5Ywb2MWM6fmZLMJD1gJ3GrT6K/yUXJoieZ0lLJezSS/BVV9Mwdx7+trYTbtdUVcTqF39I5bbFZM64idzrH8UaGt3DaUVfZw2NJvf6R8mccRMV2xaz+sUf0lRVpHcsIYQQIuCksCaECEptvjbWla1jUvIkvaOIfm5cxExslcOZNCMEg+HMixhCdAePy0PJigqiB0cQlhxyVveNijEzanQIi7+qxe+XWReie/jdGjt/7cLkVAz+tR3ViefNlMkJmGxG9i2UWWui+2maRtOCr3Dv2Ilj6lTsY8cct03sORbiLzFz4CU3deu9OqQUwc4yYAChF1+Et6KCxnkfoHmOXfevYms+a17+CT53C2Nu/B0Dpl2PMhh1Siv6OmUwMmDa9Yy58Xf43C2sefknVGzN1zuWEEIIEVBSWBNCBKVNFZtw+9xMSpHCmuheMVUzMGAiakSZ3lGE4MCyCnweP+l5yZ26/4w5kVRXedi+pTnAyYRoV/SPVpr3+Bn8azuW6M69VTHbTaRMSaC2sJ764sYAJxTifzRNo3nxYtxbtmCfMB7HhJOv2zvwPju2ZAM7H3ThaZCLE0TPsw4aROgF5+MpKaHhww/RvF78Pg87v3iWrfP+QGj8ICZ862ki00bqHVX0E5FpI5nwracJjR/E1nl/YNeXz+H3ycUFQggh+gcprAkhgtLKkpUAUlgT3a56cyI1jm3s9q/QO4oIcq31bsrWVRE/KhpnrL1T+xg/KRy73SDtIEW3qF3pofSNNhKvthA11dylfSWNi8cSambfVyVomhQxRPdwrVhJ6/oN2HJycEyZcsptjQ7F0N/a8RzS2PM7lxyXQhfWoUMJOe9cPPuLOTT3Hda/+gAlaz8gdcIVjLnxcawhUXpHFP2MNSSKMTc+Tur4yzmwZh7rX3sAd1ON3rGEEEKILpPCmhAiKK0sXUlSaBIpYSl6RxH9WOmBVkr2ealPXsaq0lV6xxFBrnhx+6zJtBlJnd6H1WZg4rRwVi2rp7XVH6hoQuCp87PzkRYcAwwMuNfW5f0ZzQbSpyfRWNrMoV11XQ8oxNe41q6lZdUqrCNG4MybeUZrVoYON5H+HRvVX3mp/NBz2u2F6A62ESPwjs5g6663aSzbzYjL/o/B59yFwSjrTovuYTCaGHzu3Yy4/Gc0Vhay+oUfUFu8Re9YQgghRJdIYU0IEZRWlqxkUsqkMzoJIkRnLVpQi8EAqTkNrCqRwprQT/PBFio3HyJpXBy2cGuX9jVzTiStLX7WrKgPUDoR7DRNY/djLXgbNIY84sBoC8zf5vjRMdijbRTll6LJuoAigFo2bcK1ZCmWwYMJOWfOWb2eTLnJQvhYI4VPteAq9nVjSiGOp2kaxav/y7ZVL2ByhJJlGY+zrE1mUIoekTBiJuNvfQqj1c6G1x6gePVcOfaEEEL0WVJYE0IEnarmKvbW7mVSsrSBFN3H79NY8lUtueNCmThoJPvq9nGw+aDesUSQ2p9fitFiJHVKYpf3NWS4k7h4C4sXSDtIERgVcz0cWuxlwPdshAw2Bmy/yqDIyEumpbqVyoJDAduvCG6t27bR/NVCLJmZhF5wPspwdm+plUEx5EEHBrNi569b8HvkpLLoGT6Pm63z/sDu+f8iJmsiE7/zDyInz8G9dRuuJUukwCF6REhcBhNu+zMxWRPZPf95ts77Az6PW+9YQgghxFmTwpoQIugcmTkk66uJ7lSwsYnaGi8zz4liYspEAGkHKXTRUNLEoV11pEyKx+zoepsng0ExfXYEWzY1UX2wLQAJRTBzFfnY+6cWIiaYSLrWEvD9Rw+JIDTJyf7Fpfi90r5UdI179x6avvgSc2oqoRdfhDJ2rhBsjTeQ9Us7TTt87H9OTiiL7tfaWM26V39O5bbFDMy7lVFX/RKTzYlj8iRsOaNpWbeeljVr9I4pgoTJ5mTUVb9g4MxbqNy2mHWv/pzWxmq9YwkhhBBnRQprQoigs7JkJSaDibFJY/WOIvqxRfNrCA0zMmZ8KGMTx2JURmkHKXqcpmns+6oEs9NE8oT4gO13xpxINA2WLqwL2D5F8PF7NHb+xoXBphj8GzvKEPj2zEopMmYl09booWxtVcD3L4JHW/EBGj/9FFNCAmGXXYoyde1ChZg8MwlXWCh5xU3tGm+AUgpxvPqynax58ce4DpWQffWvyZhyTUf7UqUUzrw8rEOH4Fq2nJaCAp3TimChlIGMqdeS/c1f4TpUwpoXf0xD2S69YwkhhBBnTAprQoigs7J0JaPjR+MwO/SOIvqppiYva1c2MHVmBCazAafFyaj4UawsXal3NBFkagvraTjQRNq0JIyWwLXYi0+wMmS4g8Vf1UrrKNFp+59z07TTT9Yv7Fhju+9tSURGGJGZYRxYXo63VQoY4ux5Kipp/OADjBERhF1xOcoSmNmVmT+yYU83sOthF556mVEpAq9iaz7rX/k5BqOZcbc8SWzWxOO2UUoRct55mAdk0LzgK9w7pbghek7s4EmMu+VJDEYz6179ORVb8/WOJIQQQpwRKawJIYKKz+9jdelqaQMputWKxfV4PBoz50R23DYxeSKrS1fj1+TEmegZmqZRtLAUW4SVhNyYgO9/5pxIykrcFO5qCfi+Rf9Xt9ZLyStuEi43E5Nn7vbxMmal4G3xUbKiotvHEv2Lr7aWhrlzUXYbYd+4EoPNFrB9G+2KoY848NRp7H6sRS5UEAGjaX4K819m67w/EJY0hPG3/YmQuIyTbq+MRsIuvhhTUhKNn31GW1FRj2UVIiQug/G3/YmwxCy2zvsDhfn/QZP3TEIIIXq5PlNYU0pdoJTaqZTao5S6/xTbjVdK+ZRS3+zJfEKIvmHbwW00tTVJYU10q/z5NaRl2MgYaO+4bWLyRBrcDeys3qljMhFMDm6tobmqhfS8JAzGwL/kmzQtArNFsfir2oDvW/Rvnno/Ox9yYU81kPlj++nvEAAhCQ5iR0RRurqKtkZZG1CcGV9TE/XvvQ9A+De+gTEkJOBjhAwxkvFdG4cWean4rxybouu8bhcF7z1G0fK3Sco5n9wbHsXiDD/t/ZTZTNjll2GMjqLhw4/wlJX1QFoh2lmc4eTe8BhJOedTtPwtNr/3ON42uXhLCCFE79UnCmtKKSPwDHAhMBy4Xik1/CTbPQF83rMJhRB9xcqS9lZ8UlgT3aWkuJXCXS3MnBPZsX4FwMSU9tY7q0plnTXR/fxeP0X5pTjj7cQOj+qWMRxOI+Mnh7NsUR0ej1xVLM6Mpmns+X0LnhqNIY/YMdoDv67ayaTPTELza+xfWt5jY4q+y9/aSsN776O53YRfeSXGyMjT36mTkq+zEDHRxN4/t+Iq8nXbOKL/a6mvYt1//o/q3asZfO63GXrh9zEYz3xWsMFmI/zKKzE4nTTMnYe3urob0wpxLIPRzNALv8/gc7/Nwd2rWPef/6OlXtZHFUII0Tv1icIaMAHYo2naXk3T2oA3gctPsN33gfcA+csrhDihFSUriLZHMzByoN5RRD+1aEEtBgNMzYs45vahMUMJs4axqkQKa6L7la8/iLu+jQGzU44p8AbazNmRNDf5WL+6sdvGEP1L1cceqr/ykv5tK6HDTD06tj3SRkJuDBUbDtJS09qjY4u+RfN4aJg7F199PaGXXYopPq5bx1MGxZDf2DHYFTt+48LvkZaQ4uw1lO1i7Us/prXhIDnXPkzq+Ms69RrA4HQSftU3UCYTDe//F19dfTekFeLElFKkjr+MnGsfprW+irUv/ZiG8t16xxJCCCGO01cKa8nAgaO+Lzl8WwelVDJwJfDPHswlhOhjVpasZFLKpG490SyCl8+nsXRhLbnjQomIPPbqYIMyMD5pvMxYE93O6/ZRvKyciIxQIgaEdetYo3JCiIwysXhBTbeOI/qHlgM+Cv/YQvgYIyk3WXXJkDYtCYPJQNGiUl3GF72f5vPR8NFHeCsqCb3wQiypqT0yriXGwOBf2mne6Wf/P6XwK87OwV0rWPfq/RhMVsbd+iTRmWO6tD9jeDhh37gSzeul/v338Tc3ByipEGcmOnMM4259EoPJyrpXf87BXSv1jiSEEEIco2cvE+28E50B//plfH8Gfq5pmu9UJ8yVUncDdwMkJiaSn58foIhCiN6uydvE9urtTA6ZLP/3A0T+HY9VvNdMbU0o0Qll5OfvP+7nib5EFlYs5NMFn2I39sy6QsHh+FaHwXxsqv0WDC4Lh8IqWbSo+1vepQ20s2Gth08/XoTdKbMsvs7I8WsyBeXx6QPDPwaDZqXm/C0sWuLRLYqKt1C9zU++eTGEBG8bUyO5x90WlMfm0TSNlP3FRNTWUpqaSm1pCZSW9GgENSmFkldj2W/fCoOaenTs3mTkCW4L+uPzJPxl69CKvoKQRNqyrmTNlr3A3oDs256eRsaeQkr/8wr7BmfhNxoDst/+Ro7N7qNlXYV/x/sUvPtb1IDZGBLH6h2p12tqapJjUgghekBfKayVAEdfKpgCfH0l3XHAm4eLajHARUopr6Zpc4/eSNO054DnAJKSkrS8vLxuiiyE6G2+KPwClsH1068nLzNP7zh9z6Ljb5Ln0GP9edV+QsOauOX2yZjMx08Kb0lu4dXXX8WaaSVvQF6P5+uv/vlkwXG3Beux2dbkYc3qzUQNC2fYpeN6ZMyBA1r5vzW70LzDycuL7ZEx+5Ily9Yed1swHp9Fz7Zy4ICboY/ZiT1nqq5ZvG4fa57ZTERDAqMuGaxrFj0t4fj2bsF4bB6haRrN+Ytora3FMXUKoydM0CWHb5LGhlua8M0dzJjXQjCH95UmM4FVvWHjcbcF8/F5Iprfx675/6Kk6CtiB09mxOU/xWi2BXyctv37aZg7j9E1tYRdeQXK1FdOI3WPBcv/cNxtcmx2L9+sOWyd9yQHd31FUkwoWXO+hTJIkfdk8vPz5ZgUQoge0Fdepa8BspRSA5RSFuA64IOjN9A0bYCmaRmapmUA7wLf/XpRTQgR3FaWrEShGJ80Xu8ooh9qavKydkUDU2dGnLCoBjA5dTIKxbLiZT2cTgSL4iVlaD6NjLzk028cIKnpNjKz7OR/WYumyYw1cbz6jV4OvOQm7mIzsedY9I6DyWokbWoCdfsaqN3XoHcc0Uu0rF5N68aN2MbkYh+v32tFo00x9BEHnlqN3b9rkedVcUK+tlYK3nuMkrUfkDrhCkZ944FuKaoBWNLTCTnvXDwlJTR+/rkck6LHGc02Rn3jAVLHX86BNfMoeP9xfG3SMlcIIYS++kRhTdM0L3Av8DmwHXhb07StSqnvKKW+o286IURfsbJkJcNjhxNuC9c7iuiHli+ux+vVmDkn8qTbRNgiGBE3gmUHpLAmAq+lppWKjdUk5MZgj+qek2snM+vcKIqLWtm7u6VHxxW9n7dJY+dDLmyJBgb+pPe0wE0cG4c1zELRwhI5SSxo3bwF1/IVWIcNwzljhu5r8YYMNZLxHRuHFnqp/FC/tqmid3I31bDu1Z9TvWcNg8+7h8Hn3NXts3dsw4bhmD6Ntl27ac5fJM+boscpg5HB597N4PO+Q/Xu1ax77X7cTbLGrxBCCP30icIagKZpn2iaNljTtIGapj12+LZ/apr2zxNse5umae/2fEohRG+laRqrSlcxKWWS3lFEP7Vofg1pGTYyBp76xPHU1KksP7Acn9/XQ8lEsCjKL0UZFWnTknp87KkzI7BYFQu/kBMc4lh7/tCCu0pjyMN2TCH6FiuOZjAZSJ+ZRFO5i+odtXrHETpq27uPpgULMGekE3LuOboX1Y5IvtFC+DgjhU+10FIsrxlEu+bqYta+9BOaDx1g9Dd/Teq4S3psbPvYsdhyc2nduJGWtet6bFwhjpY67lKyv/mr9v8LL99Hc3Wx3pGEEEIEqT5TWBNCiK7YUb2DmpYaJqdM1juK6IdKilsp3NXCzHMiT3tCblraNBrbGtlStaWH0olg0FjWTPX2WpInxmMJMff4+A6nkYlTwlm2uA53q7/Hxxe9U9VnbRz8zEPaHVbCRvW+NXniRkbjiLWxP78Uv0+O22Dkqaig4eOPMcXGEnbxxShj71mzRxkUQx50YDArdvymBb9XZggFu7qSbaz9z//h93kYe9MTxGT17DqASimcM2dgGTwY19KltG7b3qPjC3FEbNZExt70BH5vG2v/83/UlWzTO5IQQoggJIU1IURQONJ6b1raNJ2TiP5o4Rc1GI0wLe/kbSCPmJo6FUDaQYqA0TSNfQtLMDlMpExK0C3HrPOiaHH5WbWsXrcMovdoLfOz5/+1EJZtJO02q95xTkgZFBl5KbTUuKncdEjvOKKH+erqaJg7D4PDQdgVl6Ms+q//93XWOANZD9hp2u6j+Hm33nGEjg7uWsmG13+J2RHGuFv/SFhili45lFKEnn8e5tQUmr78kraiIl1yCBGWmMW4W57E7Ahjw+u/4uDuVXpHEkIIEWSksCaECApLi5cS44hhcPRgvaOIfsbj8bP4q1rGTgwnPOL0MzIyIjJIDEmUwpoImLp9DdQXNZI2LRGTVb/ZFsNGOklItLDwS2kHGew0r8bOB12gwZCHHShT72itdyJRWeGEpYRQvKQMn0fa7QULv8tF/fv/BU0j/BtXYnA69Y50UjGzzcRfZubAy27qN3j1jiN0ULrxcwree4yQ2AzG3fwk9gj9LqIBUCYToZdeijE6ioaPPsZTUalrHhG87JGJjLv5SUJi0yl491FKN36udyQhhBBBRAprQoigsLR4KdPSpvWadTNE/7FuVQONDT5mnx91RtsrpZiaNpVlxVJYE12naRr7virBFmEhMTdW1yxKKfLOjWL7lmbKS2VmRTA78B83DQU+Bv3Mji2pd7/dUEqRMTuZtiYPZWuq9I4jeoDm8dAwdx7+5mbCrrgcY+TpZ5vrbeCP7diSDex80IW3UVpCBgtN09i39A12fPI00ZljyL3xcSzOcL1jAWCwWgm/4koMdhsN8+bhq6vTO5IIUhZnOLk3Pk70gFx2fPI0+5a+iabJ86QQQoju17vf6QohRABUNFVQWFvY0YJPiED66vMaYmLNZOeEnPF9pqZOZX/9fkobSrsxmQgGB7fW0FzZQvrMZAwm/V/WzZgTiTJAvsxaC1qNW73s/5eb2PPMxF7Q8+v9dUZ4aihRg8I5sLwCT4vMCOrPNL+fho8/xltVRehFF2FOTNQ70hkxOhRDf2unrVpj9+9b5KRxEND8PnZ+9nf2Ln6VxFFzyP7mrzFZ7HrHOoYhxEnYlVeC30/9+//F73LpHUkEKZPFTvbVvyFh1Bz2Ln6FnZ//Hc0vs9CFEEJ0L/3PwAghRDc7MjNI1lcTgVZV2cbmjU3knRuFwXjmsyFlnTURCH6fn/2LSnHG2YkdcWYzJrtbVLSZ3LGhLP6qFp9PTvwGG59LY8dvWrDGKgb9zN6nZolnzErG5/ZRsrxc7yiim2iaRtOCBXj2FeGcPQvrwEy9I52V0OEm0u+2Uj3fQ9WnHr3jiG7k87jZ/P7vKN3wCemTv8mwS36MwXj6duN6MEVFEXbF5fibm2mYOw+trU3vSCJIGYwmhl/yY9InXUXp+k/Y/N/f4/PK8SiEEKL7SGFNCNHvLTuwDJvJxpjEMXpHEf3MkVk5eeecXRupnIQcHGaHtIMUXVK+/iCtdW0MmJ3SqwoYs86LorbGy8a1jXpHET2s8I8ttJb5GfKQA1No7zkmz4QzzkHcqGjK1lbhbpATcf2Ra+VK3Fu2Yp84EXt2tt5xOiXlZithuUYK/9BCS4nMxuiPPC2NbHzz1xzctZKsc+5m0Kzbe9Xf+BMxJyYSdvFFeKuqaPjoYzSfHJtCH0opBs2+g6xz7uLgzuVsfOPXeFqb9I4lhBCiC+ciVAAArqNJREFUn5LCmhCi31tavJQJyROwGC16RxH9iN+nkf9lLdljQomJO7tjy2w0MzF5osxYE53mdfsoXlpOeEYoEZlhesf5/+zdd5hcZfn/8feZPrO9ZntPNpveSUhIDxBCeugEVBBRUVGaIgooTUFBUVFBVEInIZ2EkARSIL33ZLM12d53p5fz+wPlp19AUnb3zMzer+viumCzO+cDnD1z5rnPfT//ZejIaGJiDXwo4yB7lPoNXmpXecm8xUzM0ODsrPgq2ePTUFUo31yldRTRyVyHDuPcvgNz/37YxozWOs4FU/QKhY/YQAcnHnai+qQzOJy42hrYs+gBWs+eYMCc+8kaNVvrSOfMlJdH5NQpeMvL6fhgvYwrFZrKGjWH/rPvp/XscfYsuh9Xe4PWkYQQQoQhKawJIcKa3WNnb/VexmXKGEjRuQ7sbaep0cvkyy9sBN/YzLHsr9lPh0eeohTn78z2GnwOH7mTgqtbDcBgUBg/OY69O9toaZZxZT2BuzZA8ZMOovrryfqmWes4F8wSayZ1WBK1BxtwNDi1jiM6iaekhI4NGzDmZBM5ZUrQXTPPlyVFR+8fW2k/7Kfi726t44hO0lFfwe5X7sXVVseQ639Br37jtY503iwDBmAbMwb3sWM4tsrDY0JbKf0nMOS6R3G11rH7n/dib6jQOpIQQogwI4U1IURY23l2J37VL/uriU63cV0T0TF6ho+KuqCfH5s1Fr/qZ8eZHZ2cTIQ7d7uHsztqSSyKIyotQus4X2jitDgCAdi8oVnrKKKLqX6VE484CPig8FErOkNoFy0yx6aiN+oo++is1lFEJ/DW1NC2+j0MSUlEz5iBotdrHalTJE0zkXyVkYqX3bQd9GkdR1yktqqT7Hn1flS/j+ELf0V8zmCtI10w6yWjsAwaiHP3bpz792sdR/Rw8blDGH7zr1D9XvYseoC2qpNaRxJCCBFGpLAmhAhrWyu2oqAwJnOM1lFEGGlp9rJ3Zxvjp8RhMF7YW+mYjDEoKDIOUpy38k1VqH6VnEkZWkf5UumZFgr72fjwgyYZBxXmzrzqpnWvn/x7rFgzQ79oYYowkj46hcYTLbSdlY7iUOZvaaFt2XJ0ERFEz5mNYgqvkeD591ixpOo4/nMHvg65zoaq5vKD7H39QQxmG8NveZqoXvlaR7ooiqIQMWkSpvw87B9+hPtUsdaRRA8XlZLP8FueQW+2svf1B2kqO6B1JCGEEGFCCmtCiLD2ceXHDEgeQKwlVusoIoxs3tCM3w+Tpl3YGEiAGEsMA5IHSGFNnBd7rYPaAw2kjUzGGhfcI/cmTYun+qyHE0cdWkcRXaT9qI/yv7hJnGKk19VGreN0moxLemGMMFD24VkpDIeogN1O67tLAYiZOwddRHB2914MQ6RC4aNW3HUqp5+W0aWhqP7UDva/+XMs0UmMWPg0trhUrSN1CkWnI2r6dAypKbSvWYP3rHQAC23Z4lIZsfBpLDHJHHjrYepPbNM6khBCiDAghTUhRNjyB/x8UvmJjIEUnUpVVTaua6Kwn430TMtFvdbYzLFsq9yGP+DvpHQi3JVuPIPBoidzbPAvvo0eF4PVqmPj+01aRxFdwO9QOfFzJ8YEhYIfW0N+36r/pDfpyRqXRmt5O03FrVrHEedJ9XhoW76CgN1O9OxZ6OPitI7UZaIHGsj6hpm6tV7q3vdoHUech5ojH3Fo8WNEJOcw/OZfYY5K0DpSp1KMRqJnz0YfHU3b8hX4GuVeQGjLHJXA8Jt/RWSvPA6++wTVB9drHUkIIUSIk8KaECJsHao7RLunnbGZY7WOIsLIscN2aqo8TLni4hdAxmWNo93TzqG6Q52QTIS75pJWmkvayByXitFq0DrOV7JY9YydGMu2rS10tMseQOHm9LNOnGcCFD5qwxgdPkW1f0sZmog13kzphjME/AGt44hzpPr9tK1+D19dHdEzrsKYGvwPIVysrK+ZiR6kp/hXTlxVcq6GgjN7VnNk+TPEZPZn2I1PYLRFax2pS+isVqLnzgG9nralS/F3yHhdoS2jNYqhNz5OfPYgjq56loqdy7WOJIQQIoRJYU0IEbY2lW0CYHz2eI2TiHCycV0TVpuOS8bGXPRrXZZ9GQCbyzdf9GuJ8KYGVEo3nMESayJteLLWcc7ZtOkJeD0qmzc2ax1FdKKGjV5qV3jJvMVM7LDgL/JeCJ1eR+7kDJyNLmr2NWgdR5wDVVXp2LARb1kZkZMnY8rL0zpSt1AMCoWP2kCFE484UP0yvjSYlX3yNife/xOJBSMZct2jGMw2rSN1KX1MDDFz5qC6XLQtXUbA7dY6kujhDCYrg699hKTCsZxa/1dOb1okY5+FEEJcECmsCSHC1qbyTeTG5pIZk6l1FBEmOjp87Pi4lXET4zBbLv4tNCsmi5zYHDaVb+qEdCKc1R1qxF7nJGdSBjpD6Ny+ZedZ6V1oY/2aJlm0CBPu2gCnnnQSWaQn65vBvc/fxYrvE0tMViTlW6rwuaTrMtg5tm3HfeQI1ksuwTJooNZxupUlTUfB/VbaDvip/KcULoKRqqoUf/h3Tn/0T3r1n8jA+T9Fbwzva+i/GXolEzXzavxNTbSvXIXqlxHoQls6g5EBcx8gdfA0yj5+k5Pr/oyqSsevEEKI8xM6KzNCCHEeAmqATeWbmJgzUesoIoxs2diC16My+fLO269lYs5ENpVtIiAf5sSX8Hv9lH10lqi0CBKLQm+voGlXJVB1xs3RQ3ato4iLpPpVTjzqIOBV6fsLKzpj+I2A/E+KopA7NROfw0flthqt44j/wXXoEM4dOzD374dtzGit42giebqJpCuMlL/kpu2wFIKDiRrwc2LtHynftpj0oVfRf9Y96PTh2e37ZUzZ2UROm4q3spKOdR/IwzZCczqdnqKrfkDWJfM4s2cVR1f8hoBfrp1CCCHOnRTWhBBh6UjdEZqcTUzInqB1FBEmVFVl/ZpG8ntbyS3ovLE9E7In0Ohs5Gj90U57TRFezu6oxdPhJXdqBooSeoWM0eNiiIjUs35No9ZRxEU687qH1j1+8n9kxZql1zpOt4hKjSB5QDxnd9TiapVOoGDkKSmhY8NGjDk5RE6ZEpLXyc5ScJ8Vc7LCiYed+OxSuAgGAb+PIyt+w9l9a8gecw2FV34HRemZyzCWfv2wjb0U9/HjOLZu1TqOECiKQsHkb5A/8VZqjnzEwSWP4ffKe70QQohz0zPv6IQQYe/fo/Um5EhhTXSOY4ftnK10M+2qhE593X8Xf/+9J6AQ/8nT4eXMthoSCmOJyYzSOs4FMZl1TJgSx85tbbQ0e7WOIy5Q+zE/5S+4SJhkoNdMo9ZxulXOpAwUBco+PKt1FPF/eKuraVv9HoakJKJnXIWi7xkF3y9jiFIofNiGqypAyW+dWsfp8fxeNweXPEbt0U3kT7yVgklf69GFXwDryJFYBg3CuXsPzn37tI4jBIqikHPptRRe+V0ai3ez/82f43PJlAUhhBBfTQprQoiwtKl802f7VwnRGT54r5GICD1jLovt1NfNic0hMzpT9lkTX6h8SxUBn0rOpAyto1yUqdPj8ftUNq1v1jqKuAB+p8qJnzswxiv0/om1xy0Mm6NNpI/qRf2RJtqrZLEtWPibm2lbvgJdRATRc2ajmExaRwoKMUMNZN5qpnaVl/oN8jCDVnxuB/vfepjG4t0UXvldci69VutIQUFRFCImTcSUn4/9o024T53SOpIQAGQMu4r+s++j9ewx9r72Ezz2Fq0jCSGECHJSWBNChB1VVdlUtknGQIpO09LsZee2NsZPjcNs6dy3TkVRmJAzgU3lm2S/CfFfHA1OavbVkzIsCVuCRes4FyUtw0L/QRGsX9tIICDneagpedaJszJA4SM2jDE98+NDxqWpGCMMlKyvlGt1EAjY7bQuXQZAzNw56CIitA0UZLJuNxPVX0/xkw7ctbKHa3fzOFrZ+9pPaD1zlP6z7yVj2FVaRwoqik5H1FXTMaSm0r5mLd4z0g0sgkNK/wkMuubn2BvPsGfR/bha67SOJIQQIoj1zE/GQoiwdqzhGPWOeibmTNQ6iggTH33QjN+nMvXK+C55/YnZE6mz13G84XiXvL4ITaUbz6A36ckal6p1lE4xdXoC9bVeDu7r0DqKOA8NH3mpWe4lY6GZ2BEGreNoxmDWk31ZGm2VHTSeaNE6To+mejy0LV9BwG4nevYs9HFxWkcKOjqDQuGjVlQ/nHjEgeqXYnB3cbU3sGfRA9gbKhg0/yFS+k/UOlJQUgyGT39/o6NpW7ECX6PswyqCQ2L+CIbe8Es89hZ2L7ofe+MZrSMJIYQIUlJYE0KEnX/vVSUda6IzBPwq69c20n9QBOmZXdM19O+9AGUcpPi35tI2mk61knlpCqaI8NjPauToaGJiDaxfI4tnocJdF+DU404i++rJvsOsdRzNpQxNwpZooXTjGQJ+6QLSgur307b6PXx1dUTPuApjang8eNAVrJl68u+x0rrXz5nXPFrH6REczdXseeV+3O0NDLnuURJ7j9I6UlDTWa1Ez50Dej1tS5fh75AHb0RwiM3sz7CbnyTg87Jn0f2015zWOpIQQoggJIU1IUTY2VS+ifSodPLi8rSOIsLA/r3tNNR5mXZVQpcdIz8un7SoNCmsCQDUgErJBxVYYj/d1ylcGIw6Jk6LY8/ONhobZJE32KkBlROPOgh4VAp/YUVn7Fn7qn0RRaeQOyUDV7Ob6r31WsfpcVRVpWPDRrxlZUROmYwpT+7zvkryDCOJU4yU/9lF+zG/1nHCWkddGXteuQ+/x8mwm54kLnuQ1pFCgj4mhpi5c1BdLtqWLiPgdmsdSQgAonrlM2Lhr9EZTOx97Se0VB7VOpIQQoggI4U1IURYUVWVTeWbmJAzAUWRRUBx8da/10hsnIERo2O67BiKojAhewKbymSfNQHVe+tx1LvInZKJzhBet2pTrkgAFTa+36R1FPEVzr7moXW3n/wfWbFl67WOEzTi8mOIzYmiYksVXqdP6zg9imPbdtxHjmC95BIsAwdqHSckKIpCwQMWjAkKJ37uwO+Ue4yu0Hr2OHtefQBF0THs5l8Rndpb60ghxZCcTNTMq/E3NdG+ciWqT66tIjjYEtIZsfDXmCJi2ffGQzSe3q11JCGEEEEkvFZrhBA93qmmU9R01MgYSNEp6us87NvdzqTL4zEYurZQOyF7AtUd1RQ3FXfpcURw8zp9lG+uIiY7ioTCWK3jdLrkFBODh0Wx8f0mfD5Z4A1W7Ud9lL3gImGigV6zwmMUaWdRFIXcqZn4nH4qtlZpHafHcB06hHPHDsz9+2MbM1rrOCHFGKOj8GEbzsoAJc+5tI4TdprKDrDv9Z9itEQy/JZfE5mUpXWkkGTKziZy2jS8lWfoWPeBPGgmgoYlJpnhC3+NLSGdA+/8ktpjW7SOJIQQIkhIYU0IEVY+KvsIkP3VROfYsLYJFJhyRXyXH2tizkQAPiz7sMuPJYJXxZYqfC4fedMyw7brdupV8TQ3+di7s03rKOIL+DpUjj/kxJSk0PuntrA9Dy9GZC8bKUMSqd5dj6PBqXWcsOcpKaFjw0aMOTlETpks5+QFiB1hIGOhmZplHho+8modJ2zUn9zGgbcexhLTi+G3PI01NkXrSCHN0q8I29ixuE+cwLFlq9ZxhPiMKSKWYTc9SXRaHw4v+zVVB9ZpHUkIIUQQkMKaECKsbCjdQHpUOn0S+mgdRYQ4rzfAh+uaGDYiisRkU5cfr09CH9Ki0thYurHLjyWCk6PBSfWeelKGJBLZy6Z1nC4zdEQ0CUlG1q1u1DqK+D9UVaX4KSeumgCFv7BhjJYCxpfJnpiOzqij5INK6azoQt7qatpWv4chKYnoGVeh6GUs6YXKvsNMZF89px534q4LaB0n5FUf3sihJU8Q2SuX4Tc/hTmy6x/C6gmsI0dgGTwY5549OPfu0zqOEJ8xWiIZev0vic8dwrHVv6Nix1KtIwkhhNCYFNaEEGEjoAbYULKBKXlT5GlmcdG2bWmltcXHFTMTu+V4iqIwJXcKG0o3EFBlwasnKll/Bp1RR/aEdK2jdCm9XmHa9AQOH+jgTIWMJQsmtSu91H/gJfubZmIGG7SOE9RMEUayL0uluaSNpuJWreOEJX9zM23LV6CLiCB6zmwUU9c/5BLOdEaFwl9YCXhVTjzsQPVLQfhCVe5exdEVvyE2awBDb3gcoy1a60hhQ1EUIiZOwFSQj33TJtwnT2odSYjP6E0WBl/zc5L7juXUhpc4vWmRPFwjhBA9mBTWhBBh42DtQRqdjUzNnap1FBHiVFVl7coG0jPNDBwS2W3HnZo3lQZHA4dqD3XbMUVwaDrdSvPpVrLGpWKKCP89rSZfEY/RqLB2ZYPWUcS/OEr9nP6Nk5jhejJvMWsdJySkjkjGmmCh5INKAj55IKIzBex2WpcuAyBm7hx0ERHaBgoTtmw9BfdZad3rp+Lvbq3jhBxVVSn7+C1OrnuBxN6XMPi6RzGYw7fDXCuKTkfU9OkY0tJoX/s+3jNntI4kxGd0eiMD5jxA6uBplH38Jic/+AuqPBQphBA9khTWhBBhY0PJBgCm5E3ROIkIdcUnHJSccnLF1Qnd2v04JffTc3dD6YZuO6bQXsAfoOSDSixxZtJGJmsdp1tExxgYOyGWLRubsXf4tY7T4wXcKscfcqCzKBQ+akPRS9f3udDpdeRNy8TV7KZqV53WccKG6vHQtnwFAbud6Nmz0MfFaR0prPSaYSJ5upGKv7lp2evTOk7IUFWV4g//zulNr5DSfyID5z2I3iBdlF1FMRiInjUTfUw0bStW4GuQB3FE8FB0eoqu+gFZo+ZyZvdKjq56jkBA7meFEKKnkcKaECJsrC9dT1FiEWlRaVpHESFuzcpGrDYd4yd372JeenQ6fRP7sr5kfbceV2irem89zkYXeVMz0el7zq3ZFTMTcbtVPvqgSesoPV7J713YiwMU/tyKOannnIOdIT4/hviCGCq2VuHp8GodJ+Spfj9tq9/DV1dH9IyrMKamah0pLBXcb8WaoePEzx14mqXT4quoAT/H1zxPxfYlpA+bQb9Z96DTy7jcrqazWomeOxfFYKRt6TL87e1aRxLiM4qiUDDlNvLGL6Tm0AYOv/skfp9H61hCCCG6kXxyFkKEBY/fw+byzZ91/AhxoZoavezY2sLEafFYrPpuP/6U3ClsLt+Mxy8fzHoCr8NHxeYqYnOjiO8do3WcbpWbb6Wwn433VzcSkL1+NNPwkZfqxR7SbzQRPzb8x5B2hbxpmQR8KmUfyriyi6GqKh0bNuItKyNy8mRMeXlaRwpbeptC38dteFtVTv7CiRqQa/CXCfi9HF7+DFX73yfn0mspvOLbKIoso3QXfXQ00XNmf9rJunQZAZfszSqCh6Io5I67nj7TvkX9yW0cePsRfB6n1rGEEEJ0E7kjFEKEhe1ntuPwOmQMpLhoG9Y2EgjAFTMSNDn+lNwp2L12dpzZocnxRfcq33wWn9tP3tSsbh07Giymz0qkrsbDvt3yFLoWXDUBTj3uJLKvnpzvWLSOE7Ks8RbSRyVTe7CR9iq71nFClmPbdtxHjmC95BIsgwZqHSfsRfbRk/d9C82f+Dj7pjzM80X8XhcHFz9G3bHNFEz+BvkTb+2R79VaMyQnE3X11fibm2lfuQrVJyNMRXDJHDmLfjN/REv5Ifa98RBep9zXCiFETyCFNSFEWNhQsgGdomNizkSto4gQ5vUGWL+miSEjokhJM2uSYWLORHSKTvZZ6wHs9U6q99aTOiyJiGSr1nE0MWJ0DPEJRtaukr1TupvqUznxMweqT6XvY1Z0RlksvhiZ49IwRhg4va4CVZXun/PlOnQI544dmPv3wzZmtNZxeozUBSYSJhoo+6OL9qNSrPhPPped/W/+nMbTe+g7/Xtkj56vdaQezZSdReTl0/CeOUP7++vkOiuCTurAKQyc9yDtNcXsffXHuDtk1LkQQoQ7KawJIcLChtINjEgbQawlVusoIoRt39pKa4uPK2cmapYhzhrH8NThUlgLc6qqcvr9CgxmPdnje+6+kAaDwrQZCRza18HZShnv1J3K/+am7aCfgh9bsWZ2/9jbcGMw68mZlEH7WTv1h2Ux7Xy4T5fQsWEjxpxsIqdMkY6gbqQoCr1/asOUqHD8pw58HVKsAPDYW9n7+k9oPXucAXPuJ33olVpHEoClqAjbuHF4Tp7EvnmL1nGE+JykwjEMufYRnC017Fl0P86WWq0jCSGE6EJSWBNChLx2dzs7zu6Q/dXERVu7soG0DDMDh0RqmmNK7hS2n9lOh6dD0xyi69Qfbaa1vJ2ciekYbT17X6spV8RjNCq8v6pR6yg9RstuH5V/d9NrhpHkK0xaxwkbvQYlEJlqo3TjGfwev9ZxQoL3bBXtq1djSE4mesYMFL0UebubMVqh7y9tuGpVTj3p7PGdQK62Bva8ej/2hkoGLfgZvfqN1zqS+A/WEcOxDBmCa+9enHv3ah1HiM+Jzx3K0Bsfx+tsY8+i+7A3VGgdSQghRBeRwpoQIuRtLt+ML+Bjat5UraOIEHbquJ3TJ51ccXUCOp22T8tPzZuKL+Bjc/lmTXOIruFz+yldX0lkio2UoUlax9FcdIyBSyfEsmlDM/YOKUZ0NU9DgOMPObBm68i/t2eOIO0qiqKQf3kWng4vlR9Xax0n6PkaGmhbvhx9dDTRc2ajmKTIq5XoQQZyvmWmYb2XmmVereNoxtFUxZ5F9+Fub2TI9b8ksWCk1pHE/6EoChETxmMqKMC+aTPuEye0jiTE58Sk92XYzb9CDfjZs+gB2qpPaR1JCCFEF5DCmhAi5K0vWY/FYOHSzEu1jiJC2OplDdgidIyfHKd1FMZmjcWsN7O+ZL3WUUQXqNhahafDS/6VWSgaF3GDxfRZibhdATasla61rqT6VI7/zIHfqVL0pA29Tc6/zhadEUnywATObK/F0SjjTb+Mv62NtneXohgMRM+dg85m0zpSj5ex0EzsJQZKnnViL+55Dzm015WyZ9F9+D0uht30JHFZA7SOJL6EotMRNf1KDGlptL+/Dk9lpdaRhPicqORchi98Gr3Jwt7XfkJzxWGtIwkhhOhkUlgTQoS890+/z4TsCVgMFq2jiBBVV+NhxyetTLkyAatN+zFUFoOFCTkTeP/0+1pHEZ3MXu+kamcdvQYnEp2u7cjRYJKTZ6X/oEjWrmzE5w1oHSdslb/kpnWvn4IHrETkaX+tC1e5kzPQGXWcfr+ix4/V+yIBp5O2d5ei+rxEz5uLPiZG60gCUHQKhQ9b0UcqHPupA7+j55y7LZVH2bvoARSdnuELf0V0am+tI4mvoBgMRM+ehT4mhvaVK/E1NGgdSYjPscWnMXzh05ijEtj/5s9oKN6ldSQhhBCdSAprQoiQVt5SzrGGY1xZIJuKiwv33vJ6dApMn5modZTPXJl/JUfrj1LRKnP5w4WqqpxeV4HepCNnUrrWcYLO1XMTaWr08smWVq2jhKWmT7xU/t1Nymwjva6SkXtdyRRpJHtCGi2lbTQcb9Y6TlBRPR7ali3D39ZG9KzZGBKD531XgClBR99f2HBWBDj1RM/Yb63x9G72vfEQxogYht/yDBGJWVpHEudIZ7EQPXcOisFI29Jl+NvbtY4kxOdYohMZfvOviUjM5ODiX1J7VEb9CyFEuJDCmhAipK0tXgsghTVxwTo6fHz4QTOXjo8lPtGodZzP/Puc/vc5LkJfw7FmWsvayZ6QjikieM61YDF4eBTpmWZWL63vEYu53cldG+DEI04iCnTk/Uj2VesOacOTiehlpeSDSnzunjdW74uofj9tq1bjq60jasZVGDPkAYNgFDvi0/3W6j/wUr3Eo3WcLlV7dDMH3vkltoR0ht/8a6wxyVpHEudJHx1N9Nw5nxbt332XgNOpdSQhPscUEcOwG58kJr0vh5f9mrP75POdEEKEAymsCSFC2trTa8mOyaYwoVDrKCJEbVjbhNsV4Oq5SVpH+S99E/uSFZMlhbUw4ff4KVlfSUQvG6nDgutcCxY6ncKMOYmUl7o4fKBD6zhhI+BTOfZTB6pXpe+TNvQW2VetOyg6hYIrs/G0e6nYWqV1HM2pqkrHug/wlpcTOXUK5vx8rSOJ/yHjFjNxlxooedZF+xGf1nG6xJm9azi87NdEpxUy/KanMEdqv8euuDCGpCSiZ8/C39pG29JlBDzhXRAWoclgiWDI9b8gIX84x9c8T/n2JVpHEkIIcZGksCaECFkev4cNJRu4suBKFEUWCsX583kDrF3RwIDBkWTnBVcXh6IoXJl/JetL1uP1e7WOIy5SxdZqPO1eCq7MQtHJ9erLjJsUR0ysgdVLZa+UzlL2Rxfth/z0ftCKLUv2VetO0RmR9BqcSNXOOuz1PbeLQlVV7Js34z5+HNvYS7EMGKB1JPEVFJ1C4SNWTEkKxx504G0Nn70vVVWl7JO3ObH2DyTkD2foDb/AYInQOpa4SMaMDKJmzMBXV0f7ipWovvAsCIvQpjdaGLTgIZKLxlO88WVOf/RPmdIghBAhTAprQoiQta1yG+2edhkDKS7YJ1taaW7yMWNucO7xcmXBlbR72tl2ZpvWUcRFsNc7Obujll6DEojOiNQ6TlAzmXRcPiOB/XvaOVPh0jpOyGvc5OXs6x5SF5hImib7qmkhd3I6erOO4rXlPXbxzLl7N669+7AMGYJ15Eit44hzZIzRUfSEDU+DyolHnKiB0D9/VVX9bDG7V78JDFrwM/RGi9axRCcx5+cRefk0vJWVtK9ZixoIn4KwCB86vZEBs+8lbciVnxb5338BVZVzVQghQpEU1oQQIWtt8VoMOgNTcqdoHUWEIFVVWb20nowsM0OGR2kd5wtNyZuCQWeQcZAhTFVVit8rR2/WkzslQ+s4IWHaVQmYzAqrl9VrHSWkOc8GOPELB5F99eT9QBaOtWK0GcmZmEFbRQf1h5u0jtPtXEeO4Nj6MebCQiImTpAJAyEmqp+BvB9aaP7ER+Urbq3jXBQ14Of4e7+nYse7pA+bQf/Z96LTG7SOJTqZpV8/IiaMx1NcTMeGjT32gQYR3BSdnr7T7yJ79HzO7l3N0RW/IeCXLkshhAg1UlgTQoSstafXMi5rHFHm4CyKiOB2+EAH5aUuZsxJCtqFvmhzNGMzx0phLYTV7m+g7UwHuVMyMNqMWscJCdExBsZPjmPLxhZammUM6oUIeFSOP+gAoOhJGzpTcF7jeoqUoYlEpUVQsqESn6vnLJy5TxXT8cF6jFlZRF5xedC+14r/LXW+iaTLjZT/xU3L7tA8fwM+L4eW/oqqA+vIGXs9hVd8G0WRpZBwZR02DOuoUbgPH8bx8cdaxxHiCymKQsHkb5A/8VZqjnzEoXefwO+T/QGFECKUyN2kECIkVbdXs79mP1fmyxhIcWFWL20gJtbAuEmxWkf5n64suJJ9Nfuo6ajROoo4Tx67l9KNZ4jOiqTXoASt44SUq+Yk4fervL+qUesoIankORcdx/0U/tyGJU1u97WmKAr5V2bhdfgo+/Cs1nG6hae8nPY1azCkpBA9ayaKXvb3C1WKotD7J1asWTqOP+TAXR9aI8t8HicH3n6E+hMf03vq7eRPWChF3h7AdukYLAMH4ty1G8fuPVrHEeJL5Vx6LYVXfJuGUzs48NbD+NwOrSMJIYQ4R/JJWwgRktadXgcg+6uJC1JW4mT/nnaunJWI0Rjcb4X/Psf/fc6L0FG6vhK/J0Dv6dmyiHee0tLNjLgkmnWrGnE6/FrHCSm173moXuIh/UYTCROkSzJYRKVGkDYymeq99bRWtmsdp0t5q6poW7ESfVwc0XNmoxjlPAx1eptC0ZM2/E6V4w85UH2hMV7P62xn3+s/pan8IEVX303WqLlaRxLdRFEUIiZPwtS7N44tW3AdOaJ1JCG+VMbwq+k/615aKg6z7/Wf4nW0aR1JCCHEOQju1UQhhPgSa0+vJSUyhUG9BmkdRYSgZe/UYbXpuPyq4O8iGtxrMCmRKawpXqN1FHEemkvbqDvcRMaYFGyJVq3jhKTZ1yRjt/tZv0a61s5Vxwk/xU85iRmmJ/e7sq9asMmZkI452kTxe+UE/KHV9XOufPX1tC1bji4ykph5c9FZ5DwMFxF5eno/aKVtv5+yP7u0jvOV3O2N7Fn0AO21pxk070HSBk3TOpLoZopOR9SVV2DMyqLjg/W4i4u1jiTEl0oZMImBCx6io66UPa/+GHe73P8KIUSwk8KaECLkeP1e1havZXrBdOkCEeet6qybHVtbufyqBCIig380laIoTC+YztritXj9st9UKAj4ApxeW44lzkzm2FSt44SsgkIbA4dEsnpZAx5PeBYhOpO3NcDRB+wYYhT6Pm5DMcj7Y7DRm/QUXJmFo8HFmW3hN97X39xM67tLUYxGYubPQxcRoXUk0cmSrzCROt/EmUUeGj4M3nsSR9NZdi+6D1dbHUOufZSkwjFaRxIaUQwGomdejaFXMu3vrcFTWal1JCG+VFLvSxh83aO42urYveg+HE1VWkcSQgjxP0hhTQgRcrZWbKXF1cKswllaRxEhaOWSOgxGhemzE7WOcs5m9plJi6uFjytlA/ZQUPlxNc4mNwVXZqEP8lGjwW72Ncm0NPvYtL5Z6yhBTfWrnPi5E0+DStGTNkzxct4Fq/jesSQWxVGxtRpHY/B3/Zwrf3s7rUveBVUlev489NHRWkcSXSTvbgtR/fWc/IUDe0nwjeptqz7F7lfuw+92MvTGx4nPHaJ1JKExxWQies4c9DExtC9fgbcm/B5sEOEjPmcww258Ar/bye5X7qWt+pTWkYQQQnwJ+dQthAg5K06swKw3My1PRrqI89PY4GHzxhYmTYsnNi509nyZlj8Ns97MihMrtI4ivoKjwUnlthqS+scTlxejdZyQ139QBAWFNlYuqcfvD409fbRQ/qKb5u0+8u+xEj3AoHUc8RXyp2WiM+goXlOOqob+eR1wOGhb8i6qx03MvLkY4uO1jiS6kM6kUPSUDZ1F4dj9DnwdwXMON5bsZe+rP0ZvtDDilmeISSvUOpIIEjqrlej581BsNtreXYqvvl7rSEJ8qei0Poy45Rn0Rgt7X/sJjaX7tI4khBDiC0hhTQgRUlRVZeXJlUzJm0KESUYMifOzamkDqCoz5ydpHeW8RJoimZw7mRUnVoTFImy4UlWVU6vL0Rt15E3N1DpOWFAUhTnXJFFX62Hb5hat4wSlxk1eKv/uptcsIylzQueBgZ7MFGUid3IGreXt1B4M7T1UAi4Xre8uxd/eTvTsORiSk7WOJLqBOVlH0RM2XFUBTjzsQA1of29Sc/hDDrz9CNa4VEbc+gy2hHStI4kgo4+MJGb+PBSTidYl7+JrbNI6khBfypaQzohbn8Eam8KBtx6h5shHWkcSQgjxf0hhTQgRUo41HON082lm9ZExkOL8tLX62Li2kbET4khKNmkd57zNKpzF6ebTHG84rnUU8SWqdtfRdqaDvGmZmCKlwNFZho2KJiPLzLJ36ggEweJtMHFU+DnxqIPIIj0F91pl39EQkjI0kejMSEo3VOKxB+9eVf+L6vXStnwF/sZGomdejTE9TetIohvFDDWQ90MLTVt9VPzNrWmWih1LObLiGWIy+jH85l9hjpSuSfHF9DExxMyfB4pC25Il+FtatI4kxJcyR8Yz/OZfEZNRxJHlT1Oxc5nWkYQQQvwHKawJIULKyhMrAbi6z9UaJxGhZu3KBjweldnXhFa32r/9+5xfeXKlxknEF3G1uCn78CxxedEkD0zQOk5Y0ekU5lyTzJkKN3t3tWkdJ2j47CrHHnCgGP81ls0sRbVQoigKva/Kxu8OUPJBpdZxzpvq99O2chW+6mqipk/HlJOjdSShgdQFJnrNMFLxkpvGzd1fIFbVAKc2vsypDS+RVDiWIdf/AoNFJlqI/00fF0fM/Hmofj+tS5bgb2/XOpIQX8pgiWDI9b8gqXAsp9a/SPHGl2WCiRBCBAkprAkhQsqKkysYnjqc9GgZ7yLOndPh5/2VjYwYHU16pkXrOBckIzqDYanDZJ+1IKSqKqfeK0dRoOCqbOka6gJjxseS3MvE0rfqZDEBUAMqJx9x4CgP0PcxG5YUuaUPRbZEK5ljU6g/0kTjyRat45wz1e+nffV7eMvLiZw6FXOf3lpHEhpRFIWCB6xEFuk58YgDR7m/244d8Ps4uvJZKrYvIX3YDAbOfQC9IfQmEghtGBITiZk3F9XlpnXxEgJ2u9aRhPhSeoOJgXMfIH3YVZRvX8LRVc8S8Pu0jiWEED2efAoXQoSMOnsd2yq3MbPPTK2jiBCzdlUjdrufOdeE9t4vM/vM5JPKT6i3y4brwaT2YCMtpW3kTMrAEmPWOk5Y0usVZs5P4vRJJwf3dWgdR3PlL7pp3Owj7wcW4kYatI4jLkLm2FQikq2ceq8crzP4F8nUQID2tWvxnD5NxKSJWAb01zqS0JjO/GnXrGJUOHq/A19H1z/84PM4OfjOL6g5vJG88QspvOLbKDp9lx9XhBdDr15Ez5lDoKOD1iXvEnA6tY4kxJdSdHoKr/gOeeNvpubQBg4u/iV+j0vrWEII0aNJYU0IETLeO/UeKiqzCmV/NXHuHA4/q96tZ+iIKPL72LSOc1FmFc5CReW9U+9pHUX8i6fdQ+n6SqIzI0kdHppjRkPFxGlxJCQZWfxabY/uWqvf4KXyZTe9ZhpJu1a6M0KdTq+jz8xcvA5v0I+EVAMBOt5fh+fkKWzjL8M6ZIjWkUSQsKToKHrchrMywIlHHKhduB+mx9HKvtcfpLF0H32v+j65466XTnFxwYzpaUTPnoW/pYW2d5cScGu7X6AQ/4uiKOSOu4G+079HY8le9r7+EzyOVq1jCSFEjyWFNSFEyFhxYgUZ0RkMSRmidRQRQtauaMDe4WfBTb20jnLRhqYMJT0qnRUnZRxkMFBVleK1FQR8AXrPyJGFvS5mNOqYe20yp044OLC3Z3atdZzwc/JRB9GD9BTcb5VzLkxEptjIvDSVukONNJ1q0TrOF1JVlY71G3AfP45t7KXYhg/XOpIIMrEjDOTdbaFpi4+yF7qmOOFsqWXPK/fRUVfGoPkPkj7kii45juhZTFlZRF99Nb6GBtqWLUf1dv9+gUKcj/ShVzJo3oN01JWx55X7cbbUah1JCCF6JCmsCSFCgtPrZN3pdczsM1MWEsU5c9j9rF7awPBRUeT3Du1uNfj0KcWZfWbyfvH7OL0yrkZrDceaaTzZQtb4NGwJobl3X6iZODWOxGQj77xW0+O61jxNAY7eZ8cQ8+nYNZ1J3gvDSda4VGxJn46E9LmCaySkqqrYN36I+8gRrJdcgm3UKK0jiSCVdo2JlLkmzrzipm6Np1Nf2xFoZdc/foTH0cLQGx4jqc+YTn190bOZ8nKJmj4dX3U1bctXoPqC6zosxP+VVDiGoTc8hsfRzO5//oi26lNaRxJCiB5HCmtCiJDw/un3sXvtzC+ar3UUEULWrGjAbvez4MbQ71b7t/n95mP32ll3ep3WUXo0j93L6fcriEyxkXFJitZxegzDv7rWTp90sn93u9Zxuk3Aq3Lsxw68LSr9fh2BKUFu4cONzqCjz9U5eOxeStaf0TrOZ1RVxb5pE66DB7GOGI5tzGitI4kgpigK+fdaiBmm5+QTTtoOdU5xotVfx2n3bvRGMyNueYbYTNnbT3Q+c5/eRF5+Od7KStpWrJTimgh6sZn9GXHLM+gMZva8+gD1p3ZoHUkIIXoU+VQuhAgJi48uJsGawIScCVpHESHC3uFn9bJ6RoyOJrcg9LvV/m1C9gTirfEsPrZY6yg9lqqqFL9Xjs/tp8+sXBSddA51pwlT40nqZeSd13vGXmuqqnL6aSdtB/z0fshKVJFe60iii0SlRZA5JoXaAw00ndZ+zxRVVXFs3Ypr334sQ4dgGzdOpgaIr6QzfNpVa07ScfR+B+7awEW9XoOvgjLPAcxKJCNu/Q0RiVmdlFSIz7P0KyJy2jS85eW0rZTimgh+EYlZjLj1GSISszi4+DEqd6/SOpIQQvQYUlgTQgQ9t8/NihMrmNN3DgadQes4IkS8t7wehz0QVt1qAEa9kTmFc1hxYgVun2ywroW6Q400nmwhZ2I6EUlWreP0OAaDwtzrelFyysneXeHftVb1joea5V4ybzWTfLlJ6ziii2VdloYt0cKp1WWajoRUVRXHJ9tw7t6DZdAgIiZMkKKaOGfGGB39nrERcKscudeO33n+D0GoqkqV9yRnvSeI1iWRbx6BOTKuC9IK8d8sA/oTOW0q3rJy2laukuKaCHrmyHiG3/QUiQUjOLnuBQJlH6KqF/dQgxBCiK8mhTUhRND7oOQD2j3tLOi3QOsoIkR0dPh4b3kDI8dEk5MXfoWPBf0W0OZuY33Jeq2j9DiuVjen11USnRlJ+qjwKtqGkvGT40hOMbEkzLvWmrZ6KXnWRcJ4A9l3mrWOI7rBZyMhO7ycXlepSQZVVXF8/AnOnTsxDxhAxORJUlQT5y0iT0/fx2zYiwOceMSBGjj3a7Xf66bcc5B6XzkJ+kxyTIPRK9KtK7qPZcAAIqdOxVtWRtsqKa6J4Kc3WRg0/yEyhl+NWrWbw0ufwu+VhzCFEKIrSWFNCBH0Fh9dTKwllsm5k7WOIkLEe8sacDrCr1vt36bkTSHGHCPjILuZqqqcXFUGqkqfmTICUksGg8K865IpKXayZ2eb1nG6RMdJP8cechDZR0/hL2xyvvUgUemRZI1Npe5QI/XHmrr12P8e/+jctQvLwIFETp0iRTVxweIvNZL7PQuNH/ko/+u5LfB67K3se/1BWgN1pBn6kG4slHNQaMIycACRU6fgLZXimggNik5Pn8vvRMmeSN3xj9n3xk/xOLQfLS2EEOFKCmtCiKDm8XtYfmI5swtnY9LLCCzx1VpbPu1WG3VpDNm54detBmDSm5jddzbLjy/H6/dqHafHqNpdR2tZO3lTM7HGSfeQ1i6bHEdKqom3F9US8IdX15q7LsCRH9kxRCn0e8aG3iqLyj1N5rhUIlNtFK8px93u6aajqji2bP3/4x+nTJaChrho6TeY6DXTSOXf3dSu/t/nsqPpLLtfuZf22hKyTYNIMmbLOSg0ZRk4kMgp/y6urZbimgh6iqKgSx/JgLk/ob26mN3/vBdHU5XWsYQQIixJYU0IEdQ+LP2QFlcL84vmax1FhIilb9XicQe4/pbw7Fb7t/lF82l2NfNh2YdaR+kRHA1OyjaeIb4ghl5DErWOIwC9XuHahSlUlLnYuqlF6zidxu/4155EdpUBv43AnCS36z2RTq+jcHYeAa/KqVVl3TDyVCV5yC6ce/ZgGTxYxj+KTqMoCgUPWIkZoefU405adn9xYaLlzFF2//NefK4Oht34BLH68L6PE6HDMmggEVMm4y0tpW3Vaq3jCHFOehWNY+hNT+BzdbD7n/fQcuao1pGEECLsyCd1IURQW3x0MVGmKKblT9M6iggBNdVuPljTxKTL40nLsGgdp0tdnn85kaZIFh+VcZBdTQ2onFhRis6oo/dV8vR8MBk9Loa8AitvL6rB4wn9TdpVv8rxnzuwnwrQ9zEbEb1lT6GezJZgIXdqBs0lbVTvru/CI6n0GrqThL5HsAwZQsSkiXKdE51KZ1To91QE1mwdRx+wYy/x/9ef1x7bwr7XHsRgiWTErb8hJqNIo6RCfDHroEFETP60uCZEqIjN6MeIW5/BYIlk32sPUntsq9aRhBAirEhhTQgRtHwBH0uPL2Vm4UwshvAukojO8fartej1MP+G8H/K2WKwMLPPTJYeX4ovIGNpulLF1io6qh0UTM/GFCUjaYOJTqdww9dSaKj38sF7jVrHuWilz7to2uIj/0cW4scatY4jgkDqsCTi8mMo3ViJo8HZBUdQ6TVsB/GFR2k60Y+IiROkqCa6hCFKof9vI9CZFY780I6nIYCqqpRufZPDS58iKrWAEbc+gy0+TeuoQnwh6+BBRE6donUMIc6LLT6dEbc+Q1RKPoeXPknpx292Qxe8EEL0DCFTWFMU5UpFUU4oilKsKMqPv+DPb1IU5eC//vpEUZTBWuQUQnSejaUbaXQ2sqBogdZRRAgoPe3kk00tTJ+VSHxCz1iQXtBvAQ2OBjaWbtQ6SthqrWinYms1yQMTSCqK1zqO+AIDh0QxcGgkS9+qw2H3f/UPBKmqJW7OvuEh7ToTadfIHn7iU4qi0OfqHHQmPSeWlxLwd2ZnpkrK8O3E9zlG4/H+1O4bJUU10aUsqTr6/yYCb4vK4XuaOfzu05RsXkRK/4kMvfEJTLYYrSMK8T9ZBg7UOoIQ581ki2HoTU+S0n8iJZsWcXTFM/h93bV/qxBChK+QKKwpiqIH/ghMB/oBNyiK0u//fFspMEFV1UHAL4G/dm9KIURne/Xgq8SYY5jee7rWUUQIeOMf1URG6Zk1P1nrKN3mqt5XEWOO4bVDr2kdJSx5nT6OLyvBEmsm/4osreOI/+HGW1PoaPezYklXjsvrOg2bvJx+xkX8ZQbyfiAd2uK/mSKN9L4qm44aBxWbqzrlNdVAgNRLthDX+zgNxwZQt38kIEU10fWiivTkP+ymJfkX1J3YRN5lt9Bv1r3oDdIRLoQQXUVvMNFv1r3kTVhIzZGP2PvaT3B3NGsdSwghQlpIFNaAUUCxqqolqqp6gDeB2f/5DaqqfqKq6r/fFbYDGd2cUQjRiRxeB0uPL2VBvwUyBlJ8pUP72zm4r4O51yYTEdlz9iSyGCzML5rPu8fexeF1aB0nrKiqyqnVZXjtPvrOzcNg7jnnVSjKLbBx6YRY3lteT3OTV+s456V1v48TP3MQVaSn7y9tKHopbojPSyyMo9fgRCo/qaG5tO2iXkv1+2lf/R6xuaepOziU+gMjkKKa6C7ttSUUH70f4isx7Lwb/7ZZWkcS4qIFHHIfLoKfoijkjr2egfMepKO2lF3/+CHttSVaxxJCiJAVKoW1dKDyP/75zL++9mVuA9Z0aSIhRJdacWIFHZ4Obhp4k9ZRRJALBFTe+EcNCUlGps1I0DpOt7tp0E10eDpYeWKl1lHCSs3eehpPtJAzKZ2o1Ait44hzcO3NvfD7VJa8Xqt1lHNmL/Fz9F475hQd/X9rQ2+V4ob4cvmXZ2JNtHBieSmejgsrIKteL20rVuApLqZm7ygajw5Bimqiu9Sf3MaeV+4DNcCIr/+azMnjqF7i4cwiGUkmQlvrO4sJdNi1jiHEOUnuO5bht/wa1AB7XrmP+pPbtY4khBAhyaB1gHP0RZ/2vnC3TUVRJvFpYW3cl/z5HcAdAKmpqXz00UedFFEI0Zl+f+j3JJoSUctUPir/SOs44ksEwzX01DETJcWRTLyyg08+2ax1nG6nqiqJpkR+/9Hv6dXQS+s4Gvn83mcXdW7adegOWiHWT7HzOMUfHb/w1xLdqmiQjQ3vNxKfUkJ8YmfuRXXh9ER+7msfffQRtBjR/akPoOC+/iQf75eFZXEOMj69Pm3/5x4C/VznVRPT+f1kl5Rg67BTlZlJ25v9P/c9wfC+LsKPqqqoZ3eiVmyGyBTUwrnsPX4GBpxBGZxD2R/jKKk9gTqy6bOfGfAFryPnpwhWnpYWql95hbKCfLwmGWsqtNXR0XFO10u18FoCx5ZycPEvUbLHo6TJXqtCCHE+QqWwdgbI/I9/zgA+t8GAoiiDgJeA6aqqNn7RC6mq+lf+tf9aWlqaOnHixE4PK4S4OA2OBnZt2cXdl9zN5EmTtY4j/m3T57+k9TXU7Qrw9j9OkJOv545vD0TXQ0eo3eq9ld/t+B0DRw0kwdbzuvb+/MzBz33tQs9NvzfA/r8fxWv1MezWIZgijReZTnSnYUN93H3HcY4fyOAnv8gNisWBLR/v/tzXxg6bwME7OnD7Agz6cySRfS7VIJkIVdVp9RS/V06+qZDMsann9DMBl4u2pUvx2R1ETb+SpL592fJ06+e+T+v3dRF+/F43x9f8gZqKzSQXjaff1XejN5o/+/PAZSpH7nHQ8m42RaOKSJzw6ftuw779n3stOT9FMNjwydOf+1r8NQtoW7aMoopKoufNxRD/+Ye+hOguH3300TlfL/2TpnJ01XPUHdtMrygDfaff9V/XaCGEEF8uVEZB7gJ6K4qSqyiKCbgeWPGf36AoShbwLrBQVdWTGmQUQnSSd468gy/g46ZBMgZS/G8rltTR1ODl1m+m99iiGsBNA2/CF/DxztF3tI4S8krWV+Kod1E4M1eKaiEoOsbAght7cXBfB3t3tWsd54v5FY7ea8d5JkC/X0cQ2Uf27xPnJ2VIIkn94inbdJbWyq8+zwN2O63vLMZX30DUzKsx9+3bDSmFAFdrHXsW3U/N4Y3kXnYTA+bc/7kFW51Rod9TNqKK9Bx/yEHrPp9GaYW4cMa0NGIWLED1+2l9+x28NaEzllr0bHqjhQFzHiD3spuoObyRPYvux9VWr3UsIYQICSFRWFNV1QfcBbwPHAPeVlX1iKIodyqKcue/vu3nQALwJ0VR9iuK8vnHg4UQIeG1Q6/RL6kfg3sN1jqKCGINdR5WLKln9GUxFA3o2XtgDUkZQlFiEa8dek3rKCGt7nAjNXvrSR/di7j8GK3jiAt0+YxE0jLMLHqpCp83OMZBfiYA7Emh7aCfwkesxI4IleERIpgoikLBVdlYYs0cX1qC1/HlhQh/aystb7+Dv6WF6NmzMefnd2NS0ZM1Vxxm59/vxtF0lkELfkbeZTd+aRex3qbQ/7c2LGk6jtxjp+Okv5vTCnHxDMnJxF53LYrRSNvixXgqKrSOJMQ5URSFvMtuZNCCn+FoOsvOl39Ac8VhrWMJIUTQC4nCGoCqqu+pqtpHVdV8VVUf/9fX/qyq6p//9fe3q6oap6rqkH/9NULbxEKIC1HWUsbHlR9z08CbgmKElwher/+jGoCbvn5uY7DCmaIo3DTwJrZWbKWspUzrOCHJXu/k1HvlRGdGkjMxXes44iIYDAoLb0+lpsrD2pVfOBlcGypwoBfURJL3QwtJU2UPFnHhDGY9fefm4bX7OLmqFFX9/PbTvro6Wt58C9XpJGb+PEzZWRokFT2NqqpU7l7JvtcfxGiJYuTXniWpz+iv/DljrI4Bv4tAH6Fw+Af2bkgqROfTx8YSc9216KKjaVu2HPepU1pHEuKcJfUZzcivPYvREsm+1x+kcveqL7y/EEII8amQKawJIXqGVw68AsCNA2/UOIkIZscO2/lkcyuz5ieRlCyL08Bno1MXHVikcZLQ43P7ObbkNHqTjr5z89Dp5fYo1A0dEc3QEVEsebOW1pYgGCumAoeSoDIaChtJv072rhAXLyo1gtwpGTSdauXs9v8eO+aprKT1ncUoOh0x112LMS1No5SiJ/H7PBxb/TtOrvszCXnDGfm13xKRmPnVP/gvlhQdA38fgRoEl20hLpQ+MpKYa6/BkJxM++r3cB06pHUkIc5ZRGImI7/2LPF5wzi57gWOvfc7/D6P1rGEECIoycqRECJoBNQAL+97mal5U8mJzdE6jghSgYDKKy9WEZ9oZOb8ZK3jBI2c2Bym5E7h5f0vE1CDbPxdEFNVlVOry3A2ueg7Nx9zlBRqw8XC21PxuAO8tahG6yhwLAHKYiG/Gfo0aZ1GhJG0kckk9o2j9MMztJS1AeA+dYq2pcvQRUYSc/11GBISNE4pegJXewN7X32A6oMfkDP2egZd8zMMlvMf1W3L1dP/WVsXJBSi++gsFmLmz8OYnU3H+g04du6Uzh8RMgyWCAZf83Nyxl5P9YEP2Pvqj3G1N2gdSwghgo4U1oQQQWNDyQbKW8u5behtWkcRQWzT+mZKTzu58WspWCzyNvafbht6G2UtZWws3ah1lJBRtauOhmPN5ExKJzY7Sus4ohOlZVi44upEPlzXRFmJU7sgJ+OgOB6yW6FfA8iUY9GJFEWh99U52BIsHFtaQvv2PbSvWo0hOZmY665FHyXXNdH1misOs+vlH2BvqGTg/J+SP2EhinLh92jRA2T/SRH6FKOR6FkzMfctxPHxJ9g3bZLimggZiqIjf8JCBs57EHtDBbtevlv2XRNCiP9DViSFEEHjb/v+Rrw1njl952gdRQSpjnYfb/yzmj5FNsZOiNU6TtCZWzSXOEscf9v3N62jhITWynZKN5whoU8sGaNTtI4jusD8G3oRFa3nb386SyDQ/YtZZ99yw/FESG+DQXVSVBNdwmDW03d+PvGBUtzbtmDMySFm/jx0FovW0USYU1WV8u1L2PfaT9CbbYy49TckF16qdSwhgoai1xN55ZVYhg7BtW8/7atWo/pk1qkIHcl9xzLi1t+gN1vZ99pPKN/xrhSIhRDiX6SwJoQICo2ORpYeX8rNA2/GYpCFIPHFXv9HDR3tfm77djqKIivU/5fFYOHmQTfz7rF3aXQ0ah0nqHk6vBx/twRzjIk+M3PkfApTEZF6bvpGKqeOO9i4rntHMNas8FDyWxekdMDQWimqiS6jBgKo+z8mQVdOi68XtYZBYJCOH9G1vK4ODi15nOKNL5PYZwyjvv47IpOyu/SYfpcs5orQoygKkRMnEjFhPJ7iYloXLyHg1LCTXojzFJmUzaivPUdin9EUb/gbh5Y8js9l1zqWEEJoTgprQoig8OrBV/H4Pdw2TMZAii92/Iidje83MX12Itl5Vq3jBK3bht6Gx+/htUOvaR0laAV8AY69exqfy0/R/HwMFlmADmfjJ8fRb2AEb/y9hpZmb7ccs26dh1NPOom9xADDa+SOW3SZgNtN27LluA4dxjpqJIYRl1F7sImafbIXiug67bWn2fX3u2ko3knvqd9k4LyfYDB3/b5oR+9zEHBLcU2EJuuwYUTNmIGvro6WN9/C39KidSQhzpnBEsHAeQ/Se+rtNBTvZOfff0B77WmtYwkhhKbkY74QQnOqqvLSvpcYkTaCQb0GaR1HBCGfN8BLfzxDQpKRa27spXWcoDY4ZTDDU4fz0t6XZEzHF1BVleK1FbRVdtBnZg6Rvbp+IVBoS1EUbvtOOi53gFf/Vt3lx6t738OJh51ED9LT79c20Mvvoega/rY2Wt9+B29lJZHTphIxdizZE9KJy4vm9PsVtJ3t0DqiCENV+99n9z/uIeDzMOzmp8gaNafbur5bdvk4+mMHAa9cV0VoMvfpTcyC+aguFy1vvoW3uuvvS4ToLIqikDVqLsNueoqA18Puf95L1YF1WscSQgjNSGFNCKG5XVW7OFx3mNuH3q51FBGkVi9r4EyFm6/fmYbFqtc6TtC7fdjtHKo7xO6q3VpHCTpVu+qoPdBA5rhUkvrFax1HdJP0TAuzFySx9aMWDu1v77Lj1K31cOIRJ9GD9Qx4NgK9ReY/iq7hraml5Y03CbS3ET1nDpYBAwBQdAqFc/IwRxs5tvg07jaPxklFuPB7XRxd9RzH3vs9MZn9GPWN3xOb0a9bMxQ8YKX5Ex/Hf+og4JPimghNxrQ0Yq+/DsVkovWdxbiLi7WOJMR5ic3sx6jbfk9MRhHHVv+Oo6uew+91aR1LCCG6nRTWhBCa++uev2I1WLl+wPVaRxFBqK7Gw5I3axk5OpoRl8RoHSck3DDgBqwGK3/Z8xetowSV5tOtlKyvJKEwluzxaVrHEd1szrXJpKSa+Nsfz+LxBDr99Wvf83DiUScxQ/5VVLNJUU10DXdxMa3vvINiMBBz3XWYsrP+68+NVgP9rinA7/Fz5O1i/B6/RklFuLA3nmH3P++l+uAH5Iy9nqHX/xJTRGy350idayLvHguNm3wc+7GDgEeKayI06ePiiL3+OgxJSbSvXIVz716ZNCFCiikilqHX/5KcsddTffADdv/zXuyNZ7SOJYQQ3UoKa0IITTU6Gnnt0GssHLSQGIsUTcR/U1WVl184i06ncOu3pBByrmIsMdw86GZeP/Q6Tc4mreMEBUeDk2NLS4hIslI4K7fbxlaJ4GEy6bjtu+nUVHtY9nZdp7527WoPJ3/hJGaYnv7PRqC3yvklOp+qqjj37KV95SoMiQmfLsomJHzh90Yk2+g7Nw97nYMTy0tlwVZcEFVVqTrwATtf/j7u9kYGX/co+RMWoui0mx6Qfq2Z/HstNG3xcfR+B36XnNsiNOlsNmIWzMdUkI9902Y61m9A9cuDECJ0KDo9+RMWMvi6R3G3N7Lr5R9QdfADuecQQvQYUlgTQmjqb/v+hsvn4q5Rd2kdRQShbZtb2b+nnWtv7kVikknrOCHle6O+h9Pn5G97/6Z1FM15nT6OvlOMTq/Q79oC9CYZJ9pTDRwSxbiJsSxfXE9lWeeMrKld5eHkL53EjtDT/zcy/lF0DdXvx77xQ+ybN2MqKCBmwQJ0ERH/82fiC2LJm5ZJ48kWyj48201JRbjwuewcWf40x1Y/R3RqH0bd/jyJ+SO0jgVA2jVmej9opXm7j6P32vE7ZRFXhCbFaCTq6quxjhqJ+/BhWpe8S8Dh0DqWEOclMX8Eo25/nqjU3hxb9RxHlj+Nzy3nsRAi/ElhTQihGX/Az592/YmJORMZ2Gug1nFEkGlp9vLyn8+S38fKFVcnah0n5AzsNZAJ2RP40+4/4Q/03KdfA/4Ax5eextXioWhBPpYYs9aRhMZu+WYaERE6XniuEt9F7tFTs8LDycecxI400O8ZKaqJrhFwOGh7dymugwexjhhO1NUzUIzGc/rZtBHJpA5L4sy2GmoONHRxUhEuWs8eZ8fL36Pu2BbyJixk2I2PY4kKrnuxlNkm+vzcSsseP4fvtuOzS3FNhCZFUYgYO5bI6Vfiq6mh5Y038TXI9VqEFktUIsNufJy88QupO7aFHX+7i9aqE1rHEkKILiWFNSGEZlaeXEl5aznfG/U9raOIIKOqKi/98SxuV4Dv/DATvV4Wqy/E90Z9j7KWMladXKV1FE2oqsqp1eW0lLZTcFU2MZlRWkcSQSA6xsBt38mgpNjJyiUXPhLy7JtuTj3uJHaUgX5P26SoJrqEr66OljfewFtdTeSVVxBx2WXnNcpWURTyLs8kNjea4vfKaSlv68K0ItSpaoCybe+wZ9H9EAgwbOGvyB17vaajH/+XXleZ6PsLK22H/Bz+vh1fuxTXROiy9O1LzLXXgN9P65tv4T59WutIQpwXRacnd9z1DLv5VxAIsOeV+yjfthhV7fy9jYUQIhhIYU0IoZk/7PwDmdGZzCqcpXUUEWS2ftTC7u1tXLcwhfRMi9ZxQtbsvrPJiM7gD7v+oHUUTZRvqqLuUCNZl6WRMji4nrQX2rpkbAyXjo9h8Rt1lJc4z+tnVVWl/EUXJc+6SJhooP8zUlQTXcN94gQtb70NAZWYa6/FUlR0Qa+j0+sompeHJd7MsSWncTR2zhhUEV7cHU3sf+NnnP7wHyT1Gc2o254nNqOf1rG+UtI0E0VP2Og47ufQXXa8rbKAK0KXMSWFmBtvQB8fT/uKlTh27pT9qkTIic3sx6jbniex92iKP/w7+9/8Oe4O2fdbCBF+pLAmhNDE0fqjbCjdwLdHfBuDzqB1HBFEmhq9/OPPVfQpsnHVbCmGXAyDzsC3R3yb9SXrOVZ/TOs43ap6bz2VH1eTMiSRrMtStY4jgtDX70wnMlL/6UhI77ktxKoBlZLfuqh4yU2vq40UPW5DZ5KimuhcaiCAfetW2t9bgyE5mdgbb8CY0uuiXtNgMdD/2t4oisLhN07ibvd0UloRDupPbmPHS3fRcuYYfad/jwFzf4LRGjpd3okTjfT7lQ17iZ+D37LjrpXimghd+shIYq69BnNhIY6PP6FjzVpUr1frWEKcF6M1ioHzfkLf6XfRUnmEHS/dRf3JbVrHEkKITiWFNSGEJp7f8TxmvZlvDv+m1lFEEFFVlRf/cAavL8C3785EJyMgL9o3h30Ts97M8zuf1zpKt8mJC1C8tpy4/BgKpmef19g00XNERRv45l3plJW4WPr2V4+EDPhUTj7qpOptD+k3muj9kBXFIOeW6FwBl4u25Stw7tqNZeAAYhbMRxcR0SmvbY0z0/+63vicPg6/eapTXlOENp/LztFVz3Jw8WOYoxIY+fVnSR96ZUi+b8aPMzLg2QjctQEOfLMDR2nP3V9WhD7FYCBy+pXYxl76affyG2/ib27WOpYQ50VRFNKHTmfk15/DHJXAwcWPcXTVc/jcDq2jCSFEp5DCmhCi29XZ6/jHgX9w86CbSbRJR5L4/zZtaGbfrnZuuDWV1HSz1nHCQlJEEjcPupm/7/87dfYL308qVPSKDHB5bx+RKTaK5uWh6EJvcVB0nxGjY7hsUizL3q6jtPjLP+T7XSrHfuygbq2X7DvN5H7fEpILzyK4+RoaaH3zLbwVFURMnkzk1Kko+s7d2yoqLYKi+fk4G2QcZE/XVHaAHS99l+pDG8kZez0jv/ZbIpOytY51UWJHGBj050gCXjhwh522Qz6tIwlxwRRFwTZqFNHz5hKw22l5/Q3cxcVaxxLivEUmZTPya78l59LrqD60gR0vfZfm8oNaxxJCiIsmhTUhRLf7/Y7f4/a5uX/s/VpHEUGkptrNP/9SRdGACK64OkHrOGHlvkvvw+1z8/yO8O5ai7GozOjrw+GF/tf1Rm/q3AVpEZ5u/VYa0TEGnn+mEpfr8+PDfB0qR35op2mrj/z7LWR9XYpqovO5jhyl5Y03CbjdxMyfh3XwoC47VlxeDH1m5XbZ64vg5ve6Obn+Rfa9/iCKwciIW54mf8JCdHqj1tE6RWShnsEvRmCIVjh0l52mT2SEnghtpuxsYm+6EX1cHO0rV2HfsgU1IONORWjR6Y3kT7yFEbc8jaI3sPe1n3By/Yv4fTKaWggRuqSwJoToVm3uNv6464/MK5pHn4Q+WscRQcLnDfD7X1eg0yt890eZ6KTLqFMVJhYyt2guf9j1B9rd7VrH6RJRJpXZ/T5dPFt5zIgpIjwWCEXXi4w08N17sqg+6+affz37X3/mqglw4I4O2g74KXzUStp86aQVnUv1+Wj/4AM61q3DmJJC3M03YczI6PLjJveP7/JjiODTVn2KnS//gMqdy8gYfjWXfON5YtL7ah2r01kz9Az+awTWbB1H73VQ+54s3IrQpo+OJubaa7AMGohz9x7a3n2XgN2udSwhzltMel8u+cbzZAy/msqdy9j18g9oq5bx1EKI0CSFNSFEt/rrnr/S4mrhgbEPaB1FBJE3Xqmh5JSTb30/g8Rkk9ZxwtIDYx+gxdXCX/f8Vesonc5mVJnd34tRDyuOGmh1SWFWnJ8BgyOZfU0yH65r5pNNLQB0HPdz4LYO3DUB+v8uguQr5NokOpe/uZmWN97EffgI1lGjiJ4/r9P2UxPiPwX8Xkq2vM7uf96D3+NgyPW/pPCKb6M3WbSO1mVMCToG/SmS6KF6Tj7q5MwiN6qqah1LiAumGAxETplC5BWX462qpuW11/FWVWkdS4jzpjdZKLzi2wy5/pf43HZ2//MeSra8TsAvHcZCiNAihTUhRLdx+9w8u/1ZJudOZmT6SK3jiCCxb3cbq5c2cPmMBEZdGqN1nLA1Kn0Uk3Im8dvtv8Xtc2sdp9N47F5m9/NiNcKqYwYaHHJrIy7Mght70afIxot/OMPplQ4O3NmBYoDBL0YSN9KgdTwRZtwnT9Ly+hsEOjqInjObiLGXoujk+iU6X2vVCXa+/ANKt7xGr6LLuOT2P5KQN0zrWN3CEKkw4NkIEqcaKf2Di+KnXAR8UlwToc3Srx+xN1wPBgOt7yzGsWuXFI1FSErIG8Ylt/+RXkWXUbrlNXa9fDdtVSe1jiWEEOdMPr0JIbrNqwdfpaq9ih+P/bHWUUSQaG7y8sKzlWTlWLj5tlSt44S9H4/7MVXtVbx26DWto3QKr9PH4TdOEm2B1ccN1HbIbY24cAaDwvfuy6KoI5Kzj3mwZukY8rdIIvJlrz7ReVSfj44PP6J99XvoE+KJvfkmTLnBs99Z5SfVWkcQncTvdXFq/Uvs/ue9+FwdDL7mYfrPvg+jNUrraN1KZ1Lo+0srmbeaqVnm4cjddrxtUoQQoc2QlETsjTdgys/HsfVj2t5dSqBDRkOK0GO0RtF/9n0MuubneF3t7PrnPZza8BJ+r0vraEII8ZVkBUoI0S18AR+/+vhXDE0ZytS8qVrHEUEg4Ff5wzOVuF0BfvBAFiaTvCV1tWl50xiaMpSntj6FL+DTOs5F8bn9HHnzFI56F2tOGKhqk/NHXBw1oNL+pp8xTXGUmZwcH9eBKVHOK9F5fI2NtLz5Jq79+7EMG0rMNdegjwquIkfZh2c5s71G6xjiIjWVHWDHi9+lYudS0odcyehvvkBi71Fax9KMolPI+Y6FPj+30rrPz4HbO3BW+rWOJcRF0VksRM24isipU/BWVdH86qt4Sku1jiXEBUnqfQmjv/kC6UOuoGLHUna8+F2ayg5oHUsIIf4nWS0QQnSLRQcWcarpFD8b/zMURfY/ErDkzVqOHOzg1m+lk54Zvnt8BBNFUfjZ+J9xqukUrx58Ves4F8zv8XP07VO0V9vpOy+Piha5nREXx2dXOfYTB2df85C6wITnWj8rVtSze0er1tFEGFBVFeeBA7S89jqBDjvRs2cROWECij74uiETi+Io3XCGsztrtY4iLoDX1cGx937PvtcfBJ2OYTc9Rd/p38Vgkb37AHrNMDHwDxF4m1X2f8NO677QfshICEVRsAwcSOyNN6CLiKBt2XI6Nm1C9cm5LUKPwRJB3+l3Meymp0DRse/1Bzn23u/xujq0jiaEEF9IVqKEEF3O4/fw6KZHGZE2gjl952gdRwSB3dtbWfJGHROmxjFpWpzWcXqUOX3nMDx1OI9uehSP36N1nPPmc/k4/MYpWis7KJydS2KhnD/i4jgr/Ry4rYPGLT7yfmgh/14Lt3wrjbzeVv74TCVnK2UUjbhwAYeDtuUrsG/8EGNmJnELb8aUl6d1rC9VODuXhMJYSj6opGp3ndZxxDlSVZW64x+z/a/fpvrAB2SPWcAlt/2BuOyBWkcLOjFDDQx5OQJjnMKhu+zUrg69eyEh/i9DQgKxN1yPZchgXHv30fLWW/ibm7WOJcQFicseyCW3/4Hs0fOpOvAB2//6beqOfyx7CQohgo4U1oQQXe6lvS9R3lrOY5Mek241wdlKF3/8TSX5va3c9p10OSe6maIoPDb5Mcpayvjb3r9pHee8eJ0+Dr1+kvYqO33n5pHcP0HrSCLENW3zsv/rHXgaVQb8LoL0680oioLJpONHD2ZjNCn85vFyHA4ZGSbOn6e0lOZFr+KtqCBi0kSi58xGFxHcnUM6vY6+c/OI7x3L6fcrqNolxbVg52iq4sBbD3Po3Scw2WIY8bXfUjDp6+iNZq2jBS1rpp7BL0USPUTPyV84Of2sk4BPFmxFaFMMBiInTSJq1kwCbe00v/Y6zgMHpRghQpLeaKZg8jcY+bXfYrLFcOjdJzjw1sM4mqq0jiaEEJ+RwpoQoks5vU4e2/wY47LGcXn+5VrHERpz2P385vFyTGYdP3wwW/ZV08gV+VcwNnMsj215DKfXqXWcc+Kxezn06gnsdU6K5ueTVBSvdSQRwlRVpfIVN0d+6MDcS8fQf0YSN9LwX9+TmGTi7h9nU1Pl5o+/qSQQkIUpcW5Un4+ODz+kbdlydDYbsTfegHXIkJB5kESn11E0L4+EPrGcXldBxdYqWZgNQn6vm5LNr7Ljxe/QcuYovafewchv/I7o1N5aRwsJxmiFAb+LIO1aE1Vvejj0XTuexoDWsYS4aOb8fGJvvgljair2jRtpe3cp/vZ2rWMJcUGiU3sz8hu/o/fUO2g5c5QdL36Hks2v4ve6tY4mhBBSWBNCdK0/7foT1R3VPD758ZBZUBJdIxBQ+eNvKqitdnP3j7NITDJpHanHUhSFxyc/TlV7FS/sfkHrOF/J3e7h4KsncDa56X9tAQl9YrWOJEKY36ly/CEnZX90kTjFyOCXIrGkffEtcb+BkSy8PY09O9p4903p3BFfzXv2LM2LXsW1/wCWYUOJveF6DImJWsc6bzqDjr7z8kgeEE/5pipKN56R4loQaSjeyfYXv03p1jdI6juWMXf+laxRs9Hpgm/fvmCmMyjk32Ol8FErHcf87Lulg7aDsjeVCH36qCii580lYvIkvNXVtLyyCNeRI3IdFyFJp9OTNWo2Y771F5IKL6V06xvsePE7NBTv1DqaEKKHk8KaEKLLtLnbeOrjp5iWN43x2eO1jiM0tuSNWvbsbGfh7WkUDYjUOk6PNyFnAlPzpvLk1idpc7dpHedLuVrdHFx0Ak+bh/7X9yYuL0brSCKEOSr8HLi9g4YNXnLustD3MSt66/9+6OPKmQmMnxzH4tdr2b29tZuSilCjer10fPgRrW+/A4EA0fPnEzlhAorB8NU/HKR0eh19ZuWSOjyJs9trKX6vHFU6NzXlbKnlwOJfcuDtR9HpTQy98QkGzL4Pc6R0cV+M5CtNDPlbJDqLwsE77VS945YChAh5iqJgHTyYuJtvRp+URMe6D2hbvoJAh13raEJcEHNUAgPm3M/QG59A0Rs48PajHFj8S5yt8vCbEEIbUlgTQnSZxzY/RoOjgSemPKF1FKGxzRubWfJGHROnxnHF1bIvVrB4csqTNDgaeHzz41pH+UIdtQ4O/OM4XoePATf2ITY7SutIIoTVve9h/60duOtU+j9rI3Oh+Zw6qRVF4fbvppPX28rzT1dw+pSjG9KKUOKprKT5lUW49u/HMmQIcQtvxpSVqXWsTqEoCvlXZJE5NpWa/Q0cX1ZCwC/j8rqb3+OiZMvrbP/rt2kq3UfBpK9zye3PE58zWOtoYSOit56h/4gkboyB08+4OPmIE79Limsi9OljY4i5ZgERE8bjraig+ZVXcB8/LsVjEbLicwZzye1/IH/S12gq3cf2v9xJyZbX8XtdWkcTQvQwUlgTQnSJ4qZintv+HF8b8jVGpI3QOo7Q0KH97fzld5X0HxTJ7d9Nl5GgQWRE2ghuHXwrz+14jtNNp7WO81+aS9s4+MpxUGDwLYVEp0uXo7gwfpfKyccdnPi5k4jeeoa9Gkn8GON5vYbJrOP+n+cQHWvg14+WUVfj6aK0IpQEPB46NmygbfES0OmIueYaIidNRDGF16hjRVHImZhO7pQMGo41c/TtYnxuv9axegRVDVB9aAPb/nIHpVteI7FgJGO+9ReyxyxApz+/65j4aoYohX5P28i+w0zd+172f60De7Gc6yL0KYqCddgwYm++CX1cHO1r1tK+YiX+tuCdWiHE/6LTG8kZcw1j7vgziQUjKd3yGtv+fAfVhzaiqvIAkBCie0hhTQjRJe5ddy9mg5knJku3Wk9WUebkt0+Uk5Zh4Z6fZmMwyttOsHliyhMYdUbu/eBeraN8pu5QI0fePIU5xsyQrxURkWzTOpIIUfYSP/u/3kHtSi+ZXzcz6E8RmHtd2HUoNs7Ijx/JxedTeeqRUjraZR+ensxTWvrpnjUHD2EZNoy4m2/CmJGudawulTE6hd4zsj978MHdJgXmrtRccZhdf/8hR1f+FnNkAsMXPs3AeT/BEp2kdbSwpugUsm6zMOB3NrytKvu+3iGjIUXYMMTHE3PdtdjGX4anooLmVxbh3LsXNSCFCBGaLDHJDJz3E4Yv/DWmyHiOrvwNu/7xI5orDmsdTQjRA8gKpxCi020o2cDyE8t5cNyDpEalah1HaKSxwcNTj5Rhseh44JEcbBF6rSOJL5AWlcaDlz3IsuPL2Fi6UdMsqqpS+Uk1J1aUEp0ZyeBbCjFHh1fnh+geqqpSs8LD/q914G1WGfA7Gzl3WlAMF9cxm55p4d6Hcqir8fD0L8vweGQhqqfxt7fTtnIVbcuWoxgNxFx3LZETxqMYe0b3UMqQJPpf1xtXi5v9fz9GR42MRu1sjuZqDi55nL2vPoDH3kL/Wfcy4mu/ITazn9bRepS4S4wMey2S2BGfjoY8ep8Db4tc80XoU3Q6bMOHE3fLQowZ6dg3babljTfx1dZqHU2ICxab2Z+RX/st/Wbdg6ejmb2vPsDBJU/gaK7WOpoQIoxJYU0I0al8AR93v383ubG5/HDMD7WOIzTisPv51SNlOO1+fvxILolJUhwJZj8a8yNyYnO4e+3d+ALadOEE/AFOr62g7MOzJPWLZ8D1vTFYDJpkEaHN2xrg+ENOTj3uJGrgp6Mf4y7pvKJH0YAIvvOjTE4cdfCn31YSCEgXQ0+g+v04du+h+Z+v4Ckrwzb2UmJvvhljWprW0bpdfH4Mg2/pCwoceOU4TadatI4UFrzOdk5teIntf7mTppK95I1fyJg7/0LKgEkoinxs14IpXkf/39rI+6GF5u0+9t7UQfMu6VYW4UEfE0P07NlEzbiKQEcHLW+8ScdHmwh4pBtZhCZF0ZE6YDJj7vwLeeMX0lSyh+1/vZNTG17C62zXOp4QIgzJipUQolM9v+N5DtcdZvE1i7EYLFrHERpwOf386tFSzla6uP/hXLLzrFpHEl/BYrDwzLRnWPDOAp7f8Xy3F8W9Di/H3i2htbydjNG9yJmcIXvxiQvStNXLySec+FpVsr9tJnOhGUXf+efSpeNjaWzw8trL1dhsZ7n9rnR0Ojlnw5X37Fk6NmzE39iIKS+PiIkT0MfEaB1LUxG9bAz5ehFH3y7myDvF5F+eRdqIZK1jhSSf20HlruWU73gXv9tJ2uBp5E1YiDkyXutogk/3pkq/3kzMMAPHf+bg8PfsZNxsIvsOCzqTXPdFaFMUBXOfPhizsnB8/AmuffvwFBcTMWE8poICuR8XIUlvtJA77nrShlxOyaZFVOxYxtn975N9yXwyR87CYJZtBoQQnUMKa0KITlPaXMpDHz7EjN4zmFc0T+s4QgMed4Cnf1nGyeMOfnB/FoOHRWkdSZyjeUXzuKr3VTz04UPMLZpLTmxOtxy3o9bB0XeK8XR46TMzh16DErvluCK8+DpUSn7npHaFF1uBjgHPRRDZp2vHz86cl4TD7mfpW3UYTQpf+1aaLECFmYDDgX3LVtxHj6KLiiJq1kzM+flaxwoa5igTgxYWcnxZKaffr8BR7yTv8kx0eumuOhd+n4eze1dT9vHbeJ1tJPUZQ974m4lMztE6mvgCkX30DP1HJCXPOjmzyEPTxz76/MxKVD9ZUhGhT2exEDllMuaivnRs2Ej7qtUYMzKImDgBQ5Ls6yhCkzkynqIZPyBz5GxKNr9KyeZFVO5aTs7Ya0kfNgO9QabqCCEujtwFCiE6haqq3Ln6TnSKjj/N+JMsLvZAXm+A3zxextFDdr77o0xGj4vVOpI4D4qi8MKMF+j3x37cuepO1ty0pst/j+uPNnFyVRkGs57BCwuJSo/s0uOJ8NSyx8fJXzpw16pk3mom63Zzt3URXHtzLzzuAKuXNWA0Kdz09VR5/wsDqs+Hc/9+nDt2ovp8WEeOwHbJJT1mH7XzoTfp6bcgn7IPz3Bmey0dtQ6K5uXL/pj/Q8Dvo/rgB5RufQN3eyPxuUPJm7CQmLRCraOJr6C3KvR+0EbCRC+nnnCy/zY7GTebyb7djM4s134R+oxpacTedCOuQ4dwfLKNltdexzJwALZLL0VnlSkkIjRFJucwaMFDtFadoOSjVzi1/iUqdiwjd9wNpA6aik4vS+NCiAsjVw8hRKd49eCrrDu9juenP09WTJbWcUQ38/lUnnuqggN7O7jj+xmMmxSndSRxAbJisnhyypN8f+33ee3Qa9w86OYuOY4aUCnfdJbKT2qISo+g3/x8TFGyCCvOj8+uUv5nF1Vve7Bk6Bj8VxvRA7v31lZRFG6+LRWvV2XVuw2YTDquvTmlWzOIzqOqKp5Tp7Bv2UqgrQ1jbi4R4y/DEC8j+f4XRaeQOyWTyLQITq0qY9/LR+k7N5/YbOla/09qwE/t0c2UbHkNZ3M1Mel96TfzHuJzBmsdTZyn+EuNDH/TQMnvnJx5xU3jZi99fmYleoAsr4jQp+h0WAcPxlxYiGPbdlwHDuA+cRLb6NFYBg9C0XftRAAhukpMWiFDb3ycprIDnN70CsfXPE/59sXkXXYTvfqNR9HJuS2EOD9y5yeEuGj19np++P4PGZMxhu+M/I7WcUQ383kD/P7pSvbsaOMb305j8uWyABnKvjPyO7xx+A3uXns3V+RfQVJE545/8XR4ObGylJaSNlKGJJJ/RRY6g4wNE+encZOX4meceOpVUq8xkftdC3qrNt0CivLpGEiPJ8C7b9ah1yvMuz5ZOtdCjLemBvtHm/BVV6NPTCR63jxM2fKg0PlIKoonIsnK0cWnOfTaCXKnZJA+qleP/10I+L3UHNpI2bbFOJuriEzOZfA1D5NQMLLH/7cJZYZIhT4/tZE0xcvJx50c+KadjJtMZN1uQW+R/68i9OksFiInTcQyaCD2jzZh37QJ16GDRFw2HmNujly/RMiKzxlMXPYzNBbv4vSmVziy4hlKtrxOzqXXkDJgEjq9TCgQQpwbKawJIS6KqqrcseoO2txtvDTrJXSKLJD3JG5XgN8+Wc6BPe3c8s1ULp8h+2OFOr1Oz4szX2ToX4byrVXfYsm1Szrtg3NzaRsnlpfgd/spmJ5NytBE+VAuzou7NsDp3zhp3OTDVqCj6Inu71L7Ijqdwh13ZRDwwzuv1eJw+Ln5GzIWMhT429pwfPwx7uMnUGw2IqdNxdyvH4pO7mcuhC3RypCvF3FyZSml68/QftZO76uyMVi0/z3tbn6vm6oD6yjfvgR3Wz1RvfIZOO9BkgrHoMj9ctiIG21k+BsGSp93cWaRh4YNXvLusZIwThZmRXgwJCQQPW8unpJS7Js307Z8OYa0NCLGjcOYnqZ1PCEuiKIoJPYeRULBCOpPbKPs47c4tvp3lGx5nezRC0gbPA290ax1TCFEkOt5n3CEEJ3qxb0vsuz4Mn5z+W/ol9RP6ziiGxl9UTzx8xJOHndwx/czpFMtjPRP7s+TU57k3g/u5aW9L/HN4d+8qNcL+ANUbK6i8pMabIkWBt5YSESy7NMgzp3qV6l6x0P5X1yofsi5y0L6DSZ0huApXOn0CnfenYHVpmP10gYcdj/f/G6G1rHElwh02HHs2onr0GEArKNGYR05Ap1JxtJeLINZT9H8fM5sq6Hso7O0V9kpnJ1LTGbPGA3pczs4u28NFTvexWNvISajH32n30VC3nAptocpQ6RC759YSbrcyOmnnRy9x0HCeAN5P7JiSZUiqgh9iqJgzs/DlJON6/ARHNu30/r225jy8rCNvRRDojxcKUKTouhI7juWpMJLaTy9m7JP3uLkuhco+/gNsi6ZR/qwqzCY5HOrEOKLSWFNCHHBjtUf4+61d3N5/uXcPfpureOIbmT2xjPh5AsUe5z84P4sRo+L1TqS6GQ/HPND3j/9Pj9Y+wMuy76Mvol9L+h1XK1uTiwroe2MnZQhieRdnoneKPPrxblrO+Tj9DMuOo77iRtjoOB+K5a04Fyo1Ok+HQsZEann3TfrcNgDjNA6lPgvAacT567dOPfvB1XF0r8f1ksuQR/VM4o+3UVRFDIvTSUmO4oTy0o5uOgEmZemknVZKjp9cP7+XiyPvYUze9+jcvcKfM524nOGkDPnemKzBkhBrYeIHW5g6KJIzr7poeIlF3uuayfzG2YybjSjM8k5IEKfotdjHTwIS78inPv249y9m5ZFr2Lu2xfbpWPQx8RoHVGIC6IoCokFI0nIH0FLxSHKPn6L4o0vU7btHTJHzCJj2FWYImK1jimECDJSWBNCXBC3z80NS24gwhTBP2b/Q0ZA9iA2dxoTTr6AzdOL+x/OYfBwWYwMRzpFxz/n/JNBfx7EDUtuYPtt2zEbzn0chqqq1B1uomRdBWpApXBOHsn9patRnDtXTYCyP7qoX+fFlKjQ9zEriVONQb9ArSgK196cQkSknkUvVTNijNaJBEDA5cK5dy+uvftQfb5PFwFHX4I+NlbraGEtOj2Sobf3o2RdBZUfV9NS2kbhnFyscRato3WajroyKnctp+bwhwT8XhJ7jyLn0uuISb+wB1JEaNMZFTIXmkm+3MjpZ52Uv+Cm7j0v+T+yEDdaxkOK8KAYjdhGjcQyaCDO3btx7tuP++RJLAMGYB05An10tNYRhbggiqIQlz2IuOxBtJ49Ttknb1G65TXKP3mblAGTyBw1h8ikbK1jCiGChBTWhBAX5L4P7uNA7QFW3rCS1KhUreOIbpLYPoSxxc+iUw181OdbLB6+X+tIogulRqXy8qyXmfXmLO774D5+P/335/Rz7nYPxe+V01TcSnRGJH1m5YTVIqroWn6HSuUrbs6+7gYg8xtmMhea0duCu6D2f82Yk0REhB52lmgdpUcLuFy49h/AuXcvqtuNqU9vbKPHYEiQQn93MZj19JmZS1x+DMVrytn30lFyp2SG9D6bqhqgsWQvlTuX0VS6D53BTOqgaWSOnEVEYqbW8UQQMPfS0e+pCJq2eTn9jIvDP3AQN8ZA7l0WIgqkc1+EB53FQsS4cViGDMG5Yweuw4dxHT6MuagI26iR8vCKCGkx6X0ZfM3D2Bsqqdy1nOpDG6k6sI743GFkjZpNvIx4FqLHk8KaEOK8/X3f33l+5/P8cPQPubrP1VrHEd0ku+FqRpY9jMNUzeY+36PDUq51JNENZhbO5O5L7ua5Hc8xPHU4tw659Uu/9z+71AI+lbxpmaSNSEbRyQcO8dXUgErdGi9lf3LhaVBJutxIznctWFJCtyN64rR4tkhhTRP+jg5ce/fhOngQ1ev9dB+YS8dgSErSOlqPldQvnqj0CE6uLKN4TTn1R5vofVU21vjQefDC73VTc3gjFTuX42isxBQZT/7EW0kfciVGm3RoiM+LH2Mk9g0DVYs9VP7dzd6FHfSaYST7Dgvm5NB9fxPiP+kjI4mcMgXrqFE4d+/BdegQ7qNHMRcWYh01EkNCgtYRhbhgEYmZ9J1+F/kTbuHsvjVU7lnF/rcexpaQSdao2aQMmIzeeO6TXYQQ4UMKa0KI87LjzA7uXH0nU3Kn8Otpv9Y6jugGgYDKW4tqGF36OLVRO/mk4B48hjatY4lu9PTlT3Ow7iDfWvUtipKKGJU+6nPf427zULzmP7rUZuaE1GKp0I6qqjRt9VH+Fxf2UwGi+uspetJC9CC5TRXnz9/cjGP3HtzHjkEggLmwD9YRI6SgFiQsMWYG3tSHmv0NlG44w94Xj5B1WRoZo1OC+iEMe0MFZ/etpfrQenwuO1Ep+fSbdQ+9ii5Dp5fxfuJ/05kUMm4002uGkcp/uKl6x0P9Oi/pN5rJWGjGEBG8574Q50MfFUXkpInYRo3EuWcvzoMHcR8/jqmgANuoURh6JWsdUYgLZrRFkzP2OrJGz6P22BYqdyzj+Jo/UPzhP0gdOIX0odOla12IHkZWLIQQ56y6vZp5b88jPSqdtxa8hUEnl5Bw57D7eeG5SnZta+N00mL2ZD2JqvNpHUt0M4POwFsL3mLkiyOZ+9Zc9tyxh5TIFAAC/gBVu+qo2FKFGkC61MQ5U1WVll1+yv/sov2IH0uGjsJfWEmaZgz78+eNf1Rz7cIU9Prw/vfsTr7aOhy7d+E5VQw6HZb+/bEOH44+NkbraOL/UBSF1KFJxBfEcPr9Cso+PEv90Wb6XJ1DZIpN63ifCfi81J34mLN719BSeRhFZyC576WkD5tBbGZ/Gf8kzpsxRkfeD6ykLjBT9icXlX93U7PMQ8YtZlLnmdBb5JwS4UEXEUHE+MuwjhyBc98+XPv201JcjCEjHeuwYZhyc1F00rEpQpNObyR1wGRS+k+ipfIIZ/eu5sye1VTuWk5s1kDSh15JcuFYdAZ58EaIcCer4kKIc2L32Jn71lxaXC1su20bCTYZ5xDuSoodPPdUBY31Hm75Zioz9v0S5PN+j5VoS2TZdcu49OVLmfPmHDbcsgFvtZ/TaytwNLiIL4gh7/JM2UtNnJPW/Z92qLXu9WPupdD7QSvJM4zoDD3jIrN8cT0njzv43n1ZxCfIh+4Lpfr9eE6fxrlvP76qKhSTCeuI4ViHDkUXEaF1PPEVzFEm+i0ooOF4M8VrK9j38lFShyaRPSEdo027j6mOpirO7l9L9YEP8DrbsMamUDDp66QOmoopIlazXCJ8WNN1FD1uo+0GH+V/cVP6OxdnXnFLgU2EHZ3VSsSll2IdPvzT/df27ad9xUp0MTFYhw7F0r8fismkdUwhLoiiKMRlDSAuawAeewvVB9dzdt8ajix/mpPWv5A2eBppQ6dji0vVOqoQootIYU0I8ZW8fi/XvHMNu6p2seTaJQzqNUjrSKILqarKutWNLHqpmpg4Aw8/lU+fogjYr3UyobXBKYN5de6rfOudO1n0p7fobx+EOcZEv2sKSOgTq3U8EeRUVaV1r5/Kf7pp2eHDGK+Qd4+F1DkmdKaetYh41z2ZvPjHs/z4+yf57j1ZDB4WpXWkkBJwOD5doDtwkEBHB7roaCLGj8fcvx86ixT3Q01i3zhisqOo2FxF1Z466o82kTU+jbTh3df97HM7qDv+MdWHNtBScQhF0ZHYZzTpw64iPmcwiiKdFaLzRQ8wMPB5A637fVT8TQpsInzpzGZswz998MVzqhjnvr3YP/oIx7ZPsAwYiGXIYPTRsk+lCF2miFiyxywga/Q8mkr3c3bfGip2LKV8+xJiswaSOnAKyX3HYjAHT2e+EOLiSWFNCPE/BdQA31jxDdYUr+GvV/+VOX3naB1JdCF7h58X/3CG7VtbGToiiu/8KJOoaHmrEJ/ye/wMa7iEt00r8HX42JO0g+9+/VsYTXKOiC+nBlQaN/s484qb9iN+jHEKOXdZSLum5y4ajpsUR26BleeequCph0uZc20y82/ohaGHdOxdKF9tHc79+3GfOAF+P8asLCImT8aUmyMjpUKc0Wog/4osUoYmUfJBBSXrKqnZV0/etCzicrtmsVUN+Gkq20/1oY3Un9hGwOfGGp9G3oSFpA2ahjlKpjOI7hEz5IsLbOnXm0iZZ8YYLe8NIjwoOh3mwj6YC/vgra7GuXcfzr17ce7dizEnB8vAgfKeLkKaouhIyBtGQt4w3O2NVB38gOpDGzi2+jlOvP8CSYVjSB045dOHdnR6reMKIS6SrIQJIb6Uqqrcu+5eXj34Ko9PfpxvDv+m1pFEF9q3u40Xnz9LS7OXG7+WwtXzktCF+T5H4twE/AFq9jVQsbUKr91HcmECa6JWcu/2H1H5YQnPXP6M7DUjPifgValb6+XMq26cZQEsaQr591voNaPnFtT+U3qmhcd+U8Df/3KWpW/VsX93O9/5YSaZOdJx9Z8CLhfuEydwHT6Cv64OjEYsA/pjGTwEQ0K81vFEJ4tItjLgxj40nmyhdP0ZDr9+kviCGLInpHfa/msddWVUH95IzeEP8XQ0YbBEkjpoCqkDpxCdVijvZ0Iz/1Vge9lN2QtuKv7hJmWmibTrzVjTpdggwocxNRXjjFT8bW24Dh3Gdfgw7aWl6CIjMQ/oj2XAAPRR0tEvQpc5KoHcsdeTc+l1tFWdoPrQBmqPbqb2yEeYIuNJGTCJ1AGTiUzO0TqqEOICSWFNCPGFVFXlnnX38Oz2Z/nBJT/gJ+N+onUk0UUcdj+vvFTFRx80k5Fl5p6HCsjvLSMKxKfXgYbjzZR9eBZXs5vozEj6XZNBdHokRerdVATK+O323wJIcU18xtMUoGaFh+rFHjz1KhG9dRT+0krSZCOKdGT9F7NFx50/yGToiGj+9qcz/PjuUyy4sRez5ieh1/fc/1aqquKtPIP7yGHcp4rB70eflETEpImYi4rQmc1aRxRdSFEUEgvjiM+P4eyuWs58UsO+vx0lsSiO7PFp2BKt5/2aHfXl1B3bSt3xrdgbKlB0ehIKRpI6YDKJBaPQGWSvQxE8YoYYGPh7A/ZTfs684ab6XQ9Viz0kTjSQfpOZ6AGyjCPChz46moixl2IbfQme0lJchw7h3L4D546d/+piG4ApJwdFL909IjQpikJMel9i0vvSZ+odNBTvpPrQBip3LqNi+xIiErNILrqM5L7jiEzK0jquEOI8yB2ZEOJzAmqAu967ixd2v8D3R32fZ694VhbMw9T+Pe389fkzNDd5mX1NEgtu7IXRKE/D9nT/LqhVflyDvdaBLclK/2sLiCuI+exaoCgKz135HCoqv93+W1w+F89f9Tw62YemR1JVlfYjfqrf8VC/wYvqhdiRevo8ZCb2EoO8h3yFS8bGUDQggpf/fJa3Xqlh17ZWvv2Dnte95m9txX38OK4jRwm0tqKYzVgGDMAyoD+G5GSt44lupjPoyByTSurQJM7sqKVqZy0Nx5tJHphA9mVpWGL/d4H1/xbTQCE2awB9Lv82vYouwxQR0z3/IkJcoIjeegp/biPnzgBV73ioWeqmYaOPqIF6UueZSJxslA5wETYUvR5zQQHmggL8ra24Dh/5rItNsVox9+mDuagvhpQUua8UIUtnMJLcdyzJfcfisbdSe2wLdce3UrrldUq3vCZFNiFCjBTWhBD/xRfw8a2V3+Ll/S/zwNgHeHLKk3LjGobq6zwseqmKnZ+0kZ5p5kdPF1BQKF1qPZ0aUKk/0kTFJ9U4G1xY4830mZlD8oAElC8YC6ooCr+78ndYDVZ+/cmvcflc/GXmXzDo5Paip/C7VBrWe6l6x0PHcT96G6TMMZE234QtV54sPh/RMQbufiCb7WNb+NufzvLA909y5cxEFtzYC1tE+P63DHTYcZ88ifvECXw1NQAYMzOwjRmDuXcBikGuJz2dwWIgZ0I6aSOSObOthqrdddQfbiKpfzwZo1OISP60g01VVdprimk4tYO64x9/rpiW3PdSzJEyPlSEHnOyjtzvWsj6upmalZ92hJ981EnJsy6SrzKSOteELSd83ydEz6OPifmsi81bXo7r2HFchw/jOnAAXWwslr59MRf1RR8bq3VUIS6YKSKGzBFXkzniatwdTdQd/+TzRba+Y0nsfQlRKQWyLidEEJJPqkKIz7S527h+8fWsKV7DwxMe5uEJD8ubd5jxeAKsXFLP8sV1AFx3SwpXz02ULrUezu8NUHeokTPbanC1uLElW+k7N4/EvnFfWFD7T4qi8NTUp7AarTy66VFq7DW8Of9NosyyJ0K4UlWV9sN+ald7qf/Ag78DbLk68u+zkDzdhCFC3jcuxuhxsfQbGMlbi2pYs6KBjze1cNPXUxk3KTZs9r0MuFx4iotxHz+B98wZUFX0SYnYxo3F3KcP+hjpJBKfZ4owkjc1k/RRvTizo4aafQ3UHqohIrUWQ2QJbTX78HQ0IcU0Ea70NoX068ykXWuidY+f6qWfFtmq3vQQM0xPyhwTCROki02ED0Wvx5SXhykvj4Db/em9w7HjOLZvx7F9O4bUFMy9+2DqXYA+OlrruEJcMHNk/BcX2ba+SenWNzBHJpBQMJKk3pcQlzMYvVHGogsRDKSwJoQAoLylnKvfuJpj9cf4y9V/4Y7hd2gdSXSiQEBl5yetvP6PGupqPIweF8PN30glMdmkdTShIXebh6o9ddTsa8Dn9BGZaqPftALie8ecV1FdURQemfgIqZGpfPe97zL25bGsunEVWTEyviKcuOsD1K3xUrvag7MsgM4MiZON9JppImaYXh7E6ETRMQa+eVcGk6+I5+9/ruJPz1ayfm0jN30jlcKiCK3jXZCA3Y7ndAnu06fxVlRAIIAuJgbrqJGYCwsxJCRoHVGECqUdS+JRbFnbaS47QEuNB1QTJmshGcMWkD12PJaoOK1TCtFlFEUhdoSB2BEGPI0Bald5qFnm4cTPnegjnCRONpI83UTMUP1XPiAlRKjQmc1Y+vfH0r8//vZ23MdP4D5xHPvmzdg3b8aQnIypdwHm3r3Rx8l7gAhd/1lk89hbaTy9i/pTO6g9uomq/WvRGczE5w4mseASEgtGYo6Se2ghtCKFNSEEW8q3cM071+DyuVh781qm5k3VOpLoJKqqcmBvB2++Uk3ZaRcZWWZ++lguA4dIN1FPpaoqbZUdVO2qo+FEMwAJfWJJG5FMTHbURRVHvjXiW+TF5XHNO9cw6sVRLL52MeOyxnVWdKEBb5tK02Yv9eu9NO/wQQCiB+vJ+KmVxMlGDJGyYNeV8nvb+MXT+Wze0Mwb/6zh4ftOM3RkFNcvTCE7z6p1vK/ka2rCc/o0ntMl+KqrAT4tpg0dgqlPHwy9eklBVnwlv8dFc8Uhmkr30VS6H3tDOQCW6CTSh15OfO5I3C2pVO9qpG6Ph5YTFaQMcZAyNAlztDxAJMKbKUFH5q0WMhaaadntp26th4YNXmpXejH3Uki6wkTydCMReTIqUoQPfVQUtpEjsI0cgb+lBfepYjzFp3B8/AmOjz9Bn5DwaZEtLw99crLca4iQZYqIIXXQVFIHTSXg89JccZCGUztpOLWDhlM7AYhIzCY+dwjxuUOJyxqI3tSz9mgWQktSWBOiB/MH/Dy59Uke/uhh8uLy+PDWDylKKtI6lugkxw7beWtRDceP2EnuZeI7P8pk3IRYdHr5YNETeexe6g83UnOgEUe9E4NFT8boFFKHJ2GJ6bxREtPyp7Httm3MenMWE/8xkUcnPsqPx/0YvU4WdEKFr12l8V/FtJadPlQfmFMVMm810+sqI9Ys+X/ZnXQ6hYnT4hl9WSzvr2xgxeJ6Hvj+KS6dEMuCG3uRlh48o2BUnw/v2Sq85eV4SkvwN31avDckJ2O7dAym/Hz0CQmywCX+JzXgp62m+LNCWuuZY6gBHzq9kdjM/qQOnEx8/nAik3L+61xKH5FG0+lWqvfUU7G1moqPq0noE0vqsCRic6Klc0eENUWnEDfKQNwoA/77Pn0fr1vj5cxrbs684sZWoCNxkpHEiUZs+Tq5DouwoY+N/f9Ftvb2T8dFnirGuX0Hzu07UGw2TDk5mHJzMGZlobNI0UGEJp3BSELecBLyhtPn8jvpqC+j6fQemkr3cXbve1TuWo6iMxCTUfRZoS06pQBFPocL0WWksCZED1XdXs3CpQvZULqBGwbcwJ+v/jPRZplLHuoCAZW9u9pYsbiek8ccxMYZ+Ma305h8eTwG2Uetx1EDKk3FrdQebKDpVCtqQCUqLYKCq7JJHhCP3tg1N9lFSUXsuWMP31r1LR768CE+Kv+IV+a8QmpUapccT1w8T0OApo99NG76tDPt38W0tOtMJE01Elkkox61ZrHomH1NMlOmx7Pq3f/X3p3HSVaW99//XKf2paur15nunn1hFgaGYUdQRhHRGNEoRjEC7kSNmvhDn8Rsmseo+T1onjyJEYXwg0SRJLiBUUFQUEBkk2VYBobZ95ne1+quqvv545zuqenpma6erXr5vl+vep3tPnddVV1z5lRd97Kfn/5oH7/5VQfnXJDh8nc0smRZ8qTH5Jyj0N7uJ9I2b/HnS8vnIRQi0txMfPVqoosWad4TOaJiYYiuXS/TsXUdHdueo2P78xRyfQCkZy1i7rlvpXbhGrJzVh5xThHzjLqlWeqWZhnoyLHryX3sfno/res7iFZFaFxVR+NpdaQaJn9vT5FjEUoYjZdFabwsymBrkX0/H2L/L4bYelOOrTfmSMz1qHtthPrXhvX/u0wroaoqEmvWkFizhmJfH4ObtzC4eRODr7xC7vnnwYxwczPRhQuIzptPqKEe8/QdWaYeM6OqcSFVjQuZf8EVFIZydGx/PmiU9Ds2PvAfbHzgPwjFkmTnrCQ7bxXZuaeSaVqKF4pUOnyRaUOJNZEZxjnHLU/dwqfv+TS5fI6b3nITH1jzAX2hmuKGhoo8dH8Hd31/Hzu25WiYFeF91zbz2ktricX1ZWEmGR7qcd8L7ex/oY2h3jyRVJjmcxuZdXr9SftBMRPLcNvbb+OShZfwiZ9+glP/9VS+dtnXuGb1NbreTALOOXpeLNL20BBtD+bpeaEABMm0PwySaSv1Y9tklE6HeffVs3nT5fX87K793PPjVh59eAMrVqW4/B0NrD6rCu8E9swpdHcztH07Q9t3MLR1K8WuLgC8bJb4qlVE588nMncOFtGXdhlbfrCfrh3r/STatnV07lhPMZ8DIFk3l9krLyY7bxW1C84gmsoe1XPEszEWvm4O81/TTOtLHex9tpXtj+xm+292k56dpPG0OhpW1hJN63Mq01u0zqPl3TFa3h1jsLVI6wND7P9lnh1BT7Zoo1F7QZiaV0XInh3WEM8ybXjJJPGVK4ivXIErFsnv2u0n2TZtpu/Bh+jjISwWIzJ3DpG5c4nMnUuotlb3vjIlhSIx6hauoW7hGgAGezto2/wUHVvX0b51Ha2vPA6AF45R3bKM7Nwg0dayjHBUDY5EjpYSayIzyMb2jVz742u5d+O9vHreq7nxLTeyrH5ZpcOSY7BrR4777m7lgXvb6e4qMH9hnE98Zi7nX5QlpCEfZwznHF3be9j/Qjv7X2hnsGcIL+xRs6SaWafVUbM4gxc6+QlWM+NDZ36IV897NR+660O8/0fv57Znb+OG37+BRTWLTno8M91ga5GOx/N0PJan/ZE8g/scGGROC7HgozFqL9LwUFNJdTbMu66azeXvaOAX97TxPz/czz98YTONs6O8/o21rL20lkz1sd/qFzo7/STaDj+ZVuzsBPB/jJrTQuTss4kumE+ouvqYn0umH1cs0Lt/G50719O1cz1dO9bTs38ruCKYR9WshbSseSPZuaeSnXvqUSfSDscLezSsrKVhZS2DPUPse76Nvc+2svHn29j4821k5qapX5albnnNcR0WWWQyitZ5NL09RtPbYwx1Fml7ME/rr/2hn3f/aAgL+fOo1rwqQu0FYd0TyLRhnkekpZlISzOpCy+k0NPD0LbtDG3bxtC2rQxueMUvl0wSnTuXcEsLkZZmP9GmHm0yBUVTWWafupbZp64F/ESb36DpOTq2rmPTQ7eP3Iul6+eRaVlGpnkZ1c3LSNXP1fCRImVSYk1kBugY6OBLv/4S//TbfyIWivGNN3+Dj5z1ETzTTeJUNJgr8sSjXdz3szbWPd1DKARnnVfNpb9Xy6rVaX0BniHyuQIdm7po29BJ24YOhnrzWMioXVJN/Ypa6pZWE4pOjhviZfXLeOB9D/DNx7/JZ+/9LCu+voJPnfcpPvfqz5GNZysd3rSV73F0PpWn49E8HY/n6XulCEA4Y2TPCVN7UZiaC8JEa/R/wVSWSIZ489sauOzNdfz24U7u/Wkbt92ym//89h7Oe1WG176hllNPS5c1v6bL58nv3Ut+126Gdu0iv3s3xe5uACweJ9LSQuSMM4jMaSFUr+GT5GDOFelv20X3no10736Zzp0v0b17A4XBfgDC8TSZ5lNYuOwCMi3LybasIBxPnbT4oukILefOouXcWfTu62f/i+20vtjOxnu3s/He7aRnJ6lbXkPt4mpSsxK6n5JpLVLtMevNUWa9OUox7+h6pkD7b/K0PzzE5n8ZYPO/QKTGqD4zTPVZIbJnhUnMV6JNpodQOk1oxXLiK5YDQSOibdsY2raNwa3byK1fD4BFo4Sbmog0NxFuaibcNBsvGq1k6CJHJZrK0rj8QhqXXwhAfqCXjh0v0LXjRTp3rmfviw+x86m7AQhFE1TNXkJ1yzKqZi2hatYiErVNmH4/FDmEEmsi01j/UD83Pnkjf/fA39HW38bVq6/m71/397RkWiodmkxQoeB47pkeHry/g8ce7qS/v0h9Q4R3XTWLtZfWUlOroYymO+ccffsHRpJpnVu6cUVHKBaiZnGGuqVZapdmCccmRzJtNM88PnrOR7l82eX85S/+kusfvp6bf3czf3Px3/DhMz9MIqIhKI5Vbk+RrmfydD1ToOvpPD0vF6EIXgwyq8M0vjFK9pww6VM8TD1ap51wxOPCi2u48OIadmwb4N6ftvGr+9p5+Fed1NSGedVrsly4NsvCxX7CwBWLFNo7/ETa7t3kd+8iv3cfFP0ErJfJEG5uItJ0FpG5cwjV1ekHVRlRzA/Rs38LPbtf8RNpezbSs3fTSBLNvDDpWQtpOu2SkRbQidrmSfMZSjUkSDUkmP/qZvrbBmhd38H+9e1suX8HW+7fQSQVoXZxhprF1WQXZogk9LVZpi8vbGTPDJM9M8zCj8fJ7S3S/kiezifydDyRZ/99QwBE6vxymTNCZE4Lk1rsYeHJ8W9a5FiEqqsJVVcTX7UK5xzFzk6Gdu4iv3MnQ7t20febR/yCZoTq6gjPaiQ8axbhxkbCDQ1YWP9HyNQSjqeoX3w29YvPBvzfGvrbdo6MMNC5cz1bf/tDXDEP+Mm2dONCqmYtomr2YtKzFpGun48X1u9QMrPp6i8yDfUM9nDD4zdw/cPXs6d3D69d8Fq++oavsqZpTaVDkwkYGiry3DO9PP5IJ48/0kVHe55E0uO8C6u5cG227B4IMjU55xjoyNGxuZvOzd10bOliqNe/sU3Ux2k+t5HaJVkyc1IVGebxaLVkWrjlbbfwyfM+yXX3XMenfvYpvvzgl7nuguu49uxrSUfTlQ5xSij0OXpeKtDzYoHu5wt0PZMnt8sB4MWh6tQQc6+JkT07TOa0EF5M14qZpGVunGs+0syV18zmyce6ePj+Vtbdv4m2R7tZPruPxfW9VNOJFfxrCuEw4dmzSJx1pt8ye/ZsvNTJ60kkk1chP0hf63Z692+ld/+2YLmV/radOOcnYYd/bGk67ZIp+WNLojbOnAtmM+eC2Qx2D9K+qYu2VzppfamDPc+0gkF6dpLq+VVUz6uiem6acFxfo2X6ijV6zL48yuzLo/796PYinU8W6HjCT7bt+7mfaPPiULUyRNUq/16j6tQQ0bqpc08qMhYzI5TNEspmYeUKAIoDA+R37/aTbXt2M7hxE7nnnvdP8LwDybbGRsJ1dYTq6/Hi8cq9CJEJMjOSdS0k61poOu11QEkjqj0b6Q4aUu169j62P/Hj4ByPRG0zqfp5Bx4N80jWthAKq2enzAz6RiAyjbzS9go3PH4DNz91M239bVyy8BJuf83tXDz/4knTQliOrHX/IOue7uHJR7t5+sluBvqLxOIeq8+s4sKLs6w5p4poVF9Yp6NivkjP7j66tvfQvaOXrh09DHb7P1xE0xGyCzNk52fILqginp3688Cc2XQm9119Hw9seYAv/uqLXPfz6/jSg1/ig2s+yB+f/ceag61EvsfR+3KQRHvRX/ZvKYKfRyNab2ROD9HyLr8VeWppCE8tyGckl89T6Oig0NpKvrWNQmsry9paWZLugLP8D0yuGGZba5onu5poLVRTs7iJxWc1c+rqDMnU5OzxKieWw0GkB5few651nQcn0Np3+3NwAJhHsqaJVP08Gpe9inTjIqpmLyJRM32GB4pWRZl1ej2zTq/HFR3dO3tpf6WTji3d7HxsLzse2eMn2mYlycxLk2lJU9WcIlYd1b22TEtmRmJuiMTcELPf6ifacrscXc/m6V5XoGtdgR3fybG94JePNhippSHSy0LB0iPe7GGe/n3I1OXF40QXLCC6YAHgN4AsdneT37OX/J495PfuYXDDK+TWPXfgnFSKUH094fo6P/FWX+/P2RaZGo1ORLxwhMzsJWRmL4HV/j7nivS376J790Z69m707xn3bWHfS48cdL+YqJldknCbS7K2hWS2iXCiSvdLMq0osSYyxfUO9nLXS3dx69O3cveGu/HM423L38Z1r7qO8+ecX+nwZBzdXXmee6aH557pZd3T3ezaMQhAtibMhRdnOfu8DKeuTiuZNs24oqOvdYDePX107+yla3sPvXv6cUX/h+9YdZTqeVVk5qTJLqgiURefljegZsbaBWtZu2Atj2x/hOsfvp6v/eZrXP/w9Vy25DKuWX0NbznlLaSiM6PnTDHn6NtSpG9Tgb5NRfo2FujbWKR/e0kSrcFILw/R8PoI6eUh0stDxBp0fZhJnHO4vj4KnZ0UOjopdLRTaG2l0NpGoaMDXPBhGW5xXVdLdMlSwg31hBsb8aqrqe4tkH+8m52/7eLuB7vp//k2zIMlS5OsOiPNqtVpli5LEo3pszVdOFck19NGf9su+jt20d++i/zZW3GpPbjUHoj0AfD8nWBeiGRtC1WNC5m98uKRH0aStS1Tphfa8WCekZmTJjMnzXygMFSke0cPnVu76dzaw+4n97Hz0b0AhJNhqpqSVDWnqGpOkW5KEU3NnPdKZg4zI95sxJujNF7m7ysMuJEe9L0vFeh5qUD7b/MQJNtCSUidEiJ9SojkohDJBR6JBZ7meJUpy8wIZTKEMhliS5cAQbKtp4fC/v3kW1sp7G8l37qf/qe2Q6Ewcq6XzRKqqfHv0WqyI73jvKoqzV0rk56Z5yfJaluYtfLVI/uL+SH62naMNMwaHumgdcNjuOKBz384liJR00SipolksExkm0jUNhFL106bhloycyixJjIF5fI57n7lbr677rvcuf5O+ob6aK5qHpmrSHOoTU7FgmP7tgE2vNTPhvV9bFjfx7YtAzgH8YTHilNTvP6NdZy6Os28BXE8teycFob68vTu7aN3bz+9e4Llvn5cIRi2L+JR1ZSk5bxZZFpSVLWkiaZn3o9x5885nzv+8A52dO3gxidv5MYnb+TK711JMpLk8mWXc+WqK7ls8WXEwlO7t54rOgb3OwZ2FBnYUaR/a5HejX4ibWCnPycaACFIzPVILvZofNOBJJqGWJoZXKHg/zjT2UWxs8PvhdbRSaGzg2JHJ25o6EDh0gTaKUsJ19YSqqsjVFNz2Dk/0ukwF62t4aK1NeSHiry8vo9nn+rh2d/18MP/3ssP/nMvoRDMX5TglOVJTlme4pQVSeoaItMyyT8dFPKD5Lr2M9C1j4GuvSXr+xjo3MdA5x6K+cGR8mYerroB652F174E65mF9c3irJuWkKxtxgvpa+JooYhHdkGG7IIMAMVCkb59A3Tv7B15tL+ya6R8tCpCqiFBstGfzy3ZkCBZnyAU0XVcppdQ3Kg+I0z1GQeuG8Wco3djgd6XivSs95Ntu+8cpDhw4LxwtZGc7yfZkgtC/vp8j1iTp573MuWYGaGqKkJVVUQXLhzZ74rFkdEE/GRbK4X2doa2bYN8/kAFoZA/11tNllC2Bq+6mlCmCi+TIVRVhUU1tJ5MXl44QrpxAenGBQftLxby9LXtpL99J/0du+gLGnh1797AvhcfGhlW3K8jSrx6FvHqBuKZA4/YyLJeQ0zKpKNvTCJT0Mf+52Pc/NTN1CXquOr0q7hy1ZVcNO8iQp6GcJosBnNFdmwbYOuWAbZuHmDjy/1s3NBPbsC/cUilQiw+JcF5F85i1RlpFi9NEtYXyCmrmC/S356jv3WA/rYB+tsOrA/1HfjCFEmFSc1K0nxOI+nGJKlG/4c2DY9zQEumhc+v/Tx//Zq/5tdbf83t627njufv4PZ1t/PBNR/kpstvqnSIR+Sco9ADuT1Fcnv8ZFn/dj+JNrDd3y7mDpS3ECTmeaRP8Wi8LEJykUdyYYjEPA8vos/F9OQo9vZS6O6h2NNNsaubYk83hWBZ7Oqm2Nt78CmeR6i6Gi9bTaRlDqFsNaHqLF62mlAmc9gEWjnCEY8Vq9KsWJXmD98Lfb0FXljXy0sv9vLyi3388p42fnZXKwA1tWEWLEowb2Gc+QsSzF8Up6k5pvk+T6BiscBgbzuDPf4j19vOYE8buR5/6SfP9jPU13HIudFUllimgVTdHOoXn31QC+FYdSMPXdBzyDnphuqT8KqmBy/kkZ6dJD07SdOZDQDkcwV6dvfRs7PXb1Szr5+Ox7pHGtNgkKiJkaxPEK+NkaiJk6iNEa+JEctoOEmZPryYUbUiTNWKA/tc0ZHb7ejbUqB/c5G+zUX6Nhdo+3WePXeWNBjxINZoxJu9A4+WA+uRWtO9s0wZ5nmEa2sJ19bC0qUj+50L7gfb2yl2dFBo7/BHIWjvYHDzloN6uQFYPI6XqSJUlTlo6aVSeOk0XjJ5TPeDIieCFwqTbphHumHeIceKxQK5zr30tfsjKfS376K/YzcD3fvp3r1xzHvbSDJLPFNPPNNANF1LLF3jL1M1RNPBI1WDp99G5STRVVdkCvr4uR/nipVX8PpFrycSmnk9WyajYsHxvdv3sG3LANu2DLB71+DIENPhsDF/YZyLL6lhybIkS5Ylmd0UVY+0KaQwWGCgc5Bc5yC5rkFynTkGuoLtzkFy3YMjQ/UBRFIREnUx6k7JkqiLk2pMkGpMzsieaEcr5IVGhon85zf9M/duvJfZ6dkVjak46Bhscwy1Ff1lqxtJoOX2OnJ7/fVi/8HneXGIz/FIzPWouSBMvMUjMcf/kUitsqcH5xwul6PY20exrxfX10ext5diXx9N0a2EbYiwDRLCX7Z966GDKwiFCGUyeOk0kfnz8YIWz151NaFsNV46fdKGB0qmQpx1XoazzvN75RQKjq2b+nnpxT5eXt/H1k0DPPO77pHfeyJRY+78OC1zYiwLel7L4RXzQwz1dzHU381gXydD/d3+dl9XsL+Lwd5OP3nW285QXxcH/QcTCCeqiKVqiGcaqJq9mHimkXimXq16KywcC5GdX0V2ftXIPld09Lfn6N3bR9++fnr3DdC/v5+2VzoPJNwACxmJmhjxmjjx6iixTJTY8DITJZqOKJkgU5p5w8NIenDBwceGOv1EW/9WvxHSwM4iuZ1F2h/JM7j/4Gughf2hsWMNHtFGj1iDEW3wiDX6y2iDR7TWCCX070UmLzMjlE4TSqdh7tyDjrli0b+P7Oqm2N3lN74KloX2dga3boXS0QuG64zH8VIp5g8O0p3L+Um3VJB0SybwEgm8eAJLxLGQEg9SWZ4XGmn0NZbS0RhyQUOy4VEZ+tp20L5tHfn+7jHONCLJDLF0LdFUDdFUNZFExn8kg2WiimiyOtiuwtPvqnKUpkxizczeCPwTEAJucs59ZdRxC47/HtAHvM859+RJD1TkJDiz6cxKhyCjeCHjF3e3EU94zJ0f51WvyTJ3fpy58+PMbo4RUmv+KacwWODpf3+RXNcg+f5RLQY9I1oVCeZCSxPPxkjUxUnU+i3Pw/Ep89/rlBAJRXjT0jed8OcZ6iiy/xdDQfLMMdhWZGh4vb1I4dDOHWAQrTNiszySCz1qzgsTm+URm+XvG2lZrV4IU4YrFCj29uIGBigODBy0PHhfDtffP7JNsXhoZZ5HyguTd1GGXJQBlybvIsy/dInf2jhdhZepwuKTdx7FUMhYuCTJwiVJLvt9f19+qMiObTm2bBpgy6Z+tm4e4LlneuntKUz7xJpzRQqDA+RzveQHev1lrpd8ru/g7YG+YNnDYEnirDDYf9i6Q9EEkUSGaLKaeHYWmZbl/o8C6Rq/RW6qZuRHgpk019lUZ56RrIuTrItDae8d58h1DTLQnvN7urcPMNCWo789R+eWLgqDo64pBrGqKI2n1bFgrYZ9l+klUu1RvdqjevWhxwoDjtyukoTbXsfg3iK5fUV61xdoe7B40BCTw7w4RGqMaK1/LxapMaI1HpEao+rUEJnTdb8uk5N53siwktB8yPGRBl1dXX4CrreXYk/vyHpo1y6Gtm33R0AY6/4UsGgUS/jJNn8Z99fjCbx4HIvHsFgcb3iZSmIR3XvIyRMKR0nWNpOsPfTfwLBifojB3nZyPW3BMhjhIdge7Gmnr21H2ffgkWSGaCJDOJ4mHEsRjif9ZSxFOJ4iHBu9nSIUjWtuuBlsStxJmFkI+DpwKbAdeMzM7nTOPV9S7E3A0uBxHvCNYCkiclL8880rNJzjNOJFPOLZGJmWtN9ivDpKvDqmVuPT2GCbY8M/+L/MhDNGpNaI1hqpZSGyNWGitUak1m8FHakxonUe0QbTkI3TzND27XR9/wdjHwyHgx8b4njxOF5tLeHh9VTSbxGcSuElk3ipFBaL8eCXnjikmuVrzjixL+IEC0c85i9KMH9RAqgZ2V8oHNqzarp45o4v0r7lGfK5PsbqQVbKvLD/xTueJhxPEU1Wk6qbM6q1bNVIEm14XcmymcXMiFfHiFfHyC449Hh+IE+ua4hcV85fdubIdQ+p97vMOKG4kVwYIrlw7B42I8Nw7ysGCTfHUIc/woDfOMofYaDnRb+xlCtA87ujSqzJlGVmI/eiY3ny/vtZu3atn4Dr76fY10exvx/XP+AvB/qDbX9Z7O2lsH8/xf7+g+d9K5G88EKS555zIl+WyIR54Qjx6kbi1Y3jlj101Ah/vXTUiOFjfe27yA/0kM/14Ypj/5s4wAjHktTMP53Tr/ir4/PCZMqYKncS5wIbnHMbAczsduCtQGli7a3AvzvnHPCImWXNrMk5t+vQ6kREjj8l1aYXM2PlFUsqHYacRIl5HufeVUWkRsmymSxcV0/60teP/GBhJYk0zV1xZNO5d3b1nBXEMvVBK9XkQS1VR297Yc2VJccuHA8TjodJNSYqHYrIpGZmhKsgXBUitejIw9s558h3A276NgQRGWZmWNJv+FUuNzTkj8aQy/kjNATLcOP4iQuRycwLR4hV1RGrKn90DeccxfzgqJEq+sbcjmcaTmD0MllNlV8HWoBtJdvbObQ32lhlWoAjJta+8IUvHI/4RERmJF1DZXL4g0P26LMpk8Xrwm8+ZJ8+nzIZvI4/PWSfPpsyWXw8U33IPn0+ZTK4aIxOo/psymTzwAMPVDoEkRlmD9y9rtJByEk2VRJrYzX5HN3EqJwymNlHgI8ANDWNPUGiiIgc6mIurnQIImOqb36h0iGIHNam4kuVDkFkTJuWPFLpEEQO69HcGJNmiUwCWwuHn+9HREREZg5zU6ALvJldAHzeOXdZsP0XAM65L5eU+SZwv3Puu8H2emDtkYaCbG5udjt37jyhsYuITDf3B2O2i4hI+XTtFBGZOF07RUQmRtdNEZGJM7MnnHNnT+Qc70QFc5w9Biw1s4VmFgXeDdw5qsydwNXmOx/o1PxqIiIiIiIiIiIiIiIicrxMiaEgnXN5M/sT4G4gBNzsnHvOzP44OH4D8BPg94ANQB/w/krFKyIiIiIiIiIiIiIiItPPlEisATjnfoKfPCvdd0PJugM+frLjEhERERERERERERERkZlhqgwFKSIiIiIiIiIiIiIiIlJRSqyJiIiIiIiIiIiIiIiIlEGJNREREREREREREREREZEyKLEmIiIiIiIiIiIiIiIiUgYl1kRERERERERERERERETKoMSaiIiIiIiIiIiIiIiISBmUWBMREREREREREREREREpgxJrIiIiIiIiIiIiIiIiImVQYk1ERERERERERERERESkDEqsiYiIiIiIiIiIiIiIiJRBiTURERERERERERERERGRMiixJiIiIiIiIiIiIiIiIlIGJdZEREREREREREREREREyqDEmoiIiIiIiIiIiIiIiEgZlFgTERERERERERERERERKYMSayIiIiIiIiIiIiIiIiJlUGJNREREREREREREREREpAxKrImIiIiIiIiIiIiIiIiUQYk1ERERERERERERERERkTIosSYiIiIiIiIiIiIiIiJSBnPOVTqGijGzbmB9peMQEZli6oH9lQ5CRGSK0bVTRGTidO0UEZkYXTdFRCZumXOuaiInhE9UJFPEeufc2ZUOQkRkKjGzx3XtFBGZGF07RUQmTtdOEZGJ0XVTRGTizOzxiZ6joSBFREREREREREREREREyqDEmoiIiIiIiIiIiIiIiEgZZnpi7VuVDkBEZArStVNEZOJ07RQRmThdO0VEJkbXTRGRiZvwtdOccyciEBEREREREREREREREZFpZab3WBMREREREREREREREREpy4xNrJnZG81svZltMLM/r3Q8IiKTnZnNNbNfmtkLZvacmX2q0jGJiEwFZhYys9+Z2Y8rHYuIyFRgZlkzu8PMXgzuPS+odEwiIpOdmf1Z8F19nZl918zilY5JRGSyMbObzWyvma0r2VdrZj83s5eDZc149czIxJqZhYCvA28CVgJXmtnKykYlIjLp5YH/5ZxbAZwPfFzXThGRsnwKeKHSQYiITCH/BPzMObccWI2uoSIiR2RmLcAngbOdc6uAEPDuykYlIjIp3QK8cdS+Pwfuc84tBe4Lto9oRibWgHOBDc65jc65QeB24K0VjklEZFJzzu1yzj0ZrHfj/8DRUtmoREQmNzObA7wZuKnSsYiITAVmlgFeA/wbgHNu0DnXUdGgRESmhjCQMLMwkAR2VjgeEZFJxzn3K6Bt1O63ArcG67cCbxuvnpmaWGsBtpVsb0c/DouIlM3MFgBrgN9WOBQRkcnu/wU+CxQrHIeIyFSxCNgH/J9gGN2bzCxV6aBERCYz59wO4HpgK7AL6HTO3VPZqEREpoxZzrld4HcsABrHO2GmJtZsjH3upEchIjIFmVka+B7wp865rkrHIyIyWZnZ7wN7nXNPVDoWEZEpJAycCXzDObcG6KWM4XhERGayYD6gtwILgWYgZWbvrWxUIiLT10xNrG0H5pZsz0Hdo0VExmVmEfyk2necc9+vdDwiIpPchcDlZrYZf+jx15nZtysbkojIpLcd2O6cGx4Z4Q78RJuIiBze64FNzrl9zrkh4PvAqyock4jIVLHHzJoAguXe8U6YqYm1x4ClZrbQzKL4k3neWeGYREQmNTMz/LkuXnDOfa3S8YiITHbOub9wzs1xzi3Av9/8hXNOLYdFRI7AObcb2GZmy4JdlwDPVzAkEZGpYCtwvpklg+/ul+DPiy4iIuO7E7gmWL8G+NF4J4RPaDiTlHMub2Z/AtwNhICbnXPPVTgsEZHJ7kLgKuBZM3sq2Pc559xPKheSiIiIiExDnwC+EzSE3Qi8v8LxiIhMas6535rZHcCTQB74HfCtykYlIjL5mNl3gbVAvZltB/4W+ArwX2b2QfyGCu8ctx7nNLWYiIiIiIiIiIiIiIiIyHhm6lCQIiIiIiIiIiIiIiIiIhOixJqIiIiIiIiIiIiIiIhIGZRYExERERERERERERERESmDEmsiIiIiIiIiIiIiIiIiZVBiTURERERERERERERERKQMSqyJiIiIiIgcJTNzweP+41Tf/cN1Ho/6xGdmfxC8rwNm1lLpeADM7Kogpg4za6x0PCIiIiIiUh4l1kRERERERE4QM3ubmX0+eGQrHc9MZGZx4GvB5recczsqGU+J24CXgGrgyxWORUREREREyqTEmoiIiIiIyInzNuBvg0e2opHMXB8DFgADwFcqG8oBzrkC8MVg831mtqKS8YiIiIiISHmUWBMRERERETlKzjkLHmuPU31rh+s8HvXNdGaWAP482LzFObezkvGM4TZgC/5387+tcCwiIiIiIlIGJdZERERERERkuroaaAjW/72SgYwl6LX2nWDzCjObV8l4RERERERkfEqsiYiIiIiIyHT10WD5inPuNxWN5PC+HSxDwEcqGYiIiIiIiIxPiTURERERETnhzGytmbng8flg32lm9i0ze8XM+s1sn5nda2ZXTqDeuWb2FTN70szazCxnZjvM7C4ze5+ZhcqoY6mZfdXMnjCzDjMbMrNWM1tvZveY2WfN7NTDnDv8mu4ftf8WM3PANSW7N5WUH37cMuq8+4ePlRH3ecH7t97Mus2sN3gvbzWz15Vx/kGxm1nSzK4zs8fNrD2o7zkz+7KZ1YxX3zjP9dclz3fnOGXfUVL2WTOLH+VzngasDjZvG6fs50uec22w7xIz+56ZbTOzgeC9/ZaZzR91btzMrjWzh4PPcF8Q95+bWWy8OJ1zLwBPBZt/ZGYaBlREREREZBILVzoAERERERGZeczsKuBGoDTxEAcuAS4xsz8CrnDODRyhjmuBfwQSow41B4/fBz5tZpc75zYfpo4PAV8HoqMO1QaPU4BLgfcAZ5Tz2k40MwsD/wp8eIzDi4LH1Wb238A1zrn+MupcBNwFrBx1aGXwuNLM1h7ufSzD3wOvB14DvMXMPuac+9cx4piD/7kAGACuPNJnYBxvK1n/5URONLOvAP/XqN3D7+0VZnaJc+53ZjYb/307e1TZVcCXgd8zs8vK+Bv8Ev/ztQA/GfjUROIVEREREZGTR4k1ERERERE52c4BPhes3wz8CigE+z8IpIA34w+Rd8VYFQRJtRtKdt0F/A/QgZ8Mez+wEDgNeNDM1jjn9o2qYw3wTfyRPPLA94JY9gIRoAlYA7zhKF7j/wf8EPgk8Npg37VB3aW2HkXd/w4M9+obAG4FHsZ/D8/Gfw+rgHcC1Wb2RufckXrAZfDfu+XAncBPgTb8JNJHgXnA/OB5X3MU8eKcK5rZe4GngRrgejN7wDn33HAZM/Pw/+bDveM+45xbdzTPF7g0WBaBxydw3sfxP3ebgP8DvARkgauAC4P47jCzVfjv25nAT4AfA6347+MngTrg1cBfAn81znM+UrJ+GUqsiYiIiIhMWnbk71ciIiIiIiLHLhher7TXUDfwBufcI6PKLQXux+9xBn6vte+NKrMAeB6/p1oBeI9z7r9GlUkA/42foAO4wzn3zlFl/gU/iQLwrtF1lJQLAec55x4e49jwF6oHnHNrxzh+CweGg1w4Xo+vYFjGiwGcc4cMCWhm7wJuDzb3AK9zzj0/qsx8/Pd6YbDrT5xzXz9C7ACDwDuccz8eVaYOeKykrvOcc48e6TUciZldgf93AXgGONc5lwuOfQ6/ZxvAj51zbzmG5wkBXUASeM45t2qc8p8H/rZk14+Bd5b2lgsSf/8DvDHY9QR+4vUq59xBQ02a2Sn4ybEEfrJ39vDrPMzzzwc2B5s/cM69/YgvUEREREREKkZzrImIiIiISCV8ZnRSDcA59zJ+j6th141x7ic5MPzjV8dKiAVD770H2BXsekeQ7Ci1JFh2ciDZcwjnXGGspFqFlA5P+P7RSTUA59wW4N3AcOLsM2XMNffF0Um1oK5W4Esluy6bYLyj67sDv5ciwOnA/wYws3OBLwT7dwMfOJbnwe9tlwzW10/w3L3Ae0cPQemcKwJ/V7LrLOCbo5NqQdmX8Hvfgd/b7dwjPWHwNxseLvL0CcYrIiIiIiInkRJrIiIiIiJysrXjD7E3Jufcz/B7pAGcH8xjVWq4N08e+OoR6unCn4sMwDh4zi2AvmBZhT/c4aQW9NRbE2w+65z76eHKBr3KfhFszsdPAh1OAfiXIxz/Rcn66DnYjsYn8YdXBPiEmf0hcBv+VAUOf164fYc7uUzzS9bbJnjufzjnOg9z7DFgqGT7kJ6AJR4sWS/nfWsPlnPN7JDeiiIiIiIiMjkosSYiIiIiIifbr51zg+OUKU3mnDO8YmaNHEiaPO2cGz1n2Wj3lKyfN+rYz4OlB/zSzD5kZvXj1FdJpb2e7jlsqbHLjH7tpV5yzrUf4fiOkvWaw5Yqk3OuF3+OuEH8hOd/AouDw19zzpXz2sZTW7I+0cTabw93wDmXx59HDaCXAwngsewpWS/nfRuuN4o/z6CIiIiIiExCSqyJiIiIiMjJtmGCZZpL1ptK1l9ifKVlmkYd+zf8+dzAn0PsRmCvmT1rZt80syvNrLqM5zhZjudrL7X/SJWMmhssXsbzjss59yTwV6N2/w743PGoH4iVrHdP8NzWcY4Pvx9t7siTlk/0fesqWU8ctpSIiIiIiFSUEmsiIiIiInKy9Y1fhN6S9XTJetVhyhxOz2HOJeg1dxnwGWBzsNuAVcBH8Icn3GNmXzezTBnPdaIdt9c+SvHowjlmo+c++1EZPRnLVZrUmujfrtz343i/b6VJ3P7DlhIRERERkYpSYk1ERERERE62ZBllSofCK00QdR+mzOGUJuUO6bnknBt0zl3vnFsInIqfULsV2B4UiQEfA35lZpXuRXRcX3slBfPm3TRq9+fM7Izj9BSlwz/WHrbU5DIc5yDlJU5FRERERKQClFgTEREREZGTbckEy+wsWd9Vsr60jHpKy+w8bCnAOfe8c+5G59z7nHNzgddxoCfbauCDZTzfiXTCXvvJZGaGn7xsCHZ9P1hGgduOUwJzc8n6VEusbR1niEkREREREakgJdZERERERORku8jMouOUeW3J+mPDK865vcCWYPMMM2vgyN5Qsv5o+SGCc+6XwJ+U7LpoIucHSocLtKM4v1Rp/JeWUf6oX/sJ9mkOxHY3cAXwrWB7BfCPx+E5NnGg19ey41DfCWVmCzgwD9szFQxFRERERETGocSaiIiIiIicbLXANYc7aGZvwB+WEeA3zrndo4p8L1iGgT89Qj1V+MM4AjjgB0cR6+aS9fBRnF86jGU5wzcelnNuM/BksLk6eJ/GZGZn4/e4Az8R+cSxPPfxEgz1+KVgcx/wvqB31p8BLwb7rzWztx7L8zjnChx4zcsnyRx5R3JeyfpvKxaFiIiIiIiMS4k1ERERERGphOvN7JzRO81sMXBzya6vjnHuPwP9wfpnzewdY9QTB74NNAe7vuece3lUma+a2fnjxPnRkvWnxyk7lk0l62cexfmj/UPJ+i1mtnx0ATObB9zOge97/0+QaKooM0sC38Uf8hHgA8NJU+dcH3Al/vxiAP9mZs2H1jIhPw+WHnD2MdZ1opUm1u6uWBQiIiIiIjKuo2lxKSIiIiIicix+gj+U4UNmdivwa6AAnIM/j1k6KPd959z3Rp/snNtsZn8G3ID/neYOM/tRUG8H/txiHwAWBafsAD4+RhzvAD5tZpuAe/GH4NsLxIC5wDuBM4KyrRwYrnAi7itZ/9/B0JXrgfxwbM65Z8utzDn3X2b2NvwkVBPwpJndAvwG/z08G/89HO6hdQ/wr0cR94nwj8BwIvDrzrkflx50zj1lZp8DrgfqgFvN7A3HMN/YD4D/O1hfC/ziKOs5GYaHPt3knDuaBK6IiIiIiJwkSqyJiIiIiMjJ9hh+z6WbgA8Fj9F+AvzR4Spwzn3TzAw/WRMH3ho8RlsHvCWYm2204fnPFgIfPkK8W4C3O+f2HKHM4eJ8xsy+i58Im4WfNCp1K/C+CVZ7Nf78YR8CEvi96j46Rrk7gKuPITF13JjZHwAfCTafAz5zmKJfAy7DT7y+HvhfHPqelcU595yZPYWfHH0P8DdHU8+JZmYrOJDA/U4FQxERERERkTJoKEgRERERETnpnHPfxu+hdhOwERgA2vB7Ff2Rc+7NzrmBceq4ATgFf3jEp/B7qw0Cu/ATc+8HzgjmJhvLmcAf4A8t+SiwHxgCcsD2oI4/BlY45548TB3luAo/8XV/8Bz5I5Yeh3Mu75z7MHAB8G/ABvxEWz/+0JPfBi5xzr3TOdd/+JpODjNrwf87g//evudwcQVJwGvw3yeAvzezYxlCc7i33mIze9Ux1HMivTdYFoAbKxmIiIiIiIiMzyZB40UREREREZnmzGwt8Mtg8wvOuc9XLBiZMYK59rYAjcC3nHPXVjikg5hZCD8xugD4T+fcuysbkYiIiIiIjEc91kRERERERGRaCno9fiXYvNrMmisZzxiuxE+qFYEvVDYUEREREREphxJrIiIiIiIiMp19A3+IzDjwFxWOZUTQW+2vgs1bnHMvVDIeEREREREpjxJrIiIiIiIiMm0FvdY+HWx+OJjzbTK4ElgGdDKJEn4iIiIiInJkSqyJiIiIiIjItOac+6FzzpxzcefcjkrHA+Cc+3YQU9Y5t7fS8YiIiIiISHmUWBMREREREREREREREREpgznnKh2DiIiIiIiIiIiIiIiIyKSnHmsiIiIiIiIiIiIiIiIiZVBiTURERERERERERERERKQMSqyJiIiIiIiIiIiIiIiIlEGJNREREREREREREREREZEyKLEmIiIiIiIiIiIiIiIiUgYl1kRERERERERERERERETK8P8DgOJPQpUh3C8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = 2\n", + "p = 0.1\n", + "v = 1.0\n", + "noise = 0.1\n", + "\n", + "iterations = 5\n", + "\n", + "# generate list of random colors for each iteration\n", + "color = [\"#\"+''.join([random.choice('0123456789ABCDEF') for i in range(6)]) for j in range(iterations)]\n", + "\n", + "fig, ax = make_figure(xlims=(0, 10))\n", + "\n", + "add_gaussian_bel(ax, x, p, 'green')\n", + "\n", + "for i in range(iterations):\n", + " x = x + v\n", + " p = p + noise\n", + " \n", + " add_gaussian_bel(ax, x, p, color[i])\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "markdown", + "id": "7af4d2a5", + "metadata": {}, + "source": [ + "## Calculate Normal Distribution from Samples" + ] + }, + { + "cell_type": "markdown", + "id": "142248bf", + "metadata": {}, + "source": [ + "In order to calculate the mean and variance of a set of samples, we should these steps:\n", + "\n", + "1. Calculate the mean of the samples by averaging them.\n", + "\n", + "$$\n", + "\\bar{x} = \\frac{1}{N} \\sum_{i=0}^{N} x_i \\ \\ ; \\ \\ i = 0, 1,\\dots , N\n", + "$$\n", + "\n", + "2. Calculate the square of sum of the samples deviation from the calculated mean from step (1).\n", + "\n", + "$$\n", + "\\sigma^2 = \\frac{1}{N} \\sum_{i=0}^{N} (x_i - \\bar{x})^2 \\ \\ ; \\ \\ i = 0, 1,\\dots , N\n", + "$$\n", + "\n", + "The generalization of these equations in matrix form would be:\n", + "\n", + "$$\n", + "\\vec{x} = \\frac{1}{N} \\sum_{i=0}^{N} \\vec{x}_i \\ \\ ; \\ \\ i = 0, 1,\\dots , N\n", + "$$\n", + "\n", + "$$\n", + "P = \\frac{1}{N} \\sum_{i=0}^{N} (\\vec{x}_i - \\vec{x})(\\vec{x}_i - \\vec{x})^T \\ \\ ; \\ \\ i = 0, 1,\\dots , N\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "0c187ac3", + "metadata": {}, + "outputs": [], + "source": [ + "class Gaussian(object):\n", + " def __init__(self, samples):\n", + " self.x = self.calculate_mean(samples)\n", + " self.P = self.calculate_covariance(samples)\n", + " \n", + " def calculate_mean(self, samples):\n", + " x = 0.0\n", + " for x_i in samples:\n", + " x += x_i\n", + " x /= len(samples)\n", + " return x\n", + " \n", + " def calculate_covariance(self, samples):\n", + " P = 0.0\n", + " for x_i in samples:\n", + " P += (x_i - self.x)**2\n", + " P /= len(samples)\n", + " return P" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "e55d43ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "samples = [2.0, 2.1, 1.9, 1.0, 2.5] # add samples in a list\n", + "\n", + "gaussian = Gaussian(samples) # calculate the mean and covariance out of these samples\n", + "\n", + "fig, ax = make_figure(xlims=(0, 6)) # create figure\n", + "\n", + "ax.plot(samples, np.zeros((len(samples), 1)), 'x', markersize=20, color='red') # plot samples\n", + "\n", + "add_gaussian_bel(ax, gaussian.x, gaussian.P, 'green') # plot gaussian distribution\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "b1618bf1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "samples = [2.0, 2.1, 1.9, 1.0, 2.5] # add samples in a list\n", + "samples = np.add(samples, 1.) # shift the samples by 1\n", + "\n", + "gaussian = Gaussian(samples) # calculate the mean and covariance out of these samples\n", + "\n", + "fig, ax = make_figure(xlims=(0, 6)) # create figure\n", + "\n", + "ax.plot(samples, np.zeros((len(samples), 1)), 'x', markersize=20, color='red') # plot samples\n", + "\n", + "add_gaussian_bel(ax, gaussian.x, gaussian.P, 'green') # plot gaussian distribution\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "f1533c8f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "samples = [2.0, 2.1, 1.9, 1.0, 2.5, 2.3, 3.0] # add samples in a list, increased by 2 more samples than before\n", + "samples = np.add(samples, 1.) # shift the samples by 1\n", + "\n", + "gaussian = Gaussian(samples) # calculate the mean and covariance out of these samples\n", + "\n", + "fig, ax = make_figure(xlims=(0, 6)) # create figure\n", + "\n", + "ax.plot(samples, np.zeros((len(samples), 1)), 'x', markersize=20, color='red') # plot samples\n", + "\n", + "add_gaussian_bel(ax, gaussian.x, gaussian.P, 'green') # plot gaussian distribution\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a02ea868", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "646376a1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/python/examples/images/gaussian_01.png b/python/examples/images/gaussian_01.png new file mode 100644 index 0000000000000000000000000000000000000000..899b2f05535f0e927b4f4741c8fb151c3c1f1ab4 GIT binary patch literal 15797 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 literal 0 HcmV?d00001 diff --git a/python/examples/images/gaussian_04.png b/python/examples/images/gaussian_04.png new file mode 100644 index 0000000000000000000000000000000000000000..a0fbafbd7948fbe4e8c5b42901c66e7454fba54c GIT binary patch literal 15772 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�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 z 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 Pj#jQ2nCX}5Lc;zByAVZ( literal 0 HcmV?d00001 diff --git a/python/examples/images/gaussian_08.png b/python/examples/images/gaussian_08.png new file mode 100644 index 0000000000000000000000000000000000000000..cc2c95118fd5581bf599b47cdaa11a12864dbd15 GIT binary patch literal 42286 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 literal 0 HcmV?d00001 diff --git a/python/examples/images/gaussian_09.png b/python/examples/images/gaussian_09.png new file mode 100644 index 0000000000000000000000000000000000000000..06ff588f021161dfef5f6244d41383650203e528 GIT binary patch literal 42597 zcmb@ucT^Nv*FM_nsGlf0W<&`ph=71CNs(j#X`$1i*&QNt~pM7?C_Oo}@>-)0zsHteFFc=IqPU5Zt z2D7gTgW3JyfA+!uS+;p^0{^;UE2d_vXlZ2Y@bIxAM&_Zd)gw#WN2Yp=_J)sbOf44)8Vn|`5qI~N zlH>dFZU-%ufvw7!r3!_z;>QMQ+2`K5Oa)JjT-Nlhk#6Eq4Y|l-7Vl1O4hc5ZP)WP; z{p%AK!|<%Gi@8tF=DB;kT9+1+r&PGjISbPZdPdkx&V8Bw%RR3S+p4h(o{awFh4_vA z^LGq}F-|WG*&+J#^~popfBug7d;bg5fB!@D98LUx*06r?-#2}(xAT;`b?a7+T83U4 zH^%W@Q-U1(_3J^mXlKWVN!`<$vOOE=GbXMKxVmk5ucPHKDL@l|wOJ zT7zsBJa!19bBTvXiEP&LIC59n_y1h}UK7K#w~hltc#1VrbF?**^h(etzEAw5B2zN5{Oz1i2|# z=r7OJmufLd9GX7mlR8UMz%(N{{yE=p;;+k>YxWIml z0=2%ktD770WW#U%w<`S@;P-_}pB{W>(v6`AfiGuQU|`r(KZ#M;&A`9_dtuqICanL@&H{a6uwif=$&xwjzpH{7A9hdMgIvN$zV0+h z++1EdVlGsm-05r4R5I-*V7D3ch3nZ^^NON?%S`IJ>v|B@T-@+L&ByUu?aEheZk?=C zP!r2Kt=#ZPY+$T^Y;}9Lo=VSAZ(s`OH})HA^KftJDjhN#>51#Gbqq{RWnwMk7j5rTyQ%S|hGgZblW4w;;*N^7X78MBot}WX#m7MmHN`yF@ z|D9V4k=K)H5VoN&eFt}uc|~&dtH#acWIy8|9{EP?f_W$EtXB7^@fc)Z3S>lv!qSo^ zB6VQ4N!tan_REHn5jf>J73HSiGRneoPTheE^xeTTX+Lj;jkrwMZJJL>-N}7*@aXE= z&)(I!AJG~m4*4Myn(@2d?n~_b;$BS~rYzUB_AH8PrO510%6W$J;B~~q88e)|Uah6+ zXE*gGt`Zg{HB7zVJtS?6y{Xj+oew21%Iizp<21dox|(>d>k>%p@PDI*C)-Xb_-F`A ziagr91sWKRN?l5HAx}CdPTxuPPk6fSYB5!rZo6y5)}wCC4*o2-Rt+)ZD(mQ*5S=dO zw1;O}zY*46OPV$MmeOjdnPS)8T7C5WMXZPrvVDmb!GX3@>=GRoqzx9M>x(|b%JdG3 zq@<-cme7b3xWszRi5n4~c&UL;Ly=!rIp6Pl(x|cW!rWqXOZ=m=Bxl25zTy(x#@M`S zaFMcwi~p(6D^Jv$v+pXpE&NekT_Sn#u8dR_@OKtFJ8TwKuiet&jqcIX^s|s@*58f6 z^es;G6l?ZVd=#^cYL!0TJ%ISgu3fvTql5~Rl~dw%ik(fDCc9s|cY%GI)r4WqetdZH zc(5kP(-SlBE#OWtyK1Zd`8&41zrMaJa_LxGW1LjWN3nw^*_0$8a8?tT--0WqY;LTL zeG9nw+WvhYi=5eLbCUA}xlJiUPt343TzPYIv-3cG5W^t82()4<6y z`g*z$GXkfV4f>9RdB}1q>>w|0+C?E$oo2{VRbTn zYQE>`QufTWIAS+$^V9d7Oa9DBp7!Td*L=F}g=mJCqd_Uc?@{Yk$d+7m`kI#R=1g2v z;naqesnh;-@WI1PF_td?8TuoACV1_a(g6$ z`qR`hZu`*k78pr5EKfhA6LwYm9>UQCo8>iaWNJxO=a%<<{Z*f&JX9CStM~QQmg~fO zAr}=S3Wf9Hd7S4>WWsrHcB9R>9~sEPpzo3OmAN+8@vpCs3t0bt)|#%H?kBt|Q7^Jp zMDaPB@ZrM;O<`FRlSJW-`KG_f1;1I#v+AI!D_B0Cd(q~!{<|M^Yu$-s9`PTj7ye2;w7wgA+T&9$p;$?zGJlrD%ofPHhR&#gIq-)G7Z0vLZS#4b}JaHk52d4 z+EDcq+01j_Trm#5qCT7BN4D;#{Jf>HxxS)YXm8#PqE(0UrpUg(9<%r0DHAZdH;~id z1dzwMZEY;g&b;2LI8q-aloGm_KomGPgmg*qBzfoXzHS3XRN(3)H z{=o4|-|DAI@%VVT=(L1rcMW-Yc{b(bAeD3-H>vWYOp#=KTk@m!%*<9ceTugRq;=l% zOkuaxM9bb10&#ZWJAP$$puqNYs^(HPd-`zMlRa?gZ_Sz$t-FWRvrPi%orlkh-MuS8 z5MCSS=C$k*?5P~?Ag8=IOqVR^G@A%Vmf`iKr`UyMS;6nX4X(5LDw_E3-H&d{twdxf zC_L1c-lZ??NsKSB#Z|ITgea*Jys-`v1@{_7sx%IOLzj)I;TNjH<&TR$mv)ATYwY(ENn4!g zlp?f}G!sml;=32I0eN8A#XnoT_v}AhG?|#yY+=wPE^KIWsO++(!XohDGMR>i(nUJa}^=(VpNQ zkd13p!cU0nOP|%3jtHw=#U<-`uP8PO;<{7GuN{`Q(@s)dkD`n6R?4cg;UGJk(>)x? zGD~Nw#a-_6uFq*r7PzXLl4d<`=jK=Xqw)PQK5V>cK`)+B%k$*E14YoAe15ujc3~kH zEAG&37Ybf;bSUSh{rG+GYC~^%06#g8+6k^PSU_Os(kEzn%}%T>Mtf{JbyluzEcI^9 zy$4PB*mQ>KII}KJR0Xp1E@CZ>;O1+TZ#1!WkvA*x(E!FOCb?|}Yqnf#G*ZOgo=P&V zk4jcd@O?Z~N8&MUynOw-+Fq&?_rbh*;i|Eogh@%a)%n*#l!5Pm)kW~j)eEnsQk}T` zA=|X6nkF{#rbAC%f}7@-@^W4f3Ww-ze)c<;uER}z>G7*dgm~$9k2@=+tJ534eUl(R zYF7Z;b{@~DoNrc?>sE=yM?J3RQOA1_=9`rLe2RZhY!GOf98QB(VW#FMD3%MOsj7Cu zqeT>9L6!6%H|E9JS5dH+P^scn1QxX!mBw3?+9@V^$MMA092%$%YqO)rU_^@`K`3?? zI<$c=kd5o<$rjxjfH{ke3PB2?r7jx*yU`#f(?8z=__gQ;JAy+q1YH)#%|+_LX!Lta z+J{^QDm_*PP9tElDvqAPb^4a!_YfIKR1JTs0(otRf1IUfVPli*b)EBJVg>s&`}ygY zhj7nFvA1Js-USHmp6p5j<(O3mvBK|SKn=&zgYUO$fGf*_6X%oVI0HD;J~1wC8uFSo z--n;~ox;;)donC_>C2eoI#+1v1Z)!#>$V+fG@T!Azy*i=5nN)qg{Vei_t1s;Ris^5!88@#gF2mYrnW{TD=L5^Wf3Gz?MpPz*Ae8a(7hri&)TdRu` zDQ`})OA<;p7B$@#+l|}0joLE}2}C6BkTl4WtrSi2!}1qDbLR%WhmKc@*bI7aZmvx+ zIazpkctGyGOR()L+f^IEKlP%s9_(TN;dA~>yyhKB05`T)mfN$8gD=U@Laq^=Dw^{Z z-deYji4;(VEz7?=Oc%r~bqd!ADL3`Bt}9l@=g!N+En!&wAZ}w>yQv=S<1Dhx;ET;U z=9+Q1z(Ey}flm8@wp$>dWuE!sc)Nb7ito7_AK@-$O-}7@qx2!yDaG zV;Pq8O`R=0tuEwVshOoGfU^CWL_|ao{17J@tN@i#k7GYI5-pw|JRQQsp;L5yaZ}c5 zZm^}2!NawC=mw~0ur4y6fcnsM0AD38sRpUS$hZKaLXh5jykKzm#5Q)cOs3y@boZwjJILkyUmnQ2hfbvrpE6mytP zfXEWvYX)^ElMP36fVI>0cM zy<`_@_Rz?*oYc60ACo zzxE;uB4nGjuobUO7CM7~`l^Q)h8z0h@0@5uKo?*t)yBA!4p3W2{c!tk)|#4hLF|nL z0n%XtXjB=L+xCbb-+E4wGHEZbe@ouh@igQj;t$UA=mBae}xy7Ju(nhVr{A~`&-1`BkV)K83Sd>QsCBs`C!_7`7P6!;tVEkHVhI};~tRly} z4V2l8S$#~dUr_g30ar4sA~1Jk=)b&u`?elKx?09ZfRr}nZgWHRTzKX`njz`272lk`mgR_NlZyCLbUHAl8F0NQkx(OJ$LZYUV0k{|MQ$N+Sil z1rJ39A?U+-9aq7v^|{gR!d#+M=wnximg((-)lz~w^g%lHD|17oYGm zH-wXxxEyfOe-*?(VpT$T7HXERUId>Ubm%4CIl5Y_dVIKxAb=GaoFp)2cMrN zE5yBFG6j4s;JQ5RA?!Z<UN0Mah(y9iQtpz%(YZ? zbaZ_0)d0!2I~zf8xwA=3?;xdBl(<1akFf9<;2UXTnXKmql{e}83B{jeSCJ@~?=^rp z%71QF=G`?hq*P?`Im0df`Sa)39e*UNg#r=(5<7y150dYYKS!2)@* zl2|Gu&cq6iQ)3xben}$^GIqoB=gBF3?feJ#W6Fa6=)?qv4^#!-gT(}#W{FHm0IaPK z>nS`Ha#>6Sbdv1^~IIY#;SU(=XH|Fh`Vn>f2E$H{X3B02+ z*|JwhIYp)A&Jm##g>rT8ZyYE8az?BQ0>#~cfPhs%{>>$BYd`(m=4$yfQs#dbeC^NB zuT)Cc5dvqCAO!JS>L68D0c5dYAs72N(3<_vxw@NECU7blp)5rK>|CM4Q0cwX>n#y9 zDGp%I&41kc3_%!C&ZDdwkeLZYs*`NP2*CYiHU2Y0fAq(%#(EVfof|Lu2@*_%(y-D9 zapa$TPS{Otp)@(Y^zc?(m7JVP(=i!smbmNcyR(MdPP;2NnaZ@d%ev6rbdd%G&o8EB z1R<%<3_RWW*YneQ`%MW@>Lw#4b9(V&2lbNBKWUHdpS0IBu{hP64$$hWjz$JR%hl=f zBgf-@nE@tHP1h-I1{(Kzt~xj#c$1^FuZt!UNk9)jAg}UR|NgplsEJeeHb(d63`Kg=NqLE-2Yqa$@K?io_EtiTT|7KyU3M1LnxD{PoHki{Tx{9#=Y5~%@2SC zr|r=DEYES~Bfw)Kq-F_%WGE*IQ1T7?IDIXny7x&))!G=BUJPZTu0tU_dvj>wd#7@$ zn*738o1C}Y`Gy^hnVtI|kq^$gEls}tH+jbL)y?iFJ{cpPVE-X#>hqqCIRwJF{%w`Q%O~OzeW$|E+@QV z@X@viHpX8Z+WOgRzjA^soq2DGc4M5&Q@8b*%DR$DjbdlJ@wih`!EC|9p$CehuBc}Y z$GoI(gnBy>e8i+P$DBk_EQ9X?dJCRyr+9aY(Jn1DwcNo$9&jTZ(#T zc+G-JmVdv!>y!r3;IhZ&`j%7b-PgwutZ7RbfSM;GS|3V_AOHq`@rwa;X*Z7cDOT!t zTk1~G_1NIm3B?r8UW=Ha`@23`L>Gc>D3cwyf5qXZJY$6Z_f&ca1ZMJ$n0WihpK&*8 z2d_%J-7mr*;`Wd{q0Mvr&=bC<@_q@SCaoSqxjNdE;K#%YX(s%d;Tz%A;fuJ? zN#=zvn|g$$Iec)d_gDE#alJXswxb;*TRcXUadm=3Em}xxxb(}pb*Yu%A~D9wu@bh-+eH-2i|EYz6*lbY~N40euULFQ-%|xXi|So3_j*585bmd&som=*ugY zhhtxgD7<__$K%>=Ww$~;xQ7>9?838`FH_XBjG%N4!iwv<&OFaFs!cYIcH^_BnS;Qe z=(03vEqo8S4MUPlQ0Q5bWT9&`fW1{I0#Xl|0{nyWPo`NUP%{GnfE$o81mexfy#5z^ zQok;KyXf~d&2|-Ht|6%fDq{{DLhsSLFaNr}RP3t$6<{%|prByg1X2gzy|U?X{F1ap zcKW*%)i|6&f$fOil)eK{gx5>cQpvPJ&bH%g2*mv{bdrvabc#b`IKr|dz;=WX04cOE zuEhc};^QLWDM)6OlT83Be^%b}rV02^f1Y(mIW31Hg^2~atu3Eld9CKR*C!Kl-;6Q& z>3cWqKjQjf@npx?M%>g`_sUd(ED)kU#?njEO1CyO3C;O7#sJ2+7WI*;07_nF92nku zJyp~n``JG@q;wc-OAlodTKuVxL{JMyr!Qx#qD4x*vDYYPgA z_NjdBK&h=ZVX96J}Zi=xW7ct})ZL z*V?NqE78g~EDgbYzSG18P~RJM{o_Qf#v^L#+BDo9ey9c9=q#|ft$^W}actTJ+4~OB zOh@}A$VKY}UXoD&OFnVtOj4+>yEZDT4?Y*FIIjDR68i}}Az(ppI$HSrO8gJQ$RD=nTOkUK7ig;}P zbg`+877?k7sUbNcVV{e81>9n5Xy&YGXATJ=kdRJLbE3RPu06MryX(`* z!nQ19Ik(v=76KDgn#D7evlhZ38MaWs01ul2E;%5OMpgl<@zXB0B|}YS z`py5m^FXlbG28c@$^ZjSUcN61G!2r*m~g;zDzzjlTjuE|Da6f}Zf(c`)Kavy%|6Ac zm53x8;|O30%mBBV!DWO67V<5xeIs9aRnRjH9_ zfE({T&85?P*0Shm`iA}ZPwQ?eW#@~Wb4Z)3Z0xSsy^;K>=%z*?Dc+f+*U74%dTJeR z7cJ8;xXu1#aUPGVY=+b>(|)zW?ikb=Vjn+#oL`@-9|JOjK!iv;1|h@8W{qCRIZ@n4 zs#J*=PIRkFzdGV1hlUb_ksnAQcZ^x`GEg0}OG~Q2dn-YHqNWp2g8%b+iE(1QJuAb~ z7$|yqS|6nqnNI*IcDlIL2{O4N?@S7&f)4z}uIa#tc zd3VINf+iLuVZU-k8hk2~>eQ7)pqSX8*$aQXK|Ue#t~_}l^sOVq*}|G#`-i*oZ8|sB zmI@Ji_x7DT#|@KiVzge{9Q@k@XqL64NMWso7;(OHN&IY-sa!VgYi{YqOm8P5=S5PO z|8zZG{H-o@b!HbwXQ6afbOdSj`6!FUIgDS$634VXRCo#vAH}qdi2_hPRXNLXt(S6W z=6pSTg~4SU3y8nl`slRoe^aF@sKc|Je|Ub?s^#UVLfqSXhZ+TyKX`mF61;h5$*53O zPR>o^>|t}ONZ?^SnWncBwX3Tuk5!*&C9mh%L))~4qfh$gvZT=9!jCNGsFprwFYO`6 zVrf%u(?y%Cljr_Uy~iSwd?(>ZJ`zzyFBA$&yMU7_6**e}*AmZlw>FhIjI!@X?zTgS z#_yHW{j!h0MPSpB5+2%%3s7>|L2)t01jfTe7#=ox{^A82B!kh;-1Mvo0fb^RcT9k(gGENXPv6YQdmkG2|`lMkHw|p23>3bVLBd%?kk;$ zyB2tiBDjv$5T@?xHuUUkkd3;TR9Whz1+mU#FpE1FnyGELq(<(Fs0L4gJv<}zxY5#2 zrDNydsTc{Koz85Zy;!G-&{p}}>e_N|_|k7d=v8vUZ5n=NLfI?dj25US;x4GaO~k#v zl(tyiF4Bv}biHwSjnd10&+4$y+yu9P{bJa*&M*>x zqmvGTbuaFmo&SA=D_Jk<&Fb{8BZl7AkOj}z))5B$^4D{U>%d@H`WrCqyb9EEBzk7LK6yc^iX$0}<@*oZo> z*oH{Zx#xfA-B9W0p6Zg>6Kk9xgh+|l6QjHuUYiAj3346M-`U-l@ICnX)^y8}fD3+! z`f~1vG=rM;wRVWSAaJ7 zC1$?Vzf7rekO>mHTqx|ZZgWOoi{;m;6SX=@(SnPwzbrmWsw|>Uvw@@cFDny;{!a%C zf`}sY%t;!Wuz#BUjAB`>qvZDVk?8&{li8-gV2;ZXV@zEy;+eyf&GU1dJx12T*Os)} zZeTE7InbnH7ZmJ5)D=S6(K7Rv7ORGL_x=@)>i2kLD9Kb7bh3}Xe-+wZ6~P3Ty` zk4=nP7S`R`y?1s0=vYEYYeUw(7Ble_gF^M|7|iRcwl-BjzD*F|vn_jtBL(av0ky1q zP-6&TWEJ=;LP{en4xpjSx+Sg%6r9yxV_rFmm`)$xdq2VS_@;2SpCW3v6GWgXu}&e0gy8eIYP;!UoL(1dfgcDV>L*oH(ga`^a64!N1Yj8-@4GE+Hnv zgcvjBf?#^i*-vBVn65GO$8tq2-!|Q79L+baAGzJU7m*u-`I`kbKZPKeMR1;ZdD>2u zQpmIZQdOdV2qRVl9co$B*ol|5JtmSpe79l`_{rU0wu*O0_PwIR;Y-&Vcf7OG#`9vOtsdYU64-zEP?E@9C+Tb8!b~d4gD(ZU6M4N?x?W(`9+qmM&+G=6llRMN@y!XF1a`4(# z-6wVBHrgFV_8@^;d0EWfo2O0I!)Khc8Y9>OQ@qE{5iwKzj=EqODsv;XcEYnos6^uyoa zyL&AKV`aq2@4Ces_&T;9;HiYhcTWR^id5m&WR-ewiaJH41|&*+bgP{wd-Fa=PqA8b z`bO9PaRaZ}%4JeVsbnmzuR`mGR5-P##ag3=E#Fk{XnTw$mnR%S=bLbd_@VjDBXG$zH_V zNYS}lsZ;!J=?-Q^v99lC^Xs1MA5kw(pfcnn@?~`nL%p%{{4;(u@n`g1nSBE0KM?f@ zQM{BBg^$nTC+_3TS>Yd?5EI9zR(h#LHN*tkuAg?2ofyhi1+um||FJR1dG*QW6C~S_ z7lu`yKYNbamVdS5*Q+uLdvTp4@|GH&OJY^Lv7i6vraCS#Fzyg6R3<}BeKvWbG6z5J z6&p<9@)Hyj#_IS@->DyE6?<9|)h@PhDfQYN7W|1+oILKP&A)~YXSVK`isW+s;a3S`-R}g` zqTka8pE%XVOz(pwF_S}x(C1*~;o*_ry{j+tKXV(7nNeq*B^wlC5BV$$l0zrF;W#2r5h~KVHv)Q4of453Ora)19uAuxi4p8lK^mQ|U`4b^Ly9 z<4y)9H#{lQHfyLh@@8%~w5Rljc1sKZOa;D>qwNf)=+Mw9$K-dKMx#jk$=~@-bDY`f zwi~P=Fo`vFq@xG7l@-nsrO7F--Mpbc)%HB`V8;)8ug29lyU4%#*rFU^HgeV)8IbhG zrjW=37CDg#T7%Yc#4nVv-IOp4PKLQQ&-tRhv^b8JSw?P97!-$5y#b|D&+-cO$?rPS zbnJGvk$bp)O^u}^#pqPO2OeV4j>YY!$4Y0lic6ZYjGV?rFv*ZxEqEx|SW0%jUK0y* zEx9$yz5zi`eOqw+CPS|yY3F{>pmF4Ml5S#2RM8R+scl_kC-Yaf1BpKdmJDRVPsp`) zTxjjM-P*AW>*qsm^)1$mIMCV=Kgotb9f`)tz(T~~FI7Y&s%&bc+4MbsA#zm|+<`W}(E1HzqD~U|YJH$cc~g3&g=EGr(|%p-pgpG*WNz$x_{IL^ zNCb6nqEs+v0einTEL>5bJQ44DW-e*t{o)&MUr+{egVfFqCLhhS1=hQ6A>(?v$=zB* zW#5skzOip=tp1LN*?4jWe=j02#$pdTRrq@FyGTj%=$;hbyq*Vp_x}aX&o-^pkf4++ zs=W~2D+N@54f=?KJCC@Gz#>3C$zcf}ktr!iB+TB})xIZ3Y-iVT3z|Q6LL}GM?I17u zktW;G|FHPE=5H@94(Kn-@2MIpxjCtb#BApQ6PR9XK|?B6xm+G1*|A5JGjy~iwt2|F z9$Sxk1BASoC9~3mYixLo}kfP=NXC){!-7z2gI9)$3tV4UG9Y-#Kt#v$z3=n?mx;2`H?5gW6?A_eGEOS zEy56&NH{!rkRJy=F7qa^~eAtG~q-rj1N`5KIyWxMu1UP$Sd zyR~@>%u>juH;XN_@O@9zQcj(gVE=Zc@H~y?o4y>aR|OyF=bRJo`W|y0*$jo^gTMp; z;}`V{yza7aap@m7H1-u?(BsNAgd;=>3t9!sSFUcZAa6$UP)b_DTVay_r@!g`N2CvZ z!b|<_QPaMV$m<%_7mlvLeAd_}ff$J{JE+)#EFto8E@(Z5ZS^bKE^()^f zq2%)mFTc@%ta;)wSDw#ne|lAC(xB= zawhu(+!iWTonwEWtqx_49y`|;FQ7b0JoouV^FmwNKhd)92@2L<ht~y&_aAnLt-eRGE_wqhN^lq|O#z$%XAM8oj60@wU&%HIF%l|c*3`kc z2*}YEZ~bQEC5r!^xIwb zA2BKWxJv-0gLg!Fii&hy8*B|oCM5x5Qz6CiGqC5U)QQ}pmGyLO({bgXG(?=gQE|SS zu8+=iIO!$qYoTLeDEB)u?P_Qf+R`Kz-8yYpZuh6==+1dzM5qz5^3nkGj^=)fHXBSy zg5(If^;j)TCNzy4OgNc&{i_}Fz5(V)8R{o?K3aSVFJ&1T!IKP-jWLDmwZ9!%A=KmN zs~b8PN+3DH<(?;eQPJ_|pu2M?pq86Zu2s4Ke>PTFeXW|8IXotSU=&d*w3IFLI0R4tuyvwCZBLq_CsQ!X9r|LOO*=R8 zCcC*nQPqyvZ&0z-w#3&{8rbiR<*!94HjImbv*OZVSeR<|h{DwU7nQIwCe3f>+B;uf z3~T*?nbY>~c2xdXGWQ#+R=%NIn9%Jtn|MOrNpPa*=|~U`KV$guGDW!gAhRygjRsq) zinj@_L+1WguMGF^NR38dPbSmp-=7O;?Bt+)l&ldtp;aDvr7)H!o47X|5Mbo z74l(n8>XdlQ%WZU_FA#s2|qNdm7ir~5t*dCriyy9|LvV?Gmx^WzRfMI)lh@ol2QcE z9O_VgR6n{siNA#gW{HYbu5m8i{uKHa7cdruXWvtrjLah|(2EFY2uW(qiS3*R2s=uC zoX+a7+66m55$jg5SbZ!^3@JrWA$RXQILZCs8ZsE)onq$@xtn-7R5hWthfkAziL{fF zvD*eF%7$=0ZW}{wW~woflM)Uu$IdZUn8M#P|1$d3V~S{g=lSwm&o_cwxkv>{Bfkaq zN(5XZR(;52D~)UKG{RSuoJ6&G9X(SCLx7#}Rc9}y0EbXb|Gpc{R*#(WLsorHR;B>L zI7%WkMy%VAx+YmT#!YKGLRg`>)c?&P9YHl=%02BAd%MWpj)+PJA4SIwxP+qRMIV~6 z7=wS>JoXdTTzjVxVv!_xW)>oY;JzhUBxoq`@2CjN^ypP;Dgc{7fxXk0p(;(X8K?`- za`WBhyY|DSqSxla9)@G%W3WbVu||d1c$agX&DSWY+>}Q=lq(XG;&2UPoWS4iq73OP zYFyo0gjvICs6VH#r>i<@ziTvV^c35JZa~5aARRYlS(5hR$Sqt2lMvpU)xL%A9h2MT z5iH)^8s|eOJdP+Z=>^A`_;14!3yH1ec2s@a=fTfb6vM!`^?~{&-%k19EvOfEDd{P3 zqP4>#m3*4X?c&HxN{*9k<5Fu!H^G1;6jbAbY~YP8H1yrFM=$cSw@W|IJn=Ykk7Fu7 zTS*MOEWl&cAc|&ULO{Zyrdf#&n~F6TefmO$qquiI*ceJ!3nlDyAPEVI5}#ji(WN1E zsy!LWbo3nf`zmCPHWfua*#@v+G_6Qn0ygq@mDUi}rDe^XP%W9v&U(L5LBHl2exh|t zFyMdH6EpZ-L^GHVKwdx+sN=}fX5orzP8^6;y6Iw0_tQ#rzipY_vEQsWHtTFG^6gHV zi>;gyv0F~_D(Gnf?B;)A8_>g~vQ?Gh3sV>7f#TmAH<>3&>-g@ak`tIC`6yR{Y)gsI zCQl{zGy8-R5e6I>bY^94PbD^BU6AMUA?KhJMI3iphfx7>ltLq- zFYQl!L*Qe!VFB&=>%9j&bTQPg8B&>%|30RVoXRj>NZ zZA-w5v}{hNaD{JUpiZR7B&3o>)bVfC@CTvT`YOoRs&RAijrj`={9ARrlp6lt^|wf} zId@QmA?@h*d&3PE{E~qs1HVsiB56Q_``+jV^Az|nvX8HVM%w_7aZ^}pCB`>WDBb~I z1lej@axeF3r7S`%kNtugov_iVPpE5F;`RzWbl>`_xA+XEB4qO?jt)Zjm2c0 zt~dLdc{EKC*2XZM-}Xz-(3M9M#t7ZwtTHtMOPeA60G~Jfjaw?~a+US;4%>)?@iiI| zi@sGPzNIZNNKF1i`Z($U{Nx_T;;0rEw)NY2;^{OH%3*2IW9TbTjsXz6@NHGvqw=Je z@TL>&QFYdrfV6yg^j7}odGwK;#SiQ(emC2vwXecU8M!ELx*TG&QmpYp6vAy&(r9BVQ8YrEY+sk{oS+qRla8vtRW5~nsBVm9hQ?3W376_3D z<-^O?^9>AobUw955rHQ|W5N*I;abK36k8OPP2F^FtKMKoO171iWk^N}k+4_Qft&1j z;0gaN$QY0Qa|2ZT!R*?c#kN~gfEbjjXkzJGoRQiyJoDijH1ocGwT%J#ej)Es^*XGl z$p+tK_0gpTgqFNu74TA7(8Zei@YySP($4j02=4o}kAt3AW6C|&l9>)ERDl;Nhsl-# zJc3Az&2#?u#h>};I}#cAw-TYl&F&UHk7zI*H*={v6dS#di+&tEo(nt2^9hQHy({}i zeBM|>-eZIbR9)?4Tlt?+S2;S!pd-+U=Uo)dP2ayMH{MJXVHp82*dQ1Iz|!O4>eg!a z%EVjIq%>kc_U?P3+2GtkNAChCmvH>fADdhP#%KwJyu!hG3XR&+?v#}DW< z1^Fn>FJ+YO96AOy?U%?97A5sutnnM6*e~h_A!q&l(l=P38eVKG4>@Fmp875{G13o~ z2QwgMT%bBJDX_PU`j2F^6j!LTI`Xm*5Tqz^V->M;^`Dvw?$rnF`<N$QA7PPBsBKt81GikW=D^RW|{1AY3g&BYoH=7L4?S-ExgXqbvZ1!4UeUmn4u z|NRh|y;l}_y}<^JfJ;PV=&hl|B6S7;dhy7HRqb>kF_BR3a+4v(3b#-^DLi zizlJZ!1R%Ei;y2@p;3m@VRC${8qvsJ=8-R zXa?FG+b|Ffe)xCr?h^#SPapg>szFYH-{2S#i~!99-SjOD7r6<$ZH@Hp+tEnP%C|Yh zBt}oBCS1#}24LfV7lH9$4*}oBcWi3U_PKkW7#tHRZGG};<8Wm8Z7@6d2SN+;`- z%8{@6$3dI$v-5hj|I@pjCe#Pcer&uUm7??68Buixr*gq%a3u_{ET2(64EsEugFDVIKQ^HCGNJ#?`i#g$fcJAxQ|Bb-Ot9Y|RXd#oaAwpa+z zSl`zrZB?T#Hio7H;@=Mo%d-vYkJ+Vlsk;liBVq(XshlXCb`8l_K$)RVriunX;@{8? zN8TERG!EgP@yr?hX0oIz@}4bsP7NBP`q*})=u0p6Fdb}tXQmrd{B+M#{}xgxagroytvX$C`E@LaoWU_{$gs!0UZO{Rv>@`1T${FnE+lE<1^yi|@ouvfS}D zIVGUVw!4PsFuq7!1&D9}GU-aTrYikAEls%q48ec5 z!NKbIkT^}V->a`X9L#{0LCza>!|OKCP7%Mt5VN{>EX6jh5%f&_JCe;o0aEuX!;9#; ze{UC=W$#{(v5Y?WddrSfoy>#TN*5j6ZKhR}ftc;_Az2h!D+r;ndJoX3cR~*-kGzjl z238WpRS5e(tw>^FXKyt>uieq~wLr+vZDxV-IcsD}_UP%Xajf+8Yz-O{#WUsVW?ljKnc4+3Hx0Yh>RC}?S-Ji3sD=1F(^4nw5mVhBEG^s z(B{v42R$EHMN4te*}))JwYXGVK^SlT3_ExpCnCw_T6_FVlZFBwR~^hAiVUvgo)Aqw zee~$({Jo+d`@4P%-R66FnIxyt?eWWfGvfCPLjRbT&0Ax~E1mkZWVfJA{tb@;u6{Sb z9TC5GzLU^L$XFbGr&O))opdG1kG%LKY{^A}K(_xuz1Ys0^q#yZq1E}PF0ym7w^Sqm ziWK{pm>3w_4ne-5@WSS;!%v_psC=&^@(pyDG<(G&?KiAj`o_ks&YL41Dj?GtS>5X- z*Nd}Bl09tUGvkNaZj{OVQ>{o)L0Q$>@tD7}PLXpi@4wy{By7$de}=u3fTesb(!Lcc zoEuxEgYZ{hA0kec)3D=Y^i0)cnGg$i;H8HJM2$u>+I4z2piQz~HZLahC)t1Qwq~u1%Zs5ZQ ze(0QuVBj8-=A0w`~q6~&?vp`~m|jmrBk95(rn zJMM(pyQijfQU}&TQh-N5$YW_C3>*li=Ar<4B>{W>W7=70D0m)ppgM|h|i06fpr zSV|&3IIZKc?OP*@chFl0^-VjY5ufSPuOIsmre}gZTNUP{AOh;d%g=}-sR&jvAfd_C zk#|RGnjC{L%vCr};fQBBKd{iNMwB z76Wr&8En*|nTWy=d1mmGF%S<$4(TYbDDf9C@CdA_9^y>bSiwV``x)9F+fc z<@v(bVmah`NxPH|nXRZzRpixw$e$4XQ&1~CcG=cAQDs6mE;qS|8Tw2}@J<4WlC< zZwK#>5O&~tjE>iK5$7)o;Gy8+^5J5~t+z<1)`L(Di+B2&xA{eQpxmG%I$|NZJN0Is zZ0Y*OTLGo<576F1(8B=IghcufP~m*jKq2}x6>58b(Ewa&+)Hf259lH#%Iv~Si)L_d zBNU|M2W`7SHYm$fQD5wek7ThotA4?XOtK@qFqoP@6CxFSZsHCIxt+i;=_r24lPM29 z918u0N=Z5(l|)lTw?yp{f8G+Y+)^Lg(gv;;mY#M*#ptvG{vR3IL8vU?JAf#}tXD#< zrC8u;izo%vU_WZr7UjbyW9|56Q&D@uqy^l#nxzqHN~-dZZB08~h^mhs9Wk?di$rW> z_AA4MeupzJv$IQWmZ#9TeH!1fr+cUibbYLEb&roV_R9o&dK1F0uftoI{!UnDF2gtK z#waQ>IyvI0`8Tu*mO@L?lbuqMN41qf(`D3lNsVI0oKX$%!W$a&9ItE}bs0xkfpxNd zWLI38vU>17#sT)I*gSgH*;nEunz(-_YXk|pdV;U9mtI1~mXxe!Va+0n;*6Q;0<)zW zopJ1`tp3;%Tjb1b@#2WcxW5?10v8oas|UzMm@U4qnF7Vp5K zAul$Y8L`)PV&xX7T5Yx`8Xditbp~hDwP}ePoJmpSMNYhVZYR8;57?uaoKr~VizYf_ z>+yQN$hiClm&Bq2Jf_bW7Uu4ZQVK0&VX!6vR~D&?X?X{Gw@*$l>JR$ zx|4KTvg8Beng5O&DHJ_RlU{40Q5;fnxJLPlMt_sV)M&Tg5m|U%rfe;=3!;@9^eo<_zLE`D>NQy&pX#7{mes;L&Bhwk2B~HW4JAY05>{6(Qr&aI)&3Tfs>k2 zEun$;Hg#VRr-Y4D!qf@k5|U@LHdqMN%+t%TpycQ zrPk%s`ZqZ#q=Ir&$={i}xkm8XwElagR=?74SI`8?!*?sFnMtAZ4{G=-nT7O8=H?`! zK>vPZff8f#C9Mg-Z> z#}?VKh0CMdDg3{UE2HJu%BNO#=GA}*20i_U9^ z<+I-UISH&|v4o|vlhm$~U0}G3>VnSov1}p5VF&|ia&}@n)=O9)GY>QJu6pFXqSJU; zoA$#QoIEz2AvpUBjg6%q9b#<~kGxJDQONo5$V@pt7_yWEA9Sz~X<#0j$7Sr%jx>Rn zk#AL*1J^HzPyb;=GtD$U zCIO63zx8(i>$lbLNX%C72k2Z;>S?&u8q*1n#~Ob;iXpC%$i3?Lw$VnnW?`QdwGTur zC2WKemU=)6i517{`#yb!PZY@l!P5=kjOiwnjYzhVTHWQ+M&uMba5n%le&dIU_Jo?z3UMJZ&MTRc0KQQ3-1wkuZilj z`X9Zq^<6y)FyQUkY_yg!5e_-8BLtsP^W+_@?|B^94^`j3bF?tMvz^Zw#c;z{NvWLF zmG%p3M}Ivg_z2r2Nj5{0wtE(}zDjCK zK(k_Fh30kl{~pl`ovgPfFB0N$0w?N+z-&d?az$KAFRf#5A!66r-axjXm>%pRbEeVY z2WWFUJbIqE7*n2onndQ(z?b(IdKDY^6U_*lzC#vHOcVLPH;S=-71t<#0_KUtj2Uyp z_>f*3v;ggrIx65Cu7|=K00?ggX)&JTUd|3r@mJ}y@kgY{Fi$sCT7Ah%8ylPAguKy> zql5x=e5`kV&mdOLKpKxDF|)!OC{)zcKE}H-U*+!J{cGqH=C!YlRO5BKnIOs)hS-jF zJbsCxkgQp#&9WMOD;e0aVV$T%?TO1;)E0!K4e6`5x5)f=&w=kYT!MJM#KKQ?bhvl9n&QWUyMSUXOG@%5-2VQ zdz$ixZC3k|j@b6nEx}BxSkqv1MOZI*W8-|VP0XZMco-S|zm4``1%f zNkyC_T5j+j9$aH7CF}qtEYuq-)<4Gto&8l898fKar5uMSz+c zY6XPN+JnEc>lbP!B9;0s&maX=QXc6ckQVYd{!|8Qvv=FoS;Je@kM9%M(HU0 z+wLh?vugY82UU0{6cs~$u3b&RWS`tnJuuN&X*d`&LAg5$Q(ERo!?R4ll2DwAdKc6I zzD&b5sl&H;$z}!wz;QTc#b`b*ji_f29R=4rwCxBIK=PTh*&OgFxKhcQXSlY45s-5P(Q<5O`jPubut(2t=_ufNp9Js6*RgS z1)AVN8<UhJ-`kN0*5xeKi5or!sqElN zgP6j<(F&YV8Q)IWUoE{t`W-pF%PwvJ1ow0rh*Fdb8=glt5CFG%_IT z1d`B-I~u@ZRE?f8UAhzOp1<|o4KPTn5xEb`I_`q6nG*Oq7N%vaVUM0f-B#%3w@N0h zs6AkZB2$D9C}o0WJeYeN2}lah9)Ujo8MM&2;!jEs(cphHg9UaSl!9m5QK(^+uN#`gkop4f32-G3 zw?;EKB!1ST&D=@c{)hR8yZsq%?wLd zuXGzoS4?`wan@PIFbneF3aO9Li+no)oo z+)$gfjrB~x5rf5PCT89O3Jds_f-^9G2l(q0*E{q#+Bs4CKdONrXHUT( zM6XHvl3ak;8-&hCGpr4;tnB_tOeQFSi5wd&D(c&P{gSucJPuBk4SksX9^g^bOJF{7 z!ze7bt0OSAjW2?@vnv2v4!QGo{A+2Txxux$C6MEbJULf60<~n7-FG*amTj*Lu;%G@&|O%kjb;uSV1Tee&;_P{C9|piY17T@LLxND+BMp8 zO7gjh5hOR$8zJy)7}^07_xCCGKR3QdIoR4v)9R3Dl51oa+g&Oiqj0>N)u%d2AVs$^ zrc%*Mq3tUANw7c=$}Y-9P9uy^%BdaxhSPi_0X5)Tz1{txt0F24$~HlIr3wU06XTRtIPH& z9yAs6x|R(s8>~kk2;Y3oIh_M|emwpuo6xM*p1hl$1ZiihO!M9!!L#$yKz?;3)w#jH zv425R5CqExv$qSN?d%E|Z1-K^-Cm~i_?cB#@7|Y;(BkjUE>B&djEb=5ansS9fvGo; zUkS*R4dsvvFsyx?TG|+^88sKtmFJ}jJvQryM;fz27$qqiDnnDiuBMt+$LSEn&Lh7e zvrYev^?NFIiPhp=8MHc7?2h!k|36KyO1@;$i(sBvHvr~}k7#)4@8?K1*2(b4B1 zJvJTmv3`G%9;q1w#eKK{!OXDoaL67Z-@Q|LhY^n8ydeU;4XXo(=Wj6d`J>e7h*815 z(2wLXHs9Q5+Mrl5x(Hd9Ypm2hUu_@SP&%I326)(JppLGCj+ds4{kD4MY7R9n-Y-a9 zs004&8wLr)4dt9j-w4>weF+^(8mJw+G`s0eJ<5gDoTO_v688Fz&5h-`=R;mOSaUvrQ`?2M^#_wCcZ3Eef#cgB&+|v}%!LSMIC-*e+oYccVi22_v z$bbnRfCZ)jfJ8`Z0Af~UM|oq~70rV#2WVGzck+T#lCg-F72sCFI4M=%7$b-| zM>Uv7ig+J64M58EfYl1yJ?8<^x?J5OOP9fl{2M|Lqvo=4;Yd1jjsEiPe+|8NW9)^1 z1M0ZHiT^UOQx^cJIq58^RIk~dN)FZ_cuG!i0c;s?tI~(D_ki-m-h#zw0rBld`Au&g zK?!Ouo8!$t>j*CE=xmA$X>xa4_XPe_7j48qD&)Y%kQ-B9UyGdI$21VV!Gg2R0s!04;3)b}Fy>RNla;_ALo^|Nc{XgQxPEPvzC0(rmhY z5wvUHQe2Cnu=W~^J4dyjSd|`u4Zd3Mp3DKh#DBPT*(1k*`~TmLtgfA?YTH&XpC(P@NKMD>jr4kPo6UcnT3F(3KKmb83F>$0IoAa-1HsT9GVejSJ<^}N-XD? zWI>0T6hDG^jE(6aU8EVbutObx^dE$&NAwI{vaYnCTEHF}$9MiS+Y;=q#vpy81qsp2 zv&Rc6H=MU>VVs)__MDb^C7{Y|DykGsRHACBT{oDXBcUEchYvu+vFAbcVx1{LqKMzJ z$G?d-M;kVG9%R31IMuGuwx_FCM_{g!BmFU{!1qjFcUVV*zQLRXyA5wT2?c79Wln?o z7&yK&vKg@U1t^Sx6s0Zu-S51%d0(pXhi7M_j;6y&-#)-2yfw3zl;dgZ*Yq3hXXqeZ zSS7?->ZsflDW+MS1*%ruW$zX*Qu(*W{S8oFLYG>vwQ}qQ`mcX!qoFpyM!I3DeAZN1 z)Mn;&rnIPWn+Licq@xi*4%+dt-3m=0_*`AQSN6f;1V#x|GeVsY_IE4$!zefXM55=c z8S;b!z_=dznF8qL+-Z(s++*n=Gp6v-pF+4;rFdt2O$3gX#gz7x>28!rgz#uR9VieR z^H#Ex#k5|5Hq1r1M+sb%M;-iGx0N8%%dUa+Fl-+PqCg%AAh%`qISh;))NO~i>FOc~ z-IGK$G$hfL3cV<+43b-tKuWMcib|uos#5R0S9%vgnehveb0y&08u^9faw6dUcI3&y z%MZ(N4iNGv+Idko+@Dd%Gcr`B%Qe%t7tme330b7uS)_n0(w+xwEH*?|mPNN0q=F(+ z!5dORF3Ig<-vb~&{R#jiQyCI80(2}*fN#NL!KDD=0os=^XI(dlF^PZTR2&h2NR8Z^ z&q+EkAJlNtIsIn!5##}7fXc(N!7}t)>1h8uP*sB>Nz^0^+yD&M0v643dZ#>Z7OH@~{Txf?iF6bK7T1}^B2ca?{Z~~HPR?W)gLDf9y0w}!qc@=tt5?~3=&AQ|G zbL8}f1tOQ8Y;H72a2I9o$-3^kzYd{&(Qxd|H29Fsc4-N_?=thdf0!Y%+*F-gHvu#Z zJkJrcS%izTzJM@HQ?=)Cw%A>ewbuR*F#jjdRW|o@u`K}>Mgl1{AeA4S&1w(5 z4#`g|alLd7MrEcPG5AF4J zUH@zq&~eBKT>0}?_6nXCSBFXv&NMa(i5g;Wb(Z0rupdFOytaG(e)Cx`Vc#64+B@H6Orl$DN+ldY&M8iCcnt@0L+B*HF=bHFreD zU2S%$xHHL%9wN&8CqW66v&+vcXFieELFH9M>W7o5mPV`3@0uw6V*g}tEG~i9CqP3$ z>mA4~&T!KeDVLhF18glQ*kHx}2xcGvjnX$92DB%e6}@1{4y>leLDN^TXv}$wkhG!4 zkm3f6$pC5(>WA-Mm4(4=kP(gx9qCi1k^RL5lHp-YU!6zJYVmaw_4^OkbYVZJ?=TVO zQ!f3Ib9xkf;Q}%wOWA>4FmWl>L;}!jfnJEB3iDr6Ky(0z&Z+*J6~I>siWUAWr~DVX7$DZCKFFN&PzqA@G z{Q}lP4YCtpHITW-75}D}{mH59j|A>Y2FQhkz$85Eu(iJ-Gy=1j4KPF05EMT(QdT%l zEOy|km$Nea@*1ASwa~}-LlB3IF1w#QG53}lDQBbVO#2>q7VE!qL6$op&cNJEtc?p` zZUK7Ww<($O>>%}%h~)oClC0t_KI(cMW~~E?XD5ik!m$`anu(m$RmGSPTOj^fiNL9? znxV?4fuM7b0;J)>Y=5Li1K^vrpTEu4nsl2@8&sNr*<951yoA{KFACvo!7@OqJtWn_ z?j1GHvxI2932ys$w)9jDyU^unZvoCqu*bcpz@VV{kqn4>fK^|bVjG+2xzk8Z4W_3W zkPE;1WGbydc+so0w~srl7zTK0eh_Usv$@|Ezk{_#4ym7{p4%^oVyjXCcSdSKUSEdV z#0`oDDF{AbkA|}qIg<>w(B?btK2>@SkO!=)J4!2;5&kqtm-J@@C$mZf zm=V^WOAf+vPJ!f0v!F4c^$Oig#+$-)bDF)h|G_)|$!pwk0;M^68?BRoEK}l`=a5OD z35OI?1?YoYVQdUC(cmFd_(a_Z8IVwy!z*9-^UHH-tuX&ExO2G1q}6K~se#hTz~-`^ zY9%5I6?TKFqq6|y#s#oen485`v;kSCG^pZM`Vbwk-}+6K$^V4$xTtDQ0e3Fxd?%>W z1j$b$^oQXUB%50sAszKh>{K>L>$L*RRB8{qsZKL$5~Ro2G(8f5S^WS2g5C<&Y!NCk z5NvhbB4&a@7t~PUpIk>vFi2=Ws51I00@5xLfvN-L;TJ+fqDVS+=A_r8E?9YtMuS>7 zDcukNF2Les0Qt>e3HVF7FLl|TjVtAdxBh5)*S*)-6I)N=&FmYkf+;lk3M zJV3OrHPqNhck%o0B!Ud_OH|Z|MnRxNXC@=JxIUvPOBALHA^PU(#Q*O0xVHd@@rHh@sYP!HofubxM2$QQ}m7R+%2^}_hCgFef;mof$_x0J(-q{}h z4vnTxR$Nwha78M4%l zwJol)*No=&v2|~eu7EhN5p#-m(CFy@EV1$W_^x5xpAs8J58@3f`ZnU=Dd)Rg@-u<7 z^OJom{8Gyy4kyl<)e}BLyZi6z8R%3CF?44N8EaQ<(>zoPZ*s-S|MNbuVcfz~CB{>x z+)5NvqA$n978^(mWOeCuGuss3ERl8j(BPy~)) zYomol{oARn=Hu8g^L675_tup=>j|A}6?=<{8+PWhjNTQ1(nmo%?qBzS2q7BrcYya{ zN91+So4Ga~EzQHpDEgJ*%GbXXthueeMzEYRoy9Gc6HfjRQUKPzf*o)amfAx3xriqE zzMDU5HcdGI$5ahvbBqqy)!;ry16PPza^}qZ|Jmm$M?H*K0?C?j0_G7(hQL~2umZXq zlAvMLm_INOw#E_=T_Lpq*4qAu3dVs4?`8Vma^*xPW^}rG8-Wupz%OPL2{dGweikV8 z;H!;bvIsoFxYyvgfWIBRLFP-Q`H-0AL_U7G^$WX` zr#!fIZh|@-B0nA-i>|~}fS@nbnKU$Yh;@&Rn%XvSx4W8u{Y3oRchi990DJieYw=&4 z^VM)@@iwrb&q8RQSTp3-sS4UE+p-AO7f^K2^0-MiXa5s67ivx|UL&&ZKskYE1Gec~VDv(Cl37Ac+ zGVX@q@$m#e*@Km+Jc7YBH`S!*VBJ_R5MAy{%>zSG(~*rWL0*6K$A{1Mb+cyS+}}Vx zBDVYVUH5mh4NeLAjh2v}iCDn0#}UwG_#v#OC+6>|3D_{2&lOn_6&3+1x^xm!FHVjX zhg%Dj1LqW~762C^w}Z!Pn4UVFZvpE-z*8*!%wZMC7B{E!n{Q$3H-)|XY_}Y$cMw~E zFY@4E;uq9kX8Yicd!b_KaeFBMV-FV=7-7s!N%hH5Yr4D zTug&{M`N$)E7*egV@w*T-R45snWBR#Ts8v-ki!cy zQhFefO=}8IEcOQu@*n$lcm!C1TJ3Yu+`V!(^+K8;lX@6b;G6fK8F2T}(jKf?nBzZK z?tU=t1;_4l&n~>X`%_6h@Gq298JP^X6_ieY`7nd7x7A`Fjt7$b4rF`Hcx@%3VhdxFd7kdMVGnPr4Yo z9s-#m%CbmD$}?-8&)1u$Grh(slf|Mfzu_oQ5j=)>PS{7kquUU*{I+?$F##B+M|WL< zH6@?EKar}M*4JS#;WY6y#U&8EieLthQyMIoy z#ILY|^GSHG^+_Xo(6nUb%s`T{kk_R0kJCf1L04hB7@+3({P%kk`pFb7v2>5^AJP4G zxepQ__{al%pL~>^C1+&j`P3Hg+*IpRdAJKSviltOg046Yqe^Zq$MxtAv2Pn6Ead!| z`1vF&juCBc%_Amg=hZjC zouVOId2EbWt5rN&Z=6n2*)K|6zD4RbJ&(z|A2RrT<(XI4Wcmj409g|FbG6t_f!`uY zHHUA@-_C3&+*$wqcT2^2&=f};vQ=aEY*w?ha|*rFuyT5 z8^86S`{GiqeCQe?vo0?dV8R1UrMtvJzL)aU`xzMr-OqLhB|iRsI;Q}J6Mpy=ds>dW zFELfdTYtH}Q?sQ+3TaT58Cj69JyJ!(*L{nYZw6DYD5~&?EW=$hJ15kxG-IL>RL|>D zGcB3#Lw2Ta+CD_y#TxJ?q=SnKBbkScDkwLVdRl*FEz0{#p*SxtgEaC!JN4M zEQ#&+!s|vC+||KR6iM!5sJn6{qjgcTSsMeE`|Hrf0&eiB0>(rtq9Cm$Glg&W2R>!4GKuQin%o{!%Mv#+;<@ z@^}cp2ysJLB>nr}@Z;e}_(`y9l#MS#HuIaGGBnBpdyV_M+(9v7niu!kfW(xoPwn^b zTykv}$?Ck~N*w5fnq^pBS?d)%;w9shjE(%+b+7JjM80H^$(4CN{LRA*k|1V_f3Zn@ zU%HMQ&?9PB9qu>Hi0fAWV$^*8k~M#n%!)iT=7l_U?d|UwWx8k?g&98k)TrJ{l+Yqv z=&_@WfjZy75>1g$$Yjo}6-YR4VxjQR6f;+YfIHT9WuYLn6CcF+-gaMP6e64Vqv4+nD0>FrKKV_dU?J)OYiBr6me7lfWBl$rDGNk)I zX4gtdtKW^cd|QXKQ|_JKDqXI`J1~MH!h&pI?Stq3Qdw>%dM8uQ%S-bI?n-?^7V3pOGUV{MYZ#4zRM+m$O@~BE+AWte z`WoQpN3Z{?9&7Itt0dZF7$@}&7OS*(t03o*BaymJw^C22PIVPJbjAi_gcG+83^-LI zQieUCbw%}4-r~oV*j7!9XyXEuEsh7&hfwgL6?gk?Am_`rQx+m=BOJ&I{lybo_+er- zI%oZ4r*5Iuz|vsKDzafO6cCve{FE+~+F@bNu5wrCx~lOi0USeQ?Q8c2j`OEL*>J=6 zQmz%}P1wgyA)E5|d#FksAKi%;Pd6~{PplhK?)t#;%*rz8Jt9Mf1hYrD^$&B;Gl2No zM>~g``$@J_*X9OXo8jHDSAA~`q`0;B4OI|N_LjYS9xXKno30H|WV)12zwYyn$23Q4 z)oMV*bw&%3+jIMnlX6(Xk5W{kJeerYLbf#9c)gx*VP_P1vKo#yp!{TpRdNbNJSp{S z4%-|u+FMjDw@Y4?O&f>->0bNp;MuGCdsvPv!3C7P{fn{HyRahFCc`kPLTCfppU9bh zTK<761+Qly)OXK3rg3_Nfi35uc|uIjL7|QC&{tsP-LHaUtRLz?yxqrSWgGPo5gvG| zEg0(!6foXR+L=Wiw{A* z!)J}V4DBcpTz;K+VYRrsMw=Nr?k3As^2$|mBwAwpJO|K(K0`A*cbWz*Q|z7>Ob!?f zX?OP;A=+F)yW*`+bemn^KH*dEQki6uOUZ*op_djuHQ-V_ASqC>hoA{KtT(&d6|ASZ zK;}hlfX-(A4ZE7ci17BrJ|-?{(LrQyF@Yh0U1>6}H1IbbE{&zCTJJ1uMLV|tH6B_w zCkaeb+3yFU9z-X9;Js;j;%yHNdJifclzdlIP$G*+$u-TOT^196yhKj`MO@8*U|&q5rzfA<(4Z>NTej+lC--j=XSyIRwf zh$>@{PUF(3<9|AwP&T-b{tT}zlvjqce=XdHxd4v)r&!E7xn@Ue4qx7x|3K5XcTUqG z04n{)wo+pU*p30cz4mBpFzHun1oblU08)Z!j*A5J*uA)l2;olg!mh?yfjnP7v0cD5?Ia&6~dbbD06YOc~$=R+xgz&n&RZiMZUu zn!weY*!e*DP*dO47G%55@LmqI!i~ko%*B@eEq;<5>n&Jh_XcCH<>(oO$xg&%r(v=^ z9DiF>B3+1kY`*IaamaKs32h(cW$*spY#ITK5kyzwGwh2?)_*kfYvsA9xJLJ*&qoC# zM~kC|Hs%4`d7VCI$DnMlQEuOYEg@*JuLIjS4F4NZ)0_{2{-%WY$*4bPW)=3>z6XtI z#A<^&d=$~)VN0JP=^1vc%iP#|h^rfAIfKhy8_+Ti8>b!TCE&$cI<|smyBAHa<*c0O zn;Kqtg3NvF64Y?A*%Pttm;{+r(b2xN8?ChZZry@LM&s7V(aBYD(aPU$pOx_RQdC`xDsrYjAId_d=x`#xpIQYhd@auyvGOCc7eP zwX;n!ih^9;aEnaw_fVr?5^}I4;<%7Np|PcuH;!qzH`(~k>S#NCF4^sM5MFlF){*$ z7KRh(|dN;XeJ%1?G+1XkkC4kLn3A~<4d>qkR zk%;$oE)a9aR3}7zOP6A^Rk0l1;ffn9S>R=?)BW2W9_JU|2oFy9`nGgajB*O&*TxQ# zPPN~NIb!<@k)#Ghj*pq{eB7dl5@TlH`aWm=D%wHu)|rZwC`1;A(Y>uEmL23*)xW6{k%-aS(Y@wr^lXTDuaV@S)42kZstxlbpv3%bf4f& z_?BB5nZA8{*;gKXtJXE~vZBB3FL^i=r-0E8e>Z>9=^?ox_Vqzzu@1>WJK$-Yk-S@a zU%q{b=Xw(~+$)&pBewmTh7i>P#izKpnv=h4F-j)q*o?eo-3n*MqBAQj!wAm^T=m1q zqI~{}|62$aU$s7xlkUkvp4_otlYyrc*5@!C{|oQVL^?HSiQlD9f4o zQ0FE=HF*G88>YzZA}u--o3xF=a@AlS;V#Of%w@8R_A-yo2A!pza`wFeJ}$ z@kS@Rw#gncoz{#XX}J@dvt$@U))F>RA8G{+Iqv#lI=Xy&hhI2%O95aoa&*R4@3!;S zr&3M)ezAfbVMs_fmb*o59V8a(E!{OOD|6o!US#)lDEyAuC! zHp^ewLH(^r>oTpIs(!x+Aqf(*aNJdM$e|eAT53>b7Ip}uR2b?8`QOdDFLt=S6mPef)pbNaQ^$$8RGTQT1r{sVK;#Z`QviqBkqK_#aMPpF{m|v) znXSHBUhqSNuE-f%Q936n)iHf`JgAP0tXJ;!U=0!B#R>d++MGPM(T9Bd1lLm7yMzBm zK`f?X6bJ+|w4S-zy7OMY!Y^uX$#jZL=iP_ae;2)R&TCe=4BPj)$TzE=KwoRzowplk z_OY=JS8H7n<^hE{2fu_wp!?<#4OlB$8M}7-i!@6LWhXsbo=GY(QrmzsvJzpzr0gX#l#__ zn1!sN1qko=Je@J`D@^g~4dU8NT*`gBfbe5@b*;L1^E%RQoJYj`s5$h91{U0HM$1`53Ks9OO1dfoze$&Pj3oSE@&K!pXNUVO zXhd7|pY>6O zQe2;OSpiF$Tl?LcS>IJ-ZLbO(w4EjWdnP5%fxAf-n7BZb%)3o@2*Bg_C5jGIh0oL~ zP}7qd{N+Rk;2m&lu7v<0!yaH@WhBln`;zU$rE zb!&}}F98^(1%`~EirB+F9~_<-8*k^ru-cc4M>6m9NH7mL<=Ye8Gr{e{pDw^tWBEhugzNCyE^R&?y&dm?9ZCq#tXlEs zaUXeLd(kv=<8odAl*V9B_L+B_eNjKh$N8r^8FQ@Ha;aEf=UgfrH8e$&VDpGCPq18l zJrKRrgbLOZk;`?pp?N&99V3MtK1hvY+%U0cC(-S7u&xv=^8Dd+{acd2Nm?@sOj zxa@LPyC!c&zSi~$JAP!x>+WJjOe&X6>d$hOxydnncp%TQ)b~x#Gb{$; zGmKIS=3amfWK+_?=53`8_zMH%iT8V%YftYMXS zs;hVRBzST@0S1qn#A!tRd~|_64MS|UHheFz_zvho4qfgyg<)P@GwJcJ-jr`S z&zEN1=O}S>bCzvl;Y+=N-O!#Tl@`U7bWjpkM0zs;(p+&K1VU^fK8`)Gy!bMKWI1(? zx4%s7kSPDRi6=3fXn4D7cFQF5kxJ5ZCiUYr!J(xQS6bMtZei+zf*o4mN6=$2w*o_p zF0hXVs;nc?`4A~%P?0#QKNa{(_sSUnryL7`x8$)OEw7mLrh? zUjB<4(YbDcsC2LrCGUIbN=oWGt&NL|>rZmciGx6Uks1`d11A7>+6{(EX=j)2{K3uy zRnYqQ7(b4{U7eBUJu_>~*sa*DTWXw48~H01*w!>JY{zM%+KJ2do!}<|bH`>iyA!U@ zcI4{v*9d8}6O%QG|` zi()|zmExxpst&L_xUZ4T0j;^$#B;v`)ASdtGYqqGf$;@m6tAa!_#QYf96w;vvt<;zGq9RwOiudU=oU9}R2^HaZW zOE88Vn$Ubae*;UgosR1tq_AnpYgWdVHP{Y0v zLc?)GYv$Yaf$jPIdOl?#d?wkG1En^77ZVf`e11qWV=u3GF!^=oZS><@%ElKK0?CF< zZfl!i$2L{|;@|=3;jmH>L;K|bJH9=3X6AbsPVLheZ)kS{&eoW1Uj}&j_?m~&V%^2{ zHA*Ils4oJ*V6#UyF2Nb#Rm2%XJMZ9IsD8UkmA3H4HhgADfaOh`B{8$^%PD7S8lx4x z8pXRW6m9FGotvc?+a?&%2b+u0pO)!x`VwS~89Wn!L)~Wk@yR{A#-tA(JZRmMn>=@l z=G<+^t3a!WAC-B?CM56oiZ|A2u$ZkkZ)JqHT-bff5g9S3(DhtN~wGUfH< z9a6XRu@f(Z|Az#FW^kVgARnQ*_;+)$QY^-)x%lFfJ~?r++}@}-jJ@OhLP>M+xZeq2 zB%7%zp5zaA1TCET?-ncqRKP6=6tBY6kB7(k9_$|B|IcXzJq%YOzG5v`8)iZ9;7Nf; z^AZ2isNnN?NvMBloF6Y1d*Gi2y_H?7`;RUGA1EAyo-56ep!1){U;o$RVcbZ-PTHup zx&dYQ_g~Hx)7#nd>kDDUYn$LPtS~h?YSoi_sMG@(aOWm+AL7Fg$xhV&cQ4`MWFL$9 z3!rvQ3Kgb~5c|9?BWgd}l;zQ7+1#D=H-n??bF z2mk!S!H7(g`WsdYS(85>{Xcx@J^)WnmkH#VpzP-3_Q?Lt#cP!?ca-Mb5kM=`gS4`& zDv*Pt11WAi9WKp`;<`z1rxkEd>>Qh`H;(M$$bH-63<^~UvivXKf7|nGDc|(1{GV9? zk@)W^kF7lD%>=&W3kBprfM#-GwTb`HtwMKkbu31Y6?#w9KL?bG%aONwQ-2N1Ff;%G zq5|`RPmQAZo-Y-PGza|6SDxW#1o9kwEOs3gZ_L8sc?I(vnrw;qtp>2FMl=~*9kjY>%` zXbS#vEm|+15RB7D_nx)F6XKhTU5%gYI$&e&Mk1WY4Z1XUF2wDZHM^4c3s)~m)_JRU z3~hp@eBLpjF+3n7gbs+s$TwaNB~;_KYs6Or$d)vpWASva8TixFFtha39t%`7$}si` zbC+q(J;w)!FQsGb^MP*A`X=svDY>ASWTAf^9TST&h{aswREg~90bvucjjJySdnzzA zFD^G1C&XfS9ye4ftm|m(txTtRDtXcoRTO>EqrtZ_|F5w0#;iob5uDscGw>k7n1pz^ zC#}&rN;u4{nRS3L*D6yxw?Z#lZpBT*H{c86v3TtWmjD94l>DxvyB^>CNW|sKw{0|w zgYDw$IE352%+-oHLi4%?t#4^=g72Xjx=(ZKDFwHp$b8~VqE|kiQIY6m&zqu0+qcFD z;ybk;8?!zTPUE(J#%}buv(b#Sh`WCk*EP|&jSg;nbw6X5*<1Y9^)@zgzivey5RIl- z3>^sm317Y1xsS&1#VIr$s(d=O^hTRHnm)DbY9UiQs8hp`YpmXOM^z69MH@qGi{&!{ zP}_yR1tBIJIPI1FPPMw_vy`PXYqb|LvL%{eTdQ84cux&f!JwEoqBn`We0yilpl zO(^qpze_p6HJub%7pW!w3NxFJAK z#)v)eO<98-ZSxqzf^JhI_xt$2rn!avh5L%v%ik@N8%v3enG!z%%zDLoboA-9xc3iG zDlX0CWU=Ge15OEqgP-o`8laYyi0{Q~wC?{oR`A=-QxGKi^QTH2QImgu`@d93*u#QC zC(Ag^+P075R`91cZesBRr+iHOMe=AX78P*#<%8xDX66sU{($zwBoKW~6Lz~XD+n*e zRK~a(cTr3*Zxa`PD7%6ZyU}V9fAj>W9V|Aa8J`D7q_79M0cdI^j8Ia{;DKn=Dl;lQ zgJ8lbH6vE<5R0(@B~*&MO7TV%A(-xu?V!#Ed)T>IZ@x<~e5G5^DgpnovcI{JR>A9P zkwlkxVY@{* zX}SnMBa%nom__!SF2v!b?96!@r?L3BD|zfqwjuZdd-K-G@A7m)-d&9qf_XR1-Rc`x zVtV!o8CaV8i{>?Gc-ptwC@K{AX5q!rg#osM%x%(>qM|*E$8l^*^0Qw*tvWoxZ#^)V ze=;|IRj8DYwPhz~+Fa*b0L~2FwdkYYuC7udIGC zkDN0UkHZWp>N6UacQ&5-0fZ1@sy+Y-1pB=4R*xN>gQn#b9g6}|Kh-p?gC2;*RHl3k zE#;KrPnXSo{@_WWi~{om^SD?{pGHqj94NC^A2ax}TS^fsRn#DfD^H zfr!svI-e9)n2V~k*)SU1?xL zd!izufU4~}?Genc=q2B_h0CV1FO@8sQcLwrek~{2os2NG(o}{!F1T-R9z3LQ}k;rVuA;tFKYo zt(mA|ZECJg>ob8aA7*oI_6>hMx|c*dcu`T`kFA9ztE#e;2yz5^FQpd|q;b)E7gfaa zBxuVV=uk~j!n$pKdk1SaI3sW!H`<0!QqCc!e#dhAyo~drzj)9O74WFUo&$4fW z*DDpQXJR+b>6J3$jx+q!yRg?QwMn5XC4=BfyQCm_K0OL!Z=EZ;7p0>4?$SkcdmLsU zoOC){cH|b${!T?`m|H83S&|${n7`Y`uEj1%)=!yVySpXYVM@X*PtzVL_6SCall{c{ z6Yv9Ye#4X5NVTq;;`YToL;f-`q}xqI)&-LwoIVDIA6&r}8y>^^nkn~P)Gd>+B| z$YsO;s07%zBk#uogn@(Mn=0Fqf$~=zDPEl_e9xMol74{cj80AzA>naM$-YBp-t!$9 zWbbm=8$aaK9EVO1n?V2k_GAlpvJF)yzFJN&KyflQuqoE`JMAbMD;%1&0WaU7>*<)d zws>J^$YrnBc|{E=^cO&ZU`BggEAovZNb-$crCrM4Ib}HL7~e8*KHdG-2xlDTB`*Fz zk4rK^7qtA?PK^6o!yVcsYnwM+yPhQIwW)UwAc(TOlm>@XEWgLncUd;)tP(q6*&A>w(dE&%>EFN0(!?jL4tfIK1s!L zSL*$?$M}d&hX7no9Hx%Up=5u*)_K${w4A*x6qjGyI4hjjM*g0l`o27dDW#WtT(r)_ zJ1w}m_=(lEZPQxkms$qN;h5R9-I$6vt#`HJw>1psN64|5Nl!bnhM?JRpCBufloc$v zymv1qqTAHBbe2@=X2Zsp${f%eO_^0?$nHBIpk8yieJP8!Cs=X~rOiB(ntAh8euIHz zS8dvA+`IFk8wKoE5%ZNmJn-NjOkS09t846Lvo_I}M2mLoZo8aWjRmG1N(yJYsEEEP zWD4GY6>xdS8EmG1NKN=)=pMcqbZyJ3?}oTpv1|qrE{B=qKmC5hh_$wcjekDda9hJF zJofB_thnRO!@ za-zE@3)yUKd!?D{LN>&zupr!0F~(ju_kz&lRRP@g+pm6sm#*AOLW!e=gu+}6 zYMqt$#j{J?dg%4cTsZ<`A434As^Q6;W?NDIs?u~=Kb~DX>(|pVvH`_ z?|om2!^+ojW5B%Y_l=OzSjnUzV+`?(AlXQt`T1r4NnXH70f{?Q18Mk6WmDGuU%}=~ z7bk+JPqeo&l`1E2dnzHJ|osS&W+g?9orlPBp9JW)-;KNRUI&l=Lc} z`?#eNeD$^;KY4s>*!K-#?NGn2&LQ3u-uXzlNV0)~zZw+5KY(?<2&(hU3kk7YoYX{H zphUFp8Rvffxi{r}t@#P2*nn2f$~emmZf#Khdmh)owc~ z)WZ4YVb!+LB?XCj@S5Zci_u^5}SQXz7`me5q9 z>_~bUfze!4r;SWo_Iv^Sprt-CDKg_9_3MpzqS4ir$C`_a-_uKwb?`lE=$%L{#kQ+L zHom(SpEtc(Y8iG`LbE?~l<7HZb+?_^T>OdwDL83%_8)N;-0O8IIMT&pKC<5jU6@j^ zhuqI&ZcfW!`Adm%ri^nnm=N-*xC^Hg-I5heC~d3VC?^2lue9AVT)(-~TonE2hpzZu z+S~8HqD!`}x%cTl`du~qMoae5AZCxIrI?Y%(4k9m51EBZ)!VSc6n!*(a@&$P+74V> zgCHesYg(*SnK)ZB{ zh1V(w*x9UV?^eHo`5b93Hfi}7s*dARzxVTtHtmw4B-iA{y@5_!s80H3kx1M=oW0h) z@3qOe6|@BB}8uUOWw91KIk^`!^L}_)_+%P+laCX|FE3d$ZI8?_uZQ;eO8{C2pQc zZF2uW{Q0euLP0w3PU&m6F_8Ot{Z2r=pm0zMVo?C2=lWi{Fga{(A{4ZYzqnV5@e+Yk z(W~Eq0e+Z{@OuGrZpP1ZW%HpQ+J8BAJnLRgzWn1%Q(zFUHv+tjhQsv_;B$=UyQH0h z<8t=!8GG^Ts^A^itU5=yVF^Q;H7TlGU|&qcde?|sG#76+7qk14U!%zVYxh!qG#5(& zzZ3jXV5Pc1@ZSJenTTDCgU?g{)V@YCDgOLMKnPubehH(cc7Xi)Ck^7yN9hQ8?|*$L baA!YVscEomum4f_Ir{dUTiG}6J^udye#Wy2 literal 0 HcmV?d00001 diff --git a/python/examples/images/gaussian_10.png b/python/examples/images/gaussian_10.png new file mode 100644 index 0000000000000000000000000000000000000000..28b793779042773ce57a5c983c83a4caabd77f35 GIT binary patch literal 43842 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 Vf8X|7p1%o_^>p=fS?83{1ORo6{MG;f literal 0 HcmV?d00001 From d91dd034aa548291e6016b4edbb9f7ce4b13bf40 Mon Sep 17 00:00:00 2001 From: uidk3112 Date: Sun, 27 Nov 2022 14:55:25 +0100 Subject: [PATCH 02/60] implement python for unscented transform --- ...ntroduction_Unscented_Transformation.ipynb | 1083 +++++++++++++++++ .../1.png | Bin 0 -> 84080 bytes .../2.png | Bin 0 -> 78745 bytes .../3.png | Bin 0 -> 69044 bytes .../4.png | Bin 0 -> 69582 bytes .../5.png | Bin 0 -> 41676 bytes .../6.png | Bin 0 -> 86533 bytes .../7.png | Bin 0 -> 77188 bytes .../8.png | Bin 0 -> 80930 bytes .../9.png | Bin 0 -> 61029 bytes 10 files changed, 1083 insertions(+) create mode 100644 python/examples/Introduction_Unscented_Transformation.ipynb create mode 100644 python/examples/images/posts/unscented_transformation_with_python/1.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/2.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/3.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/4.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/5.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/6.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/7.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/8.png create mode 100644 python/examples/images/posts/unscented_transformation_with_python/9.png diff --git a/python/examples/Introduction_Unscented_Transformation.ipynb b/python/examples/Introduction_Unscented_Transformation.ipynb new file mode 100644 index 0000000..6f4e92b --- /dev/null +++ b/python/examples/Introduction_Unscented_Transformation.ipynb @@ -0,0 +1,1083 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d85504e0", + "metadata": {}, + "source": [ + "# Introduction" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0d5d33d9", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.stats as stats\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1c89438a", + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " '''\n", + " Non-linear function\n", + " '''\n", + " return x**2\n", + "\n", + "\n", + "def f_prime(x):\n", + " '''\n", + " Partial derivative of function f\n", + " '''\n", + " return 2 * x\n", + "\n", + "\n", + "def f_taylor_order_1(x, x_mean, z_mean):\n", + " '''\n", + " First order Taylore expansion of function f(x)\n", + " '''\n", + " return (f_prime(x) * x_mean) - z_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ab4f9a93", + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian_pdf(x, mu, var):\n", + " '''\n", + " probability density function of gaussian distribution\n", + " \n", + " x : point of interest\n", + " mu : mean of the distribution\n", + " var : variance of the distribution\n", + " '''\n", + " return (1. / np.sqrt(2. * np.pi * var)) * np.exp(-0.5 * (x - mu)**2 / var)\n", + "\n", + "\n", + "def generate_normal_samples(mu, var, sigma_num=3, num=300):\n", + " '''\n", + " generate normally distributed 1D [samples, pdfs] such that the mean value\n", + " is included as well in the middle index of the array.\n", + " '''\n", + " sigma = np.sqrt(var)\n", + " sigma_3 = sigma_num * sigma\n", + " x = np.linspace(mu - sigma_3, mu + sigma_3, num)\n", + " middle_idx = int(num / 2)\n", + " x = np.insert(x, middle_idx, mu) # add the mean value to the samples in the correct order of points (middle)\n", + " p = gaussian_pdf(x, mu, var)\n", + " return x, p" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "258ee36f", + "metadata": {}, + "outputs": [], + "source": [ + "def create_plot():\n", + " '''\n", + " create and prepare the 3 subplot figures to be used by the KF visualizer\n", + " '''\n", + " fig, axes = plt.subplots(2, 2, figsize=(20, 10))\n", + "\n", + " axes[1, 0].set_axis_off()\n", + "\n", + " axes[0, 0].axvline(c='grey', lw=2)\n", + " axes[0, 0].axhline(c='grey', lw=2)\n", + "\n", + " axes[0, 1].axvline(c='grey', lw=2)\n", + " axes[0, 1].axhline(c='grey', lw=2)\n", + "\n", + " axes[1, 1].axvline(c='grey', lw=2)\n", + " axes[1, 1].axhline(c='grey', lw=2)\n", + "\n", + " axes[0, 0].grid(visible=True)\n", + " axes[0, 1].grid(visible=True)\n", + " axes[1, 1].grid(visible=True)\n", + "\n", + " axes[0, 1].set_title('Function Model f', fontsize=30)\n", + "\n", + " axes[0, 0].set_xlabel('p(z)', fontsize=30)\n", + " axes[0, 0].set_ylabel('output z', fontsize=30)\n", + "\n", + " axes[1, 1].set_xlabel('input x', fontsize=30)\n", + " axes[1, 1].set_ylabel('p(x)', fontsize=30)\n", + "\n", + " return fig, axes" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "cd9f4d93", + "metadata": {}, + "outputs": [], + "source": [ + "class Gaussian(object):\n", + " def __init__(self, samples):\n", + " self.num = len(samples)\n", + " self.mean = self.calculate_mean(samples)\n", + " self.var = self.calculate_covariance(samples)\n", + " \n", + " def calculate_mean(self, samples):\n", + " mean = 0.0\n", + " for x_i in samples:\n", + " mean += x_i\n", + " mean /= len(samples)\n", + " return mean\n", + " \n", + " def calculate_covariance(self, samples):\n", + " var = 0.0\n", + " for x_i in samples:\n", + " var += (x_i - self.mean)**2\n", + " var /= len(samples)\n", + " return var" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "1ea5fdbf", + "metadata": {}, + "outputs": [], + "source": [ + "class MontoCarloSampler(object):\n", + " def __init__(self, nl_model, mean, var, num):\n", + " '''\n", + " Monto-Carlo method is used to calculate the statistics of a random variable\n", + " which undergoes a nonlinear transformation.\n", + " \n", + " nl_model: nonlinear model\n", + " mean: mean of the input normal distribution\n", + " var: variance of the input normal distribution\n", + " num: number of random samples to be drawn from the distribution\n", + " '''\n", + " \n", + " # 1. draw random samples from the normal distribution defined by mean and variance\n", + " self.x_samples = np.random.normal(mean, var, num)\n", + " \n", + " # 2. calculate the pdf of the drawn samples from 'x'\n", + " self.p_x_samples = gaussian_pdf(self.x_samples, mean, var)\n", + " \n", + " # 3. transform the drawn samples through the nonlinear model\n", + " self.z_samples = nl_model(self.x_samples)\n", + " \n", + " # 4. calculate the mean and covariance of the transformed samples.\n", + " z_gauss = Gaussian(self.z_samples)\n", + " \n", + " # 5. set other outputs\n", + " self.num = num\n", + " self.mean = z_gauss.mean\n", + " self.var = z_gauss.var\n", + " \n", + " # 6. calculate the pdf of the transformed samples 'z'\n", + " self.p_z_samples = gaussian_pdf(self.z_samples, z_gauss.mean, z_gauss.var)" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "id": "8059bc88", + "metadata": {}, + "outputs": [], + "source": [ + "class EKF_Visualization(object):\n", + " def __init__(self, model=None, model_taylor=None, x_mean=0.0, x_sigma=0.0, samples_num=100, x_model_range=[-1., 1.], monto_carlo_sizes=[]): \n", + " '''\n", + " initialize the class object\n", + " \n", + " model : model to be used for projection\n", + " model_taylor : first order Taylor expansions of model f(x)\n", + " \n", + " x_mean : input mean\n", + " x_sigma : input standard deviation\n", + " \n", + " x_model_range : range of values for plotting inputs of model and model_taylor\n", + " z_model_range : range of values for plotting outputs of model and model_taylor\n", + " \n", + " '''\n", + " \n", + " self.xlim_min, self.xlim_max = x_model_range\n", + " \n", + " self.x_mean = x_mean\n", + " self.x_sigma = x_sigma\n", + " \n", + " self.z_mean = model(self.x_mean)\n", + " \n", + " self.model = model\n", + " self.model_taylor = model_taylor\n", + " \n", + " self.fig, self.axes = create_plot()\n", + " \n", + " self.monto_carlo_sizes = monto_carlo_sizes\n", + " \n", + " def update_plot(self):\n", + " '''\n", + " main function to execute the class plotting\n", + " '''\n", + " \n", + " # ==============================================================================================\n", + " # 1. generate 'x' samples to feed to the model 'f(x)'\n", + " #\n", + " x_norm_bel, p_norm_bel = generate_normal_samples(self.x_mean, self.x_sigma, num=50)\n", + " x_norm_pts, p_norm_pts = generate_normal_samples(self.x_mean, self.x_sigma, num=8)\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 2. propagate the 'x' samples through model 'f(x)' to obtain 'z' samples\n", + " #\n", + " x_model_curve = np.linspace(self.xlim_min, self.xlim_max, num=100)\n", + " z_model_curve = self.model(x_model_curve)\n", + " \n", + " z_norm_bel = self.model(x_norm_bel)\n", + " z_norm_pts = self.model(x_norm_pts)\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 3. propagate the 'x' samples through the taylore expansion of model 'f(x)' to obtain 'z' samples\n", + " #\n", + " z_model_taylor = self.model_taylor(x_model_curve, self.x_mean, self.z_mean)\n", + " z_norm_bel_taylor = self.model_taylor(x_norm_bel, self.x_mean, self.z_mean)\n", + " z_norm_pts_taylor = self.model_taylor(x_norm_pts, self.x_mean, self.z_mean)\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 4. Monto-Carlo method: draw normally distributed random samples from 'x' and transform them\n", + " # through the nonlinear function f(x), then calculate mean and covariance of the 'z' outputs.\n", + " # \n", + " monto_carlo_sampler_list = []\n", + " z_monto_carlo_approx_list = []\n", + " p_monto_carlo_approx_list = []\n", + " \n", + " for s in self.monto_carlo_sizes:\n", + " monto_carlo_sampler = MontoCarloSampler(nl_model=self.model, mean=self.x_mean, var=self.x_sigma, num=s)\n", + " z_monto_carlo_approx, p_monto_carlo_approx = generate_normal_samples(monto_carlo_sampler.mean, monto_carlo_sampler.var, num=50)\n", + " \n", + " monto_carlo_sampler_list.append(monto_carlo_sampler)\n", + " z_monto_carlo_approx_list.append(z_monto_carlo_approx)\n", + " p_monto_carlo_approx_list.append(p_monto_carlo_approx)\n", + " \n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 5. calculate the min and max samples to set plots limits\n", + " #\n", + " \n", + " z_list = [z_norm_bel, z_norm_bel_taylor]\n", + " p_list = [p_norm_bel]\n", + " for i in range(len(z_monto_carlo_approx_list)):\n", + " z_list.append(z_monto_carlo_approx_list[i])\n", + " p_list.append(p_monto_carlo_approx_list[i])\n", + " \n", + " z_lim_min, z_lim_max = np.min(z_list), np.max(z_list)\n", + " \n", + " p_input_max = np.max(p_norm_bel) \n", + " p_output_max = np.max(p_list)\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 6. set plots limits\n", + " #\n", + " self.axes[0, 0].set_xlim(0., p_output_max)\n", + " self.axes[0, 0].set_ylim(z_lim_min, z_lim_max)\n", + " \n", + " self.axes[1, 1].set_xlim(self.xlim_min, self.xlim_max)\n", + " self.axes[1, 1].set_ylim(0., p_input_max)\n", + " \n", + " self.axes[0, 1].set_xlim(self.xlim_min, self.xlim_max)\n", + " self.axes[0, 1].set_ylim(z_lim_min, z_lim_max)\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 7. plot input normal distribution\n", + " #\n", + " self.axes[1, 1].plot(x_norm_bel, p_norm_bel, color='blue', label='input normal distribution')\n", + " if (len(monto_carlo_sampler_list) == 1):\n", + " self.axes[1, 1].plot(monto_carlo_sampler_list[0].x_samples, monto_carlo_sampler_list[0].p_x_samples, color='red', marker='o', linestyle='', label='input drawn samples') # plot samples\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 8. plot output normal distributions\n", + " # \n", + " self.axes[0, 0].plot(p_norm_bel, z_norm_bel, color='blue', label='output normal distribution')\n", + " \n", + " if (len(monto_carlo_sampler_list) == 1):\n", + " self.axes[0, 0].plot(monto_carlo_sampler_list[0].p_z_samples, monto_carlo_sampler_list[0].z_samples, color='red', marker='o', linestyle='', label='output transformed samples') # plot samples\n", + " \n", + " self.axes[0, 0].plot(p_norm_bel, z_norm_bel_taylor, color='orange', label='Taylor-1st-Order Distribution')\n", + " \n", + " for i in range(len(monto_carlo_sampler_list)):\n", + " self.axes[0, 0].plot(p_monto_carlo_approx_list[i], z_monto_carlo_approx_list[i], color='black', linestyle=':', label=f'monto-carlo approx N={monto_carlo_sampler_list[i].num}, [mean={round(monto_carlo_sampler_list[i].mean,2)}, var={round(monto_carlo_sampler_list[i].var,2)}]')\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 9. plot model curve\n", + " # \n", + " self.axes[0, 1].plot(x_model_curve, z_model_curve, color='blue', label='non-linear model f(x)=x')\n", + " \n", + " if (len(monto_carlo_sampler_list) == 1):\n", + " self.axes[0, 1].plot(monto_carlo_sampler_list[0].x_samples, monto_carlo_sampler_list[0].z_samples, color='red', marker='o', linestyle='', label='input/output samples') # plot samples\n", + " \n", + " #self.axes[0, 1].plot(x_norm_pts, z_norm_pts, color='red', marker='o', linestyle='', label='') # draw point\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 10. plot model first order taylor curve\n", + " # \n", + " self.axes[0, 1].plot(x_model_curve, z_model_taylor, color='orange', label='first order taylor of f(x)')\n", + " #self.axes[0, 1].plot(x_norm_pts, z_norm_pts_taylor, color='green', marker='x', linestyle='') # draw point\n", + " # ==============================================================================================\n", + "\n", + " self.axes[0, 0].legend(loc='upper right')\n", + " self.axes[0, 1].legend(loc='upper right')\n", + " self.axes[1, 1].legend(loc='upper right')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "id": "3d9aa617", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_range, x_num = (-3., 3.), 100\n", + "x_mean, x_sigma = 0.1, 0.5\n", + "\n", + "ekf_visu = EKF_Visualization(\n", + " model=f,\n", + " model_taylor=f_taylor_order_1,\n", + " x_mean=x_mean, x_sigma=x_sigma,\n", + " x_model_range=x_range,\n", + " samples_num=100,\n", + " monto_carlo_sizes=[10, 10, 10])\n", + "\n", + "ekf_visu.update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "f8df6d63", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_range, x_num = (-3., 3.), 100\n", + "x_mean, x_sigma = 0.1, 0.5\n", + "\n", + "ekf_visu = EKF_Visualization(\n", + " model=f,\n", + " model_taylor=f_taylor_order_1,\n", + " x_mean=x_mean,\n", + " x_sigma=x_sigma,\n", + " x_model_range=x_range,\n", + " samples_num=100,\n", + " monto_carlo_sizes=[10000, 10000, 10000])\n", + "\n", + "ekf_visu.update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "id": "d07b9515", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_range, x_num = (-3., 3.), 100\n", + "x_mean, x_sigma = 0.1, 0.5\n", + "\n", + "ekf_visu = EKF_Visualization(\n", + " model=f,\n", + " model_taylor=f_taylor_order_1,\n", + " x_mean=x_mean,\n", + " x_sigma=x_sigma,\n", + " x_model_range=x_range,\n", + " samples_num=100,\n", + " monto_carlo_sizes=[10000]\n", + ")\n", + "\n", + "ekf_visu.update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "id": "3cf53ca1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_range, x_num = (-3., 3.), 100\n", + "x_mean, x_sigma = 0.1, 0.5\n", + "\n", + "ekf_visu = EKF_Visualization(\n", + " model=f,\n", + " model_taylor=f_taylor_order_1,\n", + " x_mean=x_mean,\n", + " x_sigma=x_sigma,\n", + " x_model_range=x_range,\n", + " samples_num=100,\n", + " monto_carlo_sizes=[10]\n", + ")\n", + "\n", + "ekf_visu.update_plot()" + ] + }, + { + "cell_type": "markdown", + "id": "ca6d9ec4", + "metadata": {}, + "source": [ + "# Unscented Transformation" + ] + }, + { + "cell_type": "markdown", + "id": "9be82d70", + "metadata": {}, + "source": [ + "The n-dimensional random variable $x$ with mean $\\bar x$ and covariance $P_{xx}$ is approximated by $2n+1$ weighted points given by:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\chi_0 &= \\bar{x} \\\\\n", + "\\chi_i &= \\bar{x} + \\left( \\sqrt{(n + \\kappa) P_{xx}} \\right)_i \\\\\n", + "\\chi_{i+n} &= \\bar{x} - \\left( \\sqrt{(n + \\kappa) P_{xx}} \\right)_i\n", + "\\end{align}\n", + "$$\n", + "\n", + "where subscription $i$ indicates the coloumn of the square root of covariance $P_{xx}$ [eg. $P_{xx}(:, i)$]\n", + "\n", + "and its associated weights with $i$th point:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "W_0 &= \\frac{\\kappa}{n+\\kappa} \\\\\n", + "W_i &= \\frac{1}{2(n+\\kappa)} \\\\\n", + "W_{i+n} &= \\frac{1}{2(n+\\kappa)}\n", + "\\end{align}\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "3682eb6a", + "metadata": {}, + "source": [ + "## Propagate through Non-linear Model" + ] + }, + { + "cell_type": "markdown", + "id": "2050e3c9", + "metadata": {}, + "source": [ + "$$\n", + "Z_i = \\sum_{i=0}^{N} f(X_i)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "f73da84f", + "metadata": {}, + "source": [ + "## Weighted Mean and Covariance" + ] + }, + { + "cell_type": "markdown", + "id": "1e174e5b", + "metadata": {}, + "source": [ + "The mean is given by the weighted average of the transformed points:\n", + "\n", + "$$\n", + "\\bar{z} = \\sum_{i=0}^{2n} W_i Z_i\n", + "$$\n", + "\n", + "The covariance is given by the weighted outer producted of the transformed points.\n", + "\n", + "$$\n", + "P_{zz} = \\sum_{i=0}^{2n} W_i \\left(Z_{i} - \\bar{z}\\right) \\left(Z_{i} - \\bar{z}\\right)^T\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "id": "108c36df", + "metadata": {}, + "outputs": [], + "source": [ + "class UnscentedTranform(object):\n", + " def __init__(self, x, P, kappa):\n", + " # dimension of state vector\n", + " if hasattr(x, \"__len__\"):\n", + " self.n = len(x)\n", + " else:\n", + " self.n = 1\n", + " \n", + " self.m = (2 * self.n) + 1 # number of sigma points\n", + " \n", + " self.x = np.asarray(x)\n", + " self.P = np.asarray(P).reshape([self.n, self.n])\n", + " self.kappa = kappa\n", + " \n", + " self.X = self.calculate_sigma_points()\n", + " self.W = self.calculate_weights()\n", + " \n", + " self.p = gaussian_pdf(self.X, self.x, self.P)\n", + " \n", + " def calculate_sigma_points(self):\n", + " X = np.zeros((self.n, self.m))\n", + " X[:, 0] = self.x\n", + " \n", + " for i in range(self.n):\n", + " if self.n == 1:\n", + " P_sqrt = np.sqrt(self.P)\n", + " else:\n", + " P_sqrt = np.linalg.cholesky(self.P[:, i])\n", + " \n", + " scaler = np.sqrt(self.n + self.kappa)\n", + " \n", + " X[:, i+1] = self.x + (scaler * P_sqrt)\n", + " X[:, i+self.n+1] = self.x - (scaler * P_sqrt)\n", + " \n", + " return X\n", + " \n", + " def calculate_weights(self):\n", + " W = np.ones((1, self.m)) * (0.5 / (self.n + self.kappa))\n", + " W[0, 0] *= 2.0 * self.kappa\n", + " return W\n", + " \n", + " def show_summary(self):\n", + " print(f'self.x = \\n{self.x} \\n\\n')\n", + " print(f'self.P = \\n{self.P} \\n\\n')\n", + " print(f'self.kappa = \\n{self.kappa} \\n\\n')\n", + " print(f'self.n = \\n{self.n} \\n\\n')\n", + " print(f'self.m = \\n{self.m} \\n\\n')\n", + " print(f'self.X = \\n{self.X} \\n\\n')\n", + " print(f'self.W = \\n{self.W} \\n\\n')\n", + " print(f'self.p= \\n{self.p}\\n\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "id": "af9caeab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.x = \n", + "0.0 \n", + "\n", + "\n", + "self.P = \n", + "[[0.5]] \n", + "\n", + "\n", + "self.kappa = \n", + "0.0 \n", + "\n", + "\n", + "self.n = \n", + "1 \n", + "\n", + "\n", + "self.m = \n", + "3 \n", + "\n", + "\n", + "self.X = \n", + "[[ 0. 0.70710678 -0.70710678]] \n", + "\n", + "\n", + "self.W = \n", + "[[0. 0.5 0.5]] \n", + "\n", + "\n", + "self.p= \n", + "[[0.56418958 0.34219828 0.34219828]]\n", + "\n", + "\n" + ] + } + ], + "source": [ + "x = 0.0\n", + "P = 0.5\n", + "kappa = 0.0\n", + "\n", + "unscented_transform = UnscentedTranform(x, P, kappa)\n", + "\n", + "unscented_transform.show_summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "id": "47ac9f8a", + "metadata": {}, + "outputs": [], + "source": [ + "def make_figure(xlims=None):\n", + " figure, ax = plt.subplots(figsize=(30, 10))\n", + "\n", + " ax.axvline(c='grey', lw=2)\n", + " ax.axhline(c='grey', lw=2)\n", + "\n", + " ax.grid(visible=True)\n", + "\n", + " ax.set_xlabel('x', fontsize=30)\n", + " ax.set_ylabel('p(x)', fontsize=30)\n", + "\n", + " if (xlims != None):\n", + " ax.set_xlim(xlims[0], xlims[1])\n", + "\n", + " return figure, ax\n", + "\n", + "\n", + "def add_absolute_position(ax, x, p, color, set_label=True):\n", + " label = ''\n", + " if (set_label == True):\n", + " label=f'x={x}'\n", + " \n", + " ax.vlines(x, 0, p, color=color, label=label, linewidths=5)\n", + "\n", + " \n", + "def add_gaussian_bel(ax, x, var, color, visualize_details=False):\n", + " p = gaussian_pdf(x, x, var)\n", + " #add_absolute_position(ax, x, p, color, False)\n", + " \n", + " x_bel, p_bel = generate_normal_samples(x, var)\n", + " ax.plot(x_bel, p_bel, color=color, label=f'x={round(x, 2)}, var={round(var, 2)}')\n", + " \n", + " if visualize_details == True:\n", + " sigma = np.sqrt(var)\n", + " sigma1_range = (x - sigma, x + sigma) # sigma 1 x-range\n", + " sigma2_range = (x - sigma*2, x + sigma*2) # sigma 2 x-range\n", + " sigma3_range = (x - sigma*3, x + sigma*3) # sigma 3 x-range\n", + " \n", + " # fill sigma 1 area\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel >= sigma1_range[0]) & (x_bel <= sigma1_range[1])), color='C0', alpha=0.3)\n", + " \n", + " # fill sigma 2 areas\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel >= sigma2_range[0]) & (x_bel <= sigma1_range[0])), color='C1', alpha=0.3)\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel <= sigma2_range[1]) & (x_bel >= sigma1_range[1])), color='C1', alpha=0.3)\n", + " \n", + " # fill sigma 3 areas\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel >= sigma3_range[0]) & (x_bel <= sigma2_range[0])), color='C2', alpha=0.3)\n", + " ax.fill_between(x_bel, p_bel, where=((x_bel <= sigma3_range[1]) & (x_bel >= sigma2_range[1])), color='C2', alpha=0.3)\n", + " \n", + " # arrow marking sigma 1 area\n", + " ax.arrow(x, -0.25, sigma1_range[0], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " ax.arrow(x, -0.25, sigma1_range[1], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " \n", + " # arrow marking sigma 2 area\n", + " ax.arrow(x, -0.5, sigma2_range[0], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " ax.arrow(x, -0.5, sigma2_range[1], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " \n", + " # arrow marking sigma 3 area\n", + " ax.arrow(x, -0.75, sigma3_range[0], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " ax.arrow(x, -0.75, sigma3_range[1], 0, head_length=0.01, head_width = 0.05, width = 0.01, length_includes_head = True)\n", + " \n", + " # area covered by sigma 1\n", + " ax.text(x, -(0.25-0.05), \"68.27%\", fontsize=20)\n", + " \n", + " # area covered by sigma 2\n", + " ax.text(x, -(0.5-0.05), \"95.45%\", fontsize=20)\n", + " \n", + " # area covered by sigma 3\n", + " ax.text(x, -(0.75-0.05), \"99.73%\", fontsize=20)\n", + " \n", + "\n", + "def darw_sigma_points(ax, sigmas, x, P, color, marker):\n", + " p = gaussian_pdf(sigmas, x, P)\n", + " ax.plot(sigmas, p, color=color, marker=marker, markersize=20, linestyle='', label='')\n", + "\n", + " \n", + "def update_plot():\n", + " plt.legend(prop={'size': 30})\n", + " plt.show()\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "id": "212e6fa7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = make_figure(xlims=(-3, 3))\n", + "\n", + "add_gaussian_bel(ax, x, P, 'green')\n", + "darw_sigma_points(ax, unscented_transform.X, x, P, color='red', marker='x')\n", + "\n", + "update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "id": "21001ca1", + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_weighted_mean_and_covariance(X, W):\n", + " \n", + " n, m = np.shape(X)\n", + " \n", + " x = np.zeros((n, 1))\n", + " P = np.zeros((n, n))\n", + " \n", + " for i in range(m):\n", + " x += X[:, i] * W[0, i]\n", + " \n", + " for i in range(m):\n", + " v = X[:, i] - x\n", + " P += W[:, i] * (v @ v.transpose())\n", + " \n", + " return x, P" + ] + }, + { + "cell_type": "code", + "execution_count": 217, + "id": "b0717ae2", + "metadata": {}, + "outputs": [], + "source": [ + "class UKF_Visualization(object):\n", + " def __init__(self, model=None, x_mean=0.0, x_sigma=0.0, samples_num=100, x_model_range=[-1., 1.]): \n", + " '''\n", + " initialize the class object\n", + " \n", + " model : model to be used for projection\n", + " model_taylor : first order Taylor expansions of model f(x)\n", + " \n", + " x_mean : input mean\n", + " x_sigma : input standard deviation\n", + " \n", + " x_model_range : range of values for plotting inputs of model and model_taylor\n", + " z_model_range : range of values for plotting outputs of model and model_taylor\n", + " \n", + " ''' \n", + " self.xlim_min, self.xlim_max = x_model_range\n", + " \n", + " self.x_mean = x_mean\n", + " self.x_sigma = x_sigma\n", + " \n", + " self.z_mean = model(self.x_mean)\n", + " \n", + " self.model = model\n", + " \n", + " self.fig, self.axes = create_plot()\n", + " \n", + " kappa = 0.0\n", + " unscented_transform = UnscentedTranform(x_mean, x_sigma, kappa)\n", + " \n", + " self.sigma_X = unscented_transform.X\n", + " self.sigma_W = unscented_transform.W\n", + " self.sigma_p = unscented_transform.p\n", + " \n", + " print(self.sigma_W)\n", + " \n", + " def update_plot(self):\n", + " '''\n", + " main function to execute the class plotting\n", + " '''\n", + " \n", + " # ==============================================================================================\n", + " # 1. generate 'x' samples to feed to the model 'f(x)'\n", + " #\n", + " x_norm_bel, p_norm_bel = generate_normal_samples(self.x_mean, self.x_sigma, num=50)\n", + " x_sigma_pts, p_sigma_pts = self.sigma_X, self.sigma_p\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 2. propagate the 'x' samples through model 'f(x)' to obtain 'z' samples\n", + " #\n", + " x_model_curve = np.linspace(self.xlim_min, self.xlim_max, num=100)\n", + " z_model_curve = self.model(x_model_curve)\n", + " \n", + " z_norm_bel = self.model(x_norm_bel)\n", + " \n", + " # ==============================================================================================\n", + " \n", + " # ==============================================================================================\n", + " # 3. propagate sigma points through non-linear model\n", + " # the calculate weighted mean and covariance\n", + " #\n", + " z_sigma_pts = self.model(x_sigma_pts)\n", + " \n", + " z_sigma_mean, z_sigma_cov = calculate_weighted_mean_and_covariance(z_sigma_pts, self.sigma_W)\n", + " z_sigma_mean, z_sigma_cov = np.reshape(z_sigma_mean, [-1]), np.reshape(z_sigma_cov, [-1])\n", + " \n", + " z_sigma_bel, p_sigma_bel = generate_normal_samples(z_sigma_mean[0], z_sigma_cov[0], num=50) # for bell curve dist plotting\n", + " z_sigma_bel, p_sigma_bel = np.reshape(z_sigma_bel, [-1]), np.reshape(p_sigma_bel, [-1])\n", + " # ==============================================================================================\n", + " \n", + " # ==============================================================================================\n", + " # 4. calculate mean and variance of the propagated samples 'z' from the non-linear function f(x)\n", + " #\n", + " \n", + " monto_carlo_n10000 = MontoCarloSampler(nl_model=self.model, mean=self.x_mean, var=self.x_sigma, num=10000)\n", + " z_monto_approx_10000, p_monto_approx_10000 = generate_normal_samples(monto_carlo_n10000.mean, monto_carlo_n10000.var, num=50) \n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 5. calculate the min and max samples to set plots limits\n", + " #\n", + " z_list = [z_norm_bel, z_monto_approx_10000, z_sigma_bel]\n", + " z_lim_min, z_lim_max = np.min(z_list), np.max(z_list)\n", + " p_input_max = np.max(p_norm_bel)\n", + " p_output_max = np.max([p_norm_bel, p_monto_approx_10000, p_sigma_bel])\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 6. set plots limits\n", + " #\n", + " self.axes[0, 0].set_xlim(0., p_output_max)\n", + " self.axes[0, 0].set_ylim(z_lim_min, z_lim_max)\n", + " \n", + " self.axes[1, 1].set_xlim(self.xlim_min, self.xlim_max)\n", + " self.axes[1, 1].set_ylim(0., p_input_max)\n", + " \n", + " self.axes[0, 1].set_xlim(self.xlim_min, self.xlim_max)\n", + " self.axes[0, 1].set_ylim(z_lim_min, z_lim_max)\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 7. plot input normal distribution\n", + " #\n", + " self.axes[1, 1].plot(x_norm_bel, p_norm_bel, color='blue', label='input normal distribution')\n", + " self.axes[1, 1].plot(x_sigma_pts, p_sigma_pts, color='red', marker='o', linestyle='', label='inputs drawn sigma points') # draw point\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 8. plot output normal distributions\n", + " # \n", + " self.axes[0, 0].plot(p_norm_bel, z_norm_bel, color='blue', label='output normal distribution')\n", + " self.axes[0, 0].plot(p_sigma_pts, z_sigma_pts, color='red', marker='o', linestyle='', label='output propagated sigma points') # draw point\n", + " \n", + " #self.axes[0, 0].plot(p_monto_approx_10, z_monto_approx_10, color='black', linestyle=':', label=f'approx normal dist N={monto_carlo_n10.num}, [mean={round(monto_carlo_n10.mean,2)}, var={round(monto_carlo_n10.var,2)}]') \n", + " self.axes[0, 0].plot(p_monto_approx_10000, z_monto_approx_10000, color='blue', linestyle=':', label=f'approx normal dist N={monto_carlo_n10000.num}, [mean={round(monto_carlo_n10000.mean,2)}, var={round(monto_carlo_n10000.var,2)}]')\n", + " self.axes[0, 0].plot(p_sigma_bel, z_sigma_bel, color='red', linestyle=':', label=f'approx normal dist from sigma points, [mean={round(z_sigma_mean[0],2)}, var={round(z_sigma_cov[0],2)}]')\n", + " # ==============================================================================================\n", + " \n", + " \n", + " # ==============================================================================================\n", + " # 9. plot model curve\n", + " # \n", + " self.axes[0, 1].plot(x_model_curve, z_model_curve, color='blue', label='non-linear model f(x)=x')\n", + " self.axes[0, 1].plot(x_sigma_pts, z_sigma_pts, color='red', marker='o', linestyle='', label='first order taylor of f(x)') # draw point\n", + " # ==============================================================================================\n", + " \n", + "\n", + " self.axes[0, 0].legend(loc='upper right')\n", + " self.axes[0, 1].legend(loc='upper right')\n", + " self.axes[1, 1].legend(loc='upper right')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "id": "21c382d8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0. 0.5 0.5]]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x_range, x_num = (-3., 3.), 100\n", + "x_mean, x_sigma = 0.3, 0.5\n", + "\n", + "ukf_visu = UKF_Visualization(\n", + " model=f, \n", + " x_mean=x_mean, \n", + " x_sigma=x_sigma, \n", + " x_model_range=x_range, \n", + " samples_num=100\n", + ")\n", + "ukf_visu.update_plot()\n", + "\n", + "ekf_visu = EKF_Visualization(\n", + " model=f, \n", + " model_taylor=f_taylor_order_1, \n", + " x_mean=x_mean, \n", + " x_sigma=x_sigma, \n", + " x_model_range=x_range, \n", + " samples_num=100,\n", + " monto_carlo_sizes=[1000000, 100000]\n", + ")\n", + "ekf_visu.update_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c49865c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "236d2028", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/python/examples/images/posts/unscented_transformation_with_python/1.png b/python/examples/images/posts/unscented_transformation_with_python/1.png new file mode 100644 index 0000000000000000000000000000000000000000..054602c4356c777a5380c9c5c224b764509dbf60 GIT binary patch literal 84080 zcmb@ubyQVt+daAg1rbyPgGQQ-AR*GBfW)RZC`cnMAl<2=gb0#KBaPA$(kKEV(nt$P zcc;|3me2b>-*?V9zdz0x=NUtNP+5Debzk?q=A75O4N_H>J$IJ!EDD7>Cod7>XY2F;TIvNyIM}_wq{PQMh>PZB_k(0Yg;F4%ZJxoOdT98Z6Dvfaq9*T z$2AKlCp$-BE-ssY|H2Jh2Xn3gqm3H42%(+a14k5!hz$9GgNjQaN8zAQ^3r!S+!B_4 zxw|R$Q`N7p%5$I}=H$r@Yel~Psrt4aycrwGd1r~ z4s+T2z+kc9;J$8cDULgWbrLHkao&k0#ns8PvF2tgBhxkJFGk#F6L#71Zb_b@_b2)1 zCzGpGRs`4n`_&oxjjQr^%_a6_Wyf&lEJH0(kIcHvIK zk!#`CoD zXDzl-*wQCBnOT~C59;aa#d?Zs`T`ZEl>fc^sZ%sPh3)ekVGM7&vG}rSz1?Mi};=H*Dmrz3AK*dS}W_0?+0NEhfjc zv~O2kYnM6Y+S-|cGbJrA_BNiePKt^fma<7FUAy(~>zu-Wl6la5yGo;P*|>5HH=*^t z-^RNy_OxRPE}Zn;w@I=8eY31$H={Dj^0DmP%3W5nJ;nDiInJ0IM@)_QW?Dt8NGvo2Ra2&9yjuqqs~`7 ziOg*Fj?j@uPoH*sn}nY^i^AlvMq?utSG#WY2qkJ_j#8pFG%Vy`0BG-sOTA?4wF7JI5W}vFjNg=#1i}D(@xpo~`|m;T3aIuN!zD+3~{# z|S+Uf7c37QY;srJYP^P(QbhI;$>g)=P>ie5JNwed@i!WwhB zoh^!ayP|VF<2&=m(7O3!{6hXbk^7jM^9iUIM%A(z-0e9GO{$+8>z{lg{A{w*b4Kty zF@dfhL#Fr7)0w#Rn4GL0a&?@HUh{f-LpGUI&d0jTeg#j&;JtKvyuZn%AKZndFo3D&yO&qOgyu`aG;WCX^bnhSW{2gKxM=t<5kwPss^+{qAWmR%I$% zpm~|oW||*t;jJ-}5cZ<};6~#J7{0-NSFrLH3Odqglry^`z$t7Uyl)$lZgwF>yzp#V z(>)9iy2qpF^a&T}h(5@)?0@p86|1k{jzd zymZ5x|JUmF;4wZ~3+@wUY2SFBnZ*8#hm`9XkB1QRrF!3%>^i?P?ZpQ9TmfD5J%UfT zh8Tuih0cSSf*)5r181 zw%?yxRK&Y)ymkEk)Q{7ZEJamZdt4Ny3*RWZ(io82sV&i>3{%o|rJidp{w(ZWiTN6Zh>#FYfs9z8YD z$PM$W%52Uft<8>Nf59_CG%nu4nuhAsUhUUTZZoOQu_Wr{6+1ph9(Rr6GF7Wv2<;ui zAL%<-_Jf+UPAacMg10G7wqq>cMHM^A2Hx(eiO0TodD?%dwCih;=c_b%3^(~@rN_U8 z4VAa87m}oTRq3Vh^^8Yf^<>f0IHF{pUWT{7bcFY58#B#IV$aHaCw_J?7^~;uF@x^eo<^x2xypNxN_C=oNB?<~Ks& z%nc8hpIQ5y(fu9qE0t)}&?VA#SUC_(h#tYHcJMAY+-f%EUmhZdD4MQ_9yX6s_v8{L<1Ph}O?lHC8F7xUA!?0&>)J^ATvPkUO{CHiTS*>(F? z|47Trin}LoJ=~ZTtd8W+&XmS1<;~I9=h(T}$XJ(R|Jxz{8WbT$K~_)1GyBUd@;Wl? zB`(7QFrHg%*2|K7+RxtP?j@X&XpvXIp25Hq5hrgSvgwAQoCt1BCA>{v985e&_Mbj+ z!t}l%>U`s*Xl?Z1ZH}*_PRSa1S?OP24T}$!^7bpoW|oegOW+gR7Wf(AARu-@u{nPt z$yj@cEn^35Rv9MWKvLBks>yI}m^Dk4rR*}pu-t|J&;n`wH+m9Zn>mH`I0j3LH806< zC8S#FN<1Dx?___+i9wNZFUb7j;j9Yk(qYg0?=^#z?q8P6aDAX1dR1V3`t7;K)#u+_ zy8jD?;Z%+12^ES20S6tt|Rp6(&d8_E-7qNFyn4D&HYn{d`*XrV$^u_y1 zE~RDN#~HudQ+%x_#Ld!~r+sq4QcGe*_$q1jm0kDX=OfYB40)eVv|kH8-@86o>i@0r zUlQ}}6@$_)G^5k%S{>0PyXU{>Cfd`McZ`cqoPVw!8_0ZLF2P$Y@_Xg0{Q?42In4E$ zQ`(DlPx1(_5M(;iz403ul}*Cr6z5oX^R`d=+g#dpe~A=>XOUR@WbfHyqVVhgf>}5f z&COp|nT|tD2+y^@(0X`uO82JNN=}qRYdw6}&thqY+LX#9#Q zQ^WjJ$7Hz5h|}lF1jiBmLoXfDoa@mklufE1y)ij=$(_BDP{M}9@k2ps9a#?}Jd3I= zZ<*!k&pZHY<;-VnQ-zVq;V*iNAUwYNqUragRj&joU*J^<%qsN z;n)RJ!}9roRou2{Y%9+r{b+*9*oXLTsI5M2*{q`|M*#p~>?1aAx=E1@0Zh&+w+H&} z!`@d51R6Xx4zzBJvA@op+A;p|X@D-fAWAzpe99Adj*zdOe028q*<^*hZR-pTu@r%| zOC+gLe<%i?u8*Qqh{s>>oGN6uqjZz__3E1cWx4;dmGDK2yj66D{wW_EjFA^QIo7bW z=C-+^0e@3QG*(Zsh!|!4Q*!fecrQ|wHLV*Yu=clT?Qjzs8x;9&{_beKFSyMxC=;VxeP6ESizt++>dTsrjm z1lo%Ns0-sa$GK%x;sY`djxyiITjr55Gne!k-KH_5x5NEp{N(M9;ntQrL7L%?X~?Lm zCeP5KRLc844`Z{iXdTPES-e}^FM6LFRcr3@m`x0$woZ$d_Fc?bn$-+>aD^4;H+cgN zBhTpW?vp>TySm9E`?OW+66JI*jbG^{G*((OUpLaYIR$f>?cVpHi_`k$wquzVU8#NN8C71Fl~7wM zw1$_Ja9FCe%I9(Ju8#TMwbJ9Kk|MQKEjE$Y%hSGP6<~DBb@fY;v1$>6M)vFdqm~nN z46Dr}p{qA^Q7I1_gYSnj*@kyyn?86i7DkPuqhn`ZbX&DTSG(ZzhK=NVla>hUp-aKf z@QA7K3u?@k104#+#|^!_z4K^flCIfU3U$ZCFxpr?=uV1>)Yf6oXg4$9W61mdhD*i5 zBD=Jq@O@w2?|PhpQlh0L-g2&eiN=j|B~J6Dfg)50t=Q1_@F~s>ic$`RlG#e<&LYNK zUBX{gI!w8`oO%6*`ySs$C&Q?AH4C%_&i{R_;l9-;;)e%Z9D0wI<=~x~#Po4nl4|4= zCyMBZ#Emc;u%^>`{`jOczOFto++e2RdKV2hSFY4*zPCR4pH)GYBgjTUL_~y|nwm|kFr`$Al%Y-73B}54 z{8skO4VegF*Bta&`pL5zu@(GPzI6B(UPLg{Gki%knm!v_gWtMKh@PismYzuvaXs(p z=}ApPqb4->NSK}dEPQ1Z5Y8&6qa9O{H7$Mju3D}ZPriQ5_X@|^Y~70DzaM379rByz z=%8VyZG6^zInbZP{jPG2ct;Meqs`82a#N?3>+Yd|u8LLSyj7u>go%oW9AUUnS65fm z4L$AS0Yds*N%Y}hTcjGf7R0+y!V2Mwn@jeqN#P1?I{YWhY4yCYO5*g) z$O{qOH)i!OWZ9PhdHbBGq4Qm#Dbdof`LYFkc+jEE508^WW8(4~2BSmaS}JA|<`J(w zM!r3IWb^MzZ4OzQ8AE%Wpga5Z1 zPo6x{{bWbqFf1!AUHGu^ERl@KgT~;?3eJf<#!cKdLwqQiSCox2ZSj$Mu19~isYP5k z2K#3_k~_LH6mZtIx0(6)_}YqOWMp_WN{{^y6QNl8f~HJ(@DV_ux2l7aV>V^AlarJRU6aq{`ui3jaDI`M==5!Z?N z`IZohn-h(s)YKsb1zdWSPM-${WA$r1-YFSBEw>(g`sU5m$B!RxE%t|b?ylf8(Z$(M zHg%=TlOgw=mc~fuwTAPG@>c5OUzLZ)2dgEIeg?n4_kq{<*b4=})p)Z*RBCys)ZWo? zvTC(fp)`?2IUz7IlB`4gfP;17keF^)G~fcAa$DRjdso-ln%&XKegj|Ah8O2fojNrR z_cq^?wZ6SQ{p^BxeRFdF@?HA2*Zm6Wj^mnMQB5u^VC3Y^+)j1Y)zb?K3^d$Z`<)=} zO{t=yf{TkA7#PT1XA6bDwLE-PKtQ0nx_Y3@hRTrXl8E!dSH})9+3kg&?k7jP>SC^d z1ufsBpZOdawvY!~S%u4EB3mP1+Ss?XM#hj&1$T zbiRi?wl&-LgNKp#^WdYIsjQo2%mu5@%~yw|FlXb5!ri4_+}3()x;sBlm`SZ3v9mhX zG12&Pu*#K7+lrFU!Y?fB!fB!_iVjCN^eVYMcdRp&;$?nSI=8jHyvn5v&!+I^hUvH0 z^trHjgT~5nd_l0%%vJ4A@CXDww%DNbz77w^|Eh9TFMq5D)izjcN_6W{Z;I>c=#O}T zFnXyMC_{7e=6t;>6eD_TDpIA`yo2_|d79w5I*BURRTg34IPKC$JcjkCrKKgUDi=;D zy4mm1*ZHgmUhgaqv+8Ksog5$KLZRXjoF^e8L)J1!JxjUT87|p0RBA8cxKbeapnik_}cFV|A2s=VpE0Vy~zuxFJHb0+Kr>06J2d;X$dMH^?1pe?8Q4c z3G1S~JL85$@Z|K%~#p2-MuR)38aKrwquBjm;Bs7BcfvxsN^7+{!r+I8b zLc$qh;wh*NCV0EU<+dN;w%lg7M;trUKAMq*Qt!X=*cP1|F6T;<4VwYX;xMR9__Mv} zxIAzTr}@^YPvc>oYt|5wYsySQ)ERd4_-P zt%&Q5va&Myq}@;UlLMtzSIyfK-gzJFgiziJmI^rk`}c30`ti@t(CV4QX)>=K0+1;t z2!=zK559zc3fq^Sp1!xhK;q}F`=70OY9R;zg4#d94FMN=(qu14N=mX})8*a|XGU+m zj-bU#PCcq}Sx$u&zQm~=1?-|LN1fGWWh8dx2yU^#tIoV5NwHA_ZWB6VVNucNo}Nfp zVC4kCJJa8zbJWuCQQm*HjG9AfW^5{5S7~kOmWRs;>f730;h&>4w6#@%>Mi>Ck&%~| zH18IID=RB2q6bSK6C`|-d{2%92H(Pm$-}p!vFT@^Pz6>c@?kR>o14o*k;3j%3ih=o zZKBe&*5SA63yBx7C8eN&e zC%;rPiDY0xs)Om=&sI512Jcg;GxQGCk*q2kO;omaTXSld7><_mF(0DatD`lsqVBu_ z=V`vcy%!lb$CU>K1<^Ax`N!TgZ_-J+g3vglh8NVLZm;3uMTVboQKLQwHn8u$*Lol9 z?F`$tH4G&rCJq)E6A+xI9&flHF$D<6y=v8wB*yWem`R_Py$`n8T;H;dq~!UFw6yKP zm#-tM+mop@IT{~LwZ_KA z={^g6c~-~ye9j9RqGDoXzwj^664$?`mlAYdxMbCzpJ6*z>$To^^@@_rlYh!XOBGWW zWpX+3$EDcQXD^L+rOD3B0{o&^SRZ$!4m8{EzAK$MK02@r&awObWu_U*_UqTLOjPE% zsdrzpR9v8P!KU8L8HG2HUzz4^0bEa*5 zLGf3$dt`Pt8}ePr;@*Pp8%)}ZZqB+#hlg&W{Awi4X|k$0SW{8a5jHj4M?c>qjqe%u zEVLcRAFye7S;w_YEI$AIpjlx*i7(=^WC$G(Rbtum0-J%sk$DgX96`N6UktS}TBA_m zFx~C7a+OOz-FmQiX7+CIB_ntVd{EL9H_cQ_AKlxug8jrODoX9==ZAt$7xAm$)vI&B zn?6-lZT?v-m|R{?oO#>LKDPUsT^&E_sqb--3zKAEh(%v6#bRIHWP75>NUe8#sa1b> ziKRNgeKQcGPafOsyDPt53RJg`jwWSiXS*E`o;}MuCh(~D4EH0E<*_lHn0>~^j#vZ=7@zk!Kjy92w@&dF(Ncg&Yy9DbVp5qtCY zcbmc72RAnhq@!ruTmP>hE4D? zD~q*5;>0U>_zH(s=V6+~$TFRn$JZn=&oe|sj2s*xo3kCpwzeJL!Wk_`tA%7ksp;9+ z*ha%LT8`EzDF~s4GbK+m29WFqOb*b!qMxU`XKbvnK=3f{7Qh%!v)jbiAZcbE><080 z=08Qd(7}LW3wKE?L(z-w3>e>D5KFJ0o4=o{RivnNCOX0^`8B&%CmU1j-R0~4-yXv2 zZyFm*2F&k)M)YTQH4La0kO7n4Y&AZMPCs~y6H80hqsU)^uJiU~9NtKkYZzeV8gS8A zqUgFm3m>eAm@S@qiJN^Yikv?TL}pk#v_Y-vuCm-qQ^Kc|8V3XtdCq zgP;wx2o2-w_ugNE6*Q~&!{N{_IpYV#gtRVzh*$yJB=@<8pe@#ScA9?vyw%0U2Q6yi zcSFFZii)lpPgh(#yh*(g=;8WXp9$Ar1Bczv3QcIO4gobTO%Nr9zX90z;sHH_t z#c%zslSik_8rkS=9mc+PHL!J}+3(@X*}Lg-ZVi=r3LX(wqM*gWg zbLOYec%0PZbz9(Ra$EXAdr7|fi`^Newa(YKogF7jrIZl?Z`>5p1wV>h$laA6C97E( zBqs|w%Jjd#*Lvs$tKk9ouWglgfm$$yiq9hD*T~2g5m$9efnHT+Y2Q$Dv+U|{xr$ZZ zHsI)XkBUU%RPDjmd>Sl#qD4HQZCw9@8jsSIo~$r;17MpyK=6ke8}HT~|5=2q!UogS ztMPFD^~v6thJ?gWd=$FuHkEC4_}nMWf=5TcT+K^9Zu-t%7Kr&Y>$Sab?^mt2=km-< zCUPqmXhpM2`~Co^40Uvq`sdGkW7Y2J5*}M}5}QA6{sGd}qisb)N%>w+Pj4GIZfT!3TrXqaQ)R5yd)qwO z8=mzKNP%vkbw5vz4{TGnc^%JXhB$8~L%UoUcx=8r^m)uz$7kosA%jbtXSjPs5oZ{k zMCi+xFH0NbnEndx1HQb)xj8ut3pUg5Q7seM4q00z8FGmrzrWhFrXO=*G0Xkh{YsB? zjKlzR{(KE010O*4U|Vx-hu>_NN|`cVas98VwXbACHz`hY+l|+2DCp=`I6PmUY&KVy zwqztkr(l_lMJ*^Fo(m_!Lnf_8EwDtIwP!daAMejWXi(M4f-{{$}4R z0B$gN0<~<0pJuTtCa~4O0Ggrd?p+Fjd75bF^anhTzB~iov!NF#mz?g~P3uvqAAMSGk!ksyHPRah)w{LPY?TPUd!U$dUIr<|g zA~LzO^aHwi?2HzaM$C+Jqom|H!Zu<`E02!Ui=In%t5IllfTQQ%k3c>%^ANZ%vaMCLeT&;fVbM)0Z_R4V~04> zweH-xv#w8c;X-py4;dF1mvXXr8`S^$`ucCc(w3D~Xf=BW2RfqdQ*x4L+4P3?Qo!;L z9La*4@_+vPKZ1u`*on=^$Y^P_CLW}TX$ue8G3(00!uPmaRzL(E0IiRC{bx4WcW&?_ zD|A9uQPBjwDi>gM25SI@EZPDrkrHpL^4x*?rUH&|&33+%q84@v{PLU#Q3sn=IY;!$ zH|Q^W=ANVC2S>7nxG{cB(h&N>*2*stsRL3VViV7=*8iemQS`f13-3xg6tQIZtq1Bi zrdut?YQ;cksFWx>^cTk}$z?>@$$$9vjXX6q#mha-Rl|%7J0IP*cnHFCZTvGH2*NqA zT&nx~@^qR3>%b}@$kr}pH}KxRoG9%4rLT{F@Tj7q!XA7(fUyF_#$kV zCiN;88`SqGbVC$c{YM=;Qnu|PtDV*Ej^NBRfn>1g&Atd$gz?n3@b#TrK(|5j1yogu zfIh?zkyyKN;|4J$UmyVHCh#HF;ZSHn58--XABH|7xPW`IU0><8&H#k60d7T8QxjAY zaw`>{yEougwibR~Z!s1U76x*5xqeS-I7@|Yk8U`Rj%GX&1il2ibwB+bt+ z!<9qEYWS1gN|w=|B!`OI5aoNk&k7pP9IE^jKK=&mGTfj7Q;Rr|$wSgc2}^ zi@+A=g?{ID(5FpCLgM$~!*%FMGx~QvfBwv8JDLETZDMBTMPHo2m{%keaCfE>($`H! zn?X>(zIdmcD2!N7zKS2?_y7Fa_)I_ti`|eepRAVR*CoQ9v)D=Jv-bqJ6MSqV?6TIn zljBx+!P)vX!f&_?@Da75@!@`(mmbyijK#izN#C78^YyX{mt{&CVW;|EzY<}w96)Zt zr+!u7s*whU0&fZ2rlIO%_@lQ%jx69brn_&>_^qdHLV=>{Va43xDqY%+>l1e$^=2DA z4scl>D&mc=oWAlcCT$A$@^#EPG(E4)3CSl~vqA5e4S(UAJ*D#C(z(GlEGjRbO$!r$ z*p+&>db>{tR%iqEW%oNN0#H8)Swn;Q>|QlDXYv1T{4_be2mHf0Qp4t+1tyaT?SG`s zHyQjkUdwK#P--DbEiJ8xVQMjtC~@yUUv=(-hZIUH_Q>ZL%!@+zO*3m78)TQl4opW3 zrP!Oz)$L$VA>s#o1B*Q54?)X}=VT=T7bfG-uNM6I?imV%9RMaNEp2E(K!E!`;GV_L z_m|=Q(_f$ypMssoXEPKv_|ZJRgOh=Qq0u-|(EjP&msfr-FDrpTgg6?jHM{x|_JYE~ zyx>g1_nYaPx5jYJ^n(N028b03t{LKHz@*_vf)E)usR7)M^+4eh5W&T;0va7U0L&4g zG@pN7ZVC%{{Oj6ty7K2F4C2>ylRJ_nlEGq$wHYo`%T%O57-w(0G4idd5T<@mZ?f zcu?R@W`h1-FB7q!I2C0Zc~l6=$bfB2kE40|3O` zHv6trxg-~wDpc897zEgXHNUjH967?DVJx;k73t>biMQ6Rz?E@*@M=HklfaOWug%Q_ za)-6f3%!JX!p;jM7cYjtGY0B$YjB|cTe#h!ph@b~JAke;_64RjH8t+DiLP&NSzQSa z55L6r+95d>N&-;f0_*~`L9Hkl1xv%_7yLkNsl$?^z|S<&F8~*;#G(tAJAXHfTIgwV zG97?|;#=+~oAw@=POGDdL|3_YLow|zzxgpHkg1&b=(x5E{5Ho|Jz%u4ckRCF&DV)M zs4W8VyIJZ3HY6g$L3+p)ueEaZ zg-QnM-bfUSEk+z&Xwq3gU;t{t%_k=JU4!j4Q0pxM+fGqKLnP;`f-dZ{(FDK zRSY(jN&hM^fOC|5#5)U`+A#2b?7$O1qz@4VtkVif&W*V0SeO zw0+P-V6+CVf>m4KMMk%y?fywl@L=UiyfL)mUf*CR+S%I&l~;o;2ix=+IOX98{{qK? zX;CP{Dc9e=S)5BX#jm35o|BVPoUxMf?=R1B(#kc>79T?rwA5)H_m&l9O?stEG(|GZ zX`-a^J0^oYyLG?;~mBm{QdD^7|AI-zuA82Sq?H9dLQhPkg zC!Cw!OSPR>K01-;I*Qn$rw9mc!knaj?{g{mxz@ibqe1-@!~b6DU@dhFq;i#%Pc(3# z^;{~F?*9ohrRJulCee}3rmX;GVPRnq#9gD{bP}ggWrVW&?)c$N%5+PRu z!^6!7X#(~W(vE5_egdOz&+6-MZ*BtX;016qsrupJ=^5Yb)-2W!tFiu5)4+bQkF$R7 z8JX*nmo@@67a3&`jtt#>vc_d+=>g*GfZhH5dO`J<)w+}Ox4}jt`#Fti2Z!9WmV9sQ zdP%cD6SDjmP&FH zSf5ZlYS1&jG&Drk%-~JRcBQ0TLlz&{B4TX`tzxo?E8YnvlhY4VR zGgh6*ko9oSe$(X*7gbH#_vn{(b^bh{IiGRRlB zx{EE?e)jCIqYXx-igT4#1|}Nu7-rHn6cveKkxgM*`03LpZtp)%o0Z@g$yS;-w6n^` zV)EAu>wWopFP}Zb^W0f_2QUR>^SRw>U zNCdnKKB2<onClC753?Uau!v(xg~ z_IB>a)J#0`?*SNvZ<@D%{rU6qg$oy8OYmryKYj(Y6nwGzh6YA8wari(k%^TR=<)=d z+9ifSNoR&+3Hv_)rGm#GrWWi>*g|V$lZ<(7o`e0`(9nPflewLhUqs|LV@E4Zf8@R? zbk+E>*a>jnS!$&j$8QstEu#U>U4`@F{Rjy^siu6L<`4=g5a*!Ni0Q;d)krxw!Em&^ z5xx!@4IWG#zUezOo(G@o-U;!P+YIvqI7F@-nfqgG0x|mciXPsjan+q#pOg`pGi@Eu zc#})6b>q_CS!Y3M!#6SqV;x!vAJHzm{Df=l?CdR-GRWPIdG97x*u9g}bFe}4$_({5 zOq7{oPp+afcC7LiwHf)tMOj%{y(hjB!nEFs)8Mi02cOMzPAdr_1vC!Amg=n(Fq8Ik zFEcQr$nlnOT-bJ3zU(PxzmXpP+QGGBWa=UiZeki?zUH~{nT9B9aGIX%XT_5Tv#$tbPfRRA&fdhsD-+R-XU6=Vq@av z_|z%mCOIw$$Q4Enm;Y{hbz;`nnk^s6(pBMTF1|lS)_U5U9=HNRr-1^pR3RwP2#vox zA>@0mSK@17*Yo=BrzNG{*%`Slpdr#It-k}z!4XXHO%4yRBBUQ1TUjxsg;GEH`62JG z6>$z^qn-$R&5H|k?Lg?-O4S_WKyNd@x4Nte<@>QTz#<7Fht9B$#zKH#E@sHQ4b0 zE`(!?*Q~DB%9P_D^`DHPT)C6pv!EYA%gmQ)&+C-Ol)DH@22wY*w}%31VzBJ5@^#UQ zPjFSsa!VOo^h)}`$-68fQboMV=!uVShL;hA*NOl3Om$?84Xr0}@ReJSPU(L_H>dHgqyLX2qJKv9z_8NENs&dzQe2En?aN2%8%F4LSl zIVQ@$e5Ui&g1ky|d;56;f&gOM|>NN8xg^NH^a{Z0AiTUszYo31H-eM1j((;=OT&WBuivF}7nBteu>KtF8S2@FW) zWVO~#$`{1zQzJqm_jAwuUeSw1GcZDkAb$N-XQ}bYUuU-N=NE z2`mtQwkb7Oc3dsO5>xs(Y(X06|CPTAoNJG0K`xTjYtd(ud^!aV8{m|%8$4) zf(HLQ^*7*PEiI9(LLlKJP7WPYoe^W=g2Z7xG|&go6<|#2P~8uYt_*Sq#D7%l(iS&5 z5b_T_9)RJ-bDi%JMBO7`YE=Y5HKu-|GiMB;@`7T()cgo#kmU1c-mMjQeLG?k(S7=c zp{RxZopotz+4Du<8LjGpf3g+tZiP^uRuLz(8PY9r5!}C@BqwK?Cu@;MQ_>e&|FZsm z-nN3}V43wGSc?!iQdf~Ta-?@arpZ96=Ev$JAOr)(#!K*RCTC}nAO{TMaY9UFU?^+n z>Y9a2Uxl5{_#vGI=r%;!ae%dTU!00a5yRL@|&y#qH|!PfXRYW|IY}g6Z#eS0H6PCH+|KFab5M=7b4N!5l2BGAs&|{ zEk}_`U@aD%*B4jX(`sU^&VqqdNhy8u#*lPJ8PzQ*NN5pXs_BjyF9(XOfy1Hw- zy8;E}mOU&`%+jE{z?Z)cI|J7c#(5xfFMyq-@3~w$K+6FB1JF?Jh5iB+kah#mRN^Ko zz;_a`9ZgqDlVQu4`&A_X(?x}nB$#7CGUZeX&{SzzS=N1bxtHL)AT#t$M*{-`WU33% z7I>Pb*4CGBzwu*Lz;r9YtN_Ep0?O(ALBBS{Chk{)3b+kG5FyIyXP)Ga?|JYw4cxhE z7!WF+v;XPV$Yp=S-Ly#B(aCTv^S(B*>8S_ zt(7fA{=6+CAc}-yc5zX`(C``xrWN)5{cj5D_Clzq!!Uc2Snuv0R@Cd?4@VGs;EZ_zOo#sf8a1a0t zzbzfi@8OzlHIG3f)I-Nbd`s9{iiyI}U=@%61^fJrV6fW#CX}RZ_1nGvD4?h6Fcdpa zC;kII2X@+N6d9{B6CYm`ggS~KS>q^49P-c)Ue^TpwR~JJLqm}D+Xj{+;kk3C$HB${_ck7C zg@lswk@y(MhEcCt5D5%yY=Ka9JZ@`-SGe>O*z8Xk8XGqNu-ZO8`2=Z>(5x);)M1FT zsCywEOGl)NxTVj^_;@{-7r&bEpoOe>?*U%;Pkt3Rcs1KpjXYOoC8BL^JH> zO}HYGWdcrgz8*={L0|$RLubH$y2bjZeopKXDd`t5YTANokryJY0)`FD1cE|Brog*g zKYJ&0Isx%GU=7%GKNY$^fKd?;bd$rq^%VF+*vEF^EwzGdey-|{AvOn-$1vV3?X zAV(lc?=Poky~-vl8@TD2Uih?Hqn8?$=gdu#(6`+h^Bf4-ik@*_&BD*$z9%=u(=nzG z-b$V!dJmBVpvrz-o>Q^rNq5lCvfr!9d6AN7DSq#3vcGqWI$a1Ej9dV$FTaSJ=J zB7wHQ03L71WI-zYKlY7ZSE~sa*2EONOrst!3;zw?BLgpQgiiV6uJ`w@Z(6~iu%W5x z1yqW92Iew|KAg49&9o9r_AaE%z`zi8nyZIlqZ0H9vP4@*F-#<`K0Qr@qz*uIrvQYu z)N;Yh&jifE1fT$;8&e){GFWn?Uw*Im?FI0;=_?N5V!G9jWMD;uWg_UZL_Rt?ib7mV zFqm)(f!=2-#(n_<{}ULq(8W_hrTKNmpupqd@m)cpS42cFT@OK$I~JsDCG~(3r{K3H zkLS1H<J9{vAkT7;Db|dWfuXJ8~0k#cA+vIB(yuVz{|)XFTZY@( z_!IZ|fh0@R&dyFyJ32qzY^&wl0h2@Wmi{xsR`;C;7JWbFn5S25e=u;u5X;i4U($lj zYy0vgc9Ug`jdIa9uQ3I@rXdF(G(UgFNl3WHOM1Ldz^+mF$U<@oV{d*40b;{yB;paY zTMZm!J?RZvon>^BHOY-ZsX1g={VNy{ha>Ql?j}nH*Rg$hd10s5rjE#+r=n$q@kd9Gf7pF;E0UscV28pmchK7dKI|}5o zOPf$49qh~P4MOeg-MW*;;Tw>9yYmeHA|>T_K!Fx;>n3W#iVlJg zD4^V=Q~f8wcZYZwy`bQLD5v9yV=ztJn@(8nxq%`^$UDAzb0$|Kht!ZM*kfl&UQSLf zcv%Zv4a}Pxe=+y$*@>52wJ1ZFmLO6FQWP+_xL9B_>BFCznrZ>^FXBMI=;3J?n@G#Z zkV0nh3GQjEC@a0cDcfl}Ut*=W`q|`$wcmZAa$p2x23&Y$(6waWtlMyiU4YP;P1sx<5NSXop)!adJOnceofH7QAK)Og--?Be?c0c%y)Bwq4F$2!M)2~% z^bkg%8G>aqv__0FA%?II(T|hw!%WWv=*&zR(iXu)2@u-XfX7GjJID-Xq4uGtTw~2L z3>OOvxgi=S4|Yc(Oe`QFCuP+J#pM3``BlKh zZt?k;BFDttTcH?XM%)M<2`t-3Fqtm(L*|(ePzD)UkdWL4NrOaR8XBHK%$FN70Zg8D z-dkO=x^+G@K!$+SAt7QA77&P0gP}95?HdzZHhMS@0DVyrqzGi40Vi2nVkery=#Y#i zz+}VVpwOrlj1Bkp_Btz_t!6rs!(hgMQi|jIJ^jX@36he4NznLyNgurOtc6AkpNx*; zGDypBg&BrDfP^TH2N9YE-Utr{6u({L zvCZL74P>#a&es>>+%f=-mcJ@*p@5Z&!Q=(k5L#q{uyZi*l=#J45D^LjoIu(Hux4nt z>7Wm)A)SPR`Izuvy49N-dRi3@%+Nt@a(Tj>fr97ZDR||vN$d779#BjcPlV=R4@nYz z_vy>_1O)+5XgY1@O01yPZ`3bWoFbE+@STci;_&X6Vi+nx18Vq%{3&< zj=~8d%7tDW^^DU-rtEnQk{fZb4;P@*lhB^Oaij3z>8&}V>X{|$k%-t!a!jDT6W$r! zWGF(EY#3cLq=SZxm`KZ&ReYvaS5+X}({?kl@hmYh@Gd@muKeDq7iHEz-$x6@Uet70 zHdGq?nZyMLD3IP}y~M@kE^TMW4g1I#6z2L6Z_dffDC|LLU(n6`FYloSZ+_t=GEPz{wFf#~_bwVdGwidIbv%{L0)>x^EX2ezw9yLsgXoN{(0M$~AvE z>k+}UtG7ub6VB30*E%1R@hEomUp+j87)fCCs;rXuvEabqorJjJ-W=l}C9eA$zJ%8y z2(J|J0SBHx%vU^aYzIcApzyyu1%{V2l^Z1)c%o5ozMvX+bGAWbmAnVe(MkIVSY0_h zDBx*GQap}#oI0SzVkkZ?9v$uawx$`?d5i&|$R*%3OJF(#EEwsx;pB$c zt9w=a2|{@N`46~mz%xK|fi%O2wM0JPE0~5#Wpw=!FitEgD*6p({){O|RB37Hbjt&z zGe8Cal6kMQIb%2;NP=9=0h1KWT6t%K&?vjcLiw;m2^ASrc`29<6kM$nmp1D;D3>_i|;5?#W` z?EX=2ARs;B5v!`c-Y*4{P94sTMPWhLG**iOr-zN#1&)rj&;@#jD%a5`tVw>mV*yOZ zR*)1DMCID$bq*#$yo=C4PjZ(lOV*)4SE+cdPxh%FckX^@qFG( z3NGY=cGsZ2F|(>9O#%Hngb8L)AGqmoq9+QvjL-4DxxVj_GjtKuTTs5pG%QTwcpPjG zfK`(Rxkb&2ZIDesf-i81bWpmGP-N>8MiR7;cR&W+$mkaWY2d67`jwXpKwq4h&q@w0 zSAt##9P?mH6@fv<7?fgmf$0)V`kQFcVbLksSGfA1ww+xUK0Cnpn-Ey$?{So-GS{uoZ3wT%rV zmkvIxJ-ln_W}QMq9H=<3-=9H`0rEyuKS#j_gLSaZF(Bo&>U_iuxAZ-rU%RbT%))>M z8LZE^IN949b*9`w0-|*%$HQK=KneJgSK%}Pg}`HK6u@yh4EN+&3Lq=p3U?y}=Zjf@wKSY{pkt zZS`#dLXolsGp`50AD;GfJ&et>H4A8AM^*0(S<+#NT5|UHBM;0L12z^KavGY>-mwZUr*}tPm6!1%7ZE3mp1eC;*wy{r&w3u+EeC z@ZjJ8;rm_J%pYG|Yz5~IRS!m9WTtTvv|}J&@lbI8JupyWN%ns@FaWQ|W>g%eR{flb^pKDS9D+cF8N^~gk-H`ow7@Y)G#Jt_KbQfG`#bse zD1yN-l8h;{9iz1sj0alt|AQ?--cT3wj|mB+hJ}ysk{`(ZPRKXF0SCjCSB`7rcWO_L zJvaA}Gf`lB0E9I`WkNW?KK1KG@}O{tN{x*i+dHq0{t`XpSh0cqkFM>2k?w5Ez)2yG zhf$)0uXv+Pgu~Gv=d#DYzC*U&qCcMo-X3DCQG*}?#DNofU;GKl2EdwuEg%Bh(G)V! zsOtThc*p{TLHffEXt-nQg^*Dxa9tsc(vvU;kqGJ3%`J#P1FM55VtcYg*t2I+aqX6{ z9bxAZ0m%aXrvkF%hgh&oD7B?>(h=Am=%f=6Hs645p&031et$U)Ip1d=Ki)(VHjs7$ z2Qc)4_+EWAoDKBU0;?8;IWsb{+UZ7IimxYNj#d_ zW(#`h^GMtQ`VuPp-iIq4kOjq{;j16cFTuw#UCHZ(F)DII6)Fj3(UW-&j%;PZ`HraT znm1awwxASJfn^R14Pk4&+`YWK5OoUnV_5kpK;;8)*Z1841W;O~k1iw74~HvZS`ZG8 z^ZRk!LK^h4pioyBw6SaED*{%b(%!UybwD05Ua%0(D7!b876w6&DG)+1ko|rL6Utwp zEZ@OyL~PErH9Hhcc-es98#0x^?cN1@*bStYC1~c@z7ZB!qcPDIB{ShjgLo!goGfOd1ZAEBp!_Vvknp-dh*jq_y9-# zgJ=S1Yl5yT)WC}oLJY~^%~8+QBCsh;I_hAp!O2BTV&L|7L1f@C-Wh=)AEXY0u)&B} zEDu_a#fL*w$#V%4!OPQ8F^;&5=p8sjhKL-d$au-XAB&whlmaih(%zY?7_%jVQF?F8 z+gx#GZTii|iJmh2yCESaJ&`Ib%5q`{9B^2>IrL7Rc3+TE;0OyS^}|nwpP#NLT}5M= zMmI^BF<(9P!HRL~NOqeD;-mTa_e2jrKmW`u@>84u+Iu~$swOYbCc@bvVu;odoFxve zLX;o$kd#v8t?2{s@D$_uU%|Lu?Y#yXIVf8bjS6O2f5Tfb$qe+f1JHYIZS5L2H@E%) za|q*(yF=?_Q+W3}5@vzTTmgqOgNrV+srtE&dB1^?Mzan~;CGn8%y?XU3 z10y52DevH*6FR8}X=bpY$XFD)S*4zn#AIDkjKu}};z#V-?|{GdMX`)xh?>avL5e>+ zNH@8)p`I>}B}7X|O!{ojEQQIQF?xWMHkgBc;e6NO3?P!2aPfv&4Ok@;Hgs@fFjcJZ z+UEt3Ndd-Cz1~FiPl8wmjBU%oVrCdF@!P^VYv;$K)$$NUMBpFExJevsslQ(r77;!Q58CsKihu#Y!ECUv{M`S~)&=}i4#+uKFxrPl6co;cJ6G2L z`2r(DE|oD2_9dZ#w<)n&5?>2>F^2;`1Xq}%UwbT|v-N3w_8WzH2W&8%Itl+QU)8EHLx{fqpM7QLo;D@B<*Z1sDPl zEky?1{}*%b9nR(dzYo6;P2bszWr$NT*`j(4A4uh(^5&+9SH$9bL)kAoM&CJ<}>QxPR1 zT)kN-lk7xRCLkSvy43^+3E*Uc=DU4_*w%e*b<$}QC!j74=n5;LKU0(ZqY3KAr;-xT z3oa8fHudifXJ#-|F#*(vS(Fc=x`0^&*I)h&9NPGgXRn!k3pzrKaU`9l`58)ZE%AtT z1nxk{jlh!ydS>F=gV)FhsgUSL#fUrVzx_f%j@ZhiDKkWVB!Qf-F9*c zp@g7_0m#q-Q4hv7xj@!V??DGC3C2=&&RyHmpMCR41XMoEFNv+hfER5 zjE&#(T-zAKMn-8jC7C_mqY!JSDX*ix&S3da;kk+5=78)OrkR-Qw9FgM2bazatE5NK zlUGp!8xaz=kUJ2>(l&+q40W`ogqLi0(_n=U!m4T8`&7rcOihd%abU`ZzXXQ;stE#F zj?e->2|CogwJG4*=mMCNXim0#>wlMMgbxfoc9R+NW1r@rb1S+r0j+7-O0RCwU+U}a zjS&*0h?m!PN@LY=Zyz{iJrXkcDOsME;22zd=kM}4Twl{L!bQ&inDG`bR`UiQ!N4`e zo&P(G@nlqU;w$@P@X`WPXwyZxSfByvZ({sZ^%}TY#BC1XJXQBUP8lCgEBawuk$}Pu zvDq+!_vA)jx1O@Q;o$=Gxp+b7|5Sf!NUTY{vgoH;np-ECq{clHKlt0OSl8TD%)4!Y zOqZl>9^TV$_k2ZlX8u;fwWXrI!a@wJwzQeoeLnmeqO)Ai%M|6Eo$T)JYZl&L!laf) zgv=l9)?jH)=p7ME9ectzq*xhba9t@Xt#C)gRPHM57>xPu6A0F1AuP>Y0^Wu6B zhV(1kjYqxP=ml;Lhuk$V{y5YKFkD{#3uJN)sXW9OpP?(e|!}`y2LL>XwYvDKb&-YbaH*_*$@E-;P zLp>XuqPQnSqdcUFcgJ2dJ-@-2_UKXTsThG-;kR<$QSv*O-v9HEo1$W236W~&+ORwr zzuqv{jh9et+{k}CD1SB#pT*>x$l(l+rjxFEd~#|@o6;|H2ZATBOu@j=b9&`ZAb13ZSj+>F<}rxQHNIVpKA`j93L)CN(N? z)MlShK31hcHqhPM>j`22rhQj)Z*%|O!zvXs5zb@c1mKNwujfc73>OF?Cqf8fpf$Ks z#UVy%hyzcW7-S3;>*H!Z3MocxVc=VbmgFNB{{Hrn)@v2!(yVE%ee6|kLCc-hv_@W7 ztN_16BRwCrp^ueg5_#ehEOQmKZ4z#KeuRJT2=UzBr0?z7fUuW2<4{qn{g=yM!;*E+ z9-tuCAHH`TN{ol)Kn&#flR>(9_Jkxo1A?Yo^ncnnfC%b z4?hfeY^Hk80ap1VJB$SOkdR0a-+_Cn%sl03*5+v-T@&X*dCZ~5^%*_2S$%uklQ|? zu?DA^AI=FRf~`jQih#GdcP}YbgkVDE=0aa0r=p_bH%aiXFm)#MCis+2x1}R`E+ucT zk|&xgYmnvj-Tf#OMG8h2v;;b7es& zXf(t$6};Yf%o7NO(1l5&TLX$#m!P^oK#iadph@P`t_HCK&^x&bCM0lC@?Sm?a|W<9 zBvT0s9|3HDLVgJH39ur1!1qTcsv5tBM2=~0EdI%YB(ibEJhcS_c+3{aqQKZW7qPRL z(9{L`hgPq*KQ6#1^V3v}jL>X~oKJO3)M-WK$C{zxU`-rR+XgGh86XA{ziCP!n<+ zKQn%=J>kzllJjBn1}g>ujL<~Hfz8lA3P7&q!>#C#%~e2ILWE7}z(eB%=7LYkFs@?8 zODE@u z4t)N#WQfy^qJi8R4LAX)L2`%TnMmX~z!fX0P9R1^Yl9+>h^wd?l>)@b(SHAi>`^qw z{VF7jqTBeMIbQ)S`sp~Knsl71I8;@Qz$FHMpr>sI`T*b&Bz(N2HE*v;5C$0pkO&zK zuxmoox@qS@LWtzHwsHq<6yHJgC3Ar2vjsn&peUe+=$B<@EO>-a2L)D~crCDkC$fJA zM@I>U7nB_E4q*cg^LBVWu(4-&1PDjR_=e%Wf++9BE-h8T;eM-NzWZ5yx$oI7TPCh3f zlje$rI!CDa2r^;t#~ii)T|q*M!U5cM^lAu*cu}`;{;eLAhKEKM>5cd%!nF zsJj8$Nd63ZtV&FgtE$fj9;Pe?3`JPbpd0-S^*7irTfjvxmajQ*`~Ql@2pY=g&!7)3 zJnhjy6j?fidayrxWuQr*fMI# z-!ry8Z2T4>wdW82c+A2fy9biV{;%L5dd=m_`|bmygiCc_$6xeepPg5sqK+91x#j%y z=g*%Zk!|>wc}L9j7wNHC!bGU4;@sP20$&3ug^YyXdeS_6;QJhAOCjh7(40jRjKZa* zm(Dz7umBRS`g$HE^#AWzC5+V6)IYv(D>;n)`e^tl9uUBDyr>yK>>ZvI6XFuNHwmbf zFrbO~`5cU(H~14GprYF-obTRD0wjA5vk5KOVS!mP*?MfuWIsql$dCs=j)U0P)!i+F zQx2$d7njQ3FSZKb@Px$?tD&JHc~yV6t?tXs2!MRTb*c2%$1*RC(N-qiSv=Tyts=H# zH}8cCy|&O=f3j~*&vw^oM^cB8oAW;nXHar{_Nt_v_05~TCEFHBVq$Oy^L^nrRw>ha zlz?$QnpWP#h#Aa)*AA226>o9Ol`merm_K^|-aUu;2@bG!3AYOPIYmM|^y#W%E}>4d zXz|0;?`2LNm>vXI6J){wF4cP|E`o{Xw$UN{pOZ`VQOwx|(bvJ)?l!iD>X>FV-dWsI^(24(M2B>cZdK}mh^bXf!rWJn+{+g9=BE&~PV?^O>KH2MHm zXqfS7uTc*Ax%bX1VqR{T=_Ioa>L;4|2YLbWtq_DgRBt z8zj&ES)#e{`x8LaRVa^W39qu^`TX1uz27RFACzlY+|+O4H6V}VR$m`iAFv;1+rnz* zWyUOA4&L+ma(S5{zWPxmGaj?lakJDs61%~H*bGm#Z&*(7Cg6BN!11I2=9jgup>oOT zCdzebMbmVzPHc+v<3Yc6{r@Y-XOD!?eFC|I05Z$6Jq&3aj$70x(eDt(5d_-<1#Uy? z713I^o(L;+MR-g!cq9G*2hqpvC&pr6GJ;C7=1|~C2efTF3Le7wEHT111px4GutW)> z6EuX0K%z*fL&PvziGkRYfPFwN4t?ayD&-v4j3{cMj_N4_J5vXQ{xiJ6x6OXJ%AfqX~+H2cx}A@_G&O#_g8o-ow`s*V{s zIIM>d54!PjlwGJbDh^)DyFFNnLo?Wv`qHrlLz-%c9fA4(nD+8P`(#Ww;v`@4#*AtT zDmxN5vkGWTs)j{Sors@1n$V$MzL1bLT8SE_hr=;CO0!&ah{?xOai2ZoC$6&%SqNm)&8NAj&GcQtBv zswvQKuqU&EXUloZmju@(=Hbf|E;n|Gj<+#Lt(};(_w`jNJh6pQZ~6XqIV*p!EiZRG z=_`AG!fn~%`AEU`|0k*oJ!)RXtP>yY)8j_WstF|?Dm9g3J~JlUwr(}XvnABgI#&+P zxcjP^6*V2dRi>e-DEGGHf6-ksr?WqGy5INTnRRn>+`_i0@Lvv+LF!+WrUbNy!Zk0t zEqm$YZxk^*`E2(@`<AWl%!7rMQE1DOy*Hv)U7sBWzXwdXj{gKn5 z$F5vS&}DZ!-!BO6N6)tDZ-FmlLz#eSTzYX)kjCq{5sr@G>heO%9^V;P94W`6O!TNy zk#;NnDK`#h_KJj*Gex-2$$5D+CUYpYNCAOL+OfZD)pdSa9g0p~?lvcRBazsEBkAl0 zaz*0W!}{k^{zA8N5+QL2h5fz?*CSUoLj!ptVe)rJ^}|H8Y})uQt%s`7S3^%M?423b z&FMAmRUnEW%n1nBSl9z;f%uoyS8RF+RLjSysi}naEau3O^XuBOK9u~Gu#Pk9$p1L~ z;u{qtQ9RHDhHETj4`0|_{?z=D^PI&%eZ16}XJweyEWOLFV(Db4JG>6MwdJt5?(j>x z&niG1)Bm-C?@n7a5J6nY$VrH0ms}ICn=Z;k%H@};c)pXYH3g1T# zXA;K8qivslgqLY9dXBZTdy2IZK&&H+Be)n!R5D(na@|}5M zP-t=Dwd$XRWk<1F?>}ap3QjHbewJ@mEei9S*CG=hL1++k6J9>)ydm! z+4*BY)w7%hf=ogc?Rezl5zlf6L;$fiUd__g^x=G4BKxB@ap(L($yxT2qBR0zk#)nno^^(C#l6@ zkLLBpN7t2eO-y$65?s?T;)$BTE22=6qGdgIG=Hs-KrVZY zARx|;4ikMeM$o*<%?6bqISdQ6^oh64^Ly78Hy6@Wmn*WoDgj;l@^SjZ9!1i?3L0Mh z=Z=(?s7gUjt~aRm^W7&R_D&_~f7*NaTS%WeP3Rw2ra=z+Efy4EF}8VBaW`{}yFxD2 zz74;%*5kvS#;{#)m*etCW{S_bbx?Jq`TWFb>)W2qx_DuU0$^WSOJV!Kz~oq-TKS2h z^s*NPSN;E_XndcKUi!3+JMD5R^X*ZyT~7J8_Fs|Nxqfx~uF!Ln+y0Sp5K{~{TlZJ4 zC~)T2^O#(5Zs0=Am~r0zV9fQMs>fM;Lb(-AwY^Vw%oH$|;{5cmr0S*M(&P2}TArt! z^U$(guXICb17?8Y>ha7KV;^n3dvnU!GlV!a%5J+$;P0EFF0Dv7az#xCa7~D-VSinct;l7WK!Qmm7FJ%M+C%g#CWC=Q5qM@^v>nFQdS%!8l;x#O%xZHES0; zJJ+QxO=-%m?Y}>HCt3&dRxEz_hgPRQq@nNfSN2lfz;g-kG?2fzY~No;ul|&`f3_TZ zQi1Pq?Bay(KJM3>6cRZSM|8=~keSpMP^k@?2W0L#YBBAiUDPrE6>>9ocJ>=J#RHZ< zi==nSzq4Bh)ji9@F@p%XH6DJ)i;dPN-hA~YhbMoEroNY4n9x_^8#uEAp6u^B-<_*W zBd^@P^i%i;r=Irl_uqH4zJFj<^nijo%6_!BS^e7pXXCs58>pDi{kL9XiuuYFbOH(L zUq7s_Or1ABd%&~&=G$xcU!V3?VofWu#Dfuuu`7>wYJ1*H%SP1W3O4Ofsa!F4<@l>_ zlJ+N3)bB!K)qCoiLP-Z_7Wa@eovOv3|J@L(ZQFXj_u{PE#;+gVV^Gi>h%KBimA84e zeCUg3K$BBSQ|rO8BeR@Qr%RjtKD3ynp1+YQncXzrUuL-LZ_Z4N<;mGx=~ZSrViqC88JnMYO=2Th z8m97zAM-wSm6WBOah@}FwfOHdPS?IEvo4Tc1^Tysf<-^rQtLR=CTR%yweDL}xFd5| zX*_;Bb6?b}B!ja(ZVOXcsnW(?ssT5hjLrM?Jr?Wul-76Kp+wxbv3%!?+9Hx*lwj3a%^NU-TDmM{i%uchq7BJArtknx+Qh zRpPcx4^s;W5Q7C@^#`8CUQBX3Y}wiIGNfFfQyZLE9JU_XWziP&ekRZEzDeW*A1N4K zRjXe1RH`gb6}f|TfXm5g}h9XBeP{S zsr~L?F})X?#+pz;)4qDuE580a=NID&K8T<6-8ZrDNA8kCe`Si7(!c8+9%^IIelIMy zX?bD&#A>$1N0xRJl-=pJ=_9hkxw`Ndb=p?SpKiWvazdRZ8Ff5;lf#Z1*zICD=wEJ` zRYyD`R zskzQicpEy$665t2Y{Xm`skUwiZ>gL3_dfKhtghC?(QaYidPsS_ys&?Hf=TAI{@7Kf zq(go|;eU1Zh_s7Vlo=R@HtPsI&2*j7SbUEG5u*rA(9s8!n==j``**P^7r3Lx%zl^3 z*$n+Yy&h1GKH6IH^Ic7W1aiRW4OykY@J)#_aZ4wBSyC_2YG>cm%7i01Ei)#&~*0A<&N_Z=X?1=nFHW+#+A^ua#;&UqAJI z=XZ5le4m*u@^DOYas#xKm(z?dxcv8`UrE!cc}?Lm&jHN@k!Z9=dwe)}D+f5V;=G7A zL+ky4m;f~^k|c?Cr0ThW@gt`hFHiWz%3VJ!sSy0os_^bJ25;%Qx(8b8zpM9*0^Gw? zQW*1>GisgjriniAWMmc9aoVKgP=Zm{tG6eeL{${L6?&2$cs%vsn-GrTr&EiJp9>Lh z@!XVde?;+B$f{-e%n;M*RjMugvqDa{gFLzZ1x<}WKC9`VfnO~NJVL~%oK8lwb+k=x z-(mZNx7!oX-I1YTyzi^2;PZ16+gH<6QIoC^@gV=5)59i;2I7Vr#g4~WE#cvmHTbY@ zre$V4Q~h7|Fvn|boV41z^F}*!enBd$@Agu^4(Dx3;rCLnyf!?C0Aq9CYio=8;0H;P z8&w2~sVa+N@!Ek}Jp=!DY)T4D6}+ON1_L^>o?kxwm%Y!9%drZUNg(1IO6Z zw1-Dc^H<`sw^k2VBxrtm2tVDj5e_ERRA%05G)r?VlCd#A!7;%zD}R<>p#OQ}#x25b z0rWDxI@+h#R;_!eTvkMoc}E}1TKXNy96=-0;IEK)Qz5ZOAu(DZF(*^v;a7H1KQ-xP zy=m)jj~R6Ma|P10C<>gvSK_JTQ(J6G(P4$l`8>?E^L9#NIJ%zq<&J3Txll(4Z@PMo zxDPjp()cl1N27KgiT18&fSO3A#N(3tuVpA1rGAy~GP%vJ9#{M=Q10FISsz}Of4`Tq z@3A?*@6s;b8`E(goEa9Uea&?^Y@#Qu8ISLZaBZ4rXczv9pQmV_^dJjX2Np(h zv6%EBaXl*j^XB1wiS)4n`_n0`(V#2BqNUiJ1biwX6T2*)v9J9;{pF>V)2-j71|X;V z2pWxXi+}d}Bng$3^j_@$Co8)Ae5C zJUo=t)IB`5&f1>;E&*4v?q6YcGcmx=^Ww2{)gmGO{{B(`_-8i+ZR>roroL~#x4B6y zoKd*6>T)N09~`UVE_=?pxfsZN>Yj5Q*GH=d?sT4dw3Xj*V`YebHa~A!>u4wgx=`MB z)?r1-Xt&aYolzcVi>bOKqbRyea^1Jh?}&cyQ7W%_9?aeGV zb)!cvM3k>*N%dR8ArXi4$!#n5w+ZUJTwjv7kEb^Vr%ob}chlMu`|?VT>RXw&cOH~~ z{1Gl>#@hV$<}N{oeL^&bdM}$joEQrto|EC6`5ep~yREMOJ=MM#ZrwA=?I4(ugN*_6d2|fkqawxFj0CmEiz7Q zv2Mv4=-aYKNTeff<-Ll+gHX$AlagC?irn)dVtpIhNK-?};$~x%EA5nfLu*-D8$Anlf^9YVTP8 zZjH6g`#G~2jo8Oae}2@&Z&Q4=v1ldeqiaj6jNV>27=aG6U#>WsH!??MJu^KXQN`D< zWY?ZHtJ#})h*MU{`ZqZ$D^(uHv8xF3Q+{3tVt#~!zH%q78CG24gG|c z&V#0%?jjBzi>i8(`k@bY-vw{2*K8a0Zyvc)I#8Q_o10e~T3^rdPE;F)z(FUfMCG>0 zaqx2P-;_wpczRqr&NlB7sohg z@?CS8V^s{jUb(k3IT(rGQ8jlbvPdRlMeNJs9EC)5W*O&FlLHPX2QY7QdFJail$5>7 zvvacFZ0AA7qUrp_!xrf(((i(fc(-2s^6d2Aez|7jeW`N97e-{@!*{jP6SUHw@N#Te`IAEttHs(?0@kSKb{KAw^v95pAMTm^zxO-*qzDz75f^S(&9-)F8cffG`3N*~WmF4LJb4 z2SNRTB$6LgN(&3Yu*~yXGedI9iTzdH5o#qRLBmzkWh^Su4=1Vf++49Ki}A-ll9#Nd zq1CqGrc(t@HSeNp4U*({n4jg8?Z_~o-oi?Av#m6Q=+Jtp0ltJj4f~^|ZSJ--DhdI` zJvFViTgh&&28xzTvtUD|=vp;|W^9m_j{fPGXD^r2uPiM>r=b;~`(FulUL$QQ&m~6P zAYIqSkOzFv_?jP-i>|J=C9r5@Crw(NFBE+`vX?z`LjWP}dWws<`^lbv#fC z_qyJXi+e&xJQW6}P@}Y*!TuLNMh}-+zU(kC7LDCyAD6fR8iCW`kHXqOA&522O1Ed* zaI-GU7v>|07rCSVG&1NiO2%Eire8r9dhGIg?CDk7FUJ_Y86D*J-3T?ZW4o_>J|WyN zFEunmlvr+lU=iLez8+pm0&S^CsSW;HqdF;79MhiUKgF9s?!##MrT zVCFD=nqxbWJ|d8G@$Stw5ZC4xOrmodayqqV8Hqv(d)l(EfAQiTEJ@&|XEJTH_AC!P zW&uvV$Z;O8J*Eg(ZUN|Pei~?{EBG1xDs+7bQO1aRX#bDeT3_(>>x$gn2`kMKcc8%)Wft=qrzeVQ2#l6<~i!fw|}G}ACR z1~M1UE&&n9KmOG-q3U+sGTTU zyZe&GqSbJrXZ;3j^wn^2@zPE#TE4E>z28plfqZ-HdAUE-&d&3z&Rp6JtvjA9AHG7T z7DqlnaY5O3nrj?~mKaMxwH-W^ivd_4#E!(m2vR<#NMKoq>bk?-^kL6HCm4BTtMe4h zBKLZ}3gsso((~T%qF)^q<+|*`8~(V6d)z-RMidI4eT)s`@2$rU^K895(L< zZVc3v$Sb(6NnT7cBu-nMb0@70E?Kjet zex4uNKcR zWAaxp!YGR2d`ocAf5bToLCY@-dfZR!n#k==RR21^E&8gs!>pEO!Ex6={+E0tsUqEI zN=hasIE2lqP=xh;*RnnF@6F-;($o}^(NR^EaL8`p1*(sIf0(4%E~R)p+4!+NeNe(?8hIXzm`s~k2h(bpT}rGy34A7 zax;TWwwc_UA*|pMkN9`ugH%#NRHxoJ+;UiToL{oSJ(T?cFHpIaE-6>N&l~YOJvj&z zaZxDMu8(-kMPbBa*2r#R(;nWcJzS0T)0y)wyh#Kh=fMLQd2B9*(8UxE&4hc^Tp{6b z0Qs<;;>x~i3_`%YsidsEoT~i*GG|B;&)F>1#d`1i6E4A$*-OjhXD9RoY0)H-Nr+F_ zlzhCvWY?*+F$wNn-2Wo&+e4AUaTz{O1;6PU+7xndOnFAS-D}plk8+_RGav&a6GlO` zhGo9`BZHOa*bH`>tbPYmWdfVZ)S$*Cf#CCHw2kTeI~cq?!Q@sAS|QTWs~?KtOJsTU zg%om_j>B)tEN+TjJ9pj>XHC(jJpHINMXM$&QK0JPrCYb|vbzhfQt)8yird^sW*w#W zzp#9DY%JYARX|+j(bgAtJN+J%3&Ho${Blnx%qh{x@ao) z)u;1w{m$KdKUyQsS4&b;Z!7&1d0Lav!LejGjYUZ4zbI0lb%X5g-Leg*To+Fs=c|8E zz7v3HYt~)Z$2_N+MJktnJP-IlfrP%R2QJwCSbng9Fl-V#emtXIM*Vle(pVluR>jNt z2r$Irto}cL`?I5O^|&=8Q?D$Z8g2bMzwk$Lx469;&2CT8PEY?s-ivCwu9S_*@Qtxv zE1X`~wI0*O&sRtAI|^=~EJ@c#Qhz*RhkcC}A_vPt95ZAni6eL2@5Q&huto)41SJ_2 z2}kD>JT)+Hhbd6C^j|Q?Y+*P5Y|l8nDg_S}k>K0<gP zh>mZ;@3eY*T4z`v(y=$&|hbRK;Og7o1Gkziwy*w7orAH zX=(S>6NHZ|40lMxA}rXPLQ%zD#*!4QiePd~noTNyZ&lc}*H)cNSr(hpirm7>%U=@f z6#0kL#l^(n$f;YKW2FnVmKL05;MUOx3-oU_li}g|D^5Q@?0`yr2djh(YT=A;?UMEJ z|5Z?N+(uU;bqXyM8`R%ym>#zpP4Fx~URx_SnpLARKYL|j_C4N*1AOh9xQp4#Ep$Wn zgkoV(`d$=ngmV+LQP8i1{dO%tmVlLP^(&XwkG6;4CF%ly5)xsc1(R(r$l;pzy%V*( z>XptPEiv^cGPta9=JKy!Ud=T0hd+aqO(>~Jgo4*wv?B^p-~?<0M>>ll!AlbWEfabm zLQ)CR-$ks8fpyO6<191EXS*NJv5kF7P?d8{>?rU~l)VuC^138#D8$ zmU2z;%IfUgNg?S}9CRezf+>H30POY|F|lUE*E#Ml>DiMARvO6#Doohk-2(kyag@(e zIRUhiOz?UB{smj#7Onr^zaV!CL6Y*AKkOQ+QTMXp!W?FQbg_(PuEAzjiM)TrpnX)Yg9UV2v!K&(KALsYh?sw>;*Ub45;xz;l zSzvF8-vOuFFk5Qer7G6z5|i6EM+8;+E4^L^-1Ss^RC5;u1R(d=&z z*wq;zSrsQN>|$lT0Gl=v)QmA;X|3DX`>7MO=;QF2{%YFZnlRarE0Vu-6bI0xdUY;W z?J1sB=uT^p%!rj_aO(j>(FjH^cucGwp!Z{u77ZTphGH1EaAAQV$X*-tAUTGz`C<1L zc8pTCv$0j>jhmsS`1LDF{Sanp_q`APdy161xUUDivbGa>t9)ma2+Nueo8-QF#GcoO zhlpj^_K&Cjb%mxM!fUn1>$R(?PI#Q`I-?iTv}o~^x}1z~z_ulu1gDs|(INh)J-*Nc zew~fV038^MeD;HA?*U;fHnB1g1hQzVizvNdxWJ*;kP9CIW{B<1*>@U!FKx{R_i&`e zpuvS%1s`O@QR?QhBN1f81$AMdVTC(`xg_e8Kae8&Au3Jwci(EllCTKN%Bl>cK#JESI zjMw&$GC|cD@!8MGbSRa`vEe@A`;dXQ8mK$4q&ETOg|r-5u=G4_aG64ERlLP{8iuCQvt;u>%kEDqqgcUW_meS(BL^QE$oFc39)y9&v4CUU37BLRgD5ZG3;1 zZQ^|S?*Do-5ljpp(sm8eWSf<|K0VmJpF`(Yx$k19Bdf$v^0~OuMJ<__(93Ku$W;_V zJ;Vpp=T?Jv|53aEdrC<7C~7D!;%^g+G)d47>;w(Ue!PQrU?xOOV(BYne;`<5E6?Tu zktoZ~!V9n*B7;m8(GR${GYRWvFGQSh6mwe^BQ?Jr-DlOIpK|36yOkA2?q@#Qq#K+a znyIa;tNYN2WorA|HtY3$i+y!`W*fuN;@%29!Gf<(c7`XYkX=f92*Oyp%Yu!;8VJBO zT<0hY;RiyjUX6A|gf+;G`d4RFfB#B-%!0~|w?+8)g?h+RKX>Rvw(Z$9O(tY~`ykgwW?>I_PEP)Q#N(Zk3Jonm zLt{=`gP`tbWXwhlNP+z+^E+JUt`Tl3(FMrZ@k%B{+Ls-YPafvu(1G3M&x|v=j0tkI z1ysq~nZEpdw>X`D>?XDYl<*!|%V5|S7}J-NYOtKz#&dktVsBME1z`vY#e5fnu?M{L zAchAqh=S0MKnih+2y+n5UPt4cmZc1BR~&+s9Bl$Lxw5)se>K-tD6K6XRD;|qhTGahsJpZ`C?~qRfx6#d1>R9NW3!D#p&OD;o^(pGq zVp2bT!DOtG1QF6X4L7Asw6S;XFlwCm`~55e zz4yu?#SkcnD7@?u^{{&`wYCE``(TPWj!9{0%jDTRc_(+e)kiPhY(4q*D!+@^)x6mO zbKwg;*sB~3ZapdF`@5q}gb9TyR5*)=qYIb`oLZKzzJcG8mou*c*)H zYBcDPf)^lkAqdWdU#cF)2!dw_Xw|{1xexaz*jF@-Eg&P^1Ll^?j(O8#e%qCWZ|!rL z3ugyH`bwP6i;n5#Y|>?kdf}?AjASk}TzbB0Lo1hWzx`Fru8{af*`aWA4JAalnYU$j zU(n9Q+9H&bLUGOBOhQ!t6`#?6QWdYQ&Pk&(@tOrubaHCy4TQdFS-NL^jtkt>)=`SM z{YI~ZdV1j2!+mF__bP%U4L1%s)>IryJ;6|T7E?q~Ct&sQ57@tv2098PAl{Mt{TEk; zRhbt~o+L$4Kf(4euc&MHK8XD+X!EA$$^V)8mDcvJ*kO%aAd*(Y5WU+!dOV|yMN z%7luH*!YX`g4q57nc){O_~rqk5DrEJAr%TDVjBvC<3z_oNFz{qF+w{95^*1d7l?oU zkRtrX0&6hI5BhI{Df!tBT?InZ-PQHtxYac6A%jpSLtgb@FOwn1Ce2I9mu?oR4Fv|! zY=07Aw?bd!bBh))#QQo3J`|!mjNGOqIA^Zr8lI1oTK)XFcz$xtPuhJbxZR=tK;@Qm z39dXkuhjVOSRQp-Z3$Kgd@JBGZ(3Pp)Hl_zx9F_8?$flA0JZ9DGU-_Bm(&*IGNhf` zsXvp9BIaII*XH~xt_>I&9vn>6ISY!kDvpLoD^8<2WJV&bDBCVW`T0QG zmx>Biq0s^H@oG^GZB{(lu1lG^SR^iJht@b+^7`kEGccTHya_o;BS^#1;hg7pH)fhB zN3Ve7oeZf63m7bO$*xOdNm8x>Hn(b*)M6g1b-E=t+^6PSI2c(ER(Kopks0nCP0P9>*;LZlkyAiN~9i&|NBPdVQU~dEK1yvu( zPRQYOM_HWimutqcF@0~~>5D6-lntA$G+|c>mFkkF0T%-F?^Mw=a3*mmbN|Beo zecCT0F2OTXEj`%&(hCXbcg3px4!(m&l@i@nri-3QEvqEbvb>ME6D&x-AQ`r(=0rQY zPkpwPj6F`znLUB#XLQcGv$1~ zNfRP}9Dm_fBIUviKyC>NA@m4jH55@O8{$yyldu5|F5dfK8Elas4<>Y`+lt~rB~SJE z((=&EUHbaZ76$fDOg)X#&JInv=G^L_3~w{;J?($~;Ml_Q!i!lSS_FNp7{yX277uW! zZ>_Dm!qCs)gfs}o*n~kwEZs({ag3%07Z(Dx*G>lA5?3(U;Z49IQudz+k?!b(_?@v= zs^jY;H<^5G$G@e`y6m6ZSnd9&2#o$bEBz(C!e_i27|qW0`Wy|TP9;C}(ITpZ02G6^{W$u+# zRoKi$JOP8?6h|vR51!9SIk0geqgy0N1wurQP?if>M*ouXGRqi+nTM<-l zz@~QBP+Wqm+2!&2f72?jGP*w0@0-B0O&Pc<{1W2Lf27Vle(+&4a>Y*Hjl+^_wtTxNY(Z(s~)EkG6w3hjgVX(^yhBu@XyW`fwVUU9w{Wl z??K+utMm8obeMt|mu?Zt{%Gs9-+!xFZuM`O9vOUm|C7n`${p3Wx{vUDGM#43_H$*z z9{KR4lyYbpNrbNxG6A$d8$BSUox)mO!cXL6+N2$nT>A~UA?yvR;ws-t7`wvl=6V)v zQi$y~-m|!yl~9`zHH44Av2{}u7(gh`E&|D59)%BHP4Z>F=mLky>x4;b)_8l~oPtm# z?zy3*RrgG=gOFkM)+_H%zPnx%vx!&pMTaDvRam+FjTSn$g)@-_g7&HtWV4V|tYXIF52FCECVZL+cG6IHb^j5Odx9nUAlk`HD@34;k{p;fukBC%t zxHMU|*R|o07{hSP^U)&;YkU-fs*&Pl=N`Vv4><&C5=swf zLsTK^=#d<4$$W%G^^EH5xLsdSD0y+)C#C`|fKuY?jk$r^`^d7)qflTGM$pkK@RVhw zoFv0OC9jbq9;l@V2aD)y$jJNkHq}7aXh@cUXuw!9M?1~Q=W~yBKFYPzA5>devK&y^B=@B99NnrX2LcJkxy=c|7a?FJrddezl*QES zS%gQy%F+sm)KBS?NiJv8bgYDKZ1;Si^&4hFipp*91b|VWa9kuHiD%@LG>l9da4(C& zmB@Jv;nGcDKPBg`^h&G*7>D=lr@Oqiwl^9!Hl;oCKQtrW2oLGTq^>{Ik?vdXj1P@h zAR{;^qveM|FtrDgJ{>EoH#F2FSb9{xgu<4O@8q@txYg66T_nL*R~g-dz_aSW6}Tsq zM@Z)R8WA2t5Y2d#8lm0yGvdDnL@O#PieZUd@?o55#U;-K_4uvue12OS0qqWct8gpy zVWLDcQajd`llD$~AAx*=ntrSmakLxgW9zFK+*$SmHnsT25d|qoe9CcsNbMB z^6L75GJgSxkeBTREXUBYjz!L^h)YHd2_|$d*$Zju4ODOSrg}T)`xqqmirDmOP4(r; ze|ZY>`mche`8h-QuusEhFBoY||K?5FVu|tmPe_^GVakMB37UY4h)5Chpvj1o)YMzI zZVBA8M(K4OySmFhKHS126Ds&5S$8Y5FxR;PURMSEI#LZ9K)95*`WNl3u4rjtLcJ5+ z4(Vxh@d-lhv;f_>_bhN@uSFdNZaBqQDQ@z5`m`Iy3UX_ZbYpGolO0hs5CcG}i_2vi zg}Nyn&i^O*N{epw$n9TJByi(yJ3|8sj0qqCHKhYir>Z*G&g09(DhUPFu!u`@Djtsf zINPR4vx3_v73zf#U8oN;4Lhb&pXC@9x5DPWq_Nzilvt}e>4dl}wYJQ7NO_27dSyPE zZBNoATDPSOpML%7_?d$y6=r{>H&DmD^s>PuN!T#NI!6u(ukXTgX5SLx1t)wVpy<$I*` zntG9C_d@x2K*L;$K)A$Z?#-KHpYBo}`t>nuP+d+0s|4}S#PnF1xz*U!*p!rj!ob8_@ zhO*Q*!ZMIwRMZ4^tsYX>j=&~@a`OCpaGo2f`G^36Zu$<0v*Uhu8XN_J82<#j8fEA|T>Nh{x5Ss5iqJ3lJA^2uq+5Q2yw;WJShe}1Gp zizW!ab-Zc1$*L%|ne2lbt8vx66s?)P+E3`T&@A!T_79vwDLKTs`J^kh^g>@vo`YS?muYn1TNL& zfsh7$D1RIUo3z^=I0+N7V!$@2dvL!QY;A2(=6}3BNCyu+arpB`!()YTsUb>V3;~Fh z-GH`!pwx$j%p-xmABKWx@T~zqQQ@~@sKAnZ09Ja0k3t5XEC~tm46xJ?N#|oEbOgJ& z)jVM;L2kV?dlSCAHXqN69{!w*Gwa|z@UPtDGGQ)+$i=)OX5B@?LJp_5g#=M* zpKX%r>7t-2zcWRVF&h%LbJH=?z~d0a_}FJU=p#9-IXW1tS@8;vUW+;$<>7i#KlY+Y zY{T`~2L0HEmiabLg~X#L_4W9iR1T}uXUQf0boV7QtV&ATdTTnNP+RudZhm*E03K>i zg@M15kr%C(H2^747`U&|npBrg{I;Ilmt{`P#Jpgk10WD>jH$TTbJOgnWvG@$y&<}UU*>I}fpf4(W z`VhWIL}JB`@U0#Qp~Rwd5D?f&=o+6Ob?)dw0Olf2-=YKNv@k0wZlAY$j=d=;JyeyS zTyOpPlaX@B)x`x%Iigjq3xQj~iIj5l=FKF+{)y;;JTAiD2o6+lCKtg~2BDd<=O?i| z5t&4^6)kiOfPT3pFqz~pv5(*vD?105eB?Kio3v0y>gX&!<$Ng`U#*twI8~gkZ@nnI{C8WHRT_0Qu=8K-uT}S> z0Cf1#8^K^~YDzp_uP$P7CNfHCb2CHD{UgLBz$TL#R=C$ku-*biKiPJenBxIK8%{oL z@djHqRKUzOSOZnc?~pRv$!(9}R!|c%#Rw}*qHXCSmNqfMcnYi9h~YdMPk?=A003j% z%U)tI3F~qL*qIO}wXnER0j~z8dj$2*E723q3Y-Y##LEri1{gTA;Cz(e-PO#xv11Ka z16v#TlRd!%eF{E?#GGC6;7;uR{R&DItQsj6pL(D*ko&!WFwYMl29K0XGI|)^fFTjq zMmJ1NO${%TT}-<81cs-dZ)}4%LAeTr33$~arQRV7aQ_~HZ{$Zlc zYqr}Xi~SA?Ux+Na_L^KVoJQhKsUPR!dz)CPKFC*YG%0RVEBIlWy{Y5?2}YE#fHcoS z`F8=HqTcps1-R7XylT;{<@i%x!GuQ^g^SmqE$W6iJW09Y6tuFiNCf|r`XrpoOtD%E zXzq!UY&WW~TlpD%6pcczf5qUqmer!1D^-Rk~gYIoz#(poqrWI(>W$ zanMjwMw>FjX`>HsKl%!ant1-OLks=i5nRM=dih(=WyX?-Q46oLIbsAT0gR)(S{aP> zv}A;vIy$gK>=h%y`6UMFiI^yR5Nl@f?JQb0Ktd0qM#E{8n#$fyyn~DH(reOKFxU5y zepnYfV~!wGpJ&o-_hy%3NK~`e)ZhD^?vL(K*5_T8iOCGOD5aeHy4g#R>`264yCWWA zdzT%n7Y-lOGUA(wX-eAg`?o?>WZK1^GKH3(T$Bn%)o&ZlvU6uUW~vQ-)C{YLfr-2V z7NvZ+7xnQY{I(8@*v6?%ZvIk`C2IHJ5hgPUh-J*9XdRMp>_6S$yYgNU)4rA)KJ3yu zgoXEwJA-v+a7&c|&z(d+j4L%u#GE?`*lhBL4`Lc9G&C?`$9RtYaBKi3Y4@gPW;8lF zIuy8LG2@Db1$-3N-Jx~_ljt1fh7DX8c%bA2>~jfc;}VX#29RR7H;KToG#hYrbP<5d zOEA;HC%|v;;?>eAZ)IzcG3{XP91S`GV>ZeGd<3eZ!!V;FhO%;Pt*ytk@(_`SU^gYy ziaefIMDkS{=(9_sa$Y>m)9y54^+Mt5qB&tnh}1-UHF7Yq z5S#;RCD3N5V*rcU(CR&1PDHlNp+e~*MTCm7GovIc8bldMrL4@~adzL&^L$^wKc4%!hq#=d^K+i>_whc4rb+|S zSAv+lC6N*~Zp_(|vCDU5ktfr-?YEoe(Q;S~4#gVSh9}qUjypH#!?}VvdgrvuZo_b^ zd69rOR$4OqEte(Ct}8T9a^vPrBdQSqKrGiD_@n@f>ceS9 zCQsP##OxN9(R4m787`WjJ($E~9`t~*&OcNtG^8&Bmi@L86{?KG@g*G??TqhEC z1^YiayeA}l8E@qfk{{utrKF@putJ<(wfI5AJr~uC4Gvjy9+L78M-fRAMrT4r73=PE zbKn-aO!zd~v!)*ngGg|uC$Q8ILGVK#6r$tf-ZaGEDv?Pq@KUI{c9y4iJfm0W*MVO` zCY2LEZQPAye3N+pDEO~8WcIXbDX^es1|*L&>a|Fv^6oMl&EXZPUc0uZWO8iN#-;5K z+Ja3^4tx!5&bM#NkAYLb@wPW=N~T!}rID){YOlaZ%iHbVSyw-4V`hHE*H3JIBxMhg zhZyX}VmgNm(!;nSE`)`VD)kt~bN~doffmBkyB?MQ1|T1pNZ>|Er6oOldJA~QsJQI5 zj+|u;SA!qBjC&i$iVr1@$E=I}^PwoM#2;t486RZpWBk ztIevgyi*LyGP$E6&R5IZO}d>`xPH9z)|AfRK0UB!UNeFH6l-J9qonllJu+?rGe0jU zr6)3t1YR7SsjVrqyuf?RHOE0QMBT=QN*GJn8Fn?myJP}_Z809OQtZUl}DWIPwIwX=&0 zLN4Sm(XoTck-51!foi~`d5MUKX2nQUC)aT65E~>4acnQo-%Z_+mp-?LPmnzVB4 z(3cqn_ceJ-?50EBle)!H*S8Msth>H#T%^CmXZVYHh$me)n$!IVhq$U_9rp@mqbJS3 zLj;cXC9mG^AvrN66svb8*Yo2GJ%h>j43hL#cD5A;SlIAk={p6KEh5wZTTL-pkGPWh7WaYaSR(fgk~@R#fPk@8rO z#p}0bj^*^KwM&OPhAT3+IF0cv+O%=(pgDV|$)DdDN4j^{q>BCFJ&s!@V#eOy9u$u@ zM_AYqR$rP6*b3?kv%64?0THRKufK?_j6hTfKpAuagu%Cq9XTyRD6H{18Y3nItL*r( zcsmK5_)+|OIm*P_D4U2wDq3n}7gB+J5VjGqdBPBjB!iN}7IRr-9V|i&ZWD-g5j-p? zyqoZ5Mz%40`0zmz<2v+@fdbY$e5Z0B-u{G+y&i2mpQ0lt1*Oe;d`1P-6qJb7a_4ZW zyMyscLAKT_jG?z9?UF*SCTzc1V3-u>Ck;rOkEB)#4hk=T)V0YbGL1$rN(}6R9_ml+Ylpac1c%g$H9e+u@H8oIijf&(@8&@v->D!1b=ib6v{fNQb&d2VWE(-ysa#_2TH>v@cN zDY?(imp=WdL~s2G*o(92nA3fOcTVqDAG0~yu~}8)(HWOxH8Ibg%~x3E2(;d#8;t8n zzj`$tSK0rv!uH&UXI%LiYIFO$e|=#J2vCoEGjQ!tdeaZ)Xm<012aR$2{^bAw0kSWc zo1G@?%*C>&;Z$#&IG-4~aZmPQE>0u&;Zl?Ec%OORBsV`X66OOk5Rx7wQum<~y)>uEMb!8HnoEZ#OR0h1s+wwH(Wm9r5w; z&Tn%W0s;EOg3wU@%rZd)a&I;f@E>W4e;IGRcGcLd&`G5=3$& z)K;yT9vps|#TC3ye^Eur!Cw>;%`>s556JqIEHqD7?oo|14p!7V#6HIK^;S;tWbOv* zEwYx9k7o8XjZ;I9FwYzw`miKAeB;KkKz%y(XEiUR-*9*kNIh6`Fh`Y6x>%73a*Rds>Kix4O2u?Xbbd`f=FAiq)`oeut?ospx)gQw zzZ4NzLyPR#;U3hADWEK_KSF50koJrDlM^?MK9|6A5$0jZ0H^w3|3;kE0H%;i13_0H zH(vph6i$cSIPSn0TP_}Z5%9w;T2i#?qMk2bLd|0Aq#LeE@5T3vAlaF*B^hYB#hn&F zJg@IM+21HEFaO37J5wQ$8l z+5jKJZuS!}wyrTPE)*!9nmt)^=Xuf=Z@t#3h1d&A5%M|el&JbFnWrsvr}rfF&h=~X zXg`|68uP8V{1LaODz`1Q&N=T?y<+vC<-HeK#>XXIi>e*E$K1oN#3-!6>1Hm;GZ(k( zPR=`@o}9%|Po%j87qwd?&+$ip^7I`1UHI;CTYl`sNQ**7dv=SN8lRkI4ob<#0?bgX zx?Eb`|6C9uQS-iVQrTV z@qiX-Vd{?~X+V+K3AqGqDr6 zEuap~7DZfrcHDsh7M%i8T?nwOwjF^Fr?`_rlA@%A54zs^E<9yL#yu2lnCiB+HpfXk zc;LVMBdCbhNNY&Z&5;@jquydD8<2$i22=?Wx`1&u$UAY!tRz}SO!8N*T&an}A`vFa zFt_air$Ev1HKYSGztFqsGKpxntYn()ojB;yiqCup728$}rfKq3`|pdTZFrJ8$lB7Se5!${vly zOEm~ov)-IYuX*?;?&Q(B1-Tp3EU%h^R7Ql)u5pvTP7}E-vi;;q%mn<_sI5KGeZFk| z4b%RB`AnJmCDXn?$~BN)nDaYMEb`dZ$B)IowgsQ<4lPvjOYBi!Xniu;_o+c<+?4gc zsm@ZvFE6ie_2UwuBVG*|EFsPFpnXgc>c<3nn2Qk+RcORev0TAn6N;&p4WGKfI0W;v zFtOGWH-y74%%<1F#hn3DiqiE+^f7<=6EjmKW#u(F20Hrs^=6!;tIj(^^41^mZaP?n zT9TsLLM#$%PGay+hV{>;)&>CO#ecE4y$!a7v6bgbbVD6usjor#)}7~ zQ*-V}$fr(e_UJe7{q*K$*g4&O;lXA0q2&s(+kDoY&|%%6$~U{C;-R~n{i+*DEE7c) z`CDys*uR^OyDCOY+Pz#%+G%%pf=%6+9+rVLBSFQYJI7p3Rp}~cD)rJ*DFp>TsiTSV zFd$IzOwH+v<^)HI+AU)sp!y82)LqLXDc>ckhBwk!jBrU{D4vD^V~q{Mg^r@&)OrTA z0YP95j;=71hU@Hlp>Z&k&>Psb1|3B50ARlW(V3ys88m(%7+UY%yoo_mwZ;XLveMaK zI%zjI9oh;bct>(wVr{m{KlT`S^^%l71kaqSg-R7~8%1?j1751Sgr}aPBDnp&d^p=( z4clV$20vdZ|HyS{5&(Ec{LCHS7s}xvCgm;3vM2l@=&J;PkN{s)N1dv5|3EgH8WAO> z1T>qdoMPyqs-yp6_qCoIZGwO$y3v(pY|Fjdgx1Vk;M8ixmw7sKN8!&vpZ)Qkhu9uQ(y;D`mlpgMX{j+PG zSxx=ErW@3|tbYBv$J~y8KRj2axN6mOTxkf!bm&c9W0q&h)lG-uQQ`r^z*V#kaFEv> zE#o&lEDQ)`OL0y*4D#v4OP3V70B(SC9j>Ku4?C71wSNaXLgM-DN2v!}KfHRi*}~li zorKM}W+3i~yb~XGq#Xfh53nfWVK$Q8L3+N8T9HDOi=d`NNnf)(D+eQCR33bZG+^d* z{2ihjnE_*xFmKq@R-!epOWGn0ILsbmV>}IZklz7uRO0;@>c|m9fEdC(1(9;TKQRd! zJ3hUOD`6#8I{mRcXnM=xCnvni*JsO*SI3ULXIJ$e%;&v#pv_D-VqxL3wseyebF$)F z?llvG!zspWvvosStxO%AIU;UFSQ#RC%jh*ty!0KlkdPzor=Y;1_>Eas&3=M+SYD&Hc6 z>NgpbUg3oub7uko2^kAH68zPIMlDU>40k(tN9UtgI5;@$MgD4pWB|Oat} zZf35$a2heC@=0bE@U88P}WLx1w%MCu$r_2it%eo)kZ{^hE z;FYP&J^HgjrsoUYYT=2au!)q3>G4&JO~%vBZT-fEY_s3LZ0h;Cu(-#$m(=#SJ3x}V`rzk$pEeP@W zGUifFQFWR8`KfB@Jz%m^p^xekO*jlq@1}O#mpY&uFn9l$-PP4g*C?=@_}Ds-zwjr+ z|GME?)wAELdiIZh&GSytwnBG9MDpZTMAs_s@mU*j8S`&yPoF-$<(v=>_q9rH<(``n z2uUIa?~b2BPX*2GbGY5c@CfoYH9=Xi!Ir}ieR4RILIvF*RuXb$+8kz&vZn?O*HhY2 zHxce<0r6?TE3{;6IiGw89-4c9BOir?JQ0~T&yrBM7GZecTH3tCZu09QRiCeRqFRw} z8g#WMX6~Pz*%~2`eeLIK#ksD4LBqu4$-{Rz3$+=rb{skqb<^>sV)VHAU~X@L%2&fr zR+x%*BKt^bk>aHt*@CJFaMf3Tzm``uk!MaWMqmOl?(#0fdILGyPDEnUteEW z$Uyo>3;{`MNY3p0UZZ_xv-gn=hB=aa7p8K0k6p3vi%t*6H)BTHk6T;o84$S7FRxz% z(~Z&lCoJdW^Lnetot}&jkJEg!4-Mb{?e|Bl^}d9~jvP(Ly8^Ro)CDRlQ~iAWgzun_ zdFGI_!sN5bIbFQ!4}$czN-}R=y0TMySyDQ$YW~Y)l{Bf$Lh}p7%RhApeHGs={^7*n zmCz%B%Fl$qF2DO$BBkk#1&6Lh(btxx*@ws2JT%|E5gT=vHY;%%Vm|Q7o1)uaRl3sN z-a9bET+WaGrm=U@kMAFH9j^E*+h`rTHRjy8GS~#7WxIybB!60x@1_CT;^?i(^+&_4iacWYH(Tms;sV^9s4xLz$kN`3BI>pQu$Vg%XtDW#4vQTb z-rfcb3wI<~er(H^r{m^C=OEU(UvbnM)!hEP3Dl(#JWCj0er(SjYDP5zPpRM=#L~qp zlhQjDWt-}xlx{n*e!nll-}XIPJyMD_o<(Pii7Y^ zTY*Dt?}wX*P8zcvR@u#HOsj5W{N^$EE`P(Khr*nvd2jz1WVjcyX8tcgaVO<-McKZLYN6>v7KTM9 zhfluTnX~KknBy;@wxli7*VdNTN(7ddS814DT$w4zotOLiiXbN?m}Tc~=5KFrv1Wi< zB2yX|y}km}-xSl59sBR6J9t*-Y?i6A2@MI!MR$rrAb8I+pt4&5Fj6zF_m^-nX_d2@^f!JM*yVo!wU}`}lanygQ|* zhtt(pt;; zHO&u6TnK-|HJK)C?@5;!04{`aF!LSxH7BKIo6`4YTJ68FujzF- z`^B8*)IC-AZ3`{+nV z?tFay$zxF&zJJp8XYH>G?mxx~x6 z#)@sW%OqIWROG>P4;-TMr5!(VPDal+HgY)`(#z|kHhCUc?E7oEl)hD{tgtputf=8t zMK_+MH<39V3UH#lteO|Ssz1^n!dfToFsb``Uo1fLP7DUXPx$^j>p!fUPF9RJk z{;8?KLzTxTs5=eOXi%SSI+8TCW80I@4EI)wjXgDzdG^$5;+uE))Xb0JkxRT>!6w(Y ziaqEV7|CYMSQ&n&_L|3voFX(y$G}`|9iTyBhV?xLS{K9*%}~}5^%-EQ5JU)*Qr6kG zLIH&)GBIq{HlSC;nUT>jxzEjS-`1eeRGps!e`@%hHYu}rl~i$8F~4V4+mW`Gf>c3`aSAJ z*|=VFeei+$a~7ZWb$z;`7C+|S$TYW0Xe-8q-`u6wtBsc&R1tR@56Q}|Rr$Wkeffi0 zwY(hrPl0A?QQJh|h67B5&NpmIed?Z+ErkI?~vD=1`;1nR(QhD?k& zd;0tBi!IL?$rzA{#s)fh3jmW~`=*dM+oh{DFkj1r&L2=SfDQ$?S0JV41vbkDD1p%n z(m^u-_)1dZFePBuK;KA44u6I7m_&$g+}K#>?}6g5^hqdZuU$B{{6alt<-sjZ`Xu~H`#l?KYnt>PH)Mp zVPewE-UhA( z%ewcn=!2eZ4wvTzcPJ>7Z1C31zW3s)aQ*Qgy<%%IR0Fo(g7Gm0^z0^7WD%4WVuk}I zd?y@ID3Iuwi~SJ+C8w!S{NgI)e5-ek5(FE>Cux6P0|%U2cw4~TC~s_xKx-rG@M>v!n*CW{+=r+dBm%%B)A&7T(6nq=eB|F5Jw^j9lsK1WRjYmr%iDH<~8zQ=m z3=A#I5X%dI zI!x1wO_;Z@_H#dTraxd|CZ#!^=84IlvqipUng7qBjGvR;-iG$0#}Yu#VLSeDEdq<0 zQeWtH*zDYy>%Aq*oB=Ra&c-7JcaxWm&(BP&o0{yFR1J*Vm^S3TGed%h@d@>Y_`rTn zm3ylEjxm}&nv|7MD|_n|mo;XOkC?I)$1rD3jC4`?7BsJS6`*c1N7WFyq+iBwm&DU&2(RPt*-1Mlk%lMGr`0()k#Hyyp zD+Wyxu=!~lt;!HFMl#?rvt>{%AH#^($_Xv$PLav^^xq0vL>p(TBs{*NP z{G!@-C*zXijG+Kx#hIFwl|`c3u$Z>s?ciGbjgYrDkDSalA9)%AkuidK`capWp&)qV zuM21<0K-G-@34A8Po#};Y-C>9l3ZV$bAR#3lhmzLC~lR>cPXjykj^A$;cJ7W55Q_NtPQ_ zy6`utf@TjVv;q><(V9kJY70aklVCoRJ46@Ayo!QmI^|LUl?3>tKsM=3(&_L8gu?>Lye%Y~r-s{?VdU_y20Sb{mYORENSk$E7Sp8^Wt7YvKXzIAd1x|aSqk6uv@iS(4G zNTUH`pB(q8tQQdFe8RRGgo8wwRRTlA7CV+``|1QpaBkE*(H5Y;v34&(MHbjwTh*I^ zfIx%x1#k$&oysnsu7Y+%&%xzpp`+gJ5X%$7!ckl)`}IB+d$02O^1?7P=A-}3UMV9Z z@7F^=%Em`h0>;|zZECd1w3=g4Hz?GyE)w!6V!b8CocLJ0{zQ23Xx%qv4GtkO<~X$L zoHVHx<~xdd_m}uCOCV96HR&g>g=njz3*AzXyC}J|_qN@v0LKp=E+)7$JWz1!kLc~~ zls$2HdH=+?wdN0I8`pIau_H`3M$Xmuuhl*A!`h>;`}y-P%PrP^?{z-OqflM(}R_pu!Zmb|>S7CU-Sz93mjaj8Fm; zI^rIO=i1vlM(M#E5>^j)KybY+360174`6Q>SpIn212}UD z#)Yh@b2y?;Vv3C7zyfwBn+_HTfzuBv6ro^KP#e@>heb{rLkCP|C^w|R1^JB2=*Y)` zz76zb5em&MswGA!2)hH!b^b$jTK(Y(je?4u84Z-^;;Y?V)12C?Ui>1H(2Z=3~%Oc?-KjS>9I_Fcg-=U>r+?Chg!zH?+kZ5 zpBR~zI;Fml^<&`s1BVh`>2wEv9+~B#i-#(*%|<3%l)RNUT)anEK0$W{c;PSC zCM<7dd_eKpqIW1WZby8nDwjxKUO}r9b;zBv%#M{2OLQt!&emTW-dglN_@_rv__IFK!!8eEq&rN1&3vno_m=EGs7P^t zrZ|82{iQA@@!N@X7i+3ysPSS@#L?H29=CQM<_HvHuyeqF95?}ML0y8PB@fam5E{U(uYhC#uZE3$VuYmAzF@T!-(T#6nchX17m%4~ z&0LZx)t;Eg;TMxN=N9eC!EvQ^jjphONQbqit#eZRYUi)-%u-m+_J$+}6*yh9Tyv^R zQB|3Jj238V>8+Z6WBd5a+Pyi4zI@Aa-Mo1^n=Td-+R5NH9G_e+D6m}k?5+#Nyt~JO zg?cN`UAS1b3;;!1D-+MxlSnfntLs$`*Bb>1?(Ek9A?ri(k%lkZROp;GR3G5&j6$B z7_iETA0C2e$&(^c^U&|(DWAl70pf%fUPKH9nStqm$0>%{(h@5xEAYOz1AqiYwifzB z>>P~J@*?6oDsaunVe>9Fbp>Ssa+9=)Cd5CJ$^CfWHFpw@jpHf=@fE3_J`@e0nf0klXN^n0KH>{R|Qf z!DCQD!Ls8e_L2qS8FAyOVWalp5=LPZ2D&%o##NYyZugs3gf{__*yAzSBCCX-7>c48 zc#qaZ0{16+{IdRklOptJaJ&L?ZGiMs8#k7X6E=zVolcH8$o_QI{7HR2Mtyg0bNrZPOr zoK;ira>(^>hT6bvEYC`ourzS<83%5QI>mQay8IBwk2|!3ys1m9XN|-|v{m`t-zMyd zsUF?xb>x+`)2g6sFQqg6D{A}>{bpOcNz+Y{qoP@aSttLkZLKHgm%5-~vF&HoIUHb?7?6xjcVhYE%29@R=GzM=+ z%L*kb89ys2MQw395N8Yq{2C0?z{0x-FbToK$kq&mDvER6x|g`DN#9B;w6HJ*7{wp& zc<}O&YsnsS^VQ@R#k)Y_%Q2b+Jzf`v7f1#d!=Mdh)o6@LvF{A2qhJA`)}rJ-dW0b; z$Du=qC`ehRLc&rPvnQvmA39>lYa%CyapA+gB~qyOxd}706?WW1ED%vEV+gRyV;5(MI zTu7wm{IeAng}g&l!$Jv(&8tL3+oKI*nLfR^%;tRYQGtd<(k+M2wK|1y;g`EZI1`QS z>!Xe@Z#ANx4tIURz!+yNs6Mm>XDWn~PPDdaT^B6y72OrE9QjaVEGZj0yr_vQJf-%$ z#wpn<=3R}!Q}3o`YWnsi>v%>;%<4Bcj@^zvaAI_*^`rGbc80|}ui7Vm<(pY2gM&dE zP@Er3fyp&`*_z{r!S_f793LT|%KzFd-U$+9qtBi2btDKVGz%1>r@)Fubm;`l|B)cI z@snvCb}VazP~E5JVMU4&>@RGVM=D1&5LCR)3$LYgIx`_18V6kypPwP%Y?sudq1i&{NSwk%93l z&7So&x{LzZW*aPDtr=BKI&Z6DVnxlVkk>ii%2O_}PnlJySv-1sbz(U;%fqA7RIl`@ zcW-m2G>qTwx*}$AM240t*?G_BmWo_dTwJ1<`Hosw{psvr*JJObbn;9mR(`Kd*uG*V zO>5OQ)nRzyo(?&@L@w_vp(8sxXRUZo$`Anofh>!Bme(1vU+SWtvuTsR)>$)>T+G-- z*Up_g2b{4iassDs)HfHLwgW|Ba~62Cg|Mu}<_D`5+{#Lv@C&j$cD)eM;sRX+vksgQ$-{-YE20)JTc&qlHDMw_4p8M70FEurgmOm+@U~hk;6dBl zn$wbMz_yJT0HR|4>`ZnuZXaS>QQrkUmwXpUdEC+m8XX;4HR3oE<8aE4?vUFf&Mv=* zFs|NQF0Qu8nG@K|e4_70+~q_uZ!zQYcR zb}w2t3Ya3nC>mEYNGd4g+dc{-eW~sf#<{Xp`!cSG*=mY80&Mv8Enr=ZGpb91xCT9I27)tQZxQv(R- z7Er$%)lK6nCinRKAPh#x3!Npp+D&9P}0(26hKA3a6H4NB& z@vvw^FMz7bsp+8kExJ;|Zt+62ayD5;7j}dj-pCs1??2Dk8!3dk?M`Sylmly`$T^|u zk7+q=jpITw*%EIDLb6;{{U2=y8%x3*5F&)vD5@)kh8Z}xgGft8$D`RBfs@+3ky4u zGLdjo&2;mg=P^plzG8*ezW0kt*K1^5z8|dv6r#H_8MXrk8j9)cl zc>Z5EGU+2AEJ68d4p9jv#1cwM ztAV=_`NBh+T8u0z0q20%9fRAxx3?EHjt%A@NC56u>IQQ<=BE0s&Bl!A+EE#yZ?5|I zQ2?|WoIpft0Vu7aq2UtvIC8*eVGgK`!-^D;Oe{-@Y>7~RP)Us9pj0?o$^0>3!H+y1 zP@+gGI*vUDls3TjBXQlm!C?r)od&c-z*4*jrXZnzqX(~Z&2bugXeO6D?yP&&D9P)g z>Pt0vcpuVubkr=?5E!5O+FI}FkM<20S9{&(Y2eDSZ8{L(u7{ddv5S}U9Y9K20`VkXct6oxUvKy_u#w^!v(;n?Jw8{k_3^R!vN^ zKFXfl#US)dg88BVmz(zn>#?VB5bZzKB|D@A%uLWqK- z<=|uIdhlxq9}xOX8*n~}i!x4pU>sWDO-J-$LnfiDAbQL}=`3jdZh~!v)?zO(m`nhj z5HpAZ{UC}kj5a{7P&nRtcc-9HjY$LCUMi!6cSTIjLa#B3|M86g&XH(nl>#pqFZ$LllpOVW5i4u{+Lt(qE zX6pRU@cEZMGbZ#hDDx3#^6V_`gykT(-2w}Z)MKD+%3}v(0pZ>nMqC--xN!@W5usbc z?lm5g^e|xB#1s)#bWy;98dftMtWakV74brP{P?Jvw9Qo?J|%xhmpDF7heH+-<6)7A zjt&(EaXE#l7Lbf{cm|BqiUkA`L7j(V60`D8Ee7g#*yFIGRPY{i1iZBe4-@Jmh%0yv z48RSh0aRha(~;+ z1Yxo+LLcif8uPnQl+&%%?c@E9ZEJP6+KE5yVTl$JGHx!P*xD`1)y!gQ*KI#LB<{61 zPJ3g7%g|lch?qsmYh!q-{7po4X_q1+?Lhe?{R_6+Z}c5%Q$0*wKwr_T6rCC2$3Q3* zuMBBf5KvEOR@hE=K`%GD;)pLH&?LsDWM~dvK{fUkpSr&aC>#*cUMFZUxlDlJh4adg zp%GxgT9oK0jY(V>bP~)6Tb$JdxD?s72lK!Bb31@P>Kv%Oi*uvqcT)PNzP{(^pBYNF z#^mJW7+rv7HHipiK=K~s+l^jb6lTp7oR9OfzYQ>Aj~GaU@Fa9kfZWSAE9msTRoE?;Y)W$RPJO!;`?h3WObjWB5B*beu<*40}yeW#t+0)6cQ=2l0cAR(MUpw(^pBTM$!#LQ{2x~pVEES<9?;IhIMIj3N96C3yvu$12zwlJ=cI1`X z&qfdy;(NJ%7yDnoq62}xXhG_0oKfM`cMoOYWP!BuDaMa)D^fxWjOE5dZoO0sp?`FZ;_xerRc^)lh zhfYc+dv;4*vJ|X;AvW6nMr^))-+?!t%hB?fAN;z|N!*R#xRi>!2whk>FuxTmS5|^+ zNn#*ycmUmb2*DBlb0|u7I17qy+!z6nvkzh_v}zY|3BcZ?7dQevU}1jtN5BHX6yUk! zPXtdy5{xGUQ~vHXLD{77f?*lPU?`HHiIayT!TLTnQhFk3<-H@3S>S40Jpz&!Y2R@n zP~JkLK`s*qG4OrhBY6Y?Hmh zCF!pfBMHC+VinRKg3{8~*Ip5HfDI$DK(MvFw!KzurY`@-`3 zCN>a(`o#5b)BzkN<~)J{vvLr@kTV(Inv0LG9xKp&KCj#gijjmEmZ3mOr=)F@*yLa5T-K@F`yg+h^zkIn2g#s>!YOG%7p(mS( z1{sYhxxi5e8NrlqetyOk2r=<#1LR|ei3c&e2R0Fgwah;?WDKNz7xKFj09fO-%z%v< z+8Qz|fy4MqRAo?CXQ1A|ofn2hL7Kn|fYk((Zf;(I)dRE|pOu3fR2btK4B1dVf`CnO z3;z7FBPQiQBFKRORr+Ui&k~SVG~QIcMtbOfXGeG~^w7|e1{@qwaX`8F99;bT;gONc zh&mbqG_7`H)JC+)YDdxGf)s?Dr%Z8O$G3?K;mbsitsSCkdX~I9zdh*-;-L}HL`}%U49JdURJHW*Y3<5lkWdzMa zyGZ=1VJk**PKXg0p6?YD4=9AwQLz)1DcQ7mt}*a$1)5Tb+7A~&pyg*Dl-HO>vIe4L zCwgX#OP6claOlKQD|d#tjljrL>s@vAB3|BW1%E34?$eiXS)5Y}#}(;!IX$g=6`$TQ z8O+M3ju3+dN%-d9Rd%yoePhl@CTegMMNA^lVV&FNUyZlJ5-Y%IA?;j4!;(OJc;b(Z zOPGPYK7`zcx{*SvAm}hSCRO@v#g+OC!J|_`!sR z4Sy}9coQegIIOl|p6xzV!!>wjoh3foP$rTx5?4$NpaGksM|a|l9D+|cq$5vU(6wY* zm8lW)U933%NLt)&9Eybgh69xg(_RScL9vrtdxH+gd62no_6lmimT zLBWqfY{QE>>lYBO0*~2Rvl-oe{a4veXvh2deutMG!v!D085sWj%_)xW>-=@yB!~7t z9iHZX7DhjYNdis)uM%ixlzomiyz_qHo_xmeu8b0oHvGw-66H6JsJ{hZ>ds*3g6yFr z4zyfSkLnOb28FB`;B^}F9X!eNDE-`vajBrzU#0;ZowyR=&FsS{02%J`k*&}bm6C>0iHp^j??$#7L7nz^aU?rVCk=$;3Wa42gPWuva&MH zW~RZG_xO1=P!dp7mq^kAogpX#kCSLKpnn}g$A&=-LphcVGc!IuJ;Y-XT+GuIe^cYm zfUkjHv(<6`?c{|OPTss(ycApO!1YVTJNNJ`aT4?{p)Yw`-C_IUfSla*eT#!&D&`pp zVUc78<8;`mhbwvxs+9Qru7vSbJz5A9*vlx`0K}nv7J^TT??k5qv01?^LD000U)my#aszX_AY%xV9;W4Hz)B{Fi(N9UOH{Jjc9o_pmp z8OQ4z+Ie|T_9hZ$31Gj-+wXA4_rZ{hbnq0y4Iuy1(s=Ri-Swy_&c1P+DO#CTmy*KF zE;+r;z2zPNh7qw?2B#M{AATV^KoU}AplldL1`>Lbo!B$59`0$7DXYSTO##M2_|5=~ zJ7KPj8!ipSrEZeqMXWCg*&ri?DgYi4lulIS5x2VuDW;ICi4QLz zH)HO``hRk8!(&!4a+FO>K~i&&?foVpFPC(bb!FZGOa6GUlul2QnD9G!+mwaIlSp(C zKpnuoOJUFfu@5}np5v(Eg+T}5y+JJci%_XPe-6R%M;rmf#aZx`m;%(`DllE<3o-d@d{9eU)R*LO=Ta1I8m~L7usj7rO8m^3@vchfE2K5bUGagWL<2N6n zVzRm&wr&8ljy`a;nEV0$t;B!yx<|$jNZ*R?!|Moc6Dt+)AS0P*Aa6R;3TMsqG5yv zA^|BOadF?myS#xE$0&YPEK=_6&x|>4^EVQ1^zi<*yFd6(5Mt=`xosTzxdvI)pAW7q z{uuxFcdJ?w71$~bixuR);JLsgc_$P!q|Cs>>OqM>Dm)As2u1-c4KtgI(d_#{l)+5U zWo-k-nxF^NCQG1T!!H*L7XeD?^jGNv4-VI3+{iG63LI?Pz!g!`ga~%wf;FZkC^5*@ zi(*a_Krpe_Af+ZSJUWVWI2cBtxh8`|Mn*=sS3m#wF&W3>YZ&>gk3u25375Oem?U28 zO!d^i=eGeD@AYENDXxsB4-}r6!Qo9uRt8hqL(5%M1aGQI5cYuPh5f<|nfq7r@Q@iM zG}WH~!IM)1_55hr!W>3k9GLz;ENC5=yN2!-L?YObP<|r$0!$;x9i$xqRIhq-$LY%V z?{BPFuO$mGrOy+Ow;JFV?g8B43Gm=WMM`)jByJ0bOEB(wk~~T3Gptu6sNn!3$SXix zF+2dmqTi>e_JBseDUHLRq3&<$nzm_9D(BStf9p)mJKNc{OF{tqfBW|BLS$q$P7i!| z1&H-AP<_EF=&J#i9L3MH5F$&yoc!F}@=6iAT>;qLr8D1^L8ZNd>yl^yaF`&F_9_J5 zM5Yb=p&p}(OrTQhcAQFu!w^XPq$+w1juv59f+LOIkTI30RNp;b2A?VlFz=7rQ z;^ho|fpvvI_~M<=@)T}c?>&DPnk{->RA~Gh_<5H=ngZTMx>Kx|VS%F&1v6+MDqgqx zEQ>v(L1iJcEIef5_C`1su=FIOZ3x>i5ZHx^j8LixJq0UDv@<}|!Sm6;Tx<&7v}8n0 zAx3QnJ~Lsqk_yIwj5^!j4bfDuHlec7!}pA^TPAS#cy<@(hZHfLnbyv#$YrXvQmy`R65|VxWtrLjDA;y&(n#nEH^VhP(1g!u3T3 zhD5&g4KE-UCQyXQ5WKgbP^oJuIf}|b^MaX>em+ClWk{P)WOzQ`r}0%10InY3&W8mB zpK*U5F7dvKvZS}aUkite)nEcu5_D1+N-iR~CJ!Dw06Upzh#>3G$7+y%6#JimU1(#N zP=tYbZq2RA3ZH;Id3|b`gGJIrDiW`xeiS)CqmS&Ltlgg1em=jWb zE{;jwd)Z?E5s*}t!Z>}Z6r4-KR*p4+`&^w;Ha>YQZ14C5e$n8-+w)2C~ga0Zurf7`!K3*KybX?}xYb$Kie(?*N z(G_lNE%ex(z|Zj8kdp|rt&X=c!mGvp_a|1?$CYrC;Jbg-C{QQBcmQm|Tlk%7)NpXY z?Bx7@vK9V5tzMewE~!uuQ3%{jR-J?ufrJ2XU%uqo|GshbC+!_gTpQ@5mnWP#)F#M< zN+f6q$l5?(qCbB4C#H;i+qzu5_1th4v;`xQ92XQ^Ch+rWDKh(KkC30wcU`yBrw)(G z{Lyh99F2B(6>#aTUAy+pvqS&;vP7-(P2d@37p2n{Xi2LwXa^IoZ9jn475YQ+OTnFK z3HT)JTBP;SRM9$a8T?NZ6w4=n=Q5*S;1A0Q4d4c(3?h~EAytFFzrBh`+k*)PtlM<0MWGGA04}ubc4qb0pR?Xc4ojyU3EWJ9HULfV zqCkw|Wiiq~t%%@`xt51vd?t>Lcje-HzxHEDWKP4*ay`$I$G@9&+GcK$Bk-up0eq7hJN}KZ(36tzt z*T-4qBV*rpiwpmgQiSjNHD**-wTZvsFg4Se)|S|){h&gg8HqXM+mjHZSUEl7VVDzW z{9@EX+3vzpN&5bmW^Qj|sgjcAiHq^$ka)BMiAUsnML*OfU%a>GS6i%8Zb!=O+B<4| zE#%|<=i9X?ZrZbO=f%(a-~O)p-vzx8A%>Mv)N{(Bb@8OCPjhDdPdvQ|BBQ(RGs~%WfD}S`iJuvIw7_%f_ z!_=i;u0iLinIam$3%)yOMOFT2_+BnY-_I_@nQ)huWSVqFu`gj+tKW;?_*Fdey{64y zI2hC@SW226mi)po%dk{uVBVG`fMHKxz;b7*_)DM?jzcYH=amO==^R;61UAl46iFCUG`GmNL zFRbPA^j0wnJuYIPk8Zn>rw6|QixTB*vwB@M-luo3YX|my#)Co96n>l04RirfT36b_ zi4_>cKeCj(`g6wIf4MOXa|?~X+Iml}57rsllB0c#`>@r8fz-Ig#?*Be$^;qLvKF^I zG2=6vJ?-M?+amAp^VPxEo&;)wj~#r08CmvvDoOrzdWO*^8GIwr-h*}(oyf8c?wBi#J3o!C?}du8aY zCbcahdfr$43u;v++(I^s&0H8*jrfUsw-$^HhptX+=%dz~>oc%ypzC_ehkKsG?p|cb zf0yAcqw*HLcd+~)zo&ey0-tD@5*GM1Q1IuqbQ;XVMud#D)O?H+eJ6@7|L+kcO+QcB zrKq=td5ofF(6ZcKqlv#|%I|!t!-M&xc)y0b#`5XC^g4%|b)1TNCpA(M-{?GWvbt>i zf_bX;nx4f2+Cd|FE0Tz?)KYR=8?q<=Fpd>s~ zerWLb^F1DTA9V&3?eWSpa8q8__r>Cd4;COW%lwM)qrZ}?L zdm>D%&Y|fywc?*6<3LLR<6v2=4C9BthlFA|zn|2W^38ZzhjnoH%E|K7v1DPZM;YJK z-*HxYm)Dy|d&vL$ymz>5{Izy$#Ps}u6^=}^Ypf>OtaFWz>rJ1Q-1VEezbYq}#lo84{ofk^q#65^yniyF|Ncu$1t{VEcY)BTjK=@_ClS4U8vo>={k=c#NV04H zpBqk540p@!bkK(-^;&e3((zYn#;=Djx9BPJ1$>h+`Th3a?=&hN6&MGrjik%-$|tTG z9}hS#U@mFLSbD*AqFHg1>u~|Af37ECd1dkgCBz<{tI9HX!K0lsr=UcRcpUm6^{=Mz$B1DPEeLti>Ox%}T=YNG8 zJXw8#SuwRkTJ73@z7_x9Z?$#dQrWUa{sC7djH#-W1J&CO;R2eHYWmMAC5AHJ3E>>V zwN^gW_BAe@_PkF}8c%hjUdyZFNvm$rx;E*xz_xp0Ug7c=mewn-o6V@9>PO2y?R%B@ zX46mhjJYlI?W-Ioihum)_x!k<{NUmPxZs$+E!x54MOh;xZOD{>*GVuby;J4WmvM%M zshR6mr>**281~Q3Y0*yorz)>|z46U6CbVn2Ev(&U=TZV)0ww21F9)jr+$wve)?s}c z)gz$EzJs0GmZKb7OsJdu98+R7=BI25H_&@6a}8FNr)Z2%g=yiS zQ?px02|6?SawRo$y^M$DzpL+QQWvL+ZY#a}dBp|_y_Gh$F_YOZRxO8?v?WTW)N6WA zu+eCG?COYvi+v{|=B`K-S^5q3mtmw|nP)S7x#$EF~t9<~nxA`1m@v zjina)Ed}59B~LIEOwF9NDqzAJ%=olw8wbUuE#G9{53!<@;XO^8{@wGgi~sos0n+r_ zDG!^{MJF4?i&Dhu=Xe)u(~=HwBye^wW#m_*(M!YL@AK#$-}CCfe-bu1)jxYwX$Yy zv1EjdHS3_rE|h(1Gm+dhC_;-NlqCse4Y`x0EK!L;$iDB}@4SZl{eFM``~L37pIst=X##!IcHfYZKUTvXCxlZ$iOxGq#Gd<@FYEN^-F8{>&yu_p|rtb zruek!0p@a>-DB2!lp=omV)afEs(Qu3%Q4Q^X6wHgG$_o2=5OlrOa@?D?Vjfp^$${c z?xzD-@9lq>1R zvdt*qX&Pzxb*xN0AK_d^Icx-3&8Z`V+3_NBk#z%qqQk9{Glv4T`re9@Jk*D0Po08> zbOVR}o!1`fE7JUH`#iDb47)S z>yQ0DLNoJ{s-rdsLwc(+Y|b3998Or7zpXNIb@zA;#0Vk&cs?hoLuKLK3&C)oQ^Hk} zOW%GN;$3CT$RWq*MooWShva}%u7(xS$P_(7uWLp4@WQ_eZ z7Pu=iac3xMPYIhnRNb;NJY(jYy!_RyE1E$qNOR=h4LYv_hJetN!?=%87A(M8mLh5 zKF%4**YWgB@BQ_UG2F*m;m%7nv#>BQWxZ$bjTc7?-q5+ah7`S~dB6l2(<5l1(-W%#(_!Tc`awj`En_qU7_G4@$6sf;y{K~TS%hSKEPH4=j zCL`BVa0b>BaIF$4XgN61JBydW^MEOIlQYv`n=te_1@A!nIS~r9&rH2HVAG=Z_lL@q zURx@F%1Kzz(KACAWG}6p>wDv}&;7@YYUGq&XT>IclSyf6)+=A`J;Npd{grDbPHwF& z%!J?N=g8wc*D0iHcO~*~c5|5g-ML;$0amNKVw5IWg zuCq=|kmp+uA7RkCAH23urJxDWI{>wi=mm&J{Na!m_Uxn&Gltq>Fn9#FE?^rAu>IbhM5@v9o3_YLrMFI@1S8O(s&)1nv;5h z_qZUqb>sPShd@7}T0`tr$nt|y<2Um2rcDxy7j#1iVaL?YQle$ zD0tH`u2Wz4NApYHZ^iSME@jX?*GO)cWrbigurn4vG$7h=XR8P!*T;xyhd4RuQ{*G6 z!hSsNYGSF}G-b!?CDRoaLP6IQequbHc#d6qJw)`sx8&BLm8+^UjhAjTr#v+;e4|>G zS<_`J%0RNW$NzYfB>n{0;FfcPlwc4DHoCqg^=9>{3wz(X>8#_8q2_zmI4d`mjN_l& znY#;y0Err_4+A*(P(3U(M^K>{!XPR>>5!j-(03{AYXDYBE1ib0BmigK9O>x*lvi!c zF(VxnA;u|PA5sBW6vRhfeXRt(9>h&_XUArbn$5L)M== z2inc6h2Wt$+-u>G_4!QbVy2xVIB&v`asEiV_{phuC^H-nrESz^SF`9dAW$;;?G-OT zP9aZy)cO9No13%$qJ2WB)Gd7UI5%@D7lWkEHLfLU8iIWlL(LeHp}C5x^e8U9>a* zr~&*w1e_p*HxC4cf$3=j2*d$Ph6a8?zwm4YLW)^{K_dlXLH*GpaYv-aFGPBf*1y0X z4;u~&v%#JH*Uhezne54C%=qyp;-F;PdxcLIEufwJh1bH+8EU*sS2cUVdxm@(DTN6s zjV~a>9|@DeqR>R)cFiVJCN2>0IwsABgnjf zmC}Z2T)KHv5MX@J05cpQ;r+b4y2z?;erbDvBhjyBb~nQ>h46nh^!>XR8{5j!I$w^s{W}_9Ap6XjC)ZqOX1_*9R^6W)=`#B{-lkbK z*)CcUL|n=|uQM%h3i_=>n1rgjuP>dF-;xddw!TtmM{RjJ@-|Qn9uhl$eVm<+%{zDRsEfp1e$CSpl42iw-**=p8b6!utc&NC zD|DSW`mFB8i{pjb9J)=EID%pz`0XWmCQfEYdXo>)m#leGawdi+buwDQ>Tk&;pXA zEyJ%Y9;>!?RDEkUmfAdEC}FjRJ#^;U;o{Zdlp^vCW|}Y1#jiJT{FS3*#>71lop@oL zBHx9tGs7vz?CIbcW$jHpc9AtL%C&bzKlro`=^Ld$Z%kkzAV@YaFKqkr)QhgHbpid| z;l~?istn@86PFvUs#+E<2g$TUR6;BED?}C!-S2`|%G6J7gevx{f1bzsL#!|WSP>W9 z3hR-$mg6dqOp2-;i1DQVz+KVqkmX-xgZGuY9aG$sAN!f+bD(4%>*C*DjJTLqbaAu9 zjqM-~rW&8|=-r}e>2UJ1-xxh#j3vse)8tFBYvF1jM{jH{=jN1O)%w~z1Fsv^fgoko z&4qTV9>{7($OTjo;kpfC*Yb7N%qHM+Z}5C`{&E)2aeKNHk9VV1Bb!jA%G~#>rgLAV zYS`wuZNT`e633IF5A@{wfu1%p->U8e#FrkJW*?6XR24)@;=KLop)B?8&$Ilbug#;& z%9~bDKJ2+fDftHF-=d}yD)UV;RLFnIXFu{5sV*H!ar*%4LG3?T+=Zkqj`m`C>n@%{ zHX)t|8no2!FTM6H!bty9YNqqMYvOy~B-z~H(Ele@YZ0l(0W}$7A!&VOJf;ySoUK4# zGWYv+ZM6Zmdhz8GplBg6JyR&d=jraECIdm-fn?V_yH?d@giV5U1cAt6^R-?e6UAnw z1x6Kj*`z>*{p-0#@mB8*_^1vfk0DK0ppvsPuV?ve$;b1L72`nAB4F&o(ae<4&5B8g zqdW#e|I5OUJR2kG+mGDe-acqSU{&b(8%9U^15#b@3-JS;uML#mvVkb^N}G43Gas0X zzH0Fn{&2~iZBO6wy)(#nwGM^E&!8B|1E{F&4GYq8OeRO9ej@V?vK-AwDX{Din~?>)gE%H=J%_% z_8Zb~_wI?(KG`(hntGdve0#fQkUc)waTID zxGRQant-zhn*b`oIWP8W-l6$(h!BZ&|Nc~utFWnvsz}O#YGPi!0R@BikNF)(5hi(svsgi|0L8N=hZOM|R)XV_QYR^#G!H+eMoQCy< zm?$gOaZ2M2{T-^GG^*ht=x5qOX9WSzlM30$F*%EMxn8x#dH&%A3C~FoAa!B|dN`G=KXk z;rO1jSePxVBvZN3^b$9|LhGaZK2$69G<5@sXyY=0M;)i)ruqUk@5aW)k`>%pQ=s(a zNYSItv6HH+zfGL`LJzNJCRoHOi9(N&2irXBEYT)^Q_?_-|jHgeNc?ym^RpV4}UWL5M4AnipvLmr-78BAYIxe$LZ$tvr z=C6KALo^8wt%UXT67E3JlgdO~^53{*pTXGwl(_Z7R%G%Ere?CK57FDK~+^El58jN^Pa^4y(+J2T`Z*yAXrS9xG#!s%`;l6WUUEqj8OR83m9z~LpPh*|Mj&YZ=`_q?-kQQ(n zEK!8hB)cFg>BObK-_dm|lRCUEre~a3S{f~H@$FY{Z@9n3Bu+1mGcrp* zR*o~abeZY8j~uJcw@~+fqR1{Q^-1EgkJ_{faqe^sULaH+w65vOZ1Mao7!Lls0MpgUfyW zH*x?oc)S-oXJ#8_=F>;?aRPyhH~9S|mO7v}fgexy^?#rA@C2z_!MR<}u9np&3nM6+ z3O&hdOw5M#(Vc7*LDtCuGD-FO>4Wt5Dhs#P3cfpfZLLCI`6*ePd%^C5W;)I46BfT& zFu(0N;g>uIuEb1lkk{s7*@JV%HIzM!cd4EZV}GvARj;ctB|GFa-)xt9Evn69tfR*{ zW6TLzQ(+wwDG|l_^X8X1yDum8I5!$;6nQxqP{yD@8up^>2fO3v_0;@ zT#81@Q+smr_By4~w`UH)rxe0Ck&$qmx=byKw22oPmU@+8M&B~^41ZLtpf_e?L9RNR zcjlDS{lai&WpJh_{q*`$Sv#?+GQ_TIC~Chn37OR8-APT{lflo{_mgk>h-R}){-~L4 zsO2!IKFf|gZs)A)p9vj@}-8B-s_U&T9movw_ z@KeGGBnNH9sZ#qp9fPqWFpB8ztDTXqV)5&t*5;?Te)n77D1d<_JkL5BXMme8+F58Z z-%ld-Cn{=?sho$yqAkGW*T=fOY5<$DSh)Kc84o_IFx81Fb&1#KreqVwXKJ6iTb53| z?$OB@qnv(N=;5*4{`uDEp}^#zzIB0#Vy=y)l4DoxVVG>xdTT(NWpf}+9l%8Y`_Mjs%&$_>ww*L+dp31Gt=Kz}0*xR&D!bbFe=Tdn z`H!izJzejZL^jv^X2>@ooAr%*in8A1j}Sj|f4kCwD3IRW2j2Ncua!l#F~I0idoW!0 zxYQFHVHv@0Df2kPUS|IKWK?biCS5-@N*u~LI$f8eoA;+1ie53N^3{*Q&l-TcW#-H=7BjJo3H zUm=<)%fih7$qdUKP=DExaP(;JpCGjqGm*#bC?Wg@x|JbmE|NjIrccA8Y+y-J6E|1g z*t%@l+0{xV%&dzgCM{O1uZwKlGu_|nq$c(K0cg3i4&kKnUp9NMlyYBoCl3?+Il5^} zRnXU+6MS(o?+5mpJBxI?74_)I{(5rym?KM%kHM5MZiu3haAyr@#I@>PqrOsi^Oojr zg%jIeV@Q{A*w0j9RQJzeetjL&A@R)j_{?-WXi}d@`E=Js6Lc*cPOH@mxOR&9aAv@e zva9h?xg!-cJ@L3e44Of+?n(J*#t(VlD}`~_t3t~jya0gdNmv+o#QvL$h}7VB?57Uq zR|?JoLwXa89lh5Ua@Gjjx3;`ZY&(r1slN%uX1_iEc#lF4Rml38uDr7L7f-h~pX%{) z%S(WjJh5xL=($hsKcXj=IG(*BQFf`&*K@_|p~^`xZW}wkG47FWws~IHdxe)JHdC_6 zk80T?p%v^;4^UxZVY?b?SRkyt`%6!A)90TDEvx4~bD5nX%DVph%R6khrL6INAwHsC zU%qjsrDgme6kDw;4VpheVdo%~~6VQM0#2o7{&JXkvETuJ-@@+O8HfpJZZqwzo!gIQ7i$2Q#f<;KU~ES{AXh&#8AQ>d*6uLtz<%09lk z8jd(vYQ4Vba|zDXR1XzV9+f9yGd6ZN5>N^<`BJcaZXQz-7%1>Uxmz1+SPwK`4Q7ck5^c!&pjs_cHR49fv#rgwsB8(00<%Y2Ou|L$FWqRY&XhA8dlk z%F1MSFGZK-LuBUR6+2DA(n(&1r8ou!-bBK$m(jw#$GJtL?pgJ_Q_^I{>NC~B)g#r4 zWJz)W`7W^ydU;`8-i@X_O83Q03A^aO_~Gvh%}vWc#QpXcXYAot+!s3cz}{!RGiBqaRnCqw5OY8knrLhs z@@HKU(LBWIGxL>KkrR}1SQJ6ha@F#0SzZrE8%x+0F-7FEk!J64;vZiv- zpJs(|X75Z@TL?!ueMBB9)+BuKXyVc}NmV~_d@f-{+3O5;)KhXh^;~kQYyLHvd5gAU z@rg30!m`z}kuxJLWgI#I6iG;UMBrwcXjTyE;3glzU&4;AmMPju<8ASRcxSv2xt~x9 zXFhB`BT-f%)6=o?s}{^kmw{DmZ+433owMxCsalP-l&jm2lVH?|vBUUiV%xG2wxLz; z5dGh{KsAytOoXxeAZbu*^qTPHg|4a(Rom7R;u${*`|rTT%4;YAWO{XHF6oisF-BO+ z45ENb3vCur0E=;_cC!lP*EwVzAR_T*-$bD{?1WysfspoLoFO*@$OhD0P#eCPPOPBhtx(jF7Pxg|Z%*UHvI%c2H-2xQ4NR zu`89|Wc-^om#J-q`P(EMxMkxMpFW3ATB9y@ctHpC^)OnBe##@_eEcw^H5dGYF8JwD z_TXsNXiCcVe0n{@2u_mX$mQ_$(N4t@e9+IVjnej^a;XidwVOUMYu3r5W?eMy-6wGH z1O$%|{MFEDF@!AiK%|d%aCTzFvOv!@F23MnzR-Ih#`~wI`k$Wf&CMo3l*JKiFgr!n zKpm@Dx3`Fg52enKMrA6gI^CIBe(ry5y7o=GFlti+%pwCDb)Lss$>GkoeOu6fY%c@L zKdBl+WaYkykmcL3>jr9Yv2szRocsg_2eMw2x3eBO9d*^K_B86NBzkL)6`ikGOcjs$ z`@8u?|L0o039M2bOi0C`j#Kq7gN!39W4Yi2NWKl{bi9bkO$0v>TsQ!Pl<#%~Cd+nO z!qs4vL==c6bVi7WZyt?$k}G7-i$8@OebCm`MHP)ZV7N`YmPPbPxtV0K-#@E&@_2P1 zE2CyzUiC#%*N;%g|KltuFdE8=L&@a1VELj%wX9gxZwV!RQ}u@<%QdWjX-h6C4b`Q8 z&AjMLDqd;!ydj{PhPEFb-0zfHiIeoy>-h-FM8)%VTSGns*uX z39O+n=(hK2)5&eC42iBdf00|xtdB=}$P-;I1qHK7iXzUrfFUVFq-6HJTwZOh_8gm>mCZ_{GrdQ+EcA@F zK*7swlNwccMx*eBF!~#v5|zWq++s%Zv0%jvy3O?w{b$~9s%Z+gx4b?}LbY5F`_Gh% zPtGY+;RTHz2CFlMXXyK^ZhLBz?-I-dJnpCBlJ~MOOwrm65-MfZ*y;*ZaZL&7*ByC5Vpx&K9iC|F+I2;f0h+YeP4ei zO(>IFB92D}Xt$&DL|j;u_;k$kqnX#KYzUz1)n8|H+1y;8mUh%Go>v-4j;RcJ>T1S) zLKv*|Wr}e#xnF#AZ>9pG8?##7`Z9@a?x#HQ#-k^rX_w#P^mP`ku4-O2QB{yJGip*0 zEn2)q68S9M!cwji}SV`W{{y3VVqc7uMVGg1FViW-$R_zF_LUyw!yjEMd5-p+sr{(l^t|pw?49Zx%pXG6 zhxDIeJ2LeOlR6gcjdJ8E>ge(jw8dp-YmJxRdGduipKWh(c~o$+sc|d$0j`uVM!p%H zJH>h^9@NXmj@@WALR}5gc-gz3F_s{Q9?&P>O;oHDE*%qFnbTDqAi%bMdUyRc=)E{0 zJIeKQnBoK)r(LH>yGu~l(&!`nk(CBDqmL@|)7W70-`kBk*Nif5yO*hdTRi_3ph}!( zP4Mige}wvrTFF0LL5!1koQKtmk@ibC04o(}1U2f4QD3Ferp}G00k_oPJAmq<5u_4| zc!g~UVKFZe`Jh`o)uP=0%P$&zI@!$iB{jq;l5E*1Ac|c2t}mm7AvuM!qU{yP#(23W z%wDHPZxSBv+2G|iTYI=CnDLLrn)%a($D^6HgX00@4q_X>r6MK?wD7K>SYdoSLiMOXT?H9rdvo%_#W{pT))4FX?YrKF_fzT2_$WyH2k z49PlTnwpVDD7*{Ht}P_UdE^FO_)Brnb2A0B(Es?Y~8iR|=a z#E&(uLE9VR`SDD6YW)5gff?|sY9D{ku<-5+nQ0WSm&hi3k4+l>7#m9WSz;c;Wz+pA zbaUgP(Pf`Ih<2loB3KIzcvi1hTUTEoZ?uiP4__7<_)6#&vBhRzxALNvD5RSxHk%U8 zaYPls{AM=hXTF?8-sU6aZEk32L=sBrS7-~=Vr(yat~D@Jzd~Krb*A;zktDB<^n=6F zpe~hHAX=Ou`F7=RO)g0+lvgjiWB@Dix@WJOwxJ?*Ig1M2Jq9&kC5ls}Q0FFooM7{% zx$e@Lfr}}fIrA_ql>69Ue)~Ibu<>VJ{T=7kh^asE)x`7@c$>;C2&|Q}4^^m85HdO( zRQ(o1>cnBSNkl0f46AgAni$ZUyBYkGo|XSlL$5hTNtwJ_?u(2Q0>JL6Ygdo6u{eMa zO4n~iO9A+h9JJ$Q41Q@FF^JGJ!Y((vcwt9FpRm_!jZj4vTghh2TZf)JpSo9DFje`k zi%yA$7dZluObAoJiug28R>b=yn=sxVJF2c1aK^dEE9xSy!cr>PI7n@sC9jm``VS^k ztK)t=oyqANbWjZ84qG!kSb5jIiD(-U9hnJeZ)okicQGSb!Jh6OKlAo-7%0Aji+`wp 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 E0m{94Y5)KL literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/unscented_transformation_with_python/2.png b/python/examples/images/posts/unscented_transformation_with_python/2.png new file mode 100644 index 0000000000000000000000000000000000000000..0a52d0d028aeed958f8c551b452003533b8e71a1 GIT binary patch literal 78745 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 OFqU?x=l}A$^#1_*4?*Do literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/unscented_transformation_with_python/4.png b/python/examples/images/posts/unscented_transformation_with_python/4.png new file mode 100644 index 0000000000000000000000000000000000000000..82f3c4518351e4cdf7cc360f67e03287490c2548 GIT binary patch literal 69582 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 C$SoQG literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/unscented_transformation_with_python/5.png b/python/examples/images/posts/unscented_transformation_with_python/5.png new file mode 100644 index 0000000000000000000000000000000000000000..e8412347a090be54480b50b0b57a57e744ddd856 GIT binary patch literal 41676 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

L7t;(>K*A;I^t=W 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

~9RdjbnS$dT(c=faL{RV|v=;(s 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 literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/unscented_transformation_with_python/7.png b/python/examples/images/posts/unscented_transformation_with_python/7.png new file mode 100644 index 0000000000000000000000000000000000000000..f96f77ad0d4dc6e7151082f9b010655304bfdc9c GIT binary patch literal 77188 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 B`B4A> literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/unscented_transformation_with_python/8.png b/python/examples/images/posts/unscented_transformation_with_python/8.png new file mode 100644 index 0000000000000000000000000000000000000000..44a166ef502fe3140a637d6e8a4fa473ab6b4688 GIT binary patch literal 80930 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®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

G@}DBElCp89pi(eY~qdU4GNpfh};p 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 literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/unscented_transformation_with_python/9.png b/python/examples/images/posts/unscented_transformation_with_python/9.png new file mode 100644 index 0000000000000000000000000000000000000000..dc8299351ef1f5449ac71f23a9b5dd9de8abdd94 GIT binary patch literal 61029 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

t7s{>a?{{YpJD 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 literal 0 HcmV?d00001 From 223fbca4d48a453c06ed6eea93717668524af5a4 Mon Sep 17 00:00:00 2001 From: uidk3112 Date: Mon, 28 Nov 2022 16:23:20 +0100 Subject: [PATCH 03/60] refactoring and implement unscented transform class --- cpp/CMakeLists.txt | 4 +- cpp/Examples/CMakeLists.txt | 7 +- cpp/Examples/EkfRangeSensor/main.cpp | 67 ------- .../CMakeLists.txt | 14 +- cpp/Examples/ekf_range_sensor/main.cpp | 75 ++++++++ .../CMakeLists.txt | 14 +- .../main.cpp | 26 ++- .../unscented_transform/CMakeLists.txt | 26 +++ cpp/Examples/unscented_transform/main.cpp | 82 ++++++++ cpp/KalmanFilter/CMakeLists.txt | 17 -- cpp/KalmanFilter/Types.h | 24 --- cpp/kalman_filter/CMakeLists.txt | 26 +++ .../kalman_filter.h} | 12 +- cpp/kalman_filter/monto_carlo.h | 0 cpp/kalman_filter/types.h | 26 +++ cpp/kalman_filter/unscented_transform.h | 175 ++++++++++++++++++ cpp/kalman_filter/util.h | 62 +++++++ 17 files changed, 524 insertions(+), 133 deletions(-) delete mode 100644 cpp/Examples/EkfRangeSensor/main.cpp rename cpp/Examples/{EkfRangeSensor => ekf_range_sensor}/CMakeLists.txt (54%) create mode 100644 cpp/Examples/ekf_range_sensor/main.cpp rename cpp/Examples/{StateEstimation1D => kf_state_estimation}/CMakeLists.txt (54%) rename cpp/Examples/{StateEstimation1D => kf_state_estimation}/main.cpp (63%) create mode 100644 cpp/Examples/unscented_transform/CMakeLists.txt create mode 100644 cpp/Examples/unscented_transform/main.cpp delete mode 100644 cpp/KalmanFilter/CMakeLists.txt delete mode 100644 cpp/KalmanFilter/Types.h create mode 100644 cpp/kalman_filter/CMakeLists.txt rename cpp/{KalmanFilter/KalmanFilter.h => kalman_filter/kalman_filter.h} (89%) create mode 100644 cpp/kalman_filter/monto_carlo.h create mode 100644 cpp/kalman_filter/types.h create mode 100644 cpp/kalman_filter/unscented_transform.h create mode 100644 cpp/kalman_filter/util.h diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index 2269733..c4f853b 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -23,5 +23,5 @@ enable_language(C CXX) find_package(Eigen3 3.3 REQUIRED NO_MODULE) -add_subdirectory(KalmanFilter) -add_subdirectory(Examples) +add_subdirectory(kalman_filter) +add_subdirectory(examples) diff --git a/cpp/Examples/CMakeLists.txt b/cpp/Examples/CMakeLists.txt index 475bc03..cf08794 100644 --- a/cpp/Examples/CMakeLists.txt +++ b/cpp/Examples/CMakeLists.txt @@ -1,2 +1,5 @@ -add_subdirectory(StateEstimation1D) -add_subdirectory(EkfRangeSensor) +set(EXAMPLE_EXECUTABLE_PREFIX "example_") + +add_subdirectory(kf_state_estimation) +add_subdirectory(ekf_range_sensor) +add_subdirectory(unscented_transform) diff --git a/cpp/Examples/EkfRangeSensor/main.cpp b/cpp/Examples/EkfRangeSensor/main.cpp deleted file mode 100644 index 37a9ba8..0000000 --- a/cpp/Examples/EkfRangeSensor/main.cpp +++ /dev/null @@ -1,67 +0,0 @@ -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "KalmanFilter/Types.h" -#include "KalmanFilter/KalmanFilter.h" - -static constexpr size_t DIM_X{ 2 }; -static constexpr size_t DIM_Z{ 2 }; - -static kf::KalmanFilter kalmanfilter; - -kf::Vector<2> covertCartesian2Polar(const kf::Vector<2> & cartesian); -kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX); -void executeCorrectionStep(); - -int main(int argc, char ** argv) -{ - executeCorrectionStep(); - - return 0; -} - -kf::Vector<2> covertCartesian2Polar(const kf::Vector<2> & cartesian) -{ - const kf::Vector<2> polar{ - std::sqrt(cartesian[0] * cartesian[0] + cartesian[1] * cartesian[1]), - std::atan2(cartesian[1], cartesian[0]) - }; - return polar; -} - -kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX) -{ - const kf::float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; - const kf::float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; - - kf::Matrix matHj; - matHj << - (vecX[0] / valSqrtX2PlusY2), (vecX[1] / valSqrtX2PlusY2), - (-vecX[1] / valX2PlusY2), (vecX[0] / valX2PlusY2); - - return matHj; -} - -void executeCorrectionStep() -{ - kalmanfilter.vecX() << 10.0F, 5.0F; - kalmanfilter.matP() << 0.3F, 0.0F, 0.0F, 0.3F; - - const kf::Vector<2> measPosCart{ 10.4F, 5.2F }; - const kf::Vector vecZ{ covertCartesian2Polar(measPosCart) }; - - kf::Matrix matR; - matR << 0.1F, 0.0F, 0.0F, 0.0008F; - - kf::Matrix matHj{ calculateJacobianMatrix(kalmanfilter.vecX()) }; // jacobian matrix Hj - - kalmanfilter.correctEkf(covertCartesian2Polar, vecZ, matR, matHj); - - std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; - std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; -} diff --git a/cpp/Examples/EkfRangeSensor/CMakeLists.txt b/cpp/Examples/ekf_range_sensor/CMakeLists.txt similarity index 54% rename from cpp/Examples/EkfRangeSensor/CMakeLists.txt rename to cpp/Examples/ekf_range_sensor/CMakeLists.txt index 9cf4161..ec887bd 100644 --- a/cpp/Examples/EkfRangeSensor/CMakeLists.txt +++ b/cpp/Examples/ekf_range_sensor/CMakeLists.txt @@ -1,6 +1,12 @@ -## -## @author Mohanad Youssef -## @file KalmanFilterExercise/Examples/StateEstimate1D/CMakeLists.txt +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an MIT - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/MIT. +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB PROJECT_FILES @@ -8,7 +14,7 @@ file(GLOB PROJECT_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" ) -set(APPLICATION_NAME ${CMAKE_PROJECT_NAME}_ekf_range_sensor_example) +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ekf_range_sensor) add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp new file mode 100644 index 0000000..83d4034 --- /dev/null +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -0,0 +1,75 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "kalman_filter/types.h" +#include "kalman_filter/kalman_filter.h" + +#include "kalman_filter/unscented_transform.h" + +static constexpr size_t DIM_X{ 2 }; +static constexpr size_t DIM_Z{ 2 }; + +static kf::KalmanFilter kalmanfilter; + +Vector covertCartesian2Polar(const Vector & cartesian); +Matrix calculateJacobianMatrix(const Vector & vecX); +void executeCorrectionStep(); + +int main(int argc, char ** argv) +{ + executeCorrectionStep(); + + return 0; +} + +Vector covertCartesian2Polar(const Vector & cartesian) +{ + const Vector polar{ + std::sqrt(cartesian[0] * cartesian[0] + cartesian[1] * cartesian[1]), + std::atan2(cartesian[1], cartesian[0]) + }; + return polar; +} + +Matrix calculateJacobianMatrix(const Vector & vecX) +{ + const float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; + const float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; + + Matrix matHj; + matHj << + (vecX[0] / valSqrtX2PlusY2), (vecX[1] / valSqrtX2PlusY2), + (-vecX[1] / valX2PlusY2), (vecX[0] / valX2PlusY2); + + return matHj; +} + +void executeCorrectionStep() +{ + kalmanfilter.vecX() << 10.0F, 5.0F; + kalmanfilter.matP() << 0.3F, 0.0F, 0.0F, 0.3F; + + const Vector measPosCart{ 10.4F, 5.2F }; + const Vector vecZ{ covertCartesian2Polar(measPosCart) }; + + Matrix matR; + matR << 0.1F, 0.0F, 0.0F, 0.0008F; + + Matrix matHj{ calculateJacobianMatrix(kalmanfilter.vecX()) }; // jacobian matrix Hj + + kalmanfilter.correctEkf(covertCartesian2Polar, vecZ, matR, matHj); + + std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; + std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; +} diff --git a/cpp/Examples/StateEstimation1D/CMakeLists.txt b/cpp/Examples/kf_state_estimation/CMakeLists.txt similarity index 54% rename from cpp/Examples/StateEstimation1D/CMakeLists.txt rename to cpp/Examples/kf_state_estimation/CMakeLists.txt index 8df0c14..f5142ab 100644 --- a/cpp/Examples/StateEstimation1D/CMakeLists.txt +++ b/cpp/Examples/kf_state_estimation/CMakeLists.txt @@ -1,6 +1,12 @@ -## -## @author Mohanad Youssef -## @file KalmanFilterExercise/Examples/StateEstimate1D/CMakeLists.txt +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an MIT - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/MIT. +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB PROJECT_FILES @@ -8,7 +14,7 @@ file(GLOB PROJECT_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" ) -set(APPLICATION_NAME ${CMAKE_PROJECT_NAME}_estimate_1D) +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_kf_state_estimation) add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) diff --git a/cpp/Examples/StateEstimation1D/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp similarity index 63% rename from cpp/Examples/StateEstimation1D/main.cpp rename to cpp/Examples/kf_state_estimation/main.cpp index da244c7..e6bf39e 100644 --- a/cpp/Examples/StateEstimation1D/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -1,18 +1,24 @@ /// -/// @author Mohanad Youssef +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef /// @file main.cpp /// #include #include -#include "KalmanFilter/Types.h" -#include "KalmanFilter/KalmanFilter.h" +#include "kalman_filter/types.h" +#include "kalman_filter/kalman_filter.h" static constexpr size_t DIM_X{ 2 }; static constexpr size_t DIM_Z{ 1 }; -static constexpr kf::float32_t T{ 1.0F }; -static constexpr kf::float32_t Q11{ 0.1F }, Q22{ 0.1F }; +static constexpr float32_t T{ 1.0F }; +static constexpr float32_t Q11{ 0.1F }, Q22{ 0.1F }; static kf::KalmanFilter kalmanfilter; @@ -32,10 +38,10 @@ void executePredictionStep() kalmanfilter.vecX() << 0.0F, 2.0F; kalmanfilter.matP() << 0.1F, 0.0F, 0.0F, 0.1F; - kf::Matrix F; // state transition matrix + Matrix F; // state transition matrix F << 1.0F, T, 0.0F, 1.0F; - kf::Matrix Q; // process noise covariance + Matrix Q; // process noise covariance Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3) / 3.0F)); Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2) / 2.0F); Q(1, 1) = Q22 * T; @@ -48,13 +54,13 @@ void executePredictionStep() void executeCorrectionStep() { - kf::Vector vecZ; + Vector vecZ; vecZ << 2.25F; - kf::Matrix matR; + Matrix matR; matR << 0.01F; - kf::Matrix matH; + Matrix matH; matH << 1.0F, 0.0F; kalmanfilter.correct(vecZ, matR, matH); diff --git a/cpp/Examples/unscented_transform/CMakeLists.txt b/cpp/Examples/unscented_transform/CMakeLists.txt new file mode 100644 index 0000000..7a68665 --- /dev/null +++ b/cpp/Examples/unscented_transform/CMakeLists.txt @@ -0,0 +1,26 @@ +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an MIT - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/MIT. +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_unscented_transform) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) +target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp new file mode 100644 index 0000000..21c06c0 --- /dev/null +++ b/cpp/Examples/unscented_transform/main.cpp @@ -0,0 +1,82 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "kalman_filter/types.h" +#include "kalman_filter/kalman_filter.h" + +#include "kalman_filter/unscented_transform.h" + +static constexpr size_t DIM_1{ 1 }; +static constexpr size_t DIM_2{ 2 }; + +void runExample1(); +void runExample2(); + +Vector function1(const Vector & x) +{ + Vector y; + y[0] = x[0] * x[0]; + return y; +} + +Vector function2(const Vector & x) +{ + Vector y; + y[0] = x[0] * x[0]; + y[1] = x[1] * x[1]; + return y; +} + +int main(int argc, char ** argv) +{ + // example 1 + runExample1(); + + // example 2 + runExample2(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + Vector x; + x << 0.0F; + + Matrix P; + P << 0.5F; + + kf::UnscentedTransform UT(function1, x, P, 0.0F); + + UT.showSummary(); + std::cout << " End of Example 1: ===========================" << std::endl; +} + +void runExample2() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + Vector x; + x << 2.0F, 1.0F; + + Matrix P; + P << 0.1F, 0.0F, 0.0F, 0.1F; + + kf::UnscentedTransform UT(function2, x, P, 0.0F); + + UT.showSummary(); + std::cout << " End of Example 2: ===========================" << std::endl; +} diff --git a/cpp/KalmanFilter/CMakeLists.txt b/cpp/KalmanFilter/CMakeLists.txt deleted file mode 100644 index 6669aab..0000000 --- a/cpp/KalmanFilter/CMakeLists.txt +++ /dev/null @@ -1,17 +0,0 @@ -## -## @author Mohanad Youssef -## @file CMakeLists.txt -## - -file(GLOB LIBRARY_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.h") - -set(LIBRARY_NAME ${CMAKE_PROJECT_NAME}_lib) - -add_library(${LIBRARY_NAME} ${LIBRARY_FILES}) - -set_target_properties(${LIBRARY_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${LIBRARY_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${LIBRARY_NAME} PUBLIC - $ -) diff --git a/cpp/KalmanFilter/Types.h b/cpp/KalmanFilter/Types.h deleted file mode 100644 index 42c12c8..0000000 --- a/cpp/KalmanFilter/Types.h +++ /dev/null @@ -1,24 +0,0 @@ -/// -/// @author Mohanad Youssef -/// @file KalmanFilterExercise/KalmanFilter/Types.h -/// - -#ifndef __KALMAN_FILTER_TYPES_H__ -#define __KALMAN_FILTER_TYPES_H__ - -#include -#include - -namespace kf -{ - using float32_t = float; - - template - using Matrix = Eigen::Matrix; - - template - using Vector = Eigen::Matrix; - -} - -#endif // __KALMAN_FILTER_TYPES_H__ diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/kalman_filter/CMakeLists.txt new file mode 100644 index 0000000..4ca0bcb --- /dev/null +++ b/cpp/kalman_filter/CMakeLists.txt @@ -0,0 +1,26 @@ +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an MIT - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/MIT. +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB LIBRARY_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" + ) + +set(LIBRARY_NAME kalman_filter_lib) + +add_library(${LIBRARY_NAME} ${LIBRARY_FILES}) + +set_target_properties(${LIBRARY_NAME} PROPERTIES LINKER_LANGUAGE CXX) +target_link_libraries(${LIBRARY_NAME} PUBLIC Eigen3::Eigen) + +target_include_directories(${LIBRARY_NAME} PUBLIC + $ +) diff --git a/cpp/KalmanFilter/KalmanFilter.h b/cpp/kalman_filter/kalman_filter.h similarity index 89% rename from cpp/KalmanFilter/KalmanFilter.h rename to cpp/kalman_filter/kalman_filter.h index d815219..4f7aef8 100644 --- a/cpp/KalmanFilter/KalmanFilter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -1,12 +1,18 @@ /// -/// @author Mohanad Youssef -/// @file KalmanFilter.h +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file kalman_filter.h /// #ifndef __KALMAN_FILTER_LIB_H__ #define __KALMAN_FILTER_LIB_H__ -#include "Types.h" +#include "types.h" namespace kf { diff --git a/cpp/kalman_filter/monto_carlo.h b/cpp/kalman_filter/monto_carlo.h new file mode 100644 index 0000000..e69de29 diff --git a/cpp/kalman_filter/types.h b/cpp/kalman_filter/types.h new file mode 100644 index 0000000..fb7bd37 --- /dev/null +++ b/cpp/kalman_filter/types.h @@ -0,0 +1,26 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file types.h +/// + +#ifndef __KALMAN_FILTER_TYPES_H__ +#define __KALMAN_FILTER_TYPES_H__ + +#include +#include + +using float32_t = float; + +template +using Matrix = Eigen::Matrix; + +template +using Vector = Eigen::Matrix; + +#endif // __KALMAN_FILTER_TYPES_H__ diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h new file mode 100644 index 0000000..011dfac --- /dev/null +++ b/cpp/kalman_filter/unscented_transform.h @@ -0,0 +1,175 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file unscented_transform.h +/// + +#ifndef __UNSCENTED_TRANSFORM_H__ +#define __UNSCENTED_TRANSFORM_H__ + +#include "types.h" +#include "util.h" +#include "Eigen/src/Cholesky/LLT.h" + +namespace kf +{ + template + class UnscentedTransform + { + public: + static constexpr size_t SIGMA_DIM{ (2 * DIM) + 1 }; + + UnscentedTransform() = delete; + + template + explicit UnscentedTransform( + NonLinearFunctionCallback nonlinearFunction,const Vector & vecX, const Matrix & matPxx, const float32_t kappa=0.0F) + { + // 1. calculate weights + updateWeights(kappa); + + // 2. update sigma points _sigmaX + updateSigmaPoints(vecX, matPxx, kappa); + + // 3. transform sigma points X through the nonlinear model f(X) to obtain Y sigma points + transformSigmaPoints(nonlinearFunction); + + // 4. calculate weight mean and covariance from the transformed sigma points Y and weights + updateTransformedMeanAndCovariance(); + } + + ~UnscentedTransform() {} + + void showSummary() + { + std::cout << "DIM_N : " << DIM << "\n"; + std::cout << "DIM_M : " << SIGMA_DIM << "\n"; + std::cout << "_weights : \n" << _weights << "\n"; + std::cout << "_sigmaX : \n" << _sigmaX << "\n"; + std::cout << "_sigmaY : \n" << _sigmaY << "\n"; + std::cout << "_vecY : \n" << _vecY << "\n"; + std::cout << "_matPyy : \n" << _matPyy << "\n"; + } + + Matrix<1, SIGMA_DIM> & weights() { return _weights; } + const Matrix<1, SIGMA_DIM> & weights() const { return _weights; } + + Matrix & sigmaX() { return _sigmaX; } + const Matrix & sigmaX() const { return _sigmaX; } + + Matrix & sigmaY() { return _sigmaY; } + const Matrix & sigmaY() const { return _sigmaY; } + + Vector & vecY() { return _vecY; } + const Vector & vecY() const { return _vecY; } + + Matrix & matPyy() { return _matPyy; } + const Matrix & matPyy() const { return _matPyy; } + + private: + Matrix<1, SIGMA_DIM> _weights; /// @brief unscented transform weights + + Matrix _sigmaX; /// @brief input sigma points + Matrix _sigmaY; /// @brief output sigma points + + Vector _vecY; /// @brief output y mean vector (weighted mean vector) + Matrix _matPyy; /// @brief output Pyy covariance matrix (weighted covariance matrix) + + /// + /// @brief algorithm to calculate the weights used to draw the sigma points + /// + /// @param kappa design scaling parameter for sigma points selection + /// + void updateWeights(float32_t kappa) + { + const float32_t denoTerm{ kappa + static_cast(DIM) }; + + _weights(0, 0) = kappa / denoTerm; + + for (int32_t i{ 1 }; i < SIGMA_DIM; ++i) + { + _weights(0, i) = 0.5F / denoTerm; + } + } + + /// + /// @brief algorithm to calculate the deterministic sigma points for + /// the unscented transformation + /// + /// @param vecX mean of the normally distributed state + /// @param matPxx covariance of the normally distributed state + /// @param kappa design scaling parameter for sigma points selection + /// + void updateSigmaPoints(const Vector & vecX, const Matrix & matPxx, const float32_t kappa) + { + const float32_t scalarMultiplier{ std::sqrt(DIM + kappa) }; // sqrt(n + \kappa) + + // cholesky factorization to get matrix Pxx square-root + Eigen::LLT> lltOfPxx(matPxx); + Matrix matSxx{ lltOfPxx.matrixL() }; // sqrt(P_{xx}) + + matSxx *= scalarMultiplier; // sqrt( (n + \kappa) * P_{xx} ) + + // X_0 = \bar{x} + util::copyToColumn< DIM, SIGMA_DIM >(0, _sigmaX, vecX); + + for (size_t i{ 0 }; i < DIM; ++i) + { + const size_t IDX_1{ i + 1 }; + const size_t IDX_2{ i + DIM + 1 }; + + util::copyToColumn< DIM, SIGMA_DIM >(IDX_1, _sigmaX, vecX); + util::copyToColumn< DIM, SIGMA_DIM >(IDX_2, _sigmaX, vecX); + + const Vector vecShiftTerm{ util::getColumnAt< DIM, DIM >(i, matSxx) }; + + util::addColumnFrom< DIM, SIGMA_DIM >(IDX_1, _sigmaX, vecShiftTerm); // X_i = \bar{x} + sqrt( (n + \kappa) * P_{xx} ) + util::subColumnFrom< DIM, SIGMA_DIM >(IDX_2, _sigmaX, vecShiftTerm); // X_{i+n} = \bar{x} - sqrt( (n + \kappa) * P_{xx} ) + } + } + + /// + /// @brief transform sigma points X through the nonlinear function + /// @param nonlinearFunction nonlinear function to be used + /// + template + void transformSigmaPoints(NonLinearFunctionCallback nonlinearFunction) + { + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + const Vector x{ util::getColumnAt(i, _sigmaX) }; + const Vector y{ nonlinearFunction(x) }; // y = f(x) + + util::copyToColumn(i, _sigmaY, y); // Y[:, i] = y + } + } + + void updateTransformedMeanAndCovariance() + { + // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] + _vecY = Vector::Zero(); + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + _vecY += _weights(0, i) * util::getColumnAt(i, _sigmaY); // y += W[0, i] Y[:, i] + } + + // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + _matPyy = Matrix::Zero(); + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + const Vector devYi{ util::getColumnAt(i, _sigmaY) - _vecY }; // Y[:, i] - \bar{y} + + Matrix Pi{ _weights(0, i) * devYi * devYi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + + _matPyy += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + } + } + }; +} + +#endif // __UNSCENTED_TRANSFORM_H__ diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h new file mode 100644 index 0000000..1d65541 --- /dev/null +++ b/cpp/kalman_filter/util.h @@ -0,0 +1,62 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file util.h +/// + +#ifndef __KALMAN_FILTER_UTIL_H__ +#define __KALMAN_FILTER_UTIL_H__ + +#include "types.h" + +namespace util +{ + template + void copyToColumn(const size_t colIdx, Matrix & lhsSigmaX, const Vector & rhsVecX) + { + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + lhsSigmaX(i, colIdx) = rhsVecX[i]; + } + } + + template + void addColumnFrom(const size_t colIdx, Matrix & lhsSigmaX, const Vector & rhsVecX) + { + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + lhsSigmaX(i, colIdx) += rhsVecX[i]; + } + } + + template + void subColumnFrom(const size_t colIdx, Matrix & lhsSigmaX, const Vector & rhsVecX) + { + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + lhsSigmaX(i, colIdx) -= rhsVecX[i]; + } + } + + template + Vector getColumnAt(const size_t colIdx, const Matrix & matX) + { + assert(colIdx < COLS); // assert if colIdx is out of boundary + + Vector vecXi; + + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + vecXi[i] = matX(i, colIdx); + } + + return vecXi; + } +} + +#endif // __KALMAN_FILTER_UTIL_H__ From baf53d713a8bc3d3f07655866f27e201fa68a15a Mon Sep 17 00:00:00 2001 From: uidk3112 Date: Tue, 29 Nov 2022 15:22:29 +0100 Subject: [PATCH 04/60] updated unscented transformation python --- ...ntroduction_Unscented_Transformation.ipynb | 211 +++++++++++++----- 1 file changed, 159 insertions(+), 52 deletions(-) diff --git a/python/examples/Introduction_Unscented_Transformation.ipynb b/python/examples/Introduction_Unscented_Transformation.ipynb index 6f4e92b..5f7ff7b 100644 --- a/python/examples/Introduction_Unscented_Transformation.ipynb +++ b/python/examples/Introduction_Unscented_Transformation.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 40, "id": "0d5d33d9", "metadata": {}, "outputs": [], @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 41, "id": "1c89438a", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 42, "id": "ab4f9a93", "metadata": {}, "outputs": [], @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 43, "id": "258ee36f", "metadata": {}, "outputs": [], @@ -122,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 44, "id": "cd9f4d93", "metadata": {}, "outputs": [], @@ -150,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 171, + "execution_count": 45, "id": "1ea5fdbf", "metadata": {}, "outputs": [], @@ -190,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 204, + "execution_count": 46, "id": "8059bc88", "metadata": {}, "outputs": [], @@ -340,7 +340,6 @@ " if (len(monto_carlo_sampler_list) == 1):\n", " self.axes[0, 1].plot(monto_carlo_sampler_list[0].x_samples, monto_carlo_sampler_list[0].z_samples, color='red', marker='o', linestyle='', label='input/output samples') # plot samples\n", " \n", - " #self.axes[0, 1].plot(x_norm_pts, z_norm_pts, color='red', marker='o', linestyle='', label='') # draw point\n", " # ==============================================================================================\n", " \n", " \n", @@ -348,7 +347,6 @@ " # 10. plot model first order taylor curve\n", " # \n", " self.axes[0, 1].plot(x_model_curve, z_model_taylor, color='orange', label='first order taylor of f(x)')\n", - " #self.axes[0, 1].plot(x_norm_pts, z_norm_pts_taylor, color='green', marker='x', linestyle='') # draw point\n", " # ==============================================================================================\n", "\n", " self.axes[0, 0].legend(loc='upper right')\n", @@ -359,13 +357,13 @@ }, { "cell_type": "code", - "execution_count": 205, + "execution_count": 47, "id": "3d9aa617", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "

" ] @@ -393,13 +391,13 @@ }, { "cell_type": "code", - "execution_count": 206, + "execution_count": 48, "id": "f8df6d63", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -428,13 +426,13 @@ }, { "cell_type": "code", - "execution_count": 207, + "execution_count": 49, "id": "d07b9515", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -464,13 +462,13 @@ }, { "cell_type": "code", - "execution_count": 208, + "execution_count": 50, "id": "3cf53ca1", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJsAAAJ8CAYAAABZZqAdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3yN1x/A8c8JITY1Y1RUiZBlhhoJatXoQFEtoVbrV6Wt2SIU1Zpdqq0WLVqlNTqpPaolSO1ZoWjt2EGS8/vj3NwmkZ2bPBnf9+t1X/c+9z7j+zy5Sc793nO+R2mtEUIIIYQQQgghhBDCEZysDkAIIYQQQgghhBBCZB+SbBJCCCGEEEIIIYQQDiPJJiGEEEIIIYQQQgjhMJJsEkIIIYQQQgghhBAOI8kmIYQQQgghhBBCCOEwkmwSQgghhBBCCCGEEA4jySYhhBBCCCGEyKSUUgFKKW27BVkdj0g+pVSo7ecWmgHHin6PbHDQ/roppVYppc4rpe7F2P8Tjti/yP4k2SSEEEIIIYRIFzE+oCb3NtPqmNObUqqoUirIdnvC6nisppTaEOc9sDcF2z4Zz3soIP2izRmUUh8Bi4CWQEkgt7URiaxI3jRCCCGEEEIIkXGKAmNtj+cDyy2LJHPyVErV1lrvTMa6gekdTE6jlKoFDLAtXgTeA44Ad2zP/WFFXCLrkWSTEEIIIYQQIiM8mYx1jqd7FFmM1noDoKyOI4NEYD6jBgKJJpuUUiWBNnG2E2n3WIzHL2mtv7YsEpGlyS+kEEIIIYQQIt1prZdbHYPI9H4B2gHdlFKvaq3vJrLus4AzEAWsAtpmQHw5QYUYj3dbFoXI8qRmkxBCCCGEEEKIzGCe7b440D6JdXva7tcCp9MroBwob4zHdxJcS4gkSLJJCCGEEEIIkemkZCavpNZVSs2LUUDazfZcK6XUcqXUaaXUHaXUWaXUEqWUXwpirKqUekcptUMpdcE2a9dVpdQupdSHSqnmSillW9dNKaWBEzF20TOBQuluMY6R7NnolFL5lVJDlFLrlVL/2s7rvFJqi1JqpFKqSBLbB8UttK2Uqq+UWqiUOhljfz8opVon9zqlwFbgqO1xz4RWUkrVBHxsi/NScgClVAWl1GTbz+iy7ZzOKKW+V0oFKqVyJXM/JZRSbymlDiilbtr2tUMp9ZpSKn9KYrLtr4ZSarpSKiROXCuVUt2VUun22T36vWl7f8a87ifivC/npVcMIvuRZJMQQgghhBAiJ3FSSs3CDNl6HCgH5AFcgU7Ab0qp5xPbgVIqt1JqBnAAGArUAUpgypQUBmoCLwJrgCbpdB5xY6qPSdRMBwKA0pjzKgk0BCYBx5VSLVOwz1GYBNAzwIMx9tcW+FkpNc6BpxBtvu2+jVKqVALrBNrurwLLkrtjpVR/4DAwHPMzKoY5p7KY4Xtzgd0xk30J7KcBcBAYAXgA+W37qgNMAbYrpSomM6bcSql3gT3AEEwSLWZc7YEFwDalVJnknqsQVpOaTUIIIYQQQoicZALQDTPD1hfAMaAQ8BSm4LQTMEsptVVrfSjuxraeSt8CHWxPRWJmlFsPnMckHjyAVoAv/xX3Po8pkl4K+Nj23HrMbF9xnU/JCSmlfIF1QD7bU7sxU9efAsoAT2MSTsWBH5RSLW2FxxPTD3OdzmB6D+3HJEBaA11s5zVGKbVRa70uJfEm4QtgPOaz6rOY5JmdUsoZk/wC+EZrfdvWeSxRtkTT7BhPfQ/8CIQBVYFeQCXAC9iilKqptb4Qz34qYxKVhW1P7bXF/DcmYdkNqAd8g6kplVhMyrZedPH8C8BXmJ/fTaAi5lrXse1zrVKqrtb6VpInnDLR702AQUBT2+P+xH4vnnLwcUU2JskmIYQQQgghRE7SDZMceF5rHRHj+Tm2HiaDMEmVQZjeSXEN5b9E0ymgndZ6bzzrjVBK1cZMH48tQbA8Tq+ZU2ktnG4bXrWA/xJN7wKvaK2jYqz2nlJqNCaJ4wx8oZSqqrUOT2TX3YBfgSe11jdjPD9fKbWd/5JAr2ESXQ6htf5bKbUOeBTTg2l6nFXaYXqRQTKH0Nmu+QzbYiTwjNb6mzjrTAWWYHptlQNmAZ3j2d3H/Jdomgv0i/k+sr2HpgKvJCO0QfyX5FkO9NRaX4uzzlSl1ERgFFAdGIPpUeUw0e9NAKXUEzFeWq21DnXksUTOIcPohBBCCCGEEOkugdpEVtSDOQT0jZNoivYGcNv2uFXcF5VSBTFDsADuknCiCQCt9U6t9ck0xpuUdkAN2+PfgSFxEk3RsbyJ6ckDZsaxZ5PY7yWgS5xEU7R3+a+XSzOllKM7Mcyz3XsppWrFeS3Qdn9Ea/1bMvc3iP+ScdPiJpoAtNa3MT2m/rE91VEpVTXmOkopH6B59PGBAXHfR1prjUnAbU8sIKWUCyaBBOY92SWeRFP0Pl8HNtsWX7BtK0SmJskmIYQQQgghRE7ykdb6bnwvaK2vA8G2xUrxfKhvAzxge7wosURTBnoqxuMptmRHQiYnsF18vtBaX4nvBVsya6NtMS9QOckoU+Y7IDrxEhj9pK2G02O2xfkkX/S5RgDTElrJluyZFX044IkE9gPwfiLvI53YcWxaYYZUAryX0L5iWGC7LwzUT2JdISwnw+iEEEIIIYQQGeHJJF7PqHowvyfx+hnbvQKKAv/GeK1RjMcrHRhTWtSz3WvMsLfE/AbcAAoCSc26l9zrBKagtcPY6jB9A/QBuimlXtVa38P0xsoNRGGGQibJlqCKLtb9p9Y6qXpYq4E3bY/jXqO6MR6vTWI/Sb3eOMbjgnGGr8WnXIzHHsCGJNYXwlKSbBJCCCGEEEKku7TWJnKgi0m8fifG47g9m8rHeHzQMeGkmavt/l9bz6wEaa2jlFLHMTOePaCUypNIj5q0XCdHmIdJNpXADBVcBvS0vbZWa306mftxjfH4SDLWj7mOa5zXysZ4fDyxnWitLymlwjAJy/i4xXj8TjLiismhyT0h0oMMoxNCCCGEEELkJPfVM0qBwjEe30hrIA5SyHYfX22l+MSMu1CCa6XtOqWZ1norcNS2GGir3eRtW56Xgl3FPMfkXKPErk9B231EMoa9JXW8IsnYPiF50rCtEBlCejYJIYQQQgghsrqM+hI9ZgHnggmulbGuY3rPFEjm+jHjTrQnVCYwH5iAqdN0y/bcNUwvp+SKeY7JuUaJXZ/oRFTuJHqFJed4MZNabhlQSF6IDCU9m4QQQgghhBCZUfQwrUR7cSilFP8V7U5vMYdueWTQMZMSPXtaGaVUYj2Voq9VdDHvS8nsnWOlLzA9rHIDXW3PLbbNHJdc/8R4XCUZ68dc52yc12IuJ1oUXSlVnISH0EHsmlc1ElxLiCxKkk1CCCGEEEKIzCjMdl9CKeWcyHqeJL9XT1ptjvG4Qyr3EXN4mkpDLNG2x9hX8yTWfYT/eu5sT2zFzEBr/TewLs7T81K4j/NAdK8hX6VUySQ2aRnjcdxrFHO5WRL7SepnsTHG46SK5wuR5UiySQghhBBCCJEZHbDdOxN75q64BmVALNF+Bi7bHj+jlPJKxT5iDp9yRJLs2xiPX7P1XkrI8AS2y8w+AP6w3b7XWv+Win1En2tuYHBCK9l6hr1oW9TcP1wv5vL/EkqC2n4GQ5KI6Sf+K8LeQyklvZtEtiLJJiGEEEIIIURm9EuMx28qpfLGXUEp1QczY1mG0FrfBCbbFvMA3yeWcFJK+SqlKsbZx2Xgqm3RN4nkUHL8COy3PW4ITFFK3fc5Tyk1CmhvW/wbWJjG42YIrfUKrXV92y21vcneB6KH3g1TSnWMu4JSygVYwH8zzn2rtT4acx2t9Z/AGttiNWCWUipXnP0o4G2gfmIB2d5L42yLeYCflFJ1EttGKVVXKZXSmeuEsIQUCBdCCCGEEEJkRsuBY8DDmOFfO5RSn2Hq5pQBnsAMZdqMqZ9TNt69ON5UoBFmGF1FYLdSahmwATgP5APcMcOx6gBN+W8YV7R1mKFTlYHFSqnv+G/YIMDG5NYl0lpHKaWeA7bajv0q0FQptRBTY6o08LQtZoB7QA+tdXjyTzlr01qHKqWGALMxn4GXKqVWYHoXhWHqNPUGHrJtcgYYmMDuXgB2YmYm7APUU0p9gUnglQGeAfwwQ+7Kk8j7Umv9gVKqLtADeBDYrpT6BViL+dkpoATghRmWVxk4DgxL8UUQIoNJskkIIYQQQgiR6Wit7yilugK/AsUwH7hnxlntD6AjsCMD49JKqU62WAYAuYBOtlt8ouJ5bjzQGpMc6my7xVQJCE1BTLuVUs0xw8VcgVq2W1yXgWe01huSu+/sQmv9sa3X0QzABXjcdotrH9DeVuspvv0cU0q1AVZgEkHemARkTPsxP9NNyQgtEDgKvAHkBdrYbgk5nchrQmQaMoxOCCGEEEIIkSlprXdikkzvY3o5hQNXgG2YnieNtdYXLIjrntZ6IOADvAvsxfSQibTd77TF3ERrfV/CQWsdAtQG5gCHgVsOiGkbpofOK5ji0xcwvZguYa7X60BlrfWqtB4rq9JazwaqYoa5hWB+VncxM9b9BPQCfLXWoUns5zfMbISTgUOYIXphmJ/7MKCe1vpUMmPSWusJmATjGMzP7l9bXOGY5NIa4E2ggdY6IHlnK4S1lNba6hiEEEIIIYQQQgghRDYhPZuEEEIIIYQQQgghhMNIskkIIYQQQgghhBBCOIwkm4QQQgghhBBCCCGEw0iySQghhBBCCCGEEEI4TG6rA0gv+fPn16VKVefkSfDygjx5rI4oe7l58yYFChSwOoxsS65v+pLrm/7kGqcvub7Gzp07L2qtS1odh/hP0aJF9cMPP2x1GJY6fRrOnXNc+1N+3x1LrqdjnT17FoCyZctaHEn2Ie9Rx3PENb15Ew4dggoVoFQpBwWWhSWnDZZtk01FixZl+vRgOnaEL74AX1+rI8peNmzYQEBAgNVhZFtyfdOXXN/0J9c4fcn1NZRSJ62OQcRWunRpgoODrQ7DUqGhULkytGsHkyalfX/y++5Ycj0da9y4cQCMHTvW4kiyD3mPOp4jrukzz8DZs7B/PxQq5Ji4srLktMGy9TC64sXN/eXL1sYhhBBCCCFyBjc3ePxx+Phj8024EEKIrO3vv2HJEnj+eUk0pUS2TjY98IC5v3TJ2jiEEEIIIUTO8cor5svOL76wOhIhhBBp9cEHEBUFgwZZHUnWkq2TTdE9myTZJIQQQgghMkrDhlC3LsycaT6gCCGEyJpu3IBPPoGOHU3PVZF82bZmE/zXs0mG0QmROvfu3eP06dOEh4dbHYpDFSlShIMHD1odRrYm1zh95bTr6+LiQvny5XF2drY6FCGSRSnTu6lbN/jpJ1O/SQghHCW7ttHTS1raTdevw1dfQZkykIOaXnZpaYNl62STiwvkzy89m4RIrdOnT1OoUCHc3NxQSlkdjsNcv36dQjLgOl3JNU5fOen6aq25dOkSp0+fplKlSlaHI0SydewI5cvD9OmSbBJCOFZ2baOnl9S2m7SGffugYkXw8EiHwDK5tLbBsvUwOjBD6STZJETqhIeHU7x4cfknJoSwjFKK4sWLy7e3Istxdjb1Pdavh5AQq6MRQmQn0kbPGGFhcOcOlC5tdSTWSGsbLEckm2QYnRCpJ//EhBBWk79DIqvq2xcKFIAZM6yORAiR3cj/xvR37hzkyQPFilkdiXXS8j7L9smmBx6Qnk1CCCGEECLjFS0KvXubeh9nz1odjRBCiOS6edMUBy9VytThEymX7ZNN0rNJiJxl3rx5nE1Diz40NJRFixY5MCLHKliwYJLrBAUFMXXqVADGjBnDmjVrElx3+fLlHDhwIMHXZ8+ezRe2ubsDAgIIDg5OdqxhYWHMmjXLvnz27Fk6deqU7O2FECI7ePlliIiADz+0OhIhhBDJde4cODlBiRJWR5J15Yhkk/RsEiLnyMzJpsjIyHTZb2LGjx/Po48+muDriSWbIiIiGDBgAD169EjVseMmm8qWLcvSpUtTtS8hhMiqKleGJ56A2bPh1i2roxFCiMwtMDDQ3l7s06dPol+Kppe7d+HKFShZEnKnYUo1Nzc3Ll68mKp1lixZgoeHB02bNgVg9+7d9OnTJ9F9ffDBB8ydOzf1ATtYtk82PfCA6dmktdWRCCFSY/r06Xh6euLp6cnMmTMBkxDy9PS0rzN16lSCgoJYunQpwcHBdO/eHV9fX27fvo2bmxvDhw+nXr161KtXj2PHjgGx/5HBfz2GRowYwebNm/H19WVGnCIbGzZsICAggE6dOlGtWjW6d++Otv1xWbt2LTVr1sTLy4vevXtz584dwPwDGT9+PI0aNWLJkiW4ubkxatQoGjRoQJ06ddi1axetWrWicuXKzJ49G4AbN27QvHlzatWqhZeXFytWrEjyOk2cOBF3d3ceffRRDh8+bH8+5nmOGDGC6tWr4+3tzWuvvcZvv/3GypUrGTp0KL6+vhw/fpyAgABGjRqFv78/7777bqxeUgALFizgkUcewdPTk+3btwPct46npycnT55kxIgRHD9+HF9fX4YOHRrr5xYeHk6vXr3w8vKiZs2arF+/HjDJwqeeeorWrVtTpUoVhg0bluS5CyFEZvfKK6Y9ausoKoQQIhnmzJlD9erV023/ERER8T5//rzJH5QqlW6HTtJnn33GrFmz7G3kSZMm8dJLLyW6Te/evXnvvfcyIrxkSUOeLmsoXhwiI+HaNShSxOpohMi6Bg92/Gw6vr5gyx/Fa+fOncydO5c//vgDrTV+fn74+/tTLIEqfZ06deKDDz5g6tSp1KlTx/584cKF2b59O1988QWDBw/mq6++SvCYkydPZurUqfzwww/xvr579272799P2bJladiwIVu3bqVOnToEBgaydu1aqlatSo8ePfjoo48YPHgwAC4uLmzZsgUwCZ8KFSqwbds2hgwZQmBgIFu3biU8PJwaNWowYMAAXFxcWLZsGYULF+bixYvUr1+fDh06JFigb+fOnXz99dfs3r2biIgIatWqRe3atWOtc/nyZZYtW8ahQ4dQShEWFkbRokXp0KED7dq1izW8LSwsjI0bNwImkRTTzZs3+e2339i0aRO9e/dm3759iV7Lffv2EWJ744SGhtpf+9A2nmTv3r0cOnSIli1bcuTIEQBCQkLYvXs3efPmxd3dnZdeeokKFSokeBwhhMjsGjaEunVh+nTo188MzRBCCEewoo0eGhpKmzZtaNSoEb/99hvlypVjxYoV5MuXj5CQEAYMGMCtW7eoXLkyn3/+OcWKFSMgIAA/Pz/Wr19PWFgYn332GY0bN040joCAAHu7vmDBgrz88sv88MMP5MuXjxUrVlC6dGkuXLjAgAEDOHXqFAAzZ86kYcOGbN++ncGDB3P79m3y5MnDF198gbu7O/PmzePHH38kPDycmzdvsm7duljn1bp1azw8GrF//+/UretDr169GDt2LOfPn2fhwoXUq1ePy5cv07t3b/766y/y58/PJ598gre3N5cuXaJbt25cuHCBevXq2b+UBvOF7Xvvvcfdu3fx8/Nj1qxZ5MqVK97zHj9+PFu2bOHEiRN06NCBMWPGsGfPHnx8fAAYNGgQJUqUYMyYMaxatYqJEyeyYcMG8ufPj5ubG9u3b6devXpJ/pynT5/Ovn37+Pzzz9m7dy/dunVj+/bt5M+fP8ltkyPb/6srXtzcy1A6IbKeLVu28OSTT1KgQAEKFizIU089xebNm1O8n27dutnvt23blqaY6tWrR/ny5XFycsLX15fQ0FAOHz5MpUqVqFq1KgA9e/Zk06ZN9m26dOkSax8dOnQAwMvLCz8/PwoVKkTJkiVxcXEhLCwMrTWjRo3C29ubRx99lDNnznDu3LkEY9q8eTNPPvkk+fPnp3Dhwvb9x1S4cGFcXFzo06cP3333XaL/ROLGG1P0tWzSpAnXrl0jLCwswXUTs2XLFp577jkAqlWrRsWKFe3JpubNm1OkSBFcXFyoXr06J0+eTNUxhBAis1AKXn0Vjh6FlSutjkYIIdLu6NGjDBw4kP3791O0aFG+/fZbAHr06MHbb7/Nnj178PLyYty4cfZtIiIi2L59OzNnzoz1fHLcvHmT+vXr8+eff9KkSRM+/fRTAF5++WWGDBnCjh07+Pbbb+1DzapVq8amTZvYvXs3r7/+OqNGjbLva9u2bcyfPz9WoinasWPH6NLlZYKD93Do0CEWLVrEli1bmDp1KpMmTQJg7Nix1KxZkz179jBp0iR7yYlx48bRqFEjdu/eTYcOHewJsIMHD7J48WK2bt1KSEgIuXLlYuHChQme65gxY6hTpw4LFy5kypQpBAcHxxrVMXnyZBYvXsz69esZNGgQc+fOxcn2LUadOnXsn5emTJmCr6/vfbdBgwYBMHjwYI4dO8ayZcvo1asXH3/8scMSTZADejY98IC5v3QJHnrI2liEyMoS+3YjvegExr/mzp2bqKgo+3J4eHii+4nZIyj6ccx9aK25e/dusmLKmzev/XGuXLmIiIhIMM5oBQoUiHcfTk5Osfbn5OREREQECxcu5MKFC+zcuRNnZ2fc3NxSdI7xyZ07N9u3b2ft2rV8/fXXfPDBB/H+g40v3sSOo5RK8c8DEv7ZQvzXWAghsrqOHcHNDaZMMTWchBDCEaxoowNUqlQJX19fAGrXrk1oaChXr14lLCwMf39/wHwB27lzZ/s2Tz31VKz1UyJPnjy0a9fOvv2vv/4KwJo1a2LVdbp27RrXr1/n6tWr9OzZk6NHj6K1jlU7tUWLFjwQnSiIISoKypWrhK+vF4ULQ40aNWjevDlKKby8vOwxb9myxZ5ca9asGZcuXeLq1ats2rSJ7777DoC2bdvaR2OsXbuWnTt3UrduXQBu375NqRSM0fvnn38oWbKkfTl//vx8+umnNGnShBkzZlC5cmX7a6VKleLQoUMADB06lKFDhya4XycnJ+bNm4e3tzf9+/enYcOGyY4pOaRnkxAi02rSpAnLly/n1q1b3Lx5k2XLltG4cWNKly7N+fPnuXTpEnfu3Ik15K1QoUJcv3491n4WL15sv2/QoAFgaint3LkTgBUrVnDv3r0Et09KtWrVCA0NtdeD+vLLL+3/ZFPj6tWrlCpVCmdnZ9avX59kz54mTZqwbNkybt++zfXr1/n+++/vW+fGjRtcvXqVxx57jJkzZ9qHtqX0fKOv5ZYtWyhSpAhFihTBzc2NXbt2AbBr1y5OnDiR5L6bNGli/0bnyJEjnDp1Cnd392THIYQQWU3u3KZ202+/mZsQQmRlqflyMHqbmOv36tULX19fHnvssUS3dXZ2tn/pGXP7qKgotm3bRkhICCEhIZw5c4ZChQoxevRomjZtyr59+1i8eHGsL0MT+mL16lXInTsvZcqY5ZhfDEd/KQzxf2kaHVt8XwBrrenZs6c9xsOHD99XqiIx+fLlu+/L3L1791K8ePH7JkYKDw8nX758QNI9m8D0UCtYsGCaJlhKSLZPNrm6mvt//rE2DiFEytWqVYvAwEDq1auHn58fffr0oWbNmjg7OzNmzBj8/Pxo164d1apVs28TGBjIgAED7AXCAe7cuYOfnx/vvvuuveh337592bhxI/Xq1eOPP/6w/9Px9vYmd+7c+Pj43FcgPCEuLi7MnTuXzp074+XlhZOTEwMGDEj1eXfv3p3g4GB799mY5xefWrVq0aVLF3x9fenYsWO849+vX79Ou3bt8Pb2xt/f335uXbt2ZcqUKdSsWZPjx48nGVuxYsV45JFHGDBgAJ999hkAHTt25PLly/j6+vLRRx/ZhxMWL16chg0b4unped+3Ki+++CKRkZF4eXnRpUsX5s2bF6vRIoQQ2VHv3qbX/ZQpVkcihBCOV6RIEYoVK2YfxpWcL2Dnzp1LSEgIP/30U6qO2bJlSz744AP7cvQXqlevXqVcuXIAiQ5Zi6Y1XLxoauolVes55pemGzZsoESJEhQuXDjW8z///DNXrlwBTImIpUuXcv78ecDUUk1JmQgPDw/7l9oAJ0+eZNq0aezevZuff/6ZP/74w/7akSNH7EPuhg4dak9wxbxFFxG/evUqL7/8Mps2beLSpUuOnzVaa50tb66urlprrW/f1hq0njBBCwdav3691SFka5nl+h44cMDqENKsYsWK+sKFC7Geu3btmkXR5BxyjdNXTry+8f09AoJ1JmhzyO2/W9WqVe/7OYnY3nhDa6W0Pnw4eetnljZBdiHX07GCgoJ0UFCQ1WFkK8l5j1rdRj9x4oSuUaOGfXnKlCl67NixWmutd+/erf38/LSXl5d+/PHH9eXLl7XWWvv7++sdO3ZorbW+cOGCrlixYrz77tmzp16yZMl92xQoUMC+zpIlS3TPnj3t+3r66ae1l5eX9vDw0P3799daa/3bb7/pKlWq6EceeUQPHTrUfry5c+fqgQMH3nfcq1e1XrHihK5W7b/zihlLzHO+dOmS7tChg/by8tJ+fn76zz//1FprffHiRd2iRQtds2ZNPXjwYP3ggw/aP4d8/fXX2sfHR3t5eelatWrpbdu2aa3j/6wS99y11trT01Nfu3ZNR0VF6ebNm+sVK1ZorbUODg7Wnp6e+vbt21prrWvWrBnv/uLTq1cv/e6772qttT516pSuXLmyPnfu3H3rpbYNpsx62U/ZsmV1dFewEiXg6adh1iyLg8pGoqeAF+kjs1zfgwcP4uHhYXUYaeLm5kZwcDAlSpSwP3f9+nUKFSpkYVTZn1zj9JUTr298f4+UUju11nUS2ERYwN3dXR8+fNjqMDK1c+egYkXo2RM+/jjp9TNLmyC7kOvpWNFFnseOHWtxJNlHct6j2aGNnpGS0246cgRu3wYvr8w5Y+iMGTMoVKiQvQB6fHbv3s306dP58ssvHXrs1LbBMuFldLyyZSEdhiAKIbKA0NDQWIkmIYQQwkqlS0OPHjB/vkk8CSGEsNatW3DtGpQqlTkTTQAvvPBCkiUnLl68yJtvvplBESUtk15KxypXDs6csToKIYQQQggh4NVX4e5diFFmRAghhEX+/dckmWJM+JbpuLi48NxzzyW6TosWLXBzc8uYgJIhRySbpGeTEEIIIYTILNzdoUMHU+Lh5k2roxFCiJzr7l24csUkmnLntjqa7CVHJJvKlTPZymTMxiiEEEIIIUS6GzoULl+Gzz+3OhIhhMi5zp0zM9GVKmV1JNlPjkg2lS0LUVFgm2lQCCGEEEIISzVsCA0awPTp8oWoEEJYISICLlyABx6AJMohiVTIEcmmcuXMvdRtEiL7mzdvHmfTMG42NDSURYsWpfg1R7pz5w6PPvoovr6+LF68ON2PF5+goCCmTp1qybGjbdiwgXbt2lkagxBCpKfhwyE0FL75xupIhBAiZR555BGH7zOhtnbt2rW5e/duive3fPlyDhw4kODrFy6YTillysT/elhYGLMyyZT2AQEBBAcHWx1GiuSIZFPZsuZe6jYJkc4WLgQ3N1Nhz83NLGcwq5JNEQ78Wnr37t3cu3ePkJAQunTpkqxtIiMjHXZ8IYQQGaN9e6heHSZPNsM4hBAiXaRDG/23335L8z7iiq+tHRoaSrly5ciTJ0+K95dYsikqygyhK1IE8uePf/vMlGzKinJEskl6NgmRARYuhH794ORJ02I+edIsp/Gf2fTp0/H09MTT05OZM2cC5p+Op6enfZ2pU6cSFBTE0qVLCQ4Opnv37vj6+nL79m3c3NwYPnw49erVo169ehw7dgyAwMBAli5dat9HwYIFARgxYgSbN2/G19eXGTNmxIol7mvz5s2jc+fOtG/fnpYtW3Ljxg2aN29OrVq18PLyYsWKFfZ4PTw86Nu3LzVq1KBly5bcvn0bgPfee4/q1avj7e1N165dOX/+PM8++ywhISH4+vpy/Phx1q5dS82aNfHy8qJ3797cuXMHADc3N8aPH0+jRo1YsmQJbm5ujBo1igYNGlCnTh127dpFq1atqFy5MrNnz7afx5QpU6hbty7e3t6MHTvW/vzEiRNxd3fn0Ucf5fDhw/H+PJYsWYKnpyc+Pj40adLEfn6NGzemVq1a1KpVy9742LBhA/7+/jz99NNUrVqVESNGsHDhQurVq4eXlxfHjx+3/ywGDBhA48aNqVq1Kj/88MN9x7158ya9e/embt261KxZ035t9+/fT7169fD19cXb25ujR48m/GYSQohMxsnJ9G7auxd++snqaIQQ2VI6tdGj284bNmwgICCATp06Ua1aNbp37462Zc8d0Q7/+eefad26NQBfffUVXl5eeHp6Mnz48Pu2B1i6dCmBgYH89ttvrFy5kqFDh9KwYUOOHz9OQEAAgwcP5pFHHqF6dU/+/HM7Zcrc36Pf09OT0NBQRowYwfHjx/H19WXo0KGxzv/mzZu0bdsWHx8fPD097aMRxo8fT926dfH09KRfv372axEQEMCQIUNo0qQJHh4e7Nixg6eeeooqVarwxhtvAKZNXa1aNXr27Im3tzedOnXi1q1b91371atX06BBA2rVqkXnzp25ceOG/fpFf6547bXXUvYDTQ9a62x5c3V11dEiIrTOlUvr11/XwkHWr19vdQjZWma5vgcOHEj+yhUram3+hcW+VayY6uMHBwdrT09PfePGDX39+nVdvXp1vWvXLn3ixAldo0YN+3pTpkzRY8eO1Vpr7e/vr3fs2BEjrIp6woQJWmut58+fr9u2bauvXbume/bsqZcsWWJfr0CBAlprc+3btm0bbzxxX5s7d64uV66cvnTpktZa63v37umrV69qrbW+cOGCrly5so6KitInTpzQuXLl0rt379Zaa925c2f95Zdfaq21dnV11eHh4Vprra9cuXLfcW7fvq3Lly+vDx8+rLXW+rnnntMzZsywn9vbb78d61xnzZqltdZ68ODB2svLS1+7dk2fP39elyxZUmut9apVq3Tfvn11VFSUjoyM1G3bttUbN260X+ubN2/qq1ev6sqVK+spU6bcdw08PT316dOnY8V78+ZNffv2ba211keOHNG1a9fW165d0+vXr9dFihTRZ8+e1eHh4bps2bJ6zJgxWmutZ86cqV9++WWttdY9e/bUrVq10pGRkfrIkSO6XLly+vbt27Guw8iRI+3X7MqVK7pKlSr6xo0b+n//+59esGCB1lrrO3fu6Fu3bsX7s8turl27ZnUIGS6+v0dAsM4EbQ65/XerWrXqfT8nkbi7d7WuUEHrRo3ifz2ztAmyC7mejhUUFKSDgoKsDiNbSc571Oo2utax286FCxfWf//9t46MjNT169fXmzdvth36/na41jpF7fAOHTro48eP6zNnzugKFSro8+fP63v37ummTZvqZcuWxdpea62XLFmie/bsGes40e0mf39/3adPHx0ZqfXnn2/UDz9cQ0dFaT127NhY7d4aNWroEydO3PeZI6alS5fqPn362JfDwsK01tr+uUBrrZ999lm9cuVK+7GHDRumtTbtYFdXV3sbuVy5cvrixYv6xIkTGtBbtmzRWmvdq1cve1zRn3EuXLigGzdurG/cuKG11nry5Ml63Lhx+tKlS7pq1ao6KipKa/1fO90RUtsGyxE9m3LlAldX6dkkRLo6dSplzyfDli1bePLJJylQoAAFCxbkqaeeYvPmzSneT7du3ez327ZtS3U88WnRogUPPPAAYJL3o0aNwtvbm0cffZQzZ85w7tw5ACpVqoSvry9gxp2HhoYC4O3tTffu3VmwYAG545lv9fDhw1SqVImqVasC0LNnTzZt2mR/Pe4wuw4dOgDg5eWFn58fhQoVomTJkri4uBAWFsbq1atZvXo1NWvWpFatWhw6dIijR4+yefNmnnzySfLnz0/hwoXt+4mrYcOGBAYG8umnn9qH7t27d4++ffvi5eVF586dY3VXrlu3Lq6uruTNm5fKlSvTsmVLe3zR1wDg6aefxsnJiSpVqvDQQw9x6NChWMddvXo1kydPxtfXl4CAAMLDwzl16hQNGjRg0qRJvP3225w8eZJ8+fIl/MMSQohMyNkZXnsNtmwxNyGEcKh0aKPHVa9ePcqXL4+TkxO+vr6x2nhpaYffvXuX06dP89BDD7Fjxw4CAgIoWbIkuXPnpnv37rHaxMnVrVs3rlwBL68m3L59jatXw1K8DzBt2TVr1jB8+HA2b95MkSJFAFi/fj1+fn54eXmxbt069u/fb98mZju9Ro0a9jbyQw89xN9//w1AhQoVaNiwIQDPPvssW+L8Y/j99985cOAADRs2xNfXl/nz53Py5EkKFy6Mi4sLffr04bvvviN/QmMDM1COSDaBqdskNZuESEcPPpiy55PBJM3vlzt3bqKiouzL4eHhie5HKXXf45j70FqnquggQIECBeyPFy5cyIULF9i5cychISGULl3aHlveGFNc5MqVy17j6ccff2TgwIHs3LmT2rVr31f7KaFrEN/xYx7Hyckp1jGdnJyIiIhAa83IkSMJCQkhJCSEY8eO8fzzzwOxr1NCZs+ezYQJE/j777/x9fXl0qVLzJgxg9KlS/Pnn38SHBwc61rGjSFmfDHPNe6x4y5rrfn222/tcZ86dQoPDw+eeeYZVq5cSb58+WjVqhXr1q1L8hyEECKz6dMHSpQwtZuEEMKh0qGNHldC7VxIWzt88+bNNGrUyL5eQmIeI6nPBaD491/Il88MZVZKpfizBUDVqlXZuXMnXl5ejBw5kvHjxxMeHs6LL77I0qVL2bt3L3379o21r6Ta6XHPJb5lrTUtWrSwt4kPHDjAZ599Ru7cudm+fTsdO3Zk+fLl9qGHVsoxyaZy5aRnkxDpauLE+6vr5c9vnk+lJk2asHz5cm7dusXNmzdZtmwZjRs3pnTp0pw/f55Lly5x586dWDV+ChUqxPXr12PtJ3oM9eLFi2nQoAFgxpDv3LkTgBUrVnDv3r0Et09s3zFdvXqVUqVK4ezszPr16zl58mSi5xcVFcXff/9N06ZNeeeddwgLC7OPuY5WrVo1QkND7WPcv/zyS/z9/RPdb2JatWrF559/bj/OmTNnOH/+PE2aNGHZsmXcvn2b69ev8/3338e7/fHjx/Hz82P8+PGUKFGCv//+m6tXr+Lq6oqTkxNffvllqoqVL1myhKioKI4fP85ff/2Fu7v7fXG///779obG7t27Afjrr7946KGHGDRoEB06dGDPnj0pPrYQQlgtf34YNAh+/BHkz5gQwqHSoY2eEmlph//yyy+0adMGAD8/PzZu3MjFixeJjIzkq6++sreJS5cuzcGDB4mKimLZsmX27eNru3/55WJu34bQ0C0UKVKEIkWK4Obmxq5duwDYtWsXJ06cSHD7aGfPniV//vw8++yzvPbaa+zatcueWCpRogQ3btyIVZcquU6dOmXvAfbVV1/Zk23R6tevz9atW+2fDW7dusWRI0e4ceMGV69e5bHHHmPmzJmEhISk+NiOdv+YjWyqXDlYu9YMUE3Gl/dCiJTq3t3cv/666Zb74IPmn1j086lQq1YtAgMDqVevHgB9+vShZs2aAIwZMwY/Pz8qVapEtWrV7NtEF5vOly+f/Q/1nTt38PPzIyoqiq+++gqAvn378vjjj1OvXj2aN29u7yHk7e1N7ty58fHxITAwkCFDhtj3Hfe1YsWKxbkE3Wnfvj116tTB19c3VlzxiYyM5Nlnn+Xq1atorRkyZAhFixaNtY6Liwtz586lc+fOREREULduXQYMGJCKq2m0bNmSgwcP2v/ZFyxYkAULFlCrVi26dOmCr68vFStWpHHjxvFuP3ToUI4ePYrWmubNm+Pj48OLL75Ix44dWbJkCU2bNr2vt1VyuLu74+/vz7lz55g9ezYuLi6xXh89ejSDBw/G29sbrTVubm788MMPLF68mAULFuDs7EyZMmUYM2ZMyi+KEEJkAv/7H7zzjrktWGB1NEKIbCMd2ugpkZZ2+IYNGxg/fjwArq6uvPXWWzRt2hStNY899hiPP/44AJMnT6Zdu3ZUqFABT09P+5eqXbt2pW/fvsycOZPvvvsOgNy5i9GnzyNERFzj888/B6Bjx4588cUX+Pr6UrduXXv5iuLFi9OwYUM8PT1p06YNU6ZMsZ/X3r17GTp0KE5OTjg7O/PRRx9RtGhRe2kJNzc36tatm+Lr5eHhwfz58+nfvz9VqlThhRdeiPV6yZIlmTdvHt26dbNPGjRhwgQKFSrE448/Tnh4OFrr+yY6soJKaohGVlW2bFkdc/rzmTNhyBA4fx5KlrQuruwietYBkT4yy/U9ePAgHh4eVoeRJm5ubgQHB1OiRAn7c9evX6dQoUIWRpX9peQaBwYG0q5dOzp16pTOUWUfOfE9HN/fI6XUTq11HYtCEvFwd3fXCc1mKZL22mumzXr0KFSqZJ7LLG2C7EKup2ONGzcOINbstiJtkvMezSpt9Pja4cl1+vRp+vbty88//5zmOKLbTY0bB9C371Rat65DqVJp3q3DhYaG0q5dO/bt22d1KLGktg2WY4bRVali7mVWbCGEEEIIkRkNGWJqiMSYgVsIIXKk8uXLOyTRFNPdu2bysOLFHbpbkYAcM4wuZrLpkUesjUUIkXFizoYhMqd58+ZZHYIQQmQK5cpBz57w+ecwejSUKWN1REIIkXqZqR1+6xZ8+OEGypY1CafMyM3NLdP1akqLbN2z6fff4dVXITzcdEXOlUt6NgkhhBBCiMxr2DDz7fv06VZHIoQQ2cc//5h8QGYcPpddZetk07595h/1hQvg7AxubpJsEkIIIYQQmVeVKtC1K8yaBZcuWR2NEEJkfXfuOHHlikk05c4xY7usl6WSTUqpXEqp3UqpH5Je+79C4BcumPsqVSTZJIQQQgiREiltf4m0GzUKbt6Ed9+1OhIhhMj6Ll/Og5OT9GrKaFkq2QS8DBxM7srRRe8vXjT30cmmbDoBnxBCCCFEekhR+0ukXY0a0LEjvPce3LiRSYuLCCFEFhAeDteu5aZkSTPaSWScLJNsUkqVB9oCc5K7TXw9m27cgPPnHR+fEMLxLl26hK+vL76+vpQpU4Zy5crZl+/evZusfQQGBrJ06dJUx7BkyRJq1KiBk5MTwcHBia4bFhbGrFmzEl1ny5Yt1KtXj2rVqlGtWjU++eSTZMdSsGDBZK8bn4CAANzd3fH29qZatWr873//IywszP76I0nMnjBp0qREX3/ssccICwsjNDQUPz+/FMW2YcMGfvvtN/vy7Nmz+eKLL1K0DyGE46Wm/SUc4/XX4epVWL68nNWhCCHEfd577z08PDzo3r07K1euZPLkycneNjQ0lEWLFjk0noTa/P/+C0pB6dKJbx+3LZpSQUFBTE2HqUTv3LnDo48+iq+vL4sXL4712qFDh/D19aVmzZocP36c27dv4+/vT2RkZIL727t3L4GBgQ6PMz5ZacTiTGAYUCihFZRS/YB+AK6urhw6tAVoxLZtRylX7gy3bz8AePPNN7vx8rqaETFnWzdu3GDDhg1Wh5FtZZbrW6RIEa5fv27Z8fPkycPmzZsBk+goWLAggwYNAswf3jt37iS5j3v37nH79u1Y5xEZGZngeUVGRpIrxhQVlSpV4ssvv+Tll1/m5s2biV6P06dP88EHH/Dcc8/F+/q5c+fo1q0bixYtwtfXl0uXLvHkk09SrFgxWrduHWvdiIgIcsczqDy5Pw+tNVprnJz++04hMjKSTz75hFq1anH37l2CgoJo166dfVrZVatWJbr/SZMm8dJLLyV4rOh/gDdu3EBrnaL3zqpVqyhYsCBeXl4AdO/eHUj++eY0ib2Hs6vw8PBM8XcxB5pJCtpfJUuWlJ+TA9Wv78U335SnY8dN5MsXZXU42UJmaWNlN3JNHSc571Gr2+gAH3zwAd9++y1ubm4ANG3a9L6YEmrPHjhwgC+++IL27dun6thx2+sQf5v/3j3FpUsFKFz4Lnfu3CXmR4e4scVti6bUnTt3cHZ2TvbPJaFrE9f27dsJDw+3fyaKuf/FixfTunVrXn/9dQBmzZrFY489xq1btxLcn5ubGydPnuTAgQNUqFAhWbGmug0W/SEhM9+AdsAs2+MA4IektnF1ddWRkVrnyqX1669rrbXWx45pDVp//rkWabR+/XqrQ8jWMsv1PXDggNUh2I0dO1ZPmTJFf/LJJ7pOnTra29tbP/XUU/rmzZv62rVr2s3NTd+9e1drrfXVq1d1xYoV9d27d3XPnj31kiVLtNZar1mzRvv6+urq1avrXr166fDwcK211hUrVtTjxo3TDRs21F999VW8x/f399c7duywL+/bt0/XrVtX+/j4aC8vL33kyBHdpUsX7eLion18fPRrr7123z7eeOMNPXr06FjPrVmzRjdq1EhrrXXPnj31kCFDdEBAgH7llVf0X3/9pevXr6/r1Kmj33jjDV2gQAH7du+8846uU6eO9vLy0mPGjNFaa33ixAldrVo1/cILL2hfX18dGhqa6DlERERoNzc3HRISorXW9v2fPXtWN27cWPv4+OgaNWroTZs26eHDh2snJyft4+Ojn3nmmXiPVbFiRX3hwgV94sQJXaVKFd2jRw/t5eWlO3bsqG/evGm/1hcuXNBaa71jxw7t7++vT5w4oUuXLq3Lli2rfXx89KZNm+w/b6213r17t/bz89NeXl76iSee0JcvX7afz7Bhw3TdunV1lSpV9KZNm+L92WVH165dszqEDBff3yMgWGeCdkp2vaWm/VW1atV4fnoitX77zbRdp02zOpLsI7O0sbKLoKAgHRQUZHUY2Upy3qNWt9H79++vnZ2dtaenp54+fbqeO3euHjhwoNb6/vbshg0btI+Pj/bx8dG+vr762rVr2s/PTxcuXFj7+Pjo6dOnx9p3VFSUfu2113SNGjW0p6en/vrrr7XW5roEBATobt26aQ8PDx0VFaUHDhyoPTw89GOPPabbtGljb/MHBwfrJk2aaE/PWrp+/ZZ6//6jWmvTdhw5cqRu0qSJnjp1qv2Y8bVFV65cqevVq6d9fX118+bN9b///qsjIyP1ww8/rM+fP6+11joyMlJXrlxZX7hwIdlt1/iOr7XWly5d0o8//rj28vLSfn5++s8//9Tnzp3TlStXtl+rY8eO2df/8ccf7TEHBARorbVu0KCBPnHihNZa6++++043b95cR0VF6bNnz+oqVarof/75R2ut9cyZM/Xbb7+d7J93attgWaVnU0Ogg1LqMcAFKKyUWqC1fjaxjZycoHjx/2o2Vaxoqs9LkXAhUmHnYLgS4th9FvOF2jNTtMlTTz1F3759AXjjjTf47LPPeOmllwgICODHH3/kiSee4Ouvv6Zjx444xxiYHR4eTmBgIGvXrsXV1ZWBAwfy0UcfMXjwYABcXFzYsmVLsuOYPXs2L7/8Mt27d+fu3btERkYyefJk9u3bR0hISLzb7N+/n549e8Z6rk6dOuzfv9++fOTIEdasWUOuXLno0KEDL7zwAj169ODDDz+0r7N69WqOHj3K9u3b0VrToUMHNm3axIMPPsjhw4eZO3duksP5AHLlyoWPjw+HDh3Cx8fH/vyiRYto1aoVr7/+OpGRkdy6dYvGjRvzwQcf2M8tNDQ00WMdPXqUuXPn0rBhQ3r37s2sWbN47bXX4o3Dzc2NAQMGULBgQfs6a9eutb/eo0cP3n//ffz9/RkzZgzjxo1j5syZgPlWaPv27fz000+MGzeONWvWJHneQohkS1X7SzhOgwZQq9YVpkwpxosvgouL1REJITIdC9ros2fP5pdffmH9+vWUKFGCefPmxXo9Znu2ffv2fPjhhzRs2JAbN27g4uLC5MmTmTp1Kj/8cP+8E9999x0hISH8+eefXLx4kbp169KkSRPA9PLZt28flSpV4rvvvuPw4cPs3buXc+fOUb16dXr37s29e/d46aWXWLp0Bf/8U5Jt2xbz1lvj+PLLLwFT9mLjxo2xjhlfW/TKlSv8/vvvKKWYM2cO77zzDtOmTePZZ59l4cKFDB48mDVr1uDj40OJ6GLRNom1XeM7PsDYsWOpWbMmy5cvZ926dfTo0YOQkBDmzJkT77V67LHHYsV89+5d/vrrL3tPsyeffJJvv/2WDz/8kF9++YVx48ZRpkwZwHz+mDx5MsOGDUvwZ+wIWaJmk9Z6pNa6vNbaDegKrEtuQ6dkyf9qNuXODQ89JMkmIbKyffv20bhxY7y8vFi4cKE9UdOnTx/mzp0LwNy5c+nVq1es7Q4fPkylSpWoWrUqAD179mTTpk3217t06ZKiOBo0aMCkSZN4++23OXnyJPny5UtyG601Sqn7no/5XOfOne3dgrdu3Uq3bt0AYg3NW716NatXr6ZmzZrUqlWLQ4cOcdT2h61ixYrUr18/2edhvpiIrW7dusydO5egoCD27t1LoULxj55J7Fjly5enYcOGADz77LMpSuTFdPXqVcLCwvD39wfu/7k99dRTANSuXZvQ0NBUHUMIEb+0tL+E4zz33En+/Rc+/9zqSIQQInlitmcbNmzIK6+8wnvvvUdYWFiSQ8e2bNlCt27dyJUrF6VLl8bf358dO3YAUK9ePSpVqgTApk2b7OuVLVuWZs2aAabNv2/fPlq0aEG3br7Mnj2BM2fO2Pef3Db/6dOnadWqFV5eXkyZMsX+maN37972uqKff/75fZ85kmq7JnT8LVu22Nv7zZo149KlS1y9mvzSPxcvXqRo0aKxnnv//fd56623yJs3r/0zBUCpUqU4e/ZssvedWlmlZ1OqlSjxX88m+G9GOiFECqWwB1J6CQwMZPny5fj4+DBv3jz7+OGGDRsSGhrKxo0biYyMxNPTM9Z28SVVYipQoAAAvXr1Yvfu3ZQtW5affvopwfWfeeYZ/Pz8+PHHH2nVqhVz5szhoYceirXO66+/zo8//ghASEgINWrUIDg4mA4dOtjX2blzJ9WrV78vjmjxJae01owcOZL+/fvHej40NPS+7RMTGRnJ3r178fDwiPV8kyZN2LRpEz/++CPPPfccQ4cOpUePHvdtn9ix4sYdvZw7d26iokzdkfDw8GTHmpC8efMCppdWREREmvcnhBCZjY9PGA0bwuTJ0KcP5MljdURCiEwlk7TRY4rZRhwxYgRt27blp59+on79+kn2Qk+szZ7cdnL16jWYNWsbRYuaziYx6xwlt6380ksv8corr9ChQwc2bNhAUFAQABUqVKB06dKsW7eOP/74g4ULFyZrf0kdP77zju/8EpIvX7772tZnzpzBycmJc+fOERUVZa/lGh4enqwvytMqS/RsiklrvUFr3S6568fs2QQm2XTsGCTxuVMIkUldv34dV1dX7t27d98f9x49etCtW7f7vmEAqFatGqGhoRw7dgyAL7/80v6NQ0xz584lJCQk0UQTwF9//cVDDz3EoEGD6NChA3v27KFQoUKx/plNnDiRkJAQ+9CzgQMHMm/ePPvypUuXGD58eIJdWBs2bMjXX38NEOtcW7Vqxeeff86NGzcA84/kfAqn2bx37x4jR46kQoUKeHt7x3rt5MmTlCpVir59+/L888+za9cuAJydnbl3716y9v/333+zbds2AL766isaNWoEmG7KO3fuBODbb7+1rx/32kUrUqQIxYoVsxdFTOjnJoRIXyltfwnHUQreeAP+/htkkk4hRFZz/PhxvLy8GD58OHXq1OHQoUMJtvvAfOm5ePFiIiMjuXDhAps2baJevXrxrvf1118TGRnJP//8w/r16wFwd3fn338vEBKyDVdX0+Y9ePBgknHGjenq1auUK2dmA50/f36sdfv06cOzzz7L008/fV+h8tS2XZs0aWJv72/YsIESJUpQuHDhJLeLVqxYMSIjI+0Jp4iICHr16sWiRYvw8PBg+vTp9nWPHDly3xfz6SHLJZtSqkSJ+5NNN29CjJ50Qogs5M0338TPz48WLVpQrVq1WK91796dK1euxOomGs3FxYW5c+fSuXNn6tevj5OTEwMGDEjyeMuWLaN8+fJs27aNtm3b0qpVK8DM/uDp6Ymvry+HDh2iR48eFC9enIYNG+Lp6cnQoUPv25erqysLFiygb9++VKtWjUceeYTevXsnOBPHu+++y4cffkjdunVjdaNt2bIlzzzzDA0aNMDLy4tOnTole+aL7t274+3tjaenJzdv3mTFihX3rbNhwwb7NKrffvstL7/8MgD9+vXD29vbPlNcYtzd3Zk/fz7e3t5cvnyZF154ATDj0V9++WUaN24c659z+/btWbZsGb6+vvZ/ztHmz5/P0KFD8fb2JiQkhDFjxiTrXIUQIrto1Qr8/GDiRLh71+pohBAi+WbOnImnpyc+Pj7ky5ePNm3a4O3tTe7cufHx8WHGjBmx1n/yySfx9vbGx8eHZs2a8c4779hrDcVdr0qVKnh5efHCCy/YEzpOTnl4662lzJ49nPr1ffD19eWPP/5IMs64bdGgoCA6d+5M48aN76vJ1KFDB27cuBHvF9yQurZrUFAQwcHBeHt7M2LEiPsSXMnRsmVLe+mKSZMm0bhxYxo3bsz06dOZM2eOPem2fv162rZtm+L9p5RKamhJVlW2bFl99uxZxoz57x9zrlywdSs0agQrV0IqZ1oUmA+jAQEBVoeRbWWW63vw4MH7hlhlZkuXLmXFihX2AoAJuX79eoJ1iIRjyDVOXznx+sb390gptVNrXceikEQ83N3d9eHDh60OI1uJbhP88gu0aQOffmqG04nUySxtrOxi3LhxgPkySThGct6jWa2NnpHOnIF//oEaNSB6pJij203BwcEMGTLkvi9IrbZ7926mT5+e6GehO3fu4O/vz5YtW5KsnxUttW2wHNGzKSoKrlwxy76+ZpY62ygOIUQ28dJLLzFixAhGjx5tdShCCCGEw7VqBfXqSe8mIYRISEQEnDsHxYr9l2hytMmTJ9OxY0feeuut9DlAGtSsWZOmTZsSGRmZ4DqnTp1i8uTJyU40pUW2TzaVLGnuo4uEFygA1apJskmI7Ob999/n2LFj9tnmhBBCiOxEKQgKgtBQqd0khBDxOXfOdDQpWzb9jjFixAhOnjxpr0ea2fTu3fu+OlIxValSJcN6d2b7ZFP08MqYdZtq15ZkkxBCCCGEyFpat5beTUIII7uWw0mtjOjVlBOl5X2W7ZNNpUub+3///e+52rXNOM5//rEmJiGEEEIIIVJKejcJIcBMfHPp0iVJOMWQEb2achqtNZcuXcLFxSVV26f/QD2LVahg7v/++7/natc29zt3QjuZxFcIIYQQQmQRMXs39egBefJYHZEQIqOVL1+e06dPcyHm8J0cLDLSFAbPl88k4+MKDw9PdcIkp3NxcaF8+fKp2jbbJ5uKFjV1mmImm3x9zTdDkmwSQgghhBBZiVIwdiy0bWt6N8nMdELkPM7OzlSqVMnqMDKNN96ASZNgzx6Ib5K+DRs2ULNmzYwPLIfL9sPolIIHH4RTp/57rmBBKRIuRE4WFhbGrFmzMvy4gYGBLF26NMOP60jz5s3DycmJPXv22J/z9PQkNL6vkeKxadMmatWqRe7cue+7FvPnz6dKlSpUqVKF+fPnJ7mvwMBAKlWqxOzZs1N0Dhlp586deHl58fDDDzNo0KB4u7tv374dX19ffH198fHxYdmyZfbXXn/9dSpUqEDBggUzMuxEnThxAj8/P6pUqUKXLl24m0DhmNatW1O0aFHaxflWp3v37ri7u+Pp6Unv3r25d+8eAIsXL+bhhx++b30hxP3atIG6daV2kxBCXLoE770HnTuDp6fV0YiYsn2yCcxQupg9m0CKhAuRk129ejXDk02JTUGakbTWREVFpWkf5cuXZ+LEiana9sEHH2TevHk888wzsZ6/fPky48aN448//mD79u2MGzeOK1euJLm/KVOmMGDAgFTFkhFeeOEFPvnkE44ePcrRo0f55Zdf7lvH09OT4OBgQkJC+OWXX+jfvz8REREAtG/fnu3bt2dIrNHHTMrw4cMZMmQIR48epVixYnz22Wfxrjd06FC+/PLL+57v3r07hw4dYu/evdy+fZs5c+YA0KVLF/tjIUTiYtZumjfP4mCEEMJC06bBjRswerTVkYi4cnSy6ezZ2IXDhRCZS2hoKNWqVaNPnz54enrSvXt31qxZQ8OGDalSpYr9Q/jly5d54okn8Pb2pn79+vZeN0FBQfTu3ZuAgAAeeugh3nvvPQDGjh3L8ePH8fX1ZejQoWitGTp0KJ6ennh5ebF48eJ447lx4wa9evXCy8sLb29vvv32W8AkFOrUqUONGjUYO3asfX03NzfGjx9Po0aNWLJkSax9rV27lpo1a+Ll5UXv3r25c+fOfcf79NNPqVu3Lj4+PnTs2JFbt24BpkfPgAEDaNy4MVWrVuWHH34ATK+jxx9/nNatW+Pu7s64cePs19HDw4MXX3yRWrVq8ffff8d7voMGDWL8+PEArFq1iiZNmsSbmGrXrh379+/n8OHDyfkxxuLm5oa3tzdOTrH//axatYoWLVrwwAMPUKxYMVq0aBFvYiYxgYGBvPDCCzRt2pSHHnqIjRs30rt3bzw8PAgMDLSvt3r1aho0aECtWrXo3LkzN27cAGD8+PHUrVsXT09P+vXrZ++FFBAQwPDhw6lXrx5Vq1Zl8+bNyYrnn3/+4dq1azRo0AClFD169GD58uX3rZc/f35y5zaj2sPDw1FK2V+rX78+rq6uyb4Gfn5+7N+/374cEBDAzp072b59O4888gg1a9bkkUcesf/s5s2bR+fOnWnfvj0tW7ZMcv9aa9atW0enTp0A6NmzZ7znBNC8eXMKFSp03/OPPfYYSimUUtSrV4/Tp08n+/yEEP9p0wbq14c334TwcKujEUKIjHf+PLz7LnTtKr2aMqMckWx68EGTVIr5WS5mkXAhRPIEBAQwz/YV6r179wgICGDBggUA3Lp1i4CAAHvi4urVqwQEBPDdd98BcPHiRQICAvj+++8B+DeZmd5jx47x8ssvs2fPHg4dOsSiRYvYsmULU6dOZdKkSYBJHtWsWZM9e/YwadIkevToYd/+0KFDrFq1yt5b5t69e4wbN47KlSsTEhLClClT+O677wgJCeHPP/9kzZo1DB06lH/ima7yzTffpEiRIuzdu5c9e/bQrFkzACZOnEhwcDB79uxh48aNsYaYubi4sGXLFrp27Wp/Ljw8nMDAQBYvXszevXuJiIjgo48+uu94Tz31FDt27ODPP//Ew8MjVg+S0NBQNm7cyI8//siAAQMIt33S2L59OwsXLiQkJIQlS5YQHBwMwOHDh+nRowe7d++296KJe76TJ09m8eLFrF+/nkGDBjF37tz7kkIATk5ODBs2zH79Y+rSpQu+vr40bNjQPjTM19eXL5KYNunMmTNUiJ7RAdN76syZM4luE58rV66wbt06ZsyYQfv27RkyZAj79+9n7969hISEcPHiRSZMmMCaNWvYtWsXderUYfr06QD873//Y8eOHezbt4/bt2/bk3hgev1s376dmTNn2pN4hw8fjnWOMW9hYWGcOXMmVkHFxM7pjz/+oEaNGnh5eTF79mx78imlunbtyjfffAOYZNfZs2epXbs21apVY9OmTezevZvx48czatQo+zbbtm1j/vz5rFu3juvXryd4TgcOHODSpUsULVrUHl9qf05g/oZ8+eWXtG7dOlXbC5HTKQUTJsDp0/Dpp1ZHI4QQGW/yZJNsDwqyOhIRn2xfIBz+m5HuzBl46CHzOGaR8LZtLQtNCJGESpUq4eXlBUCNGjVo3rw5Sim8vLzsdYK2bNli72XUrFkzLl26xNWrVwFo27YtefPmJW/evJQqVYpz587dd4wtW7bQrVs3cuXKRenSpfH392fHjh106NAh1npr1qzh66+/ti8XK1YMgG+++YZPPvmEiIgI/vnnHw4cOIC3tzdgki9xHT58mEqVKlG1alXA9A758MMPGTx4cKz19u3bxxtvvEFYWBg3btygVatW9teefvppnJycqFKlCg899BCHDh0CoEWLFhQvXhwwyaotW7bwxBNPULFiRerXr5/k+X766ac0adKEGTNmULly5QR/Ls888wwTJ07kxIkTsZ6PTjZev3493l4tCYmvllHMHj7J1b59e/v7o3Tp0rHeO6GhoZw+fZoDBw7QsGFDAO7evUuDBg0AWL9+Pe+88w63bt3i8uXL1KhRg/bt2wPmWgLUrl3b/r5zd3cnJCTEIecU3SPp4MGD9OzZkzZt2qRq1pSnn36aFi1aMG7cOL755hs6d+4MmORvz549OXr0KEope50kwN6jDKBQoUKJnlN8s96k5ucE8OKLL9KkSRMaN26cqu2FENCsGQQEmNpNzz8P+fNbHZEQQmSMM2dg1izo2RNsTWqRyeSoZNPff/+XbCpUyLwppWeTEMm3YcMG+2NnZ+dYy/nz54+1XKRIkVjLJUqUiLVcpkyZZB0zb9689sdOTk72ZScnJ3uNmcQ+1MfcPleuXPHWpYlve4APP/yQT21fF//0009ore/7YH3ixAmmTp3Kjh07KFasGIGBgfZeRgAFChRI9vHiCgwMZPny5fj4+DBv3rxY1y9uHNHLCT0fM47Ejr93716KFy/O2bNnE40td+7cvPrqq7z99tuxnu/SpQuHDx8mKioqVq+oV155JVaPs7jKly8f6/xOnz5NQEBAojHEJ+b7I+57JyIigly5ctGiRQu++uqrWNuFh4fz4osvEhwcTIUKFQgKCor1c4zeV8z30OHDh+NNJoL5XYmeljjmOZUtWzbR+D08PChQoAD79u2jTp06KThzo1y5chQvXpw9e/awePFiPv74YwBGjx5N06ZNWbZsGaGhobGubcz3xvXr1xNM/ixatAgPDw/CwsKIiIggd+7cyTqn+IwbN44LFy7Y4xNCpI5SZhhd48bw4YcwdKjVEQkhRMaYOBGiomDMGKsjEQnJEcPoYiabYpIi4UJkD02aNGHhwoWA+ZBfokQJChcunOD6BQsW5Pr167G2X7x4MZGRkVy4cIFNmzZRr149Bg4cSEhICCEhIZQtW5aWLVvywQcf2Le7cuUK165do0CBAhQpUoRz587x888/JxlvtWrVCA0N5dixYwB8+eWX+Pv737fe9evXcXV15d69e/bzi7ZkyRKioqI4fvw4f/31F+7u7gD8+uuvXL58mdu3b7N8+XJ7D5641yu+8z158iTTpk1j9+7d/Pzzz/zxxx+JnkdgYCBr1qyJ1dtl8eLFhISEsHXrVvu1CwkJSTTRBNCqVStWr17NlStXuHLlCqtXr7b35Bo5cmSsGdrSon79+mzdutV+7W/dusWRI0fsiaUSJUpw48aNZM0aGN2zKb5b0aJFcXV1pVChQvz+++9orfniiy94/PHH79vPiRMn7AmskydPcvjwYdzc3BI99vfff8/IkSPjfa1r16688847XL161d6z6+rVq5QrVw7APhQ2PtE9m+K7Va9eHaUUTZs2tV+f+fPnx3tOiZkzZw6rVq3iq6++ineYphAiZRo1gtat4e234do1q6MRQoj0d+IEzJkDffpAEk0mYaEc0cpLKNlUv77pfhdnFIgQIosJCgoiODgYb29vRowYwfz58xNdv3jx4jRs2BBPT0+GDh3Kk08+ibe3Nz4+PjRr1ox33nkn3p5Xb7zxBleuXMHT0xMfHx/Wr1+Pj48PNWvWpEaNGvTu3Tve5E5cLi4uzJ07l86dO+Pl5YWTk1O8M6q9+eab+Pn50aJFC6pVqxbrNXd3d/z9/WnTpg2zZ8+2D7lq1KgRzz33HL6+vnTs2DHe3jHxnW/p0qV5/vnnmTp1KmXLluWzzz6jT58+sXr3xJUnTx4GDRrE+fPnkzznaDt27KB8+fIsWbKE/v37U6NGDQAeeOABRo8eTd26dalbty5jxoyxD+3au3dvsnvCJaVkyZLMmzePbt262QvKHzp0iKJFi9K3b1+8vLx44oknqFu3rkOO99FHH9GnTx8efvhhKleuTJs2bQBYuXIlY2xfxW3ZsgUfHx98fX158sknmTVrFiVKlABg2LBhlC9fnlu3blG+fHmCbEUJTpw4kWBCtVOnTnz99dc8/fTT9ueGDRvGyJEjadiwYZpnRnz77beZPn06Dz/8MJcuXeL5558HIDg4mD59+tjXa9y4MZ07d2bt2rWUL1+eVatWATBgwADOnTtHgwYN8PX1tRelF0Kk3ptvmum/333X6kiEECL9vfkmODnB669bHYlIjErucI6spmzZsjrmMJASJaBzZ4hZg/fgQaheHT7+GPr1syDILGzDhg2pGuIikiezXN+DBw/i4eFhdRgOl9J6QplNYGAg7dq1s88IFm3evHkEBwfH6n1lFUde41atWtkTFTEldB1ygi5duvDBBx9QsmRJq0NxqA0bNjB16tRYxdmjxff3SCm1U2ud8vGGIt24u7vr1MxUKRKW3DbBk0/CunXmS1Rbrl7EI7O0sbKL6EkzYs7GK9JG3qOJO3IEPDzg5ZfBNsdLkuSaOl5y2mA5omcTmN5NcXs2VasG5crBr79aE5MQQoikxZdoAlMXbPTo0cyePTuDI7LenDlzsl2iafHixbz44ov2wvtCiJQZPx6uX4dp06yORAgh0k9QELi4wIgRVkcikpLiAuFKqb9sD68AgVrrvcncrgXwMaC11glPcZROKlSAkyfjxgQtWsCKFRAZCblyZXRUQgiRcgnV3AkMDCQwMDBDY7HSuzJeJFvp0qVLggXXhRBJ8/KCLl3MULqXX4ZSpayOSAghHGvvXvj6a5Nokr9xmV9qeja5ARWBmsBWpVT7ZG6X37atWyqOmWYVK0JoKMQdNdiiBVy5Art2WRGVEJlfdh1qK4TIOuTvkBDJExQEt2/DpElWRyKEEI43erSZVf6116yORCRHWofRFQSWKaUy/USr7u5mho5//439/KOPmnsZSifE/VxcXLh06ZJ80BNCWEZrzaVLl+xF8IUQCXN3h169TI3S0FCroxFCCMf57TczImnYMKlLl1WkeBhdDHOArpiE02SllAfQT2sd4ZDIHCy6pujBg+Dq+t/zpUqBj49JNo0aZU1sQmRW5cuX5/Tp07Gmts8OwsPD5YNrOpNrnL5y2vV1cXGhfPnyVochRJYQFAQLFsDYsZDE5KxCCJElaG2GzpUuDYMHWx2NSK60JJt+AD4EVgIVgJ5AZaXUU1rrS44IzpGik00HDkCzZrFfa9HCjG+/eRMKFMj42ITIrJydnalUqZLVYTjchg0bqFmzptVhZGtyjdOXXF8hRELKl4eXXjKFwocOBU9PqyMSQoi0+fln2LwZPvxQPq9nJWkaRqe1/hOoB/wBKKAR8Ietl1Om4uoKhQubnk1xtWgB9+7Bpk0ZH5cQQgghhBCONHKkafdKr30hRFYXFWX+plWuDH37Wh2NSIm01mxCa30OCAC+xiScKgHblFKt07pvR1LK9G6KL9nUuDHkzSt1m4QQQgghRNb3wAOmrsn338PWrVZHI4QQqff117BnD7z5Jjg7Wx2NSIk0J5sAtNZ3tNbPAGNtTxUGvldKveyI/TtKQsmmfPmgUSNJNgkhhBBCiOzh5ZehTBlT50Tm+RBCZEV375oZ6Hx9oUsXq6MRKeWQZFM0rfWbQBfgNpALmK6U+lgplcuRx0ktDw8zG11Y2P2vtWgB+/bBP/9keFhCCCGEEEI4VIECMGYMbNkCP/1kdTRCCJFyn34Kf/0Fb70FTg7NXIiM4PAfmdZ6KeAPnMUMq+sDrAYsn6Aw5ox0cbVoYe7XrMm4eIQQQgghhEgvffqYOicjR5q6J0IIkVXcuAHjx4O/P7RqZXU0IjXSJT+otQ4G/IBdmIRTAGbmOksllmzy9YUSJWD16gwNSQghhBBCiHTh7AwTJsDevbBwodXRCCFE8s2cCefPw+TJpv6yyHrSrTOa1voM0Bj4DpNwyptex0quSpVMIfD4kk1OTtC2LaxcCbdvZ3xsQgghhBBCONrTT0OtWvDGGxAebnU0QgiRtHPn4O234cknoX59q6MRqZWaZNMp2+1WUitqrW9rrTsBkzAJJ0vlygVVq8afbAJ49lm4dg1++CFj4xJCCCGEECI9ODnBlClw6hS8957V0QghRNLGjTPJ8cmTrY5EpEWKk01aazetdSWtdbKrG2mt3wBqAU2BZik9piN5eMCBA/G/1rQpuLrCggUZG5MQQgghhBDppVkzeOwxmDQJLl2yOhohhEjYoUPwySfQv7/pKCKyrgyr6a61DtFab9Rab8yoY8bHwwNCQ+FWPP2ycuWCZ54xM3ZcvJjhoQkhhBBCCJEu3nkHrl+HN9+0OhIhhEjYiBGQPz+MHWt1JCKtctwEgt7eoDXs2RP/6889BxER8M03GRuXEEIIIYQQ6aVGDejdG2bNguPHrY5GCCHut2kTrFhhEk4lS1odjUirHJdsii4wtm1b/K97e4OnpwylE0IIIYQQ2cv48WaGupEjrY5ECCFii4qC116DcuVg8GCroxGOkCWSTUopF6XUdqXUn0qp/UqpcandV9my8OCDCSeblDKFwrdtk299hBBCCJGzObINJqzn6mo+zC1ZAr//bnU0Qgjxn2++gR07YMIEM4xOZH1ZItkE3AGaaa19AF+gtVIq1ZMgNmiQcLIJTN0mgIULU3sEIYQQQohswaFtMGG9oUOhdGmTdNLa6miEEALu3DE9Ln18TFkbkT1kiWSTNm7YFp1tt1T/e2zQAE6fNrf4VKgAAQFmKJ38ExZCCCFETuXoNpiwXsGCZjjd1q2wfLnV0QghBHz4oZnEa8oUM2mXyB5yWx1AcimlcgE7gYeBD7XWf8SzTj+gH4CrqysbNmyId1958hQCavPZZ/vx978Q7zp16pRhw4ZqzJ69Ew+P6445iWzkxo0bCV5fkXZyfdOXXN/0J9c4fcn1FRkpqTZYzPZXyZIl5b3pYOnx+165sqJixTr8739OFCiwnTx5ck7+UP5+pg+5po6T096jV686M3ZsPerWvY6z8x7S49Rz2jXNLJTOYl13lFJFgWXAS1rrfQmtV7ZsWX327Nl4X7t7F4oUgRdfhGnT4t8+LAzKlIF+/eC999IcdrazYcMGAgICrA4j25Lrm77k+qY/ucbpS66voZTaqbWuY3UcOUVy2mDu7u768OHDGRpXdpdev++//AJt2sDUqfDqqw7ffaYlfz8da9w4U8ZtrMxT7zA57T36v//B7Nnw559m1sz0kNOuaUZIThssSwyji0lrHQZsAFqndh958kDt2onXbSpaFNq3h6+/hnv3UnskIYQQQojswRFtMJF5tG4Njz1mhtRdiL+jvxBCpKv9+02iacCA9Es0CetkiWSTUqqk7ds0lFL5gEeBQ2nZZ4MGsHOnKUaWkOeeM/98V61Ky5GEEEIIIbKm9GiDicxj2jS4eRNGj7Y6EiFETqM1vPIKFCoEQUFWRyPSQ4qTTUqpJrbbAyncrmj0tik9JuAKrFdK7QF2AL9qrX9IxX7sGjQww+lCQhJep3VrM5Tu3XfTciQhhBBCiCzL4W0wkXlUqwYDB8Knn8KePVZHI4TISX7+GVavhrFjoUQJq6MR6SE1PZs2AOuBRinczs+27bqUHlBrvUdrXVNr7a219tRaj0/pPuKqb5u0N7GhdHnywJAhsGYNBAen9YhCCCGEEFlLerTBROYydqwpH/HKKzILsxAiY9y7Z/7mVK1q6iiL7MmKYXTKgmPep2xZePDBxJNNYMaPFi0Kb72VIWEJIYQQQgiRYR54AMaNg7Vr4fvvrY5GCJETzJoFhw+bobx58lgdjUgvGZlsik4yZZrvTBo0SDrZVLiwqZC/bBkckgoFQgghhBAim+nfHzw8zKx0idUzFUKItLp0ydRoatEC2ra1OhqRnjIy2RQ9EvNmBh4zUf7+8PffJquamEGDwMUF3n47Y+ISQgghhBAiozg7w/TpcOwYvP++1dEIIbKzoCC4ds38zVGZYsyTSC8ZkmxSSuUFetoWQzPimMnRrp25X7ky8fVKloS+fWHBAjh1Kv3jEkIIIYQQIiO1bg2PPQZvvgn//mt1NEKI7GjvXvjoI9Ob0tPT6mhEeks02aSU6qmUWhfzFuPlCXFfi+e2Xim1HbgANMMMoVubjueTIhUqgK9v8sanv/qquZ82LV1DEkIIIYQQwhIzZsDt2zBihNWRCCGyG63hpZegSBGT1BbZX+4kXncDAri/zpICaqTgONEd5M4DU1OwXbrr0AEmTDBjR4sXT3i9Bx+EZ581U8O+8Ybp7SSEEEIIIUR2UbWq+YJ18mTo1w8eecTqiIQQ2cXixbBxI8yenfjnbpF9JHcYnYpxi++5hG4AN4A9wAygltb6bNrDdpz27SEqCn76Kel1hw+H8HB49930j0sIIYQQQoiM9vrrUK6c6YEQGWl1NEKI7ODGDXjtNahVC/r0sToakVESTTZprcdprZ1i3qJfAp6I+1o8t1xa6yJaa1+t9auZLdEE5g1ftmzSdZsAqlWDJ5+EDz4wRc2EEEIIIYTITgoWhKlTYdcumDPH6miEENnBxIlw5oyZgCBXLqujERkltQXCs03deCcnUyh81arkTfU6ciRcvWq6/wkhhBBCCJHddOliZm0eNcqUmhBCiNQ6csTUPe7ZU4bm5jQpTjbF6LWUjL5AWUP79nD9uhlDmpQ6daBFC1NAMTw8/WMTQgghhBAiIylleiBcvQqjR1sdjRAiq9IaXn4ZXFxMLTiRs6S2Z1O20rw55MuXvFnpwPRu+vdfmDUrfeMSQgghhBDCCl5eMHCg6c2/e7fV0QghsqLvv4dffoFx46BMGaujERlNkk2YRFOLFqZuk4477148AgKgdWsYO9aMPRVCCCGEECK7GTcOSpSA//3PTKgjhBDJdfs2DBkC1aubvyEi58md0g2UUmPSelCt9fi07sPROnQwyaY9e8DHJ/F1lTJFwj094ZVXzDSOQgghhBBCZCdFi8Lbb0Pv3jBvnrkXQojkeOst+OsvWLsWnJ2tjkZYIcXJJiAIMxtdWmS6ZFPbtub++++TTjYBVK5siiaOGQPPPw8tW6ZvfEIIIYQQQmS0nj3h889h6FDz5WyJElZHJITI7A4fNjWann0WmjWzOhphlbTMRpfaW6ZUpgzUrw9ff528oXQAw4ZB1apmPLsUCxdCCCGEENmNkxN89BFcuwbDh1sdjRAis9MaXnwRChSAqVOtjkZYKTXJpqbJuDUHugDTgYuYnlBf2V7LtLnN55+H/fvht9+St37evKZI+LFjUl1fCCGEEEJkT9GlIz7/HLZssToaIURmtmgRrFtnhtGVLm11NMJKKU42aa03JuO2Xmu9RGv9GlAFWA10BZporTc6+iQcpWtXKFzYzLqRXM2bQ7du5pfp6NH0i00IIYQQQgirjBkDDz4IAwbAvXtWRyOEyIyuXDGJ6Xr1oF8/q6MRVkv32ei01leBjsBZYKxSqkF6HzO1ChaE556DJUvg4sXkbzd9Ori4mOF0yR2CJ4QQQgghRFZRoAC8/74ZBTBjhtXRCCEyo9dfN5+jZ882Q3BFzpYhbwGt9S1gru14mXriw/794c4dmD8/+duUKQMTJ8Kvv8I336RfbEIIIYQQQlilQwdzGzcOTp60OhohRGayfbtJMr30EtSsaXU0IjPIyHzjftt9oww8Zop5eUHDhvDxxxAVlfztXngBateGIUNMAUUhhBBCCCGym/feM/eDBlkbhxAi84iIMENsXV1hfKabd15YJSOTTXls96Uy8JipMmCAqb+0fn3yt8mVy2Ry//0XRo9Ov9iEEEIIIYSwSsWKEBQEK1fCd99ZHY0QIjN47z3YvRtmzjQ1kIWAjE02tbLdX83AY6ZKp07wwAMpKxQOUKeO6eH0wQfml00IIYQQQojsZvBg8PU19UrDwiwORghhqRMnTGeL9u3N52ghomVIskkpNRDoBmjgj4w4Zlq4uECvXrB8OfzzT8q2nTgRSpaEnj3h5s10CU8IIYQQQgjLODvDnDlw/jwMH251NEIIq2htRgU5OcGHH4JSVkckMpPcKd1AKTUmmavmAcoCAUBFQGGSTe+n9JhW6NcPpk2Dzz83VfWTq2hR+OILaN3a7GPBAvmlE0IIIYQQ2Ut0rdJp0+CZZ8Df3+qIhBAZbcECWL3ajOypUMHqaERmk+JkExCESRqlRHS6ZbzWek0qjpnhqlaF5s3hk09gxAhTkym5WraEN9+EN96ABg3gf5l6/j0hhBBCCCFSbtw4U7epXz/4808zOkAIkTNcuGASzg0amFIyQsSV2mF0KgW3e8AvwKNa63FpDTgjDRgAp07BTz+lfNuRI8241SFD4LffHB+bEEIIIYQQVipQwMzgfOQITJhgdTRCiIwUPQv7nDlmGJ0QcaWmZ1PTZK53BwgDjmmtI1JxHMs9/jg8+KD51qZt25T9Ejk5meF0depA586wcyeUKZN+sQohhBBCCJHRWrQwtUrffhuefhq8va2OSAiR3n7+GRYuhLFjoXp1q6MRmVWKk01a643pEUhm5OxshsP17AlLl5p/oClRtKjpWly/PnTpAmvWmH0KIYQQQgiRXUybZkYC9OkD27alrPyEECJruXHDjADy8DCjeYRIiHR4S0L37uDlBaNGwb17Kd/e29vUfdq0SX4ZhRBCCCFE9lO8OLz3HuzYATNmWB2NECI9jRgBf/8Nn34KefNaHY3IzCTZlIRcuWDyZDh+3PxCpcazz5oi4dOmwTffODY+IYQQQgghrNaliylB8cYbcOiQ1dEIIdLDhg3w4YcwaBA0bGh1NCKzS3OySRn1lFIDlVITlVLv2u4H2p5XSe8lc2vTBpo0MbWbbtxI3T6mTTOV+nv3hgMHHBufEEIIIYQQVlIKZs+G/PlNezcy0uqIhBCOdOOG+d2uXBkmTbI6GpEVpDrZpJRyUkoNAUKBbcB7wAjgf7b792zPhyqlBiulsmwvKqVM0cPz52H69NTtI08eWLLEzNrx1FOmcr8QQgghhBDZRZky8P77pm7TzJlWRyOEcKQRIyA0FObONUllIZKSqgSQUuoBYAswFSgPqERuFYBpwBalVDEHxGyJ+vVNkmjKFLhwIXX7KFfODKM7dgx69QKtHRujEEIIIYQQVnrmmf+G0x0+bHU0QghHiDl8rnFjq6MRWUWKk022Hko/A/UxyaQo4CfgNeAJoIXt/jXgRyDCtp4f8FNW7uE0aRLcvg0TJqR+H/7+8M47Zpa6N95wXGxCCCGEEEJYTSn46CPIl898uSrD6YTI2mIOn5s40epoRFaSmsRPP6AuoIH9gK/Wup3WerrWeqXWeq3tfrrWuj3gC+zDJJzqAX1TekClVAWl1Hql1EGl1H6l1MupiDvN3N3h+efNP9C//kr9foYMMVPDTpoE48c7Lj4hhBBCCEfKLG0wkbW4uspwOiGyi5jD5woUsDoakZWkJtn0rO3+ItBUa70/sZW11geA5kD04LPnUnHMCOBVrbUHpkfVQKVU9VTsJ83GjoXcuWH06NTvQyn4+GPo2dPs7623HBefEEIIIYQDZZo2mMhannkGOnSQ2emEyMrWrzfD5156SYbPiZRLTbLJA9OraY7W+mJyNtBaXwDmYHo3pbiBorX+R2u9y/b4OnAQKJfS/ThC2bIweDAsWgQ7d6Z+P05O8Nln0L07jBoFU6c6LEQhhBBCCIfITG0wkbVEz05XoAA89xzcu2d1REKIlLh61XSOePhhmX1OpI7SKaxSrZS6AeQDntFaL07Bdl2Ar4CbWutCKTpo7P24AZsAT631tTiv9cMM88PV1bX2okWLUnuYRN24kZuePetSuHAEH3+8kzx5olK9r8hIxcSJHqxfX4qBA4/RqdNpB0aafm7cuEHBggWtDiPbkuubvuT6pj+5xulLrq/RtGnTnVrrOlbHkVMk1AaL2f4qWbJk7W+++caaALOprP77vnFjCYKCPOnRI5RevUKtDifLX8/MZuPGjQD4+/tbHEn2kVneo5MmVWPt2tK8//4uqle/bnU4aZJZrml2kpw2WO5U7Pc0UAVI6YSH0eunOpuilCoIfAsMjptoAtBafwJ8AlC2bFkdEBCQ2kMlacECeOyxvPzySxOmT0/bvpo0gW7d4MMPH8bD42EGDnRMjOlpw4YNpOf1zenk+qYvub7pT65x+pLrKzJaYm2wmO0vd3f3dG1/5URZ/fc9IMDUOl240I0XXnCjfn1r48nq1zOziU42yTV1nMzwHl26FH79FcaMgRdfrG1pLI6QGa5pTpSaYXQ/YYbDtUzhdq0ww+9+SsUxUUo5Yxo5C7XW36VmH47Upg0MHAgzZsCaNWnbl7MzfPWVmSb2f/8z9ZyEEEIIITKDzNYGE1nPe+9BuXJmON3Nm1ZHI4RIzD//QP/+UKeOzJ4u0iY1yaZ3gWtAZ6VUu+RsoJRqC3QGwmzbp4hSSgGfAQe11mnsR+Q477wD1aqZsayXL6dtX87OsHgxtG0LAwaYek5CCCGEEFbKrG0wkbUUKQJffAHHj8Nrr1kdjRAiIVpD795w+7YZyePsbHVEIitLcbJJa30Skzi6BnyrlJqglCoZ37pKqZJKqTcx34aFAZ211qdSEWdDzCx2zZRSIbbbY6nYj0Plzw8LF8L58yZBlMLyV/fJm9d0WWzVCvr2hfnzHROnEEIIIUQqZco2mMh6/P3h1VdN0fCfUjXOQQiR3mbPhl9+gSlTwN3d6mhEVpfimk1Kqc9tD0OAAGAkMEwptR84BtzC1Gd6GKgB5Iqx/rNKqWcT2LXWWj+fwAtbMEP3Mp1atWD8eDOjXPv2pntwWri4wLJlZqrYXr1MNvmZZxwTqxBCCCFESmTmNpjIeiZMgFWrTM+JvXuhZLxfVwshrHDkiEkIt2oFL75odTQiO0hNgfBATO0lYtznBrxtt5hUjHUCkrHveJNNmd2wYeYbmoEDoXFjcHNL2/7y5YMVK8yQuueeAycn6NrVIaEKIYQQQghhibx5zdCcunXh+edNe1dJKlMIy929ayascnGBzz+X30vhGKmp2QQmiRTzFt9ziT2f0LpZUq5c8OWX5vFzz0FkZNr3mT8//PADNGpkfvEnTEj7MD0hhBBCCCGs5O1t6p5+/z18+KHV0QghwIzS2bXLJJrKlrU6GpFdpKZnUyWHR5ENuLmZf5g9eph/oCNHpn2fBQqYrsZ9+8Lo0bB/vykcnj9/2vcthBBCCCGEFQYNMtOqv/aaGRXg42N1RELkXL/8AtOmmaFzTzxhdTQiO0lxsslWIFzE49lnzbc0Y8ZAy5ZQu3ba9+niYmbv8PKCESPg6FFYvhzKl0/7voUQQgghhMhoSsHcuaaXU9euEBxsvmQVQmSsf/81M6t7esLUqVZHI7Kb1A6jE/FQylTwL10annoKzpxx3H6HDYOVK03htrp14fffHbNvIYQQQgghMlrJkqZ+0+HDMGSI1dEIkfNERZlE07Vr8PXXpm6wEI6U4mSTUqqH7ZaivjVKqbLR26b0mFnJAw+YpNDly9C6NYSFOW7f7drBtm1mGF1AwH91ooQQQgghhMhqmjeH4cPh009h6VKroxEiZ5kxA1avhpkzoUYNq6MR2VFqejbNA+YCtVK4nZdt289TccwspVYtM9Tt8GHo0AFu33bcvmvUgO3b4ZFHTH2oYcMcU5BcCCGEEEKIjDZ+PNSrZ2qUnpRiHUJkiOBgU2P4qaegXz+roxHZlRXD6LL0zHPJ1by56Xm0ZQt07+7YhFDx4qZw+IsvwpQp8PjjpvujEEIIIYQQWYmzM3z1lRnS06WLmYJdCJF+wsLg6aehTBnTq1DliE/nwgoZmWyKPlZUBh7TUl26mG6Jy5aZxJDWjtu3s7OZ/W7WLJN4ql8fjh1z3P6FEEIIIYTICA89ZGZc/uMP02tfCJE+tIZeveDvv2HxYlMCRoj0kpHJJlfb/fUMPKblBg0ys8h98gmMG+f4/b/wghlre+6c6YK8bp3jjyGEEEIIIUR66tTJtJvffVfqNwmRXqZPN+VepkyBBg2sjkZkdxmSbLIVE3/Btng8I46ZmUyaBIGBJtk0e7bj99+0qanj5OoKLVuaf9KO7EUlhBBCCCFEepsyBfz8oHdvOHrU6miEyF62bjUF+Tt2hJdftjoakRMkmmxSSr2slPor5i3Gy5/EfS2e2wml1HngJKaguAZ+TsfzyZSUMj2b2raFgQPhu+8cf4zKlc1MdW3bwuDBJul06pTjjyOEEEIIIUR6yJMHvvnGlIvo1Mmxk+wIkZNduGBKvFSqZIasSp0mkRGS6tlUFHADKtru3WzPK6BUjOcSulUEStjWV8ARYFqao86CnJ3NP8969eCZZ2DjRscfo3Bh0y1y9myTePLygrlzpZeTEEIIIYTIGh58EBYsgD174KWXrI5GiKwvMtJMWHXxIixZAkWKWB2RyCmSSjaFYXolnbLdR09IqoELMZ5L6HYC2AusBF4G6mitrzr0DLKQ/Pnhhx9MRvnxx2HXLscfQyno39/8g65Z03RD7tAB/vnH8ccSQgghhBDC0dq0gVGjTA+MefOsjkaIrO3NN+HXX+GDD8DX1+poRE6SaLJJa/2u1rpSzFuMl/vGfS2eW2WttY/W+gmt9fta65vpfD6ZXvHiZva4woXB3x9+TqdBhQ89ZIqFz5wJa9ZAjRpmWlnp5SSEEEIIITK7ceNMXdIXXoCdO62ORois6YcfzO9Sz57w/PNWRyNymtQUCD9lu91ycCw5xoMPmmFulStD+/bw6afpcxwnJ1P8LSQE3N3N8L2nnzZjdoUQQgghhMiscuc2U7OXLAlPPintVyFS6vBhM3yuVi346COp0yQyXoqTTVprN1uvpTXpEVBOUa4cbN4Mjz4K/frB66+nX68jd3dzrLfegpUrTS+nZcvS51hCCCGEEEI4QsmSps164YL5wvTePasjEiJruHYNnnjCFN1ftgzy5bM6IpETpaZnk3CQQoXg+++hTx+YNAmeew7u3EmfY+XODSNGmG7I5cvDU0+Z4125kj7HE0IIIYQQIq1q1zazOm/YAEOHWh2NEJlfVJQZNnf0qJmg6sEHrY5I5FSSbLKYs7P5BzphAixcCK1bp28CyNMT/vgDxo6Fr782y+lVN0oIIYQQQoi0eu45Uxri3Xfhyy+tjkaIzG3iRDND+dSppu6ZEFbJndINlFKfp/GYWmst5cliUMoMo3Nzg169oGFDkwCqWDF9jufsDEFBpl5Uz57w2GOmYNy0aTIVphBCCCGEyHymTDF1SPv1MyUhatWyOiIhMp8ffjCdCp591iRohbBSipNNQCCQ1upCkmyKR/fuULasKYJYv775Y1G7dvodr3ZtCA42f5CmTjX1nN580ySecqfmnSGEEEIIIUQ6cHY2Q4Lq1IHHH4ft28HV1eqohMg8Dhwwnyd9feHjj6UguLBeaofRqRTeiPPYEhEREVYePlmaNoWtW00xN39/+Omn9D2eiwu8/bYZWufuDgMGQM2asHp1+h5XCCGEEEKIlChVClasgMuXTfHj27etjkiIzOHCBWjXzhQCX74c8ue3OiIhUpdsqpSMW2XADxgEHMQkmb6yPf9QmqNOhaioKDp06MDo0aOtOHyK1KgBv/9ukj/t28P776ffTHXR6tSBTZtg6VK4eRNatYK2beHgwfQ9rhBCCCGEEMlVs6apc7pjBwQGmmLIQuRkd+6YkTFnz5pkrBQEF5lFipNNWuuTybid0Frv0Fp/APgA84CuwHCt9UkHn0OyRERE4ObmRrly5aw4fIq5usLGjaae0qBB0KEDnDuXvsdUCjp2NAmmd96BLVvAywteegkuXkzfYwshhBBCCJEcTzwBkyebYXXjxlkdjRDW0drUMdu6FebPBz8/qyMS4j/pPhud1joC6AscBfoqpVqn9zHjkydPHmbNmsWAAQMAWLlyJa+++iq3bt2yIpxkKVjQZKdnzoRffzWJn5Ur0/+4efOaqWWPHTN/vGbNgipVYPp0uHs3/Y8vhBBCCCFEYoYONRPrjB8PX31ldTRCWGPyZPjiCzP5U5cuVkcjRGzpnmwC0FpHAvMxw+leyIhjJmXXrl2sXr2aPHnyAHDv3j2LI4qfk5OZSWDnTihXzhRE7NsXbtxI/2OXLGkSTXv2mCz5q6+aIX7Ll6f/sD4hhBBCCCESohTMng1Nmpik0++/Wx2REBnru+9g1Cjo1g3GjLE6GiHulyHJJptjtvs6GXjMBAUFBbFjxw5y585NREQE1atXZ/r06ebFhQvBzc1ketzczLLFatQwRbyHD4fPPjOzDGzblnHH/uUX+PlnU7j8ySfhlVd82L07Y44vhBBCCCFEXHnywLffmi9kO3SA48etjkiIdGb7nKqdnKjTyY3RlRfy2Wcy85zInDIy2VTIdl88A4+ZKBcXFwBu3rxJq1at8PDwgIULOd+3L2+fPMm/WsPJk2YsWSZIOOXJY7pKbtwIERHQqJHJYmdUp6zWreHPP+HDD+HEiQLUrg29e8M//2TM8YUQQgghhIipRAkze3NkpGmrXrhgdURCpJOFC83n0pMnUVrzoD5J0Nl+5PvO+s+pQsQnI5NNT9nuM12p6SJFivDBBx/Qpk0beP11Nt++zQgguh536K1b7HztNXQmGTvWuLEZ2vbcc/Dmm/DII3D4cMYcO3duePFFWLBgO6++CgsWmHpOY8eaaWiFEEIIIYTISO7u8P33cPq0mf795k2rIxIiHbz+OsSpN+x0+5Z5XohMKN2TTUqp/EqpKcBjgAY2p/cx0+TUKToCpwBv21MfAfX//ZerV68CsG/fPg5nVHYnAYULw7x5sHQp/PWXmQZ21qyMq6VUsGAEU6aYmevatDHFGStWhGHD4N9/MyYGIYQQQgghwHz5+tVXEBwMXbuaUQBCZCf61Kn4X0joeSEsluJkk1Lq82TeFiil1mE6CL1i2zwKmObIE3C4Bx8EoAKmmjnAUOD7UqUoWrQoAGPGjDG9oGw2btzIgQMHMjTMaB07wt69pjjiwIHQtm3GDmurXBmWLDExdOgA06aZMlcDB5oRiEIIIYQQQmSEJ56A99+HH34wPfEzyaAEIdLs3j04n/fB+F98MIHnhbBYano2BQI9k3HrBvgDBTB5m7tAf611cJqjTk8TJ0L+/LGeKpE/P62ji4cD77zzDnPnzrUvDxw4kFdffdW+PH36dH755Zf0j9WmbFlTvPv992H9evDwMEmfO3cyLAQ8Pc0w4sOHzfC+Tz+Fhx82s4NY3AlMCCGEEELkEC++CCNHmrbohAlWRyNE2mkNL7wAQ8Inci9P7M+p5M9vPr8KkQmldhidSsEtFJgN+GqtP09jvOmve3f45BMzJkwpc//JJ+Z5m4cffhh/f3/78vfff88777wDgNaad955x55s0lrz6KOPMm/ePPv6YWFhDg9bKfjf/yAkxHQjfu01M4vcsmUZ+63Oww+bf+7Hj5t/9osXm+TX00+b2IQQQgghhEhPEydCjx5mIp2PPrI6GiHSZuRIMxv5w6O74/x54p9ThchMUpNsqpTMW1kgv9b6Ia31i1rrQ44JOQN07w6hoRAVZe6T+AWuVKkSXl5eACilOHPmDBNsX6XcvHkTFWMuysuXL1OsWDHef/99++tTp07l6NGjDgnd3d3MyPHLL5A3Lzz1FDRtCrt3O2T3yVahArz7rrl8I0aYeGrWNEUbt23L2FiEEEIIIUTOoRTMmQPt25vSDgsWWB2REKnz1lvw9tumZ9O4caT4c6oQVkpxsklrfTKZt3+11uHpEXRmlytXLgoWLAhAwYIF+fXXXwkMDATAycmJKVOm0LhxYwCOHDnC0KFD2bNnDwD79++nevXqbN5s6qhfvnyZjRs3cuPGjRTF0KoV/PmnKRq+fz/Urg29e2dsPSeAUqVg0iRTt+7NN+H3303Pq2bNYO1aGUsvhBBCCCEcz9kZvvkGAgIgMBBWrLA6IiFS5sMPYdQok0/64AOTRBUiK0n32egcwVZw/LxSap/VsaRV0aJFee211/D19QWgZs2aXLp0yV5wPCoqCnd3d0qUKAHAli1bCAgI4ODBgwCsW7eOZs2a8ddffwFw+vRpNm3aRHj4/Xm93LlNFvzoUXj1VfOtTpUqZvz67dsZcLIxFC0Kb7xhEvDTpsGhQ/Doo9CgAaxcKUknIYQQIjPKTm0wkfO4uJgkU+3apqTD2rVWRyRE8nz5pSmR8vjjMHcuOGWJT+1CxJZV3rbzgNZWB5FeHnjgAfLbipJ7eXmxbNkyPDw8AGjUqBGrV6+mevXqANy7d487d+7Ye06tWLECf39/ex2oRYsW0axZM65duwbAgQMH2LbtZyZPjuTAAWjZEkaPNsPtFi3K+CRPwYLwyivw119mDP25c+aPqI+PGYt861bGxiOEEEKIRM0jG7fBRPZXqJCZSKdqVdPmPHCgsNUhCZGoLVtK0KuXGQny9deml54QWVGak01KqcJKqU5KqSlKqQVKqRW2+3dsz6f5L7rWehNwOa37yYoeeOABWrRoQYECBQBo1aoVW7dupVSpUgB06tSJVatW2ZcBIiMj7cmoL774gscffxylFA8/DJ6eY6hQoRrFi2u6d4dq1X7glVfes297+fJlbmVAxsfFBQYMgCNH4IsvTNKrTx8oVw6GDDHPCyGEEMJaObkNJrKPBx6A1auhTBkYPtyLXbusjkiI+K1aBePHV6dOHdMrz8XF6oiESD2lU9m1RSmVFxgPvAAUSGTVm8AsYKzW+k6qDmaO5wb8oLX2TGSdfkA/AFdX19qLFi1K7eGyjStXrnD+/Hnc3d0BMwxv//79vPjiS6xeXYaZM9/i7t1NNGv2O717n2Du3Dc4cOAA0ddu0aJF3Lx5k759+wLw559/kitXLtzc3ChYsCBRUVE4OaBfp9awZ08RVq4sy8aNJYmMdKJ27cs8/vhZHnnkErly5axxdjdu3LAnDIXjyfVNf3KN05dcX6Np06Y7tdZ1rI4ju0uqDRaz/VWyZMna33zzTQZGl/3J77vj/PuvC4MGeRMe7sy0aX9SpUrKaqKK+23cuBEg1kzdInW2by/GG294UaHCdWbM2EvhwhFWh5RtyN9Rx0tOGyxVySal1APAWsAbSE6pMg38CTTXWl9J8QFJXrIpprJly+qzZ8+m5lA5yvXrmokTb/Puu/m5excaN15N8+bnGD36OQBeeOEFLl68yJIlS4D//pGMGzeOgIAAmjRpQrFixVhhq7o4evRoypQpw8CBAwHYtGkTJUuWtA8LTI5//zVD6j7+GP7+2/R26t/f9HxydXXk2WdeGzZsICAgwOowsi25vulPrnH6kutrKKUk2ZQBUtIGc3d314cPH07/oHIQ+X13rK+++p0RI+pz/bqp4VSzptURZW3jxo0DYOzYsRZHkrWtWmWGeXp4QFDQFh5/vJHVIWUr8nfU8ZLTBkttl5RvAR9MoukW8BnQBagJVLHdPw3MwfRsUrb1l6byeCKdFCqkmDw5P3/9Ba+9Brt2tWTMmOdo1QrWrYNZsz6yJ5oA5s+fz8cff2xffvrpp+nQoYN9+ffff7fPrAfQs2dPJk2aZF/28PDg1VdftS8PGjSImN+Afv/991y9epjXXzd1nZYsuUuNGjBmDDz4IHTpAhs3SkFxIYQQQgiRcq6u4WzYYGo5NW8Ou3dbHZHI6WImmtasgSJFpEeTyB5SnGxSSj0B+GN6KwUD1bXWfbXWS7TWf2qtj9vul2qt+wHVgR2YhFOAUupxB8YvHMTVFd5+G06dgrfegj//NP+A/fzg228hMtKs5+bmRrVq1ezb/e9//+P555+3L//666+xklHLli3j9ddfty8/8cQT1K1b1768atUq9u/fD4DWmieffJIvv/wSAKUiefppFxo3nsCRIzBw4D2++64VAQHf4ekJ7757l6lTP7BvHxkZyalTp7hzJ9WjNYUQQgghRDZXqRKScBKZQtxEU/HiVkckhOOkpmdTN9v9OaCl1vpUYitrrf/GzGJyzvZU95QeUCn1FbANcFdKnVZKPZ/UNiJ1ihaFESMgNBRmz4bLl6FTJ6heHebMgZTmcXx9fWMlp9566y26du1qXz58+LC9+y3Arl276N+/PwARERG8+eab+Pv7U6UKjBt3C1/fMPr2vU2+fDB48EWGDn2JF1/cwp49cPr0aSpWrMiCBQsAOHnyJJ6envz8888A/PPPPwwePJi9e/cCEBYWxg8//MCFCxfsxwsPD0/pJRNCCCGyLWmDiewqbsIpONjqiERO8/PPkmgS2Vtqkk1+mF5Nn2utw5Kzga1O0xxM7ya/lB5Qa91Na+2qtXbWWpfXWn+W0n2IlHFxMXWSDh+GxYuhYEHo29f8Y54yBW7ezOXwYyql8Pb2pkKFCgDkzZuX119/ncaNGwNQpEgRduz4g08+6U5wMPz+exm6dDnHH388g48PdO1alOef/5Q6dRrb91m1alWKFCkCmGTT559/zunTpwHYt28f7du3Z7ft66wtW7aQL18+1q9fD5ghgY0bN+bAgQMAHDx4kHHjxvHvv/8CcO7cObZu3crt27cBiIqKIrUF94UQQojMSNpgIjuLTjgVKWKmmbfVuhYi3X3zDXToADVqSKJJZF+pSTaVst3vTeF2+2z3JVNxTGGRXLng6afNtz2//mp6OA0bBl26NGDUKDh3Lul9pBc/Pye+/roUZ84UYupUuHixCJ991odGjaoSGAjHjlVkyZLveOSRRwCoVasW165do02bNoDpdfXHH3/g52fynxUrVmTixIlUqVIFMMkjZ2dn8uTJA8DevXsJCgoiLCwMgNWrV9OoUSPOnDkDwLx588ibNy9///03YIYQPvroo1y+bGaM3rJlC+PGjbMnp44fP8769euJtI1RvHPnDhERMkZbCCGEECKjVKoEW7ZA+fLQujX8+KPVEYnsbs4c6NoVGjQwNXIl0SSyq9Qkm+7a7vOlcLvo9e8mupbIlJSCRx81mfcdO6BOnctMngwVK8KAAXDkiHWxFS8Or75qemFt2GCKiC9bZuKtWNEkx/bGkxotWLAg9erVs/d8qlSpEqNGjaJ8+fIAPPLII6xbt46HH34YMMXQ7927R9WqVQFo0aIFv/zyi319T09PXnnlFR544AHA1JC6desWefPmBeC3334jKCgIJyfza7dgwQKaNWtmj+fNN9/ExcXF3jtqxowZsaaRXbp0KWPGjLEvBwcHs3r1avvy5cuXuXIlVZM9CiGEEELkWOXKwaZNppfJE0+YXv1CpIdp08xokdat4ZdfTK86IbKr1CSb/rbdN03hdtGfqv9OdC2R6dWpA0FBBzh8GHr2hLlzwd0d/P3hiy/g1i1r4nJyMjHMmQP//msaCjVrwowZ4O0Nvr7mD/w//6T+GLlz57Yni8qUKUOrVq1wcXEBoF69ekyePJkCBQoA0KlTJ3777Tf78rBhw7h37549+fT888+zceNGcuUyQxJbtGjBpEmTUEoBJhlWsuR/HQG3bt3KwoUL7cvvv/8+ffv2tS+/9NJLsYqv9+/f396LC0y9rJjF2pcsWRJrpsE9e/YQc7pq6WUlhBBCiJyiRAlYu9b0NunWDT791OqIRHaiNYwebWb/fvppWL4c8ue3Oioh0ldqkk1rMbWXuimlGiZnA6XUI5jC4tq2vcgGqlSBjz+Gkydh8mQ4e9Ykn1xd4YUXYOdO84fVCvnymT/k339v4nrvPciTx/yBL18eWrWChQvh5s2MjSt37tz2x+XLl6dJkyb2ZX9/f4YNG2Zf7tu3L0uXLrUvz5gxg+PHj9uXJ02axI8x+nr36tWL8ePH25dr1KhB7dq17ct//fUXR2J0QXv//feZNWuWfbl///689NJL9uX69evToUMH+3LXrl1jJavGjx8fK/m1bNkyduzYYV8+evQoly5dSvBaCCGEEEJkJkWKmN4mrVtDv34waZJ1bVmRfUREwIsvwoQJ0KcPLFpkPpcIkd2lJtk0G4gEcgE/K6X6KaVyx7eiUiqXbdaSn2zrR9q2F9lImTIwfLgZSrdhg5lVYd480wOqZk344AOwcnRXyZLw0kuwfTscPAgjR5ohd88+C6VLmwTZr7+CrXRSllGuXDk8PT3ty48++ijPPPOMfXnQoEFMmDDBvvzpp5/G6sm0atUqli1bZl9+9913Y63ft29funXrZl8uVKiQvZcWwHfffcfmzZvtyy+88AJz5syxL/v5+TF27Fj7squra6xhgC1btmTevHkAaK0ZNmyYvTh7VFQU33zzDUePHrUvnzhxgpsZnR0UQgghRI6SP7/pddK9O7z+upkwRzp7i9S6eROefNLM8j18OHzyiamJK0ROkOJkk9b6EDAJ07upAPARcFYp9Y1SaoJSaqTtfjFwFvgEKIzp1TTJtr3IhpT6byjdP//ArFnmj+lLL5neTt27myJ4UVHWxVitmvlW4a+/TGKsa1fToGjZEh58EIYOhT17rIsvI+XLl4+iRYval+vVq0e9evXsy/3794+VbPr0008ZNWqUffn/7N13eFRF28fx76QXQuid0KX3Lr2IKBYEFRULNgR7B8Gu2PsjUlR4fRREUcBeUVQURBBQaT6ogAjSSyCEtHn/mM1mEwIESHKS7O9zXefanbOn3HsI2ZN7Z+5ZtmwZEydm5Y4XLFiQLbk0adIkLrvsMn/74osvpl27doBLHiUnJ/uH6iUnJ/Piiy+yaNEiABITExkyZAgffPAB4OpR1a1blylTpgDw77//UqFCBX/Pqi1btnDaaafx1VdfAbBt2zbuueceVqxYAcCePXt47733/DMJpqSk8Pfff5OSohJyIiIikl1EBLz+uks2vfyymzVs3z6vo5LiZssW6NkTPv7Y/V302GPu7yWRYHE8PZuw1t4HPO5rGqACMBi4C3jY93iub70BMoDHrLX3n2C8UkyUKZM1lO7nn12X0Y8/hj593PC7cePAN4mbJ3Kr79SmDTz3HLRs6ZaHH3Y9oSRv6tSpQ7Vq1fzt8847L1sNqSeffNI/LC8kJIRvv/2Wq666CnCJr6SkJP8wwtjYWH777TcuvvhiAGJiYpg6dSp9+/YF3HDEIUOGUKdOHQAOHDjAjh07/MmjTZs2MW7cOP+wwTVr1jBw4EAWL14MwO+//05CQoK/J9X8+fOpVKkSCxYsAFzx9dNPP53Vq11ufOXKldx9991s9hX8+vvvv5k9ezaJiYkA7N27lw0bNqjOlYiISAlhjLsXnDQJPv/c3TeeSN1PCS6rV0OnTrByJbz3nvu7SCTYHFeyCcBaexfQFZgDHMQllXIuKcAsoIu1dmzuR5KSLnMo3aZN8MYbboa4u+92PYnOOMP1LEpN9S6+3Oo7xcS4In5NmriZSe69F5Yv17j9gpZZHD0sLIymTZtSqVIlwCWbhg0bRuPGjQGoUKEC48eP5+STTwagdu3aLFq0iP79+wPQsmVL0tLS/MmtZs2asWTJErp27Qq4IX2TJ0/2D0MsX748gwYNonLlyoBLXm3fvt0/M+CqVat45JFH/LP9ffPNNwwaNMjfU+rdd9+lVq1a/P23m/9g6tSpVKxY0f/67NmzOe2009i7dy8A8+bNY+zYsRw8eBCA3377jXfffZd031jObdu2sW7dOv/5RURExBvDh8P777sSDJ06ga/TtMhhffstnHyymzTpm2/c3zsiwei4k00A1toF1tpBQDzQERgIXOJ77AjEW2vPtdb+eIJxSgkQHZ01lO5//4PRo12vp3POcUW7r7/eDW3zsnZSZn2nBQvg779d4qliRdcTq1Ur1ytr1ChX/0l5gKItJCTEP9NfTEwMbdq08Q8bLF++PFdffTXVq1cHoHHjxkycOJG6desC0K1bNxYtWuRPbg0ePJj09HR/+4wzzmDp0qUkJCQA0KVLF1555RV/sqpevXqce+65xMXFAW6Y4M6dOwkPDwfgxx9/5PHHH/fPbPj2229z3nnn+dvPPPMMDRs29CffRo8eTc2aNf3v7dlnn+Wcc87xt2fMmJGt3tb8+fP58MMP/e0NGzawfv36E7ugIiIiQer0010CISXFJZzee8/riKSomjTJjeSoVAkWLnQ1bEWC1QklmzJZa1OstT9Za9+31k7zPf5krVVBFMlV/fougbNhg+tR1K0bTJkCvXpBtWowYgR8+aW3BRlr1HCJp3nzXLfpSZOgXj145hno2NH10Lr5Zvjuu+JXXFyOnTHGn/wpU6YMrVq1IjIyEoCTTjqJK6+8khjfHLbdu3dnwoQJ/oLqF154IT/++CPR0dEAjBo1itTUVH/y6cYbb2T58uX+459//vm8+uqr/nN37NjRP6QQXEH1wF5P8+bNyzYz4H/+8x9uu+02f/vmm2/mjICv1QYOHEi3bt387ZtuuonrrrvO337uueeyzVT44Ycf+occgptpcNOmTXm8ciIiIsVfmzaweDE0bgwDB8JDD3lbh1SKlpQUN1RuxAhXC3bhQvBVexAJWvmSbBI5XmFhrmvpO+/Atm3w9tuukN4bb8App7iZ7q66yk1D62Ut50qVXDfqzz6DrVvdbHutWrmZJbp3h+rV3QeM1wkyKT5MQIXIChUq0Lx5c3+7devW2ZJL55xzDo8++qi/feuttzJnzhx/e+LEiawKKDD2n//8h08++cTfvu2223jiiSf87bPOOovzzjvP346IiCAiYA7eTz75hC+++MLfvueee3j22WezxXPDDTf4202bNuWKK67I9vr06dP97TFjxvDOO+/429OnT2fJkiX+9m+//cb27dsREREpyqpXd8OiLr7YlVg4/3wVDhf3t0Hfvu7vgtGj3bDLgDl4REqe9OQ8baZkkxQZsbFw3nmuWPfWrTBrFpx6qktAnXYaVK4Mw4bBhx+Cr9SNJ8qWhcsucx8k27bBjBku4fTf/7oEWeXKcMUV8NFH3sYpwatSpUr+IYHghvmddtpp/vYVV1zBjTfe6G8/+eST2ZJJn332GbNnz/a3P/roIyZMmOBvP/PMM9x6663+9mWXXUa/fv387cjISMLCwvztt956i4ULF/rbV199NTNmzABcL63WrVvzzDPPAG6mwsjISB555BEAUlNT6dKliz95dfDgQW699Vbmz5/vb8+YMYM///wTgLS0NP766y+SkpLyfsHyw7RpULu2m32gdm3XFhGREic62t3zPf00zJ7tavNsfU6fAcFq6VJo3971eps+HR591M3GLVIsZaRD0ibYsRg2vg//mwDL74GFV8DX/eGj5vBOeXgrOk+HCzv6JiKFLybG1XI65xxIToYvvnC9n+bMgddeg7g4Nw3tuee6hFR03n7e811cHAwZ4pYDB1zPp3ffdYmyqVOhdGk3zn/AAJcwK1/emzhFTkTgLINAtsQS4J9FMNOMGTOYN2+ev/3HH39ke33lypX+IYfgklENGjQAID09ndtuu42OHTsCkJKSQnR0tL/+1t69e3n55Zc56aST6Nq1K9u2bePCCy9k8uTJ1K1bl7///pu6desydepUhg0bxtq1a+ncuTMvv/wyAwcO5K+//uKGG27g7rvvplOnTvzzzz+8+uqrXHTRRdSvX5+dO3eyePFi2rdvT9myZUlJSeHAgQPExcX5a2odYto01/UxM8G1fr1rgytUJyIiJYoxcOut0KwZvD1wGqVuGQ7oMyCYWAuTJ8NNN7kREPPnu6GWIkWStZC62yWSDvwDBzZBku/xwD9Z65P/BZtjfLAJgagqEF0d4upBpe4QXQ24+6inVbJJiryoKDjzTLekpMDcuVmJp2nTXI+oM85wiafTTnNtL0RHuzH8Awdmxfnuu64n1owZ7suuzp1d4umMM9wNSsBIKpGgUatWLf9zYwyDBg3yt8PDw/29mgBiY2P58ssv/e2KFSuSmJjob1euXJmVK1f6Zy4sV64cU6dO9c88GB0dzXnnnecv5n7gwAE2b95Mim9c7l9//cV9991Hly5dqF+/PkuXLuXUU0/lm2++oXv37nz99df079+f77//npNPPpmvvvqKm266ibfeeosmTZqwePFiXh0xgnuSkqgG/AEsBM5KSiJu7Fh2DxjA3r17qV69uj9hVqCmTYOxY11BvIQEVxxPf+yIiBSIfv2gV9mxhB/I0Zs2Kcn9Ltbv35Ij4PM1o0YCL9UYxw0LhnLqqfD6625CIRFPpB3IJYGU4/mBTZB+4NB9I8q5xFFMdSjTLOt5dHX3PLoaRFWGkNzuYZVskhImIsIllE47zY2L/uYbl3iaNcsNv4uMdEPa+vd3S+PG3iR0AuPMyIAlS9ywug8/hDFj3FKzpks6DRgAvXt71ztLpDgLDw/3zxIIEB8fz7Bhw/zt6tWrZyt23qRJk2z1orp27Upqaqq/hla7du34/vvvadasGeCKvz/99NPUq1cPcDMbNmjQwD/T4Pr163ln3z4y+3Z9DVwNbADiNmzgzTff5Nprr2Xz5s1UqVKFyZMn8/DDD/PLL79QpkwZ5syZw9tvv82UKVOIiopi4cKFLF26lOHDhxMaGsrGjRvZs2cPTZo0yVbnK1fqYSUiUujCN2/I/YUNh1kvxU+Oz9eQv9dz+d/DqXkenDljKIfr+CxyQjLSXE+jpE1ZPZByJpKS/nE9lnIKjXYJo5jqUL5DQBKpWtbzqKoQVrB/gCrZJMVWeLgrxte3L7z4opsV7oMPXDHx225zS82aLul06qluGlIvivWFhLix3O3bw/33u5ntPv7YJZ/++1+YMMElmnr3zko+iUjhCawvFR8fz8knn+xv16lTJ1t9qk6dOjFr1ix/e/DgwQyuVcsldoALgG5AVYCEBHr16sUrr7xCuXLlANerq0+fPv6ZCv/9918WL17sL9D+/vvv8+STTzJixAgAnn/+eV588UUOHHDfRt11113MmTPHX0PrlVde4ZdffuGFF16AsWP5LimJXcBZvvh2JCURdtddxCvZJCJSMBIS/J8BgZIqJBCTy+ZSDI0dm/VFjk8sSZy9aCyE6PNVjpG1kLLz0KRRYEIp6R9I3gLY7PuaUIiu6hJGcQ2gUs+sJFJgMik8vkgMoVGySUqEsDDo1cstzzzjvkz67DOXeHrrLXj5ZVesr3PnrF5PrVvjyTcRVavClVe65eBB+PZb1+Ppww9dAgqgbt12DBnikk8dO6rQoEiRNm6c/xvPUkBDcIXnxo2jUaNGNGrUyL/pqaeeyqmnnupvjxgxwp9YArjvvvu46aab/L2Yhg0bRpcuXfyvt2rVitTUVH977dq1WT21NmxgPPAzWcmma4CVf//NSl/72muvZe/evbzxxhsATJgwAWOMP4YlS5YQExOTrbeYiIgcQcBnQKYDJoarto0j8nJ47jmIj/cuPDlxdsMGcv2zXb3XJKe0/Yevi3RgU1YvpYxcZpGKrJCVLCrbKvtQtphqrh1Z8TBD2oqmkp1sStsP2xdClT5eRyKFLCEBrr7aLampsHChSzx99hncfbdbKlZ0PZ5OPdWNufeVfClUkZFuBrtTTnE3I2vWuKTTtGmpPPGEm9GifHk3HO/0010vLo0JFyliMnsN5UOtpMjISCpXruxvN23alKZNm/rbQ4YMYciQIf4C7I899ljWzgkJvLh+PXsDjnc1sKtCBX+7SpUqlCpVyt9+//33ycjI8CebRo4cSbly5fj0008B6NWrF/Xr1+fll18GYNy4cdStW5cLL7wQcMmpypUrU6NGjWN+ryIiJUIunwHhD4yj7v+G8uij8NVX8H//574QleJn5kzoZBKoaQ/tvYavHqQEgYxUOPDv0Wsjpe45dN+w2KzEUcWTfQmk6r4Eku95dFUIjSz891XASnayac1/YPldUOsiaPkwlKrjdUTigfBw6NbNLePGwdat8PnnWckn3xf8tG2b1eupUyfXW6owGQONGrmlXbvltGrVk88/d8mnTz7JirNNm6wE2cknu/pQIuKxoUO9r4s0bhwVhg+nQsC366fGxLhMts+9996bbZdPPvkEa7O6aE+cODFbu0ePHtmSXzNmzKBTp07+ZNMZZ5zBmWeeyeTJkwFo2bIl559/PmPHjvWfr0ePHvTp47702b9/v38IoYhIiZHjMyAMeBjXQ/3SS12phFtucfehqtFZPOzaBddfD9Onw911xvHA5uGEJAcMpfP1YJZizmbAwR25FNQOmKHtwD+QvI1Dh7SFZfU8im8CVfoGDGermlUzKSyuSAxp80LJTjY1ugXSk2Hlo7BhBtQ4B2pfDNVOK5GZQ8mbSpXg4ovdkpEBS5e6xNOnn8Jjj7nPjdKloWtXV2y8Rw+XiAoPL9w4y5SB8893S3o6/PyzS5J9/jk8+aTr9RQbCz17usRTv37QsGHQ/i4TkePsYRVYeLxNjnmb77///mztX3/9NVsyatq0aZQvXx4Aay0dOnSgdu3aAKSlpfHUU08RHh5Onz59OHjwIHFxcTzyyCOMHj2alJQUxowZw/nnn0+HDh3IyMjgwIEDSkaJSInRqZO7zxw1Cp591tXsnDTJ3VtK0WQtzJ4NN9zgvqB+4AEYM2YoIW+h2V6Lm9REfxKpctJcWPlj9iFumUtG6qH7RlbMqoFUrl32mkiZj5EVwKg6/JGU7GRTaCS0uB/qD4c1z8GfU+Hvd112sVIPN7yuci+IbwohJftSSO5CQlwiqW1b9/mxezfMnQtffOFqKX38sdsuJsbVe+re3S0dOxbuN1OhoVlFxseOhb17Yd68rORTZq2nmjVd0imzILqvJrGIBItC6GEVmJzq3bt3tvWZw+3AFV7fv3+/v8ZUWloajz76KD18f2X9+++/jB8/nmbNmtGhQwfWrVtHvXr1eP3117n44ovZu3cvr7/+OoMGDaJq1aoF+p5ERApKbKybyObss+Gaa9yXhJdf7r449OXqpYjYsMH1ZvrgA2jRAt57D9q1871YFHowi5OeAsmbj14bKS3Rv0tjgGW4PEBMddfrqGL3HEPZMmdpqwKhGjqSH4IjwxJTDVo/AS3Hwb9fwcbZ8O9c2PShez002hXhKtcOyraE0o0hvjFElPU0bCl8ZcrA4MFuAfeNxvz5LvH0zTduNjlrXS+nDh2ykk8nn+x6QxWW0qXhrLPcAvDXXy5B9tln8M478OqrrodT+/ZZvZ46dSr83lkiEtyMMf6Z9mJjYxk1apT/tYSEBPbv3096err/9UceeYR2vjv7hQsXcv3119OkSROqVq3K//73Pz766CMuueQSyn/6KYwdS1toW/jvSkTk2J1yCvz2Gzz4IDz1lEtoPP00XHKJeqV7Zto0GDsWu2EDiWUSuG//OOaGDeXJJ+Gmm3TfXOhshhuudkhB7Rz1kQ5uO3TfkIiAIW3NoWr/bLWRfvx1Ix17nAPhpQ7dVwpMcCSbMoWEQ7VT3QKwfwNs/Q52LoGdi+HPKa6oeKaoSi7xVKqeq/cUWwdK1XaP0VXUbS4IVKoEgwa5BVzPp++/d8mnb7/NGs4WEuJqKWUmn7p2Ldxvq+rUcROhDB8OaWnw009ZvZ4eeQQefhji4ty3aX36uKVpU93ciIi3QkJCCPFNC1q5cmXuuusu/2unnHIKf/75J9WqVQPgq6++4pZbbuH8sDAYNYqDOaahFhEp6mJiXMmGiy5yvZwuu8wVD3/uOdeTRgrRtGn+WQQNUHrXeiaEDOeJx6HizerBlK+shdS9uRTUztkraTPYtBw7G/c3eXR1iK4B5TsEJJGqZz2PLH/EP2wOrJqnRJMHgivZlFNsAtQZ6haAjHTYvw72roa9q2DPKvd808eQ/G/2fUMis/+A5xzHGVXV/ccIL62/6EuQMmVgwAC3AOzf72a6y0w+vfQSPPOMe61ZM5d46tLF9YKqV69wfhTCwtyQv86d4b77XILs669dr6cvv3TfpIFLpPXunZV8qqP6+SJShBhjqBPwi+maa67hjDPOoFqXLmxLSqIpoHmARKQ4atHCfXk5aZIrj9C6NVxxBTz0EFSp4nV0wSH1zrGE5/jSIiojiajnxoKSTXmXnuySRLkW1w5IKAV26MgUHp/193Pp3tn/nvb/TV3ZdRiRYim4k005hYRCXD23VB+Q/bW0A7B/Pez/yyWk9v2V9Z9q18/wzweQnsu3rCERLukUWck9Zi6RlVwGNrI8RJTzPZaHyHL6D1WMxMZmJWsADh6ExYuzht39978uAQVQtqxLOgUulSoVfIxlysA557gFYP16Nw3v3LlumTHDra9dO+u99Oqlmx0RKVrWrVvHjz/+yJANGygLnAxs9DooEZHjFBICI0fCkCGuB/p//uPuyUaPhltv1ax1BWXXLne9n9y0IfcNNhxmfbDJSIeDWw+dpS1nUungjkP3DeyUUbY1VDsjR22kqr5Z2jQhSEmnZFNehUVDfCO35MbfPfAf958weQskb3X/SZMDlr2r3GvpyUc4V1yOJFQ5iCjjlvAcjzmfh0bl57uWYxQZ6XoydekCd93lhrStXAmLFmUt48a5WfAAatVyxcYzk09t2rgEVkGqVcsVprz8cvdju3p1VuLp3XddvSdww+z69HG9n3r0cEkrEZE889XCON6ZezZu3MgHH3zAVVddRXh4ONOmTePuu++mb40alN+4kTlAu6MdRESkiCtXzvWKHznSzVp3990wcaJ7vPxyiIjghH+fCuzb574Afvxxl3C6KzaBCvvXH7phQgnvM2stpO45ck+kpH/cqB6bnn1fE+J6GkVXh9haUOHk7CN9YnyPEWU1skcAJZvyjzEQEe+W+CZH3tZaSNvnMsEpO+DgTt/znI++1/avh9TdkLIr96kZA4VEuhjC490QPv+Ss53LurA4CI+DsFKuaLp+SZywsDDXVbpFC7jqKrdu/374+efsCai333avhYS44Xc1a57E//7nElBNm7rjFARjoHFjt1x/PaSnuyl65851vZ9efhleeMHF1a6d6/HUu7dLpml2chE5rIBaGIDrUjl8uHvu+wMpMTGRxYsX06JFC8qXL8/ixYu59dZbmTBhAk2bNmXhwoVce+21tG3blg4dOnDFFVdw3nnnUW7RIlfsRDWbRKQEadAAZs1yPeNHjYIRI1zdzSl9p9F7xnDMEX6fyuFlJpmefBK2b4f+/V3drAq/jcv+OQWuqNa4cd4Fe6LSDvhmaQushZRLr6T0A4fuG1E2qzRM1abZh7JlJpOiKmkGdzkm+mnxgjEuqRMeB9TO+37Wuh5Rqbshxbf4n+/Kvj4t0fW0St3rhvyl7slq58xS5xpjqEs6hZXyJaACElHhcTTYnQhLP8q+PqyU6w7p3y9HOyRCCSxckqZbN7dk2rrVFfVetAh+/BG+/bYiH33kXouOhrZtXbKnVSto2RKaNPF905XPQkPdedq1czc6Bw+6mlSZw+6eftp9I5Q5G1/v3i4B1bkzRKlTnYhkGjuW5KQkFgD1gZrAX0lJXH7lldxTpQp9+vRh9erV9O7dmzlz5nD22WcTGRkJQHKy6/nbv39//vjjD3/dpqpVq1K1alU46ST3WTJ2rPujS0SkBOnRAxYscJO83Hcf1JsyFkOO5HpSkvsdqGTTYe3d63qIBSaZ7rvPzc4MQEvftSsOPcYy0tzImNyGsQX2SErZdei+oVFZSaTy7bOeR1fL6okUXc2N4hHJZ0o2FSfGuF8EYdFurOvxsNZlszMTT/5lD6QmuiRV2j73PGc7LRH2b4e0fVRM3gm/f37k4YCHxB+aPREVGutLSGUmpWLdurDDLLm+FuPWhxZA5qUQVaqUvfD4119/T82aPf09n3780RWRPOD7IiI83PVGykw+ZT7m9wx4kZHupqdHD3jgAdcr6/vvXfLp66/dZ/JDD7ntTj7ZJZ569XKJqIJIhomId6y1LFmyhPLly1OnTh1SUlIYPXo0/fr1o3///uzevZvGjRtzzz33cO2GDewBegP/Aa4HSgHpBw+Snu6+8GjSpAlz586ldevWADRv3pxvv/3Wf75SpUpRqtRhZo4ZOhSGDmWJMUsK8j2LiHjBGDj1VOjXDwjdADaXjVRbKFd//unqX736KiQm5pJkCuT7LPGMtS5BlCNp1GD3T/DNs1lJpOQtYDOy72tCIaqK63kUVx8qdc+apCqmetawtvAy+rJfPKNkU7AxxiVowmIg+vgrQP8wbx49e/Z0mfa0RDfDQOo+SPc9pu1z69JyPM9tm+StAdv4loyDx/i+wnIkpmIOTUiFxeR4LSYgiXW413yPhdwryxioX98tF13k1qWnw//+B8uWwfLlbvniC1eEPFONGlnJp8wEVL16bhhcfoiNdTc+/fq59p498N13LvH09dfuw/zee10v5K5ds4bdtW3rek2JSD6aNg1uugl2+Ipzli8Pzz9/1Btnay3G9/ts6dKlREZG0qSJG/796KOPUr9+fc477zwAWrRowcCBA3nwwQcB6NKlCzfffDOPP/444eHhTJ06lcqVK9O/f39Kly7NGWecQYMGDSAhgQrr1zMXaOY7b0Xgu1q1/L9AYmNj6d27d75eEhGRksQYXI+bXHpxbo9JYOMyaLUiSOs5BdSxsjUTWH3pOMb8NpT33nP3nOefDzffDO3bexRfWlJAL6R/Dl9oO5e/eSqZ0hBRyyWMyrTIvS5SZEU3uZVIEaZkk5yYkDA3xjeibP4eNyPNze4XmIDKuaQfbn3mfkmuR1bylhzr9+dtKGEgE+pLPOWSlMpLsiq3BFhgoisPNbJCQ6FRI7dccEHW+q1bs5JPmYmoTz91ySlwCaIWLVzyqUUL1yOqSROoWPHYLkFu4uPhjDPcArBzp6s1kJl8uuuurO169MgqON60qb5kETkRlb78Ep54gi2pqSQBdQB27OD9YcNI++knBj33HAB33nknsbGx3HfffQB07NiR2rVr89ZbbwEwZMgQ2rZty5tvvgnA1KlT6d27tz/Z1L17d0466SQAjDF88MEH1K1b19/etSury35ISAgvv/yya4wbR+jw4fQuSbUwRES8MO7Q2kIpYTHckTqOg62n8WrIcKIzgqyeU466gGbDehIeHk7FWBgzZigjR0L16gV07oxU97dFUs4EUo5EUuqeQ/cNi80atlahsy+JVNWXRMpMKFXl++8Wui/1RYo5JZukaAoJgxBf4fL8Zq37oEj3JaRyJqiyJa2SjrxdehKkbDp0m2MZXgiAr8eZLyHV/iDwacVDk1PZ6mK51yqFleKUxrGc0jwWhrn1B9NjWfNHKZb9FsuS5TEsW2aYNg0mTMg6Y4UKWYmnJk2ynlerdvyJoHLl4Jxz3AIuEfb111k1n95/362vVMklnTKTT76/XUWKj3yaGWjPnj3s2rWL2rVrA/Djjz+yceNGBg8eDMCUKVP4888/efjhhwEYOXIkf/31F3OWLYPUVC4FdgM/+o73fFoayRMn+pNNmzdvpnTprN+jF1xwAeUDxttOmTKFsmWzvixYvXo1IQFdIV988cVs8fbL7NZ4NJnXIhi/bRcRyU+5/D6NGDeOZwcMJaRubaJ3HVrPyY4Ziykpv29zfN6m3D+O1DvGEptjkohYkphYbiwhDx/n+7bWTdCUW0HtwOfJWzhkXKMJy0oalW4ElXsH9ESqnlVoOyxO37ZKUFGySYKPMa7GU2hE/vfIypSR7mpj5exRddS2e5707zpiI2Nc+8DmQ3txZaQc8fSRQAugRRRc2tFAlxhsaCzpphRJqXEkHijFrsQ4tu0uxaatcexYUoqfvi/FV8lxpFGK0uXiKFe5FJWqxVG9VikS6sVRLaEUIZG+GQxDwvN0GSpVgiFD3ALuC7fMxNNXX8GMGW597drQt68bV9+3r+sJJVJkBXyjuh1Yt349ba++GgMsbtiQH374gRtvvBGAt956i/fff59p06YB8NBDD/HGG2+wZs0aAEaPHs0777zDtm3bAHjllVf46KOP/MmmxYsXs3TpUn+yqXHjxpQrV47Izz8HYBQQOEfpW0Dkwawu+a+//nq20G+55ZZs7a5du2Zrh+TXmFvwvhaGiEhJkcvv0zIAu3Ov22Q3bGDYZTBwoBu5XGxnEM5lZtPUy4cTnbNguk/IxsPUsUrdl6Ogdm69kjbnfn8dWTGroHa51jl6IfkeoyqCycfPT5ESQskmkYIQEgohvkLox2FFZk2sw8lIDUg+7cvD8/2YtH2Epe2jdNo+Sqfuo3raTkjbgE1NxKbsg7REQkg79Fz7gV98i09KRjSpuMRTWHQ8EbHxmIjSEB7vW3zPI+J9wyzLQ2Q5alUsx+WXlufyy6OwFlavzko+zZwJr7wCYWGu2Phpp7mlRQt9CST5JzU1lV27dlG2bFnCw8P5999/+emnn+jVqxelSpVi+fLlzJw5k9tuu42yZcvy6aef8vTTT/PWW29Rrlw5Jk2axE0jRrAZKAtMBe4EEg8coNTYsXw+fDhjx45l+PDhREVFsXnzZpYvX05GRgYhISE0bNiQPn36+OO59NJL6dGjh7/94IMPcvfdd/vbL730Urb4M5NYya++StSWLeSseFQBoFat/LxkIiJSVB2mntPO2AQ++MDV9YyKcgmn006Dnj2hYcOif1+VkQG//AJ1bxhL6Vx6MGWEhLovdkNxH8ZlfI/1ysCy0YcmlNISDz1JWKmsQtoVuwUkkDKTSFXdEhpZ4O9XpKQqNskmY0x/4Hncr5VXrLWPeRySiHdCwiGijFtOkPEtbnhhim/mQZd82rtjH3//lcjmv/exffNeEnfu5cDevaQd2EOpyD2Ujt5LfMweysTuoULpzZQptYe4yD1EhebyoR4oNBoTWZ7GEeVo3Kg817UoR8aoimzYVo0lK6vz1YJqTHupOk88XJ3o+LKcdprh4ouhe/f8K3YuR3G4YWL5NHzsWKSmur474eHh7N+/n6VLl9KwYUMqVqzI5s2bmT59Oueccw5169Zl5cqVPPDAA9xzzz00a9aM+fPnc/HFF/Puu+/Stm1bPv74YwYOHMiSJUto06YN8+fP57zzzuOXX36hefPmrFq1ikcffZRLLrmEsmXLkpqayv79+0lOdkNjmzdvzo1A5o/hQKAhEAGwYQM33HADI0eOJDLS3ZzefPPN3Hzzzf73cv7553P++ef72507d6Zz587+dtWqeZtp9M+rrqLJE09Aamr2FyIiVBdJ8p3uwUSKqFzqORETQ4VJ49hyPsyfD3PmuCWzlEGVKi7p1LOn+3KvUSM3y/EJy3l/cPrp8PHHebpfSE6GFStcvPPmwbffZhCatp1/y66HWrhEUsASUjYdygGHVNvYBaufyUoaxTeFKv2yimpnro+pDuFx+fCmReRIikWyyRgTCowHTgE2Aj8ZY9631q70NjKREsQY9+1NaCS+/hGULgNN60HTHJtmZMA//7jZ8dauha/Xwtpl7vnatZCcnEFcVCLxMXsoV2oXJyXsoF7CTupU20GNijupXHYHFdhJabODWHYSfmAlIQe3UvvgDmrXgMHnAa4+MSnpUWzYXpMls1rzxJR2VGvejr5D2lMt4fh6jUke5NJtneHD4fvv4bXXDl0P2W4g09PTSUtL8z//+eefqVq1KjVq1CA5OZn/+7//o1OnTrRq1Yrdu3dz++23c9FFF9G7d282bdrEgAEDuO+++xg4cCBr1qyhUaNGvPnmm1xwwQX8+eefdOvWjZkzZ3LuueeyefNmbr/9durXr0/dunU5ePAgy5cvZ88eV5izfPny9OjRg1jfGIJWrVrx4osvUq1aNQB69+7NTz/9RL169QA477zzGDJkiH+2tjPPPJMzzzzT/95OPvlkTq5Vy/9NcgPfAkBCAnFxhXPzurVvX5o0bnxcs9GJHAvdg4kUYUeojxeOmxW4Vy947jl3fzZvXtaSWcogMhKaNcuaybhpU6hTx81wHJbHvxSb/fILPPFE9vuDwEKhvvuF1DTY0OlM/v1zE5v+2MSOjf9wYMcmwlP/oUqZTbQvs4lzT/mHyoM3ExaS48uUDGAvsAtIjoa4TvDlz7BuD4RVgstugsFXQ2R5DWkTKSKMtfboW3nMGNMZuN9ae6qvfReAtfbRw+1TrVo1e8011xRShCKSyVpITCzFzp3l2LmzHHv2xLNnTzx795b2P09Ly/4VWmhoGnFxiZSJ20XtyuuoVXEDNcpvpFrZTVSJ30yVUluoWepvapbdCEBaeiiP/DoGG6spX/NDRkYGGRkZhPnuKns/9RRV9u3zJ1Few32x2M0YQq3lBqAzcJHv9XahoVTo25fOnTuTkZHBgw8+SI8ePejVqxdpaWk8/PDD9O7dm+7du3Pw4EEeffRR+vbtS9euXTlw4AAvvfQSvXv3pnXr1hw4cIDZs2fToUMH6tevz4EDB1i0aBGNGjWicuXKpKSk8Pfff1O5cmVKlSpFeno6qampRERE5G+9oSNo9ssvnPnBB0QE9CpKCQ/ngzPP5LcWLQolBnHuv//+Jdbadl7HUZId6z2Y7r9Eij5rYefOcvzzTzX+/beKf0lKyiruZEwGpUvvpUyZ3ZQuvZeoqORsS2RkCsa4vyPHf3QtFVO2Zw1ny1zK4db5HjPKGkKiD/3bc9/BWHanxJNkYzlANIlppUlMi6PMHztp9+Viwremwx4gXZ+3IkVFXu7BikXPJqA68HdAeyPQMedGxpjhwHDI+1AEEclfxkDp0vsoXXoftWsfWqjRWkhKimbv3nhf8skloRIT40hOjmTHnvKkJ4eye1sZtsZVonq5iiRWWEfpOnv9yaaw0HQMNudcIEEjIyODtLQ0IiIiANi2bRtpaWn+33urVq3CWkuTJk0A+OabbwgPD+fkk08G4O233yYuLo7TTjsNgPHjx1O1alXOPfdcAC7Zt48euCQTwF3A6UAP35cT83D3jZnqpadzMCoKcAWme/XqRUJCAgBhYWFceOGFVKxYEYCIiAhuu+02onzbR0dHc9ttt/mPFR0dzUUXXZStHVjTKCIiwt8LCSA0NJTQ0MJNOmbe4PaZO5f4PXvYEx/P3D59dOMrJdVR78F0/yVSvBgD5cvvpHz5nbRo8RuQ9WXh9u0V2b07nt27y7B7dxn27onj4J4I4lITKZO+i6rh/1I94h+qldlEtbKbqF72Hyr03p7LkDYgBTdl6i5gA5jllteqXUpySBQ22pAaFkFiWilS7WHqIlWATU2q02fzXOLT9XkrUtwUl55N5wGnWmuv8rUvATpYa2843D7VqlWzmzZtKqwQg868oxWwlhNSIq5vRhqk7oGUXW4q2ZSdR348uM0VcszI3m3aYkgLr0pKTGvSSrcjo1w7YmudTESpcoc58dEV9vVNTU1l3759/inm165dy6ZNm+jevTsAX3zxBX/88QcjRowAYMKECaxZs4bnfNPX33LLLfz+++989NFHAJxxxhn8+++/LF68GHDT0e/du5eFCxcC0KtXL9LT0/n2228BGDhwIPHx8bz22mv+41WqVIm77rrLf77KlSszaNAgAL6uUoUKW7bQ3Bf/FqAUEBsaCunph77BWrVg3bpsq0rEz3ARpuvrGGPUs6mAHes9WMOGDW3mbIuSP/T/PX/pevpY6+7TDmzKPjNbthnaNrlZ2mz2z36LIS2sMmnh1fnfPymc9OsaoramuKRS4LIvxzlzuV+QQ+lnNP/pmua/vNyDFZeeTRuBmgHtGoAySSL5zVpIT/YXCCc15+MeSN0LKXuynqfmeJ7ie56e+7S0jvEVOC/nxtZHVoDSjbJmBcks3hhdHRNdhfCQcPKjdmVepaamsmfPHsqVK0dISAgbN25kxYoV9OnTh7CwMBYtWsSXX37JqFGjCA0N5d133+XNN99k5syZGGN49tlnmThxon96+1GjRvHyyy+TmOgKpz/33HNMnz6dnTt3AvDuu+8yZ84cf7Lpzz//ZPny5f54MnsJZbr88sv9xwJ49NFHCfziYNasWf5eTwBz5szJtv+zzz6brT1y5Mhs7V5PP52tZlNlgJgYuOyy7DWbMterILVISaZ7MJHiJj3ZlzjalD1xlDOhlNu9WniZrJnZ4ptkn6HNt95EVSY8JIxwYPYDD9Bs+y8M/vzT7PcHOel+QSToFJdk009AA2NMHeAf4AKyyoWIBKeMVEjb70sM7T/K84B2wGxz/iRS2r6s9TaXniu5CYuD8NIQEQ/h8RBRFmJru+fhpbMeI8tBRHnfoy+5FF4GQvJv6FN6ejq7d+8mLi6OiIgItm/fzuLFi+nUqRNlypTh999/Z+bMmVx11VVUrlyZ3377jRdeeIH//Oc/VK9enVmzZnHLLbcwf/58atasyauvvsrIkSPZtGkTVatWZfbs2dx4441s27aNChUqMH/+fMaOHcu1115LmTJl2LZtG6tXryYlJYXIyEhq1qxJp06d/NPdDxw4kDp16vjjvfHGG7MNFXv66aezJYCefPLJbO/vlltuydYePHhwtnbbtm2ztTN7UB23IxQcpUuXQp+NTkQ8pXswkaIiIx2St+SeQAp8nrLz0H1Do7KSRuXaQsxZAUmkallJpbCYYw7rtxYtGDxo0HHPRiciJVOxSDZZa9OMMdcDn+Gm3Z1irV3hcVgiR2YzIC3JfWsUmPTJ2U5LgvSA52n7abTrD/juP/622y9H4ijHcLOjCouFsFK+JJHvMbIClKrjW1/KTQOb22PmPpkJpLC4E0oWWWtJ2r+f0NBQoqKiOHDgAD/++CMNGzakatWqbN++nalTp3LmmWfSqFEj/vrrL0aPHs3tt99O+/btWbp0KYMHD2bq1Kn06NGDb775hj59+vD111/Ts2dPfv75Z0477TTmz59Ply5d+P3337n77rs55ZRTqFy5MsnJyfzvf/8jyfcNXJUqVejVq5e/QHbXrl154YUX/DOYDRo0iDZt2lC6tCtIcN1113Hdddf5ew+NGDHC3ysJ4Nxzz/XXPwLo3r27f8gcwEknncRJJ53kb2eep0gZOjT3m8LDrReREkn3YCKFwFpXdiBn0igzqZTke0z+191fBjIhEFXVJYri6kGlbjl6ifuSSBFlXbGmgqL7AxHJoVgkmwCstR8DH3sdh5Qg6SkBiZ/MhE9SjoRQLu1Dtsuxjf8x+dhjCo2BsFji00JhbzkIjXVJougqAcmiwMe8PC8FodEnfINhrSUjI4PQ0FCstSxZvJiKFStSq1Yt0tPTmTBhAu3ataNTp04cOHCAESNGcO6553LmmWeya9cuunTpwujRo7n00kvZtGkTNWrUYNKkSQwfPpwtW7bQq1cvpkyZwuWXX86uXbu48847qVq1Ko0aNSItLY3ly5eza9cuAMqUKUOXLl2Ij48HoFGjRjz//PP+wtEdOnTghx9+oFmzZgD079+fgwcP+pND7dq14/bbb/e/t5NPPtlfPBugWbNm/n0BqlevTvXq1f3tyMjDFLIUESmBdA8mcgLSkgKSSJnJo5x1kTblft8YUS4raVSmacBQtoAkUlTlfO0tLiKSX4pNskmCUEZ6jt48uSy5vX7URJHvuU07tnhMiD8Z5H8M8z1GV81qhwas928X+FrA64HbBCSEfiyAInb//vsv1lr/TEEff/wx8fHxdOnSBYAHH3yQ+vXr+4d3DRgwgB49enDnnXcCUK5cOa688kqeeuopjDF06dKFW2+9lUcffZSQkBBuvPFGxo4dS6dOnQgPD+ebb76hU6dOAMTExNC0aVMqVKjgP9bjjz9Ohw4dADd70VdffeWfPa1u3brs3bvX3+OnQYMGrF692v9e6tSpw+uvv+5vV6tWjRtvvNHfLlOmDJ07d/a3M3ssiYiIiOSLjLSsIW1J/+QyrM3XIyl196H7hkZnJY7KdwzogZTZI8mXSAqNKvS3JSKSX/QXmJy4jFRfzZ/MGkH7AuoF5Xh+1G0CloyDxxaHCTs0gZO5RFU6fKIoW8Inx2uB7ZDIgu1+nIv09HT/tO6///47+/fvp3Xr1gDMnDmT5ORkLrnkEgDGjh2LMYaHH34YgNNPP534+HjefPNNAE455RQaNGjArFmzALj11ltp2bKlP9k0c+ZMunXr5k82lS5d2j89PcCdd97pPzfAe++9R926dQEwxrBlyxZ/T6OwsDDWBcw2EhkZycyZM/3t6OhofxIr8/VevXr526GhocTFxR33dRMRERE5Lta6WXIPGcaWoydS8pZchrSFuS8go6tB3ElQqVf2oWyZvZTC4wv9nlJEpLAp2RSMbIavUPTeQ5dsM48lZi8eHdDumLgN3k116zJS8n5uE+arBRQ4HKyU6wLsT/zEZk8UBS6HvBaTtT404ujnL0QZGRns37/fnzT5/fff2bBhA3379gXg/fffZ+XKlYwePRpwM4otX76cGTNmAHDRRRfx66+/8uuvvwJwxx13sH79epYtWwbAlClT2L59uz/Z9O+//2ICblx69OhBTExWkceHHnrIX3MI4IMPPsiW0Mk8T6bMJFWmu+66K1u7f//+2doVK1bMy2URERER8UbafqLT/oYt8w5TG8nXzu3eNrJCVu+jsq2yD2XLHNoWVdH1hBcRESWbih1rXcInZbdbUn2PKbsC2nsgLWciaU/A80TAHuEkPiYsR6HoOH9iaM/BKkTXqO8rHB3nS/xkFpOO9SWTciSUwmIhJKJYfZOTnJxMZGQkxhg2bNjAL7/8wmmnnUZoaChff/017733Hs888wwhISFMmjSJSZMmsWTJEowxjBo1ivHjx/uLUL/00ktMnTqVPXv2APDZZ58xe/Zsf7IJyDZ9/dlnn03Hjh397XvvvZfU1Kyi4O+880622kGvvvpqtthHjRqVrT1w4MBs7QYNGhznVREREREpQjJS4cC/hw5ly5lMSt1LR4C5AfuGxWYlkSp2yTFDW2ZCqSqEql6jiMixULLJKxlpLkF0cIebnjTXxx1wcKcvkbTLJZJS9xzaZTensNiA6ed9S3S17O3AqekzZxcLL509uXSEYWOr582jSvue+X5ZCoK1FmMMu3fvZsWKFbRs2ZJSpUqxcuVKZs6cyfXXX0/58uX57LPPeOihh3j33XepXLkyEydOZOTIkfz7779UrlyZ2bNnc/PNN7N9+3bKly/P0qVLmTp1Kg899BBxcXGULl2ahIQE0tLSCA8P54wzzqBKlSr+899www0MDZil44UXXmD8+PH+ds6eQ0OGDMnWzjm9fZGcwUxEREQkv9gMOLg9e3Ht3GZsS97KIV+khoS7WdpiqkN8E6jSF2Kqs2rdHhq36ZtVGym8dK6nFhGRE6NkU35KT4Hkze7DMPlf98GXvBUObs3xfItLIh2ud5EJdbNPRJaDiPLu25T4JhBRBsLLuMfDPQ+Ph5CS+c+akZHBrl27iImJITo6mu3bt/Phhx/Su3dvEhISWLlyJffccw/3338/zZs356uvvmLAgAF89dVXdO7cme+++46zzjqLRYsW0b59e9asWcP999/POeecQ/ny5QkNDSUiIoKDB12tqI4dOzJu3Dh/76HzzjuPzp07+4ee3XLLLdx6663++C688EIuvPBCf7tHjx706NHD365Xr55/tjTAX4tJREREJOikJuZeUDuwd1LyZtdrKafIillD18q1CyiqXT2rRlJkhVyHtG3ZOo/GVXoW/PsTEQlyJTMrURAy0t0H3/6/YN862L8OkjZmH+N9cFvu+0aUdQWqIytB6cZQqYf7kIysAJHlfYml8lnPw0sHxXjv9PR0fv/9d8qVK0flypVJTEzkpZdeom/fvrRt25aNGzcyZMgQxowZw4ABA1i5ciXNmzfnrbfe4vzzz+eff/7h8ssv55133iEhIYH09HRWr17tH6ZWq1Ytrr/+eipVqgRAp06d+OyzzzjppJMAOPPMM0lNTfXPVNa3b19/PSWA1q1bZyuIXa1aNapVq+Zvm2I0HFBERESkUAR++ZrbDG2Z7bR9h+6b2Rs/urq7X86ZQIquBlFVilydThEROZSSTYGsdb2O9q6Gvatgzyr3fN+fkLQhxzcrxiWQoqtBdA0o3yFgutLqrjdSZCWXUAqiD8Q///yTyMhIqlevTkZGBo888ggdOnSgX79+HDx4kNatW3Pddddx3XXXsX//fpo0acKTTz7J7bffTlpaGqNHj+bZZ5+lbdu2xMTEEBUVRUiIS7wlJCTw3HPP0apVKwAaNWrEH3/84U8ANW/enBUrVvhjqVevHk8++aS/XbFiRfr16+dvZyaZREREROQobAYkb8slgZTjeW5fvoZEZCWLyrSAqv0D7pszayNVdWUcRESkRAjuv7aTt8H2H2DHYtjpWw5uz3o9rBSUbuS65yacB6XqQGxtiK0DsQlBUShw165dJCcnU7VqVQBeeeUVKlWq5J/VrH///nTu3Jn77rsPgDZt2nDZZZfx/PPPExISwhNPPMG1115Lv379iIyMpFWrVv5jxcXF8eabb/prEZUpU4Z9+/b5Z1ArV64cc+dmVXAsXbo0N910k78dGRlJ3bp1C/4iiIiIiJRU1roJZLINZQvshZT5fDPYtBw7GzejcHQ1d29coeOhPZH8Q9rUI1xEJJgEV7LJZsC2H2DjbPh3Luxe7tabUIhvCtXPgrIt3VC3+Mbuw7KEfzD+/PPP7N+/n27dugFuBrOwsDDGjRsHQPfu3alXrx5z5swB4Nlnn6Vx48Zcf/31AFSvXp1y5cr5j/fqq69mSwDt2LGD8PBwf3v69On+58YYLrjggmxtFb0WERERySfpyS5JdEhtpBy9ktKTDt03PD4raVS6V44e/L7Z2qKqlNhaoSIicmKC49MheTv8bzz88Sok/e268lbsAi0ehso9oWxrCIvxOsp8k5SU5O8d9PHHH/PXX39x3XXXAXDttdfy+++/8+WXXwIwduxYtm3bxuLFiwGXHAocXvbAAw8QHx/vby9YsIBSpUrx7bffAi65FGjw4MHZ2oGJJhERERHJBxnpbrhaYFHtnHWRDmxysxvnFBKZlUQq2waqnXFoT6SYam52YxERkeNUspNNGamw+jn49X73jU3V/tDyUahxVrEeE56YmOifEW3u3LnMmzePhx56CIAbbriBt99+my1btgAwZ84cPvzwQ3+yqVmzZpQtW9Z/rKeffjrbrGivvPJKtnMNGjQoWztz+JyIiIiI5DNrIXV3tuLaCYnz4aeZ2XsiJf8LNj37vibE9TSKrupKPlTsmlVsO7pqVo+kiLIlvue+iIh4r2Qnm1Y9DcvvcsPjWj0K8U28jihPMjIyMMZgjGHBggXMnDmTxx57jIiICB577DHuuusukpOTiYyMZMGCBTz77LPcfffdREZGMmDAABISErDWYozh2WefZcKECf5jX3vttdnO1aRJ8bgmIiIiIsVa2oHcC2rnLLidfiDbbnUBDpbNShxVbZI1pM0/rK2aq52kIW0iIlJElOxPpJOucwmmGmd5HclhbdmyhS+//JLTTz+dsmXL8s4773DJJZewcuVK6tSpw++//86kSZO4+eabSUhIoFevXjzxxBOkpaURGRnJqFGjGDt2LMb3DVX//v3p37+///iqgSQiIiJSgDLS3GzGOesi5Uwqpew6dN/QqKyC2uXbH5pEiqnOtz/9j+69Ti389yUiInICSnayKTyuSCSakpOTsdYSHR3NqlWruO6663jsscfo0KEDK1as4OKLL+bLL7+kT58+NG7cmGuvvdZfN+niiy/m0ksv9SeTOnbsSMeOHf3HVk0kERERkQJgrUsQBdZFyq1XUvIWNwlNIBPqhq5FV4O4BlCpp6uD5B/W5ksmhccfdUhbhtlQcO9RRESkgJTsZJMHUlNT+eGHH6hWrRoNGjTgzz//5KSTTuLVV1/lsssuIzY2lqSkJJKS3KwfHTt2ZMWKFdSvXx+Apk2b8vTTT/uPF1hPSURERETyQdp+XwIpMImUo7j2gU1uNrecIstnJYzKtDh0hrbo6hBZEUJ0DyciIsFLyaYTlJGRwcSJE6lduzann3466enp9OnTh9GjR/Pwww9Tq1YtxowZQ8uWLQFISEhg4cKF/v1jY2NVN0lEREQkP2Skup5GSTl7IeVop+45dN/QmKykUflOWYmjwLpI0VXd0DcRERE5IiWbjsPkyZOx1nLNNdcQEhLC008/TY8ePTj99NOJioriq6++8ieQQkNDefDBBz2OWERERKQYsxYObs99GFtgD6XkrYDNvq8J8w1pqw7xjaFKn1ySSNUgvLRmaRMREcknSjblwUcffcSvv/7K6NGjAZg9ezYA11xzDQA//fQTZcuW9W/fvXv3wg9SREREpDhK3Xf4oWyBiaWMlEP3jayYlTAq1yZgKFtAr6SoimBCCv99iYiIBDElm3KxdetWPv/8c4YOHYoxhrlz5zJr1ixuv/12wsLCmDVrFtHR0f7ty5Ur52G0IiIiIkVQegok/3uYnkgBw9rSEg/dNywuK2lUsWuOXki+hFJUVQiNKPz3JSIiIkelZJNPRkYG1lpCQ0OZNWsWI0eOpG3btjRu3JgHH3yQp556ipAQ961YYKJJRERERJzotH/gk9YuiXRw26EbhIRnDVuLbwZVT81qByaUwuMKP3gRERHJN0o2AX/++Sf9+vXjySef5JxzzuH888+nS5cuNGrUCIBSpUp5HKGIiIhI0RdCGkTXgPIdsoaxBSaRIstrSJuIiEgQCNpkU3JyMuvWraNRo0YkJCTQunVrypQpA7hhcRoaJyIiInJs9ofVgp4feB2GiIiIeCxok03nn38+K1asYPXq1YSHhzNz5kyvQxIRERERERERKfaCKtm0f/9+oqKiCA0NZdSoURw4cIDw8HCvwxIRERERERERKTGCZtD87t276dChA+PGjQOgS5cu9O3b1+OoRERERERERERKFmOt9TqGAmGMSQTWeB1HCVYB2O51ECWYrm/B0vUteLrGBUvX16llra3odRCSRfdfBUL/3/OXrmf+0zXNX7qe+U/XNP81tNYecerYkjyMbo21tp3XQZRUxpjFur4FR9e3YOn6Fjxd44Kl6ytFmO6/8pn+v+cvXc/8p2uav3Q985+uaf4zxiw+2jZBM4xOREREREREREQKnpJNIiIiIiIiIiKSb0pysmmy1wGUcLq+BUvXt2Dp+hY8XeOCpesrRZV+NvOfrmn+0vXMf7qm+UvXM//pmua/o17TElsgXERERERERERECl9J7tkkIiIiIiIiIiKFTMkmERERERERERHJN8U62WSM6W+MWWOMWWuMGZ3L68YY84Lv9V+MMW28iLO4ysP1Heq7rr8YY34wxrT0Is7i7GjXOGC79saYdGPMuYUZX3GXl+trjOlpjFlmjFlhjPmmsGMszvLwOyLeGPOBMWa57/pe7kWcxZUxZooxZqsx5rfDvK7POCmSjDEP+X4mlxljPjfGVPM6puLOGPOkMWa177rONsaU8Tqm4swYc57vcynDGKPp0I9TXu9jJW+O9rkvx84YU9MY87UxZpXv//xNXsdUnBljoowxiwLu7R840vbFNtlkjAkFxgOnAU2AC40xTXJsdhrQwLcMByYUapDFWB6v719AD2ttC+AhVHjtmOTxGmdu9zjwWeFGWLzl5fr6btZfAs6y1jYFzivsOIurPP78XgestNa2BHoCTxtjIgo10OLt/4D+R3hdn3FSVD1prW1hrW0FfAjc63E8JcEXQDPfPdfvwF0ex1Pc/QYMAr71OpDiKq/3sXJM/o8jf+7LsUsDbrPWNgY6Adfp5/SEHAR6++7tWwH9jTGdDrdxsU02AR2AtdbaP621KcAM4Owc25wN/Nc6C4EyxpiqhR1oMXXU62ut/cFau8vXXAjUKOQYi7u8/AwD3AC8C2wtzOBKgLxc34uAWdbaDQDWWl3jvMvL9bVAnDHGAKWAnbgPfckDa+23uGt2OPqMkyLJWrs3oBmL+10gJ8Ba+7m1NvP3p+65TpC1dpW1do3XcRRzeb2PlTzKw+e+HCNr7WZr7c++54nAKqC6t1EVX757zn2+ZrhvOexnfHFONlUH/g5ob+TQH5y8bCO5O9ZrdyXwSYFGVPIc9RobY6oD5wATCzGukiIvP8MnAWWNMfOMMUuMMZcWWnTFX16u74tAY2AT8Ctwk7U2o3DCCwr6jJMiyxgzzhjzNzAU9WzKb1egey7xnj6DpFgxxtQGWgM/ehxKsWaMCTXGLMN1hPjCWnvY6xlWaFHlP5PLupxZtbxsI7nL87UzxvTCJZu6FmhEJU9ervFzwChrbbrrHCLHIC/XNwxoC/QBooEFxpiF1trfCzq4EiAv1/dUYBnQG6gHfGGM+S5Hrwc5fvqME88YY74EquTy0lhr7XvW2rHAWGPMXcD1wH2FGmAxdLRr6ttmLK6H6LTCjK04ysv1lBOizyApNowxpXAjRW7WfeiJsdamA6185UhmG2OaWWtzrTNWnJNNG4GaAe0auG/Pj3UbyV2erp0xpgXwCnCatXZHIcVWUuTlGrcDZvgSTRWA040xadbaOYUSYfGW198R2621+4H9xphvgZa4ehhyZHm5vpcDj1lrLbDWGPMX0AhYVDghlnj6jBPPWGv75nHT6cBHKNl0VEe7psaYy4AzgD6+36tyBMfwMyrHR59BUiwYY8JxiaZp1tpZXsdTUlhrdxtj5uHqjOWabCrOw+h+AhoYY+r4Cs5eALyfY5v3gUt9M/Z0AvZYazcXdqDF1FGvrzEmAZgFXKKeIMflqNfYWlvHWlvbWlsbeAe4VommPMvL74j3gG7GmDBjTAzQETeWW44uL9d3A67XGMaYykBD4M9CjbJk02ecFEnGmAYBzbOA1V7FUlIYY/oDo3ATWiR5HY8IebsPEPGUr27oq8Aqa+0zXsdT3BljKmbOhmqMiQb6coTP+GLbs8lam2aMuR43Q1coMMVau8IYM8L3+kTgY+B0YC2QhPuWXfIgj9f3XqA88JKv502atVbTx+ZRHq+xHKe8XF9r7SpjzKfAL0AG8MrhuoFKdnn8+X0I+D9jzK+47vajrLXbPQu6mDHGvImbxa+CMWYjrmdIOOgzToq8x4wxDXG/V9cDIzyOpyR4EYjEDUcGWGit1XU9TsaYc4D/ABWBj4wxy6y1p3ocVrFyuPsAj8Mq1nL73LfWvuptVMVeF+AS4FdfnSGAMdbaj70LqVirCrzmm40yBHjbWvvh4TY26oUrIiIiIiIiIiL5pTgPoxMRERERERERkSJGySYREREREREREck3SjaJiIiIiIiIiEi+UbJJRERERERERETyjZJNIiIiIiIiIiKSb5RsEpFiyRjTxhiTboyxxpi2+XzsUGPMGt+xH83PY4uIiIiIiJR0SjaJSHE1Hvc77ANr7ZL8PLC1Nh142Ne81RhTPz+PLyIiIiIiUpIp2SQixY4xZhDQyde8v4BOMx34HYgAHiqgc4iIiIiIiJQ4SjaJSHF0v+/xU2vtzwVxAl/vpid8zSHGmCYFcR4REREREZGSRskmESlWjDGnAs19zf8W8OlmAsmAAW4u4HOJiIiIiIiUCEo2iUhxM9L3uA94ryBPZK3dC3zga15sjIkryPOJiIiIiIiUBEo2iUiBMsb09M3qZo0x9/vWNTfGTDbG/GGMOWCM2WaM+dIYc+FRjlUeON3XnG2tTTrMdvcHnDOvS8/DnHaa7zEaOPdY37+IiIiIiEiwUbJJRAqVMeYS4CfgaqAuEAVUAPoA040xHxpjog6z++lAuO/51wUdq888wPqen11I5xQRERERESm2wrwOQESCSntgjO/5FOBbIN23/kogFhgAvEHuvYhOCXi+6AjnmQEsO0osZYGXcMkugD25bWSt3WOMWQ00BvoYY0J9xcNFREREREQkF8Zae/StRESOk294WmAvpESgn7V2YY7tGuB6EVXzrTrXWvtujm3WACf5jlHGWptxnDGFAZ8BvX2rxllr7z7C9lOBYb5mS2vtL8dzXhERERERkWCgYXQiUtjuyJloArDW/g/XuynT7YGvG2MigQa+5v+ON9HkM56sRNO7wD1H2X5VwPMWJ3BeERERERGREk/JJhEpTLuAqYd70Vr7KbDS1+xkjKkS8HJNwPie7zzeAIwxNwPDfc2fgUvt0bt47gp4Xut4zy0iIiIiIhIMlGwSkcL0nbU25SjbfBXwvH3A83IBz48r2WSMOQ14ytfcDJx1uBntctgR8Lzs8ZxbREREREQkWCjZJCKFae0xblMt4HlkwPPEYz2xMaYprnB4KHAAONta+08ed98b8Dz6WM8tIiIiIiISTJRsEpHClJdeRPsDnpcKeH4w4HnpYzmpMaYC8IFvPwsMs9b+dAyHiA94fuBYzi0iIiIiIhJslGwSkcIUk4dtYgOe7wt4Hjh0LnBI3REZYyKA2UAd36oHrLVv53X/XM533PWiREREREREgoGSTSJSmOof4zabAp5vADJnoMtzsgmYDHT1PX/LWvvAMeybKfB8649jfxERERERkaChZJOIFKauvp5GR9Ir4Ll/qJuvsPj/fM36xpij/v4yxowCLvM1FwHD8h5qNo0Dnv9ynMcQEREREREJCko2iUhhKkdW8ucQxph+QFNfc4G19t8cm/zoe4wDmhzpRMaYs4FHfM2NuILgycccsdPR95gIrDzOY4iIiIiIiAQFJZtEpLA9ZYxpn3OlMaYeMCVg1dO57PtFwPMOhzuBMaYVMA33O24/cFYuias8McbEAw19zbnW2vTjOY6IiIiIiEiwCPM6ABEJKh8DpwDfG2NeA74D0oH2wJVkzT43y1r77mH2TwEigJ5kT04Feo2sQuNvA7WMMbWOEtt8a+32XNb3BIzv+ZyjHENERERERCToGWut1zGISAlmjOkJfO1rPgCsBV4BIg+zy8fA4MMNeTPGzAYG4maqq2ytTcplm3XA0ZJLOfWy1s7L5VhvAecDB3znSzzG44qIiIiIiAQVDaMTkUJlrX0D15PpFeBPIBnYCXwFDLXWDjhKbaWXfI+lcEmnAmOMiQPO9DXfUKJJRERERETk6DSMTkQKnbX2V+Dq49z3C2PML0ALXLHx6blsU/uEAsxyHhANWOC5fDqmiIiIiIhIiaaeTSJSHN3ve+xnjGlbECcwxoQCd/qab1lrNQudiIiIiIhIHijZJCLFjrV2NrDA17y/gE5zIW4WuhTgngI6h4iIiIiISImjZJOIFFfXAxnAGcaYdvl5YF+vprt9zWestWvz8/giIiIiIiIlmWo2iUixZK39GQgtoGOnA40K4tgiIiIiIiIlnZJNIiIiIpIvypQpY+vXr+91GCXK/v37iY2N9TqMEkPXM39t2rSJylu3Epqenqftf41oS0oKhIVBlSpQsSKEaKxNNvoZzX+6pvlvyZIl2621FY+0jZJNIlKgrLXzAON1HCIiUvAqV67M4sWLvQ6jRJk3bx49e/b0OowSQ9czf91xx1M8/tSdeavNUqsWrFvMd9/BAw/A3LmQlgajRsE110B0dEFHWzzoZzT/6ZrmP2PM+qNtozyyiIiIiIiI5NnWrXDHHfDcczexgZpH3yEmBsaNA6BbN/jyS/j2W2jSBG65BerWheeegwMHCjZuESk8SjaJiIiIiIhInsycCXXqwDPPQJMmK5l3Sg+XTAoUEQHly4MxrkfT5MkwdGi2Tbp1c72bvvkGGjd2SacGDWD58kJ8MyJSYJRsEhERERERkaOaPh0uuABatYKVK2HQoDms71LPJZNq1cpKLk2ZAtu3Q0YGrFt3SKIpUPfu8NVXMG+e2713b/j558J6RyJSUFSzSURERERERI7ov/+Fyy93PZI+/BBKlQp4cejQIyaU8qJHD9fLqVcv6NMHPv8c2rc/sZhLgtTUVDZu3EhycrLXoRRb8fHxrFq1yuswiqWoqChq1KhBeHj4Me+rZJOIiIiIiIgc1pQpcNVVrtfR++8fOmouv9St6xJOvXtD376w+NZpNJg6FjZsgIQEV/fpBJNaxc3GjRuJi4ujdu3aGKM5d45HYmIicXFxXodR7Fhr2bFjBxs3bqROnTrHvL+G0YmIiIiIiEiuJk2CK6+Efv3ggw8KLtGUqXZtl3C6Imoa1e8fDuvXg7XucfhwmDatYAMoYpKTkylfvrwSTVLojDGUL1/+uHvVKdkkIiIiIiIihxg/HkaMgAEDYM4ciI4unPPWrAlPho8lhqTsLyQlwdixhRNEEaJEk3jlRH72lGwSERERERGRbJ57Dq6/Hs4+G959F6KiCvf8YZs25P7ChsOsF5EiRckmERERERER8Rs/Hm65BQYPhpkzITLSgyASEo5tvRSYk08+Od+PuW7dOqZPn57vx80vpbJVwM/d/fffz1NPPQXAvffey5dffnnYbefMmcPKlSsP+/rEiRP573//C0DPnj1ZvHhxnmPdvXs3L730kr+9adMmzj333DzvX1CUbBIREREREREAfv7ZJZrOPBPefBOOYxKq/DFu3CEFopJMDPvGjPMooOD1ww8/5PsxCzLZlJ6eXiDHPZIHH3yQvn37Hvb1IyWb0tLSGDFiBJdeeulxnTtnsqlatWq88847x3Ws/KRkk4iIiIiIiJCU5CZ7q1gRpk71MNEELpDJk6FWLTCGg1VqcQ2TuXLuUKz1MC4P3Xwz9OyZv8vNNx/9vJm9fObNm0fPnj0599xzadSoEUOHDsX6/jFq167NqFGj6NChAx06dGDt2rUADBs2LFviI/NYo0eP5rvvvqNVq1Y8++yz2c53pPPMnTuX1q1b07x5c6644goOHjzoP/+DDz5I165dmTlzJrVr12bMmDF07tyZHj168PPPP3PqqadSr149Jk6cCMC+ffvo06cPbdq0oXnz5rz33ntHvRbjxo2jYcOG9O3blzVr1vjXB77P0aNH06RJE1q0aMHtt9/ODz/8wPvvv88dd9xBq1at+OOPP+jZsydjxoyhR48ePP/889l6SQG88cYbnHzyyTRr1oxFixYBHLJNs2bNWLduHaNHj+aPP/6gVatW3HHHHaxbt45mzZoBrsD85ZdfTvPmzWndujVff/01AP/3f//HoEGD6N+/Pw0aNODOO+886ns/VmH5fkQREREREREpdu68E1avhi++gPLlvY4Gl3AaOhSASKDxI64++BlnwCWXeBtasFq6dCkrVqygWrVqdOnShe+//56uXbsCULp0aRYtWsR///tfbr75Zj788MPDHuexxx7jqaeeOuw2uZ2nXbt2DBs2jLlz53LSSSdx6aWXMmHCBG72ZcyioqKYP38+4BI+NWvWZMGCBVx33XUMGzaM77//nuTkZJo2bcqIESOIiopi9uzZlC5dmu3bt9OpUyfOOuuswxbFXrJkCTNmzGDp0qWkpaXRpk0b2rZtm22bnTt3Mnv2bFavXo0xht27d1OmTBnOOusszjjjjGzD23bv3s0333wDuERSoP379/PDDz/w7bffcsUVV/Dbb78d8Vr+9ttvLFu2DHC9xjKNHz8egF9//ZXVq1fTr18/fv/9dwCWLVvG0qVLiYyMpGHDhtxwww3UrFnzsOc5Vko2iYiIiIiIBLmPP3a1mm69FY4wGshTo0bBp5/C11dP44LRYwnfvMHVcBo3zp+UKsmee87rCKBDhw7UqFEDgFatWrFu3Tp/sunCCy/0P95yyy35fp64uDjq1KnDSSedBMBll13G+PHj/cmmIUOGZDvGWWedBUDTpk1JSUkhLi6OuLg4oqKi2L17N7GxsYwZM4Zvv/2WkJAQ/vnnH7Zs2UKVKlVyjem7777jnHPOIcY3vDPz+IFKly5NVFQUV111FQMGDOCMM8447HvMGW+gzGvZvXt39u7dy+7duw+77ZHMnz+fG264AYBGjRpRq1Ytf7KpT58+xMfHA9CkSRPWr1+fr8kmDaMTEREREREJYlu3wuWXQ/Pm8MgjXkdzeKGh8O6gabx4cDjhm9aDtbB+PQwfDtOmeR1eUIgMqBYfGhpKWlqavx3YIyjzeVhYGBkZGQBYa0lJSTnu89ijjJ+MjY3N9RghISHZjhcSEkJaWhrTpk1j27ZtLFmyhGXLllG5cmWSk5OPeI7D9XrKFBYWxqJFixg8eDBz5syhf//+eY73SOcxxmS7lsBRYwWOeM2O9G+ZH5RsEhERERERCVLWwlVXwZ49MH26RzPPHYOKz40lhqTsK5OS3Pg68dRbb73lf+zcuTPgaiktWbIEgPfee4/U1FQA4uLiSExMPKbjN2rUiHXr1vnrQb3++uv06NHjuOPds2cPlSpVIjw8nK+//pr169cfcfvu3bsze/ZsDhw4QGJiIh988MEh2+zbt489e/Zw+umn89xzz/mHth3r+828lvPnzyc+Pp74+Hhq167Nzz//DMDPP//MX3/9ddRjd+/enWm+ROzvv//Ohg0baNiwYZ7jOBEaRiciIiIiIhKkJk+GDz5wQ7R8NYWLtg0bjm29FJqDBw/SsWNHMjIyePPNNwG4+uqrOfvss+nQoQN9+vTx9+Zp0aIFYWFhtGzZkmHDhuVp2F1UVBRTp07lvPPOIy0tjfbt2zNixIjjjnfo0KGceeaZtGvXjlatWtGoUaMjbt+mTRuGDBlCq1atqFWrFt26dTtkm8TERM4++2ySk5Ox1vqLn19wwQVcffXVvPDCC3maKa5s2bKcfPLJ7N27lylTpgAwePBg/vvf/9KqVSvat2/vH05Yvnx5unTpQrNmzTjttNO47rrr/Me59tprGTFiBM2bNycsLIz/+7//y9ajqSCZo3VFExERERHJi4YNG9rA2XnkxGXOyiT5Q9czuzVroHVr6NYNPvkEQo5x3MsDDzwAwH333VcA0R1G7dpu6FxOtWpBQGHk4irnz+iqVato3LixdwHlUe3atVm8eDEVKlTwOpRDJCYmEhcX53UYxVZuP4PGmCXW2nZH2k/D6ERERERERIJMSoqrqR0TA1OnHnuiyTPjxrmgAxwMi3HrRaTIKC6/UkRERERERCSfPPAALFkCL78M1ap5Hc0xGDrUjf2rVQuMYVfpWlyeNpk5sSV/NrqibN26dUWyV5N4R8kmERERERGRILJiBTz2GFxxBZxzjtfRHIehQ92QuYwMYretY1WroVx3Hezf73VgIpJJySYREREREZEgcscdEBcHTzzhdSQnLiICXnwRNm2Cp5/2OhoRyaRkk4iIiIiISJD44gtXDPzuu6F8ea+jyR9dusDgwS55tnmz19GICCjZJCIiIiIiEhTS0+H226FOHbjhBq+jyV+PP+6Knt97r9eRiAgo2SQiIiISlIwx/Y0xa4wxa40xo3N5vacxZo8xZplv0Z9wIsXca6/BL7+4ek2RkV5Hk7/q1YPrr4cpU+DXX72OxkPTpkHt2m56wdq1XfsEnXzyySd8jJzWrVvH9OnT87TtsGHDeOedd/I9hqKmpL1PJZtEREREgowxJhQYD5wGNAEuNMY0yWXT76y1rXzLg4UapIjkq3373NC5zp3hvPO8jqZg3H03xMe73ltBado0GD4c1q8Ha93j8OEnnHD64Ycf8inALMeSbDqc9PT0fIpGCoKSTSIiIiLBpwOw1lr7p7U2BZgBnO1xTCJSgJ56ytUzevppMMbraApGuXJuGN3nn8Onn3odjQfGjoWkpOzrkpLc+hNQqlQpAObNm0fPnj0599xzadSoEUOHDsVaC0Dt2rUZNWoUHTp0oEOHDqxduxY4tLdO5rFGjx7Nd999R6tWrXj22Weznc9ay/XXX0+TJk0YMGAAW7du9b9Wu3ZtHnzwQbp27crMmTN5+eWXad++PS1btmTw4MEkJSWRnp5O3bp1sdaye/du4uPj+fbbbwHo1q0ba9eu5f777+eKK66gZ8+e1K1blxdeeOGQ952ens6wYcNo1qwZzZs398eZ2zkz3+vIkSPp1asXdevW5ZtvvuGKK66gcePGDBs2LNs1uO2222jTpg19+vRh27Zth5x7yZIl9OjRg7Zt23Lqqaey2VeM7IUXXqBJkya0aNGCCy644Bj+FQtfmNcBiIiIiEihqw78HdDeCHTMZbvOxpjlwCbgdmvtipwbGGOGA8MBKlasyLx58/I/2iC2b98+XdN8FKzXc/v2CB5/vCM9euzg4MGV5PclKErXtGlTQ7VqHRg5MoNXXllMaKj1OqRjkvNnND4+nsTExDztW2rDBnLLI9oNG9iXx2McTmJiIklJSSxdupQff/yRqlWrcsopp/DFF1/QuXNnrLVERkYyd+5cpk+fzvXXX8/MmTNJTU3lwIED2d5DYmIi9957Ly+88AIzZ870r8v0/vvvs3LlSn744Qe2bt1Khw4duPDCC0lMTMRaizGGTz75BIAdO3b4ky4PPvgg48ePZ8SIEdStW5effvqJdevW0apVK7788kuaNGnC33//TeXKlTl48CArVqzgo48+Yt++fbRp04aLL76Y8PBwfxxLly5lw4YNLFiwAIDdu3eTmJjIKaeckus5U1NTSUxM5L333uPjjz/mzDPP5PPPP+fZZ5+lZ8+efP/997Ro0YL9+/fTuHFj7r//fh577DHGjh3L008/7b9WO3fu5Nprr2XGjBlUqFCBd999lzvvvJOXXnqJRx99lF9//ZXIyEh/PAUtOTn5uP6PK9kkIiIiEnxy/XskR/tnoJa1dp8x5nRgDtDgkJ2snQxMBmjYsKHt2bNn/kYa5DJ7Ekj+CNbreeWVkJEBU6ZUom7dSvl23G+++QagyF3TF16Ac8+FP//swdVXex3Nscn5M7pq1Sri4uLytnNCghs6l4NJSMj7MQ4jLi6OmJgYOnToQKNGjQBo27YtW7duJS4uDmMMw4YNIy4ujiuuuIIxY8YQFxdHeHg40dHR2c6feaywsLBc4/rpp5+4+OKLKVOmDGXKlKF3797+YxhjuPTSS/37/fzzz1xyySXs3r2bffv2ceqppxIXF0evXr1YsmQJf/31F7fddhtvvPEGq1evpkOHDsTFxREZGclZZ51FhQoVqFChApUrVyYpKYkaNWr442jevDnr169nzJgxDBgwgH79+hESEnLYc4aHh3P66adTunRpOnToQOXKlenUqZP/WNu2bSMuLo6QkBCGDRtGWFgYV155JYMGDcp2rTZt2sSqVas455xzANfDqmrVqsTFxdGyZUtGjBjBwIEDGThwoL+nWEGKioqidevWx7yfhtGJiIiIBJ+NQM2Adg1c7yU/a+1ea+0+3/OPgXBjTIXCC1FE8sPy5TB1qpt9rm5dr6MpHIMGQdeucM89UAgdP4qOceMgJib7upgYtz6fRAZUlg8NDSUtLc3fNgHjMzOfh4WFkZGRAbjhcSkpKXk6jznCWM/Y2Fj/82HDhvHiiy/y66+/ct9995GcnAy44XLfffcdixYtol+/fuzevZt58+bRvXv3PL0XgLJly7J8+XJ69uzJ+PHjueqqq454zsBjhoSEZDt+SEjIIcc/3Hu11tK0aVOWLVvGsmXL+PXXX/n8888B+Oijj7juuutYsmQJbdu2PewxiwIlm0RERESCz09AA2NMHWNMBHAB8H7gBsaYKsZ3B2yM6YC7b9xR6JGKyHGz1hXLLlv2hMv2FCvGuNpUW7bAE094HU0hGjoUJk+GWrXcRahVy7WHDi2U07/11lv+x86dOwOuxtKSJUsAeO+990hNTQVc76bDDQHr3r07M2bMID09nc2bN/P1118f9pyJiYlUrVqV1NRUpgUUQu/YsSM//PADISEhREVF0apVKyZNmkS3bt3y/H62b99ORkYGgwcP5qGHHuLnn38+4jnzKiMjw1/Havr06XTt2jXb6w0bNmTbtm3+4XupqamsWLGCjIwM/v77b3r16sUTTzzh71lVVGkYnYiIiEiQsdamGWOuBz4DQoEp1toVxpgRvtcnAucCI40xacAB4AKbWQlWRIqFTz6BL7+E5593Cadg0qEDXHihSzpdcw0EjI4q2YYOLbTkUk4HDx6kY8eOZGRk8OabbwJw9dVXc/bZZ9OhQwf69Onj75XUokULwsLCaNmyJcOGDeOWW27xH+ecc87hq6++onnz5px00kn06NHjsOd86KGH6NixI7Vq1aJ58+b+BFZkZCQ1a9b0D2Pr1q0bb775Js2bN8/z+/nnn3+4/PLL/T2zHn300SOeM69iY2NZsWIFbdu2JT4+3p+kyxQREcE777zDjTfeyJ49e0hLS+Pmm2/mpJNO4uKLL2bPnj1Ya7nlllsoU6bMMZ27MBndM4iIiIhIfmjYsKFds2aN12GUKMFaY6igBNP1TEuDFi3c42+/QURE/p/jgQceAOC+++7L/4Png3XroFEjGDIEXnvN62jyJreaTY0bN/YuoDyqXbs2ixcvpkKFojfaOjEx8YRrVuWnUqVKFekeSTnl9jNojFlirW13pP00jE5ERERERKSEeeMNWLUKHn+8YBJNxUHt2nDTTfD667DikLk0RaQgKdkkIiIiIiJSgqSnw2OPQatWMHCg19F46847XY3sxx/3OpKSbd26dUWyV1NRVJx6NZ0IJZtERERERERKkFmzYM0aGDPG1YkOZuXLu5pN06fDn396Hc3xUekb8cqJ/Owp2SQiIiIiIlJCWAuPPAING8KgQV5HUzTcdhuEhsKTT3odybGLiopix44dSjhJobPWsmPHDqKioo5rf81GJyIiIiIiUkJ8+iksWwZTp7oEi0C1anD55TBlCtx7L1St6nVEeVejRg02btzItm3bvA6l2EpOTj7uhEmwi4qKosZxTuWoZJOIiIiIiEgJ8cgjkJAAQ4d6HUnRcued8PLL8MwzxauHU3h4OHXq1PE6jGJt3rx5tG7d2uswgo6G0YmIiIiIiJQA330H8+fDHXdAeLjX0RQtdevChRfChAmwc6fX0YiUfEo2iYiIiIiIlADjxkGlSnDllV5HUjSNHg3798MLL3gdiUjJp2STiIiIiIhIMbdkCXz2Gdx6K0RHex1N0dSsGQwc6JJNiYleRyNSsinZJCIiIiIiUsw9+ijEx8PIkV5HUrTddRfs2gWTJnkdiUjJpmSTiIiIiIhIMbZqFcyaBTfcAKVLex1N0dahA/TtC08/DcnJXkcjUnIp2SQiIiIiIlIcTZsGtWvTqEkI66jNHdWneR1RsTBmDPT6dxqp1WtDSAjUru2upYjkmzCvAxAREREREZFjNG0aDB8OSUkYIMGuh9uGQxwwdKjX0RVpPTdNo1PIcKJ3JrkV69e7awm6diL5RD2bREREREREipuxYyEpKfu6pCS3Xo7IjB1LdIaunUhBUrJJRERERESkuNmw4djWSxZdO5ECp2STiIiIiIhIcZOQcGzrJYuunUiBU7JJRERERESkmEm+dxxJxGRfGRMD48Z5E1BxMm6cu1aBdO1E8pWSTSIiIiIiIsXMa6lDuYrJJFeuBcZArVowebIKXOfF0KHuWtWqhcWwjlqsG6trJ5KfNBudiIiIiIhIMWItvPACRLUZSuTioWC8jqgYGjoUhg5l9y5oWgOGrIUpXsckUoKoZ5OIiIiIiEgxMncurFwJN93kOjXJ8StbFi67DKZPh23bvI5GpORQsklERERERKQYef55qFQJhgzxOpKS4YYb4OBBN7JORPKHkk0iIiIiIiLFxNq18NFHMGIEREZ6HU3J0Lgx9OsHL70EqaleRyNSMijZJCIiIiIiUky8+CKEhblkk+Sfm26CTZvg3Xe9jkSkZFCySUREREREpBjYuxemTIHzz4eqVb2OpmTp3x8aNHBDFEXkxCnZJCIiIiIiUgy89hokJrpeOJK/QkJc7aaFC2HRIq+jESn+lGwSEREREREp4jIy4D//gU6doH17r6MpmYYNg7g4eOEFryMRKf6UbBIRERERESniPv0U/vc/9WoqSHFxcMUV8PbbsHmz19GIFG9KNomIiIiIiBRxzz8P1arB4MFeR1KyXX89pKXBhAleRyJSvCnZJCIiIiIiUlRNm0ZKtdp88nkIK/bXJvztaV5HVKLVrw8DBsDEiXDwoNfRiBRfSjaJiIiIiIgURdOmwfDhRGxeTwiWMnvWw/Dhbr0UmJtugm3bYMYMryMRKb6UbBIRERERESmKxo6FpKTs65KS3HopMH36QJMmbuiitV5HI1I8KdkkIiIiIiJSFG3YcGzrJV8YAzfeCEuXwvffex2NSPGkZJOIiIiIiEgRZGsm5P5CwmHWS765+GIoWxZeeMHrSESKJyWbREREREREiqBl549jPzHZV8bEwLhx3gQURGJj4YorYPZs2LzZ62hEih8lm0RERERERIqge1cP5fbSk7EJtdzYrlq1YPJkGDrU69CCwjXXQFoavPqq15GIFD9KNomIiIgEIWNMf2PMGmPMWmPM6CNs194Yk26MObcw4xMJduvXw0cfQfkbhmLWr4OMDFi3TommQtSgAfTt6/J76eleRyNSvCjZJCIiIhJkjDGhwHjgNKAJcKExpslhtnsc+KxwIxSRl192j1df7W0cwW7ECOj69zQOVq0NISFQuzZMm+Z1WCJFnpJNIiIiIsGnA7DWWvuntTYFmAGcnct2NwDvAlsLMziRYJeaCq+8AgMGuJFz4p2z90/jFYYTs209WOu6nA0froSTyFGEeR2AiIiIiBS66sDfAe2NQMfADYwx1YFzgN5A+8MdyBgzHBgOULFiRebNm5ffsQa1ffv26Zrmo+JyPefNq8iWLU05+eRfmDdvp9fhHFVxuKbHq9OdtxFDUvaVSUkk33YbC6tXz/fzFZef0eJE19QbSjaJiIiIBB+Tyzqbo/0cMMpam25Mbpv7drJ2MjAZoGHDhrZnz575FKKA+yNe1zT/FJfr+dBDrkfTnXe2IDTU62gO75tvvgEoFtf0uG3NvWNn1NatBfK+i8vPaHGia+oNJZtEREREgs9GoGZAuwawKcc27YAZvkRTBeB0Y0yatXZOoUQoEqTWrIGvvoJx4yjSiaagkZDghs7ltl5EDks1m0RERESCz09AA2NMHWNMBHAB8H7gBtbaOtba2tba2sA7wLVKNIkUvEmTICwMrrzS60gEcFm/mJjs62Ji3HoROSwlm0RERESCjLU2DbgeN8vcKuBta+0KY8wIY8wIb6MTCV4HDsD//R8MGgSVK3sdjQAwdChMnoxNqEUGhn8ja8HkyW69iByWhtGJiIiIBCFr7cfAxznWTTzMtsMKIyaRYPf227BrF4wc6XUkks3QoZihQ3nicRg9Gla2gcZexyRSxKlnk4iIiIiISBEwYQI0agQ9engdieTm8sshPBwm5pqWF5FASjaJiIiIiIh4bOlS+PFHGDECjjABpHioUiU491x47TVISvI6GpGiTckmERERERERj02cCNHRcOmlXkciRzJiBOzZAzNmeB2JSNGmZJOIiIiIiIiH9u6FadPgggugbFmvo5Ej6dYNmjTRUDqRo1GySURERERExEPTpsH+/a7XjBRtxrh/p59+giVLvI5GpOhSsklERERERMQj1rrC4G3aQPv2XkcjeXHppRATo95NIkeiZJOIiIiIiIhHFiyAX39VYfDiJD4eLrwQpk939ZtE5FBKNomIiIiIiHhk0iSIi3PJCyk+RoxwM9JNm+Z1JCJFk5JNIiIiIiIiHti1C95+G4YOhVKlvI5GjkXbttC6tUsWWut1NCJFj5JNIiIiIiIiHnjjDUhOhuHDvY5EjpUx7t/tl19csXARyU7JJhERERERkUJmresV07696yEjxc9FF0FsLEye7HUkIkWPkk0iIiIiIiKFbMECWLFCvZqKs9KlXa2tN99UoXCRnJRsEhERERERKWSTJ7vC4Bdc4HUkciKGD3eFwqdP9zoSkaJFySYREREREZFCtGsXvPWWCoOXBO3aqVC4SG6UbBIRERERESlEKgxecmQWCl++XIXCRQIp2SQiIiIiIlJIrHVD6DJ7xEjxp0LhIodSsklERERERKSQLFgAv/0G11zjdSSSXwILhe/d63U0IkWDkk0iIiIiIiKFZPJkV6dJhcFLFhUKF8lOySYREREREZFCoMLgJVe7dtCqlQqFi2RSsklERERERKQQqDB4yZVZKHzZMli82OtoRLynZJOIiIiIiEgBCywM3qaN19FIQRg6FGJiVChcBJRsEhERERERKXALF7rC4OrVVHKpULhIljCvAxARERGR7IwxlYAOQAugFlAWiAYOADuB9cAvwCJr7Tav4hSRvJs0SYXBg8Hw4fDqq65Q+IgRXkcj4h0lm0RERESKAGNMPeBi4Gyg5THstwyYA7xhrf2rQIITkROSWRj8sssgLs7raKQgtW+fVSj8mmtcLSeRYKRhdCIiIiIeMsb0M8Z8CvwO3ItLNJljWFoB9wNrjTGfGGNOKeS3ICJHocLgwUOFwkUc9WwSERER8YAxpivwGNA5c5XvcQewCPgRWAXs8q3bC8QD5XxLY6AjbrhdOd++/YB+xpgfgNHW2u8L/p2IyJFY63q5tG2rwuDBYuhQuP129+/evr3X0Yh4Q8kmERERkUJmjJkGXEBWgmkj8CYwzVr7y3EcrwVwEXAhUBPoAnxrjHnTWntx/kQtIsfjhx9gxQp4+WWvI5HCUro0XHSRq9v09NMQH+91RCKFT8PoRERERArfhbhE01dAX2ttgrV21PEkmgCstb9Ya0dba2sBfX3HNb7ziIiHJk1ydZpUGDy4XHMNJCXBtGleRyLiDSWbRERERArfV0A3a21fa+1X+Xlga+1X1tq+QDffeUTEIzt3wttvw8UXu5noJHi0a+eGTU6c6IZSigQbJZtERERECpkvyVSg9ZSstd9ba1UsXMRDr70GBw+6Xi4SfK65Bn79FRYu9DoSkcKnZJOIiIiIiEg+yywM3qkTtGzpdTTihQsvdD3aJk3yOhKRwqdkk4iIiIiISD779ltYs0a9moJZXJwbQvnWW7Brl9fRiBQuJZtEREREighjTLkT3P/0/IpFRE7MpEluFrLzz/c6EvHSNddAcjK8/rrXkYgULiWbRERERIqOX40xvY91J2NMhDHmP8AHBRCTiByjbdvgnXfgsssgJsbraMRLrVpBhw4qFC7BR8kmERERkaKjKvC5MeZxY0xYXnYwxjQDFgPXHsuJjDH9jTFrjDFrjTGjc3n9bGPML8aYZcaYxcaYrsdyfJFg9n//B6mpGkInzjXXwKpVMH++15GIFB4lm0RERESKjnTAALcDC4wx9Y+0sTHmBmAR0NS335q8nMQYEwqMB04DmgAXGmOa5NhsLtDSWtsKuAJ4Je9vQyR4ZWTA5MnQtSs0yfm/SoLSkCFuSKUKhUswUbJJREREpOjoBqzDJY7aAEuNMZfn3MgYU9EY8yHwHBDl2/4VoF0ez9MBWGut/dNamwLMAM4O3MBau89a/6CPWEADQETy4OuvYe1aGDHC60ikqIiNhUsucUMrt2/3OhqRwpGn7tkiIiIiUvCstQuNMS2BCcBQXJLnFWNMf2C4tXaP7/lUoBIuybQLuNpaO+sYTlUd+DugvRHomHMjY8w5wKO+cw3I7UDGmOHAcICKFSsyb968YwhDjmbfvn26pvmoMK7nQw81oXTpslSsuIB58zIK9FxFhX5Gj65Nm1gOHmzPvfeu5fzzNx52O/2fz3+6pt4wVlXKRERERIocY8yFwEtAPK5X0d+4oW3DcEkmgHnAJdbaf47x2OcBp1prr/K1LwE6WGtvOMz23YF7rbV9j3Tchg0b2jVr8jSST/Jo3rx59OzZ0+swSoyCvp7//gs1a8KNN8LTTxfYaYqMBx54AID77rvP40iKhy5dXM+m1avBmNy30f/5/Kdrmv+MMUustUfsTa1hdCIiIiJFkLX2TaA18AMuuZRAVqIpBRgD9DnWRJPPRqBmQLsGsOkIsXwL1DPGVDiOc4kEjalTIS0Nhg/3OhIpikaMgN9/B3WykWCgZJOIiIhIEWWtXQe8mdkMePwUeNoefxf1n4AGxpg6xpgI4ALg/cANjDH1jXHfvRtj2gARwI7jPJ9IiZdZGLxXL2jY0OtopCg691woW1aFwiU4KNkkIiIiUgQZY8oaY2YBL+ASTIas2erOBBYZYxodz7GttWnA9cBnwCrgbWvtCmPMCGNMZlnjwcBvxphluJnrhpxAckukxPv8c1i3zk1zL5Kb6Gi47DKYNQu2bvU6GpGCpWSTiIiISBFjjOkF/IKbIc4Au4HzcUW8f/etawEsCUgOHRNr7cfW2pOstfWsteN86yZaayf6nj9urW1qrW1lre1srZ1/wm9MpCSaNg1q16bfaSFsCKnN4ORpXkckRdjw4ZCa6oZcipRkSjaJiIiIFBHGmDBjzGPAF0A1XFLpW6CltfYda+1SXB2nV32vRQPjjTHvGWPKexW3SNCaNs1lD9avJwRLzYz1hF073K0XyUXjxtCjB0ycCOnpXkcjUnCUbBIREREpOhYAd+Du0dKBe4Fe1lr/PNnW2gPW2quBc4GduKTTGcCvxphTCj9kkSA2diwkJWVfl5Tk1oscxnXXuSGXn3zidSQiBUfJJhEREZGioy0uefQX0M1a+/Dh6iRZa2cBrYBvfPtUAT4upDhFBGDDhmNbLwIMHAjVqsH48V5HIlJwlGwSERERKVreAFpZa3882oa+Hk+9gbFAKrq3EylcCQnHtl4ECA93oy8//RTWrvU6GpGCoRsSERERkaLjUmvtpdbaxLzuYJ1Hga7AHwUXmogcYtw4DoTEZF8XEwPjxnkTjxQbw4dDWBhMmOB1JCIFQ8kmERERkSLCWvvGCez7E654uIgUkqVNhnJlxmT2lq0FxkCtWjB5Mgwd6nVoUsRVrQqDBsGUKYeW/RIpCZRsEhERESkhrLX7vY5BJJiMHw9zooeS/sc6yMhwVZ+VaJI8uu462L0bpk/3OhKR/Kdkk4iIiIiIyDHatcslCYYOhbJlvY5GiqNu3aBZM5e0zH0qCJHiS8kmERERkUJmjCmU4W7GmDaFcR6RYDR1Khw44HqniBwPY+D662HZMliwwOtoRPKXkk0iIiIihW+xMWa2MaZlQRzcGNPaGPMesKggji8S7DIy4KWXoEsXaNXK62ikOBs6FEqXdr2bREoSJZtEREREvHEW8LMx5kNjzBBjTNSJHMwYE2WMucAY8wmwGDgT0MAMkQLw+efwxx/q1SQnrlQpGDYMZs6ELVu8jkYk/yjZJCIiIlL42uN6HRngNGA6sMUY83/GmMuMMY3zchBjTBNjzDBjzP8BW4BpQD/fcRcAHQoieJFgN348VK4Mgwd7HYmUBNdeC6mp8MorXkcikn/CvA5AREREJNhYa38GOhtjBgH3A82AOOAS34IxJhH4H7DTtyQCpYFyvqW+b59Mxvf4C3C/tXZOQb8PkWD011/w0UcwdixERHgdjZQEDRtC374wcSJ06mSOvoNIMaBkk4iIiIhHrLWzgFnGmH7ASOB0INz3cmngSAW+A/8iSQE+Bl6y1n5ZELGKiDNhAoSEwDXXeB2JlCTXXQfnnAPff1+ePn28jkbkxGkYnYiIiIjHrLWfW2vPAaoClwKvA7/7Xja5LBZYA/wX1xOqqrV2kBJNIgXrwAF49VU4+2yoUcPraKQkOeMMqFkT5syp7nUoIvlCPZtEREREighr7U7gDd+CMSYCqIkbNhcJHMQNqdtgrU31Kk6RYPXWW7BzpwqDS/4LC4MRI2Ds2LKsWgWN81S5T6ToUs8mERERkSLKWptirf3DWvuTtXa+7/EPJZpEvDF+vEsC9OrldSRSEl11FYSHZ/DSS15HInLilGwSERERERE5ioULYfFiN3OYUQ1nKQCVKkHPnlt57TXYu9fraEROjJJNIiIiIkWYMaaSMWaAMeZqY8wtvscBxphKXscmEkyefRbi4+Gyy7yOREqywYP/ITHR1QYTKc5Us0lERESkCDLGnAPcDnQ6wjYLgKestXMKKy6RYLRuHbzzDtx2G8TFeR2NlGQNGybSrRs8/zzccIOr5SRSHKlnk4iIiEgRYoyJMMa8DbyDSzTlNhtd5tIZeNcY87avmLiIFID//McNnbvhBq8jkWBw662wfj3Mnu11JCLHT3lSERERkaLlXeB0XDIJYCXwFbAW2A/EAvWBXkBT3zaDgSjgrEKNVCQI7N0LL78M55/vpqYXKWhnngn16sEzz8B553kdjcjxUbJJREREpIgwxlwADAAssAm40lr7dO2/vwAAIH1JREFU2RG27we8ClQHBhhjhlhr3yqUYEWCxKuvQmKi620iUhhCQ+Hmm11PugULoHNnryMSOXYaRiciIiJSdFzpe9wP9DhSognAWvs50BPY51t1VcGFJhJ80tJc7Zxu3aBdO6+jkWAybBiUKeN6N4kUR0o2iYiIiBQdLXG9ml611v6Rlx18272KG3bXquBCEwk+s2e72jnq1SSFrVQpuOYamDUL/vrL62hEjp2STSIiIiJFRynf40/HuF/m9jH5GItI0HvmGVc758wzvY5EgtH110NICLzwgteRiBw7JZtEREREio5NvsfQY9wvc/tNR9xKRPJswQJYuNDVzgk91v+RIvmgRg0YMgReeQX27PE6GpFjo2STiIiISNHxle+x2zHu1w03/O6ro20oInnzzDOuZs6wYV5HIsHslltg3z6XcBIpTpRsEhERESk6XgBSgEuNMe3zsoMxph1wGXDQt7+InKC//nK1cq65xtXOEfFK27bQo4crVJ+W5nU0InmnZJOIiIhIEWGt/Q24Glfs+wtjzFXGmLDctjXGhBljrgS+wPVquspau6LwohUpuV54wdXKuf56ryMRcQXq//4b3n3X60hE8i7XmxcRERERKXzGmHt9T78ATgcmAY8ZY74D1gJJuCLg9YGuQDnf9h8D9QP2P4S19sGCilukJNmzxw1ZGjLE1cwR8doZZ0D9+vD003D++WCM1xGJHJ2STSIiIiJFx/24XkoEPJYDzsplWxOwzem+5UiUbBLJg1decTVybrnF60hEnJAQ9/N43XXwww/QpYvXEYkcnYbRiYiIiBQtJseS27ojrT/ctiJyFGlprjZOjx6uVo5IUXHZZXBVzDQanFLbZZ9q14Zp07wOS+Sw1LNJREREpOjo5XUAIsHs3XddbZwXX/Q6EpHsYudMY3zKcCLSktyK9eth+HD3fOhQ7wITOQwlm0RERESKCGvtN17HIBKsrIVHH4UGDVyNHJEiZezYrERTpqQkGDtWySYpkjSMTkRERCQIGWP6G2PWGGPWGmNG5/L6UGPML77lB2NMSy/iFCksH30Ey5fDmDFulJJIkbJhw7GtF/GYfo2KiIiIBBljTCgwHjgNaAJcaIxpkmOzv4Ae1toWwEPA5MKNUqTwWAsPP+zK4KiTiBRJCQnHtl7EY0o2iYiIiASfDsBaa+2f1toUYAZwduAG1tofrLW7fM2FgCaBlxJr7lz48UcYPRrCw72ORiQX48ZBTEy2VRnRMW69SBGkmk0iIiIiwac68HdAeyPQ8QjbXwl8ktsLxpjhwHCAihUrMm/evHwKUQD27duna5qPDnc9b7+9FRUqRFOnzkLmzbOFH1gxp5/R/HPY//PVq1Pplluo+8orRG7ZygZq8n7L22hevTro+h+Rfo96Q8kmERERkeBjclmX61/YxpheuGRT19xet9ZOxjfErmHDhrZnz575FKKA+yNe1zT/5HY9v/vO1Wp67jno16+HJ3EVV9984+Y00M9o/jni//mePd14T+Cui+CDD2BdcyhfvtDCK5b0e9QbGkYnIiIiEnw2AjUD2jWATTk3Msa0AF4BzrbW7iik2EQK1bhxULEiXH2115GI5N2YMbBvH7zwgteRiOROySYRERGR4PMT0MAYU8cYEwFcALwfuIExJgGYBVxirf3dgxhFCtxPP8Fnn8Fttx1SDkekSGvWDM45xyWb9uzxOhqRQynZJCIiIhJkrLVpwPXAZ8Aq4G1r7QpjzAhjzAjfZvcC5YGXjDHLjDGLPQpXpMA8/DCULQsjR3odicixGzsWdu+Gl17yOhKRQ6lmk4iIiEgQstZ+DHycY93EgOdXAVcVdlwihWX5cnj/fbj/fihd2utoRI5d27Zw2mnwzDNw440QG+t1RCJZ1LNJRERERESCziOPQFyc+yNdpLi65x7Yvh0mT/Y6EpHslGwSEREREZGgsno1zJwJ11/vhtGJFFedO0Pv3vDkk5Cc7HU0IlmUbBIRERERkaDy6KMQFQW33OJ1JCIn7u67YfNmmDLF60hEsijZJCIiIiIiQePPP2HaNBgxAipW9DoakRPXsyecfDI8/jikpHgdjYijZJOIiIiIiASNxx+H0FC4/XavIxHJH8a43k0bNsDrr3sdjYijZJOIiIiIiASFf/6JZsoUuOoqqFbN62hE8k///tCuHTz4oGo3SdGgZJOIiIiIiASFV1+tQ0SE6wUiUpIY42qRbdgAEyZ4HY2Ikk0iIiIiIhIEFi+Gr7+uxG23QdWqXkcjkv/69oV+/eDhh2HPHq+jkWCnZJOIiIiIiJRo1sKoURAfn6JaTVKiPfYY7NwJTzzhdSQS7JRsEhERERGREu3zz+Grr+CSS9ZTurTX0YgUnNat4aKL4NlnYdMmr6ORYKZkk4iIiIiIlFgZGa5XU506cOaZ+utbSr6HHoK0NLj/fq8jkWCmZJOIiIiIiJRYb74Jy5e7OjYREdbrcEQKXN26MHIkvPoqrF7tdTQSrJRsEhERERGREungQTfzXOvWcMEFXkcjUnjuvhtiY2HMGK8jkWClZJOIiIiIiJRIEybAunXw+OMQor98JIhUrAh33AGzZ8OCBV5HI8FIv3JFRERERKTE2bPHDZ3r2xdOOcXraEQK3y23QOXKrmaZ1QhSKWRKNomIiIiISInz5JOwY4ebCl4kGJUqBffdB999Bx995HU0EmyUbBIRERERkRJl82Z45hlXp6ltW6+jEfHOVVdBgwYwejSkp3sdjQQTJZtERERERKREeeABN/X7uHFeRyLirfBweOQRWLECXn/d62gkmCjZJCIiIiIiJcbKlfDKKzBihJsCXiTYDR4MHTrAPffAvn1eRyPBQskmEREREREpEayFkSOhdGn3h7WIgDFuWOnGjfDgg15HI8FCySYRERERESkR/vtf+PZbePxxN/W7iDhdusAVV8Czz8Jvv3kdjQQDJZtERERERKTY27kTbr8dOneGK6/0OhqRoufxx12vv5EjISPD62ikpFOySUREREREir277oJdu2DCBAjRXzkih6hQAZ54AubPh9f+v707j7ayrvc4/v5yEDQRR0LFITNEwZElKFqGQwjqVdL0iiNUDiVX8V7MIY0hvZmmgUqlF03NaalgKuCA3vBqieKEKA4LLQWtHApnUeN3//ht4kgHzgE259nD+7XWWXs/z37Osz/nWQxrf87v+f2uKTqNap3/DEuSJEmqatOnwxVXwMknww47FJ1GqlxDhsBuu8Fpp8HbbxedRrXMskmSJElS1frss7zyXJcuMGpU0WmkytamTR79N38+nHFG0WlUyyybJEmSJFWtyy6DmTNhzBhYa62i00iVb/vtYdgwGD8e/vCHotOoVlk2SZIkSapKr70G55wDAwbAIYcUnUaqHiNHwiab5FGBn35adBrVIssmSZIkSVVp2LB8G91ll0FE0Wmk6tGhA1xyCcyalR+lcrNskiRJklR17r4bbr0VfvhD+PKXi04jVZ+BA2H//WHECJg7t+g0qjWWTZIkSZKqykcfwUknQbdueVUtScsvAi69FBYuzKMEpXKybJIkSZJUVUaNgpdfhl/8Atq3LzqNVL222ALOPhsmToTbbis6jWqJZZMkSZKkqjFtGlxwAXznO7DXXkWnkarf8OHQsyccdxy8/nrRaVQrLJskSZIkVYW//x2OPhq+8hUYM6boNFJtaNcOrr8ePvwQBg/Ot9VJK8uySZIkSVLFSwlOOAH+8pf8wbhDh6ITSbVj663h5z+HqVNh7Nii06gWWDZJkiRJqnjXXgu33AKjR0OvXkWnkWrP8cfDgQfCGWfAzJlFp1G1s2ySJEmqQxHRPyJeiIg5EXFGE69vHREPR8SCiBheREZpkZdegqFDYY894Ac/KDqNVJsiYPx4WG89OOKIvOqjtKIsmyRJkupMRDQA44ABQHdgUER0X+KwvwEnAz9r5XjS53z6KRx5JDQ0wG9+kx8lrRqdOsE118Ds2Ra7WjmWTZIkSfWnNzAnpfRySukT4CbgoMYHpJTeSCnNAD4tIqC0yLnnwiOPwOWXw2abFZ1Gqn39+sGpp8Jll8GUKUWnUbVqW3QASZIktbouwNxG2/OAXVbkRBFxPHA8QKdOnZg2bdpKh9Ni77//fl1f01mzOnLuuTvRr99f6dz5eVb2UtT79VxVvKblUyl/Rvv3b8Ptt/fkqKPaMX78DNZbr3p/71Ap17TeWDZJkiTVn2hiX1qRE6WUrgCuAOjWrVvq27fvSsTSkqZNm0a9XtN33oEhQ2DzzeGWWzakY8cNV/qc9Xw9V4UHHngAwGtaRpX0Z/SOO2DnneHKK3dn0qQ8p1M1qqRrWk+8jU6SJKn+zAM2bbS9CfB6QVmkf5ESfO97MHcuXH89dOxYdCKp/vToARdemG+lGzu26DSqNpZNkiRJ9WcG0DUitoiIdsDhwB0FZ5L+6fzz4cYbYfRo6NOn6DRS/TrpJDjoIBg+HO69t+g0qiaWTZIkSXUmpfQZMBS4B3gOuDml9GxEnBgRJwJExIYRMQ/4T+DsiJgXEY4v0So3cSKcdVZeev3MM4tOI9W3CLjuujzK6dBD8yp1Uks4Z5MkSVIdSilNAaYsse9XjZ7/hXx7ndRqHn8cjjoKdt0VrryyeueIkWpJhw5w553Quzf827/l1SE32KDoVKp0jmySJEmSVLjXXoMDD4ROneC3v4XVVy86kaRFNtsMbr89/z09+GBYsKDoRKp0lk2SJEmSCvXBB7loevddmDQJOncuOpGkJe2yC1x9NTz4IJx4Yp7IX1oab6OTJEmSVJiFC+GYY+DJJ/NS69ttV3QiSUtz+OHw/PMwahRssw384AdFJ1KlsmySJEmSVJizz86Tgl90ERxwQNFpJDVnxIhcOJ1xBmy1FQwcWHQiVSJvo5MkSZJUiGuvhZ/8BI47Dk49teg0kloiAn79a+jVC448Mo9KlJZk2SRJkiSp1U2ZkkumPfeEceNceU6qJmuskScMX3992H9/ePHFohOp0lg2SZIkSWpVd94J3/wmbLstTJgAq61WdCJJy2vDDeGuu+Czz6Bv33xrnbSIZZMkSZKkVnP77XDIIbDDDnDffbDuukUnkrSievSAadPyRP99+8Ls2UUnUqWwbJIkSZLUKiZOhG99C3r2hKlTLZqkWtC9ey6cInLh9MwzRSdSJbBskiRJkrTK3XILHHYY9O4N994La69ddCJJ5bL11rlwWm21PA/b008XnUhFs2ySJEmStErddBMMGgR9+sDdd0PHjkUnklRu3brlwql9+1w4uUpdfbNskiRJkrTKXH99Xh59993zZMJrrVV0IkmrSteu8MADsOaasPfe8PjjRSdSUSybJEmSJJVdSvDLX8Ixx8DXvw5TpkCHDkWnkrSqbbllLpw6doR99oHf/a7oRCqCZZMkSZKkslqwAI4/Hr7/fejfHyZNyiMdJNWHLbbIhdOGG8I3vgFjx+YCWvXDskmSJElS2bz+el6Ravx4OOssuOMO+MIXik4lqbVtvjk88gjsvz8MGwaDB8NHHxWdSq3FskmSJElSWTz8MOy8M8yalVefO+88aGgoOpWkonTsCLfdBiNGwLXXwh57wNy5RadSa7BskiRJkrTSxo/PczOtsUYunb71raITSaoEbdrAyJG5dHr++VxIP/hg0am0qlk2SZIkSVphn3yS52Y67rh8+9yMGbDddkWnklRpBg7Mt9WtvTbstVdeQMB5nGqXZZMkSZKkFfLss/C1r+UPjaedllecW2+9olNJqlTdu8Ojj0K/frmkPuIIePPNolNpVbBskiRJkrRcFizIt8XstBO89BLcfDNccAG0bVt0MkmVbp118sIBo0fDhAmwzTZw3XWOcqo1lk2SJEmSWuzhh6FnTxg1Cg47DJ57Dg49tOhUkqpJQwOccw48+SR07QpHHw377QevvFJ0MpWLZZMkSZKkZr33HvzHf8Duu+fnkyfn0QidOhWdTFK16tEDHnoILrkkTxreoweMHQv/+EfRybSyLJskSZIkLdOUKflD4LhxMHRonqtpv/2KTiWpFjQ05CJ70Rxww4blUnvWrKKTaWVYNkmSJElq0gMP5BXm9t8fOnRYPAJhrbWKTiap1my+eS62r7sO5syBHXeEo46CF18sOplWhGWTJEmSpM956CHYe+9cNL3wAowZk+dW2W23opNJqmURcOSR8Pzz8F//BRMn5gnEjz02F1CqHpZNkiRJkoA8+Xe/fvlWlmeegYsvhpdfhlNOgfbti04nqV5ssEFe4fKPf8y31d18M2y9NXz72/nfJFU+yyZJkiSpji1cCFOnwoABeeTSU0/BhRfmD3SnngprrFF0Qkn1qnNnuOii/O/R0KFwww3QrRt897swc2bR6bQslk2SJElSHZo3D378Y9hyyzya6bHH4Pzz84e64cNhzTWLTihJ2UYb5dt5X3oJTjwxz+u0447Qqxdcfjm8+27RCbUkyyZJkiSpTnz6Kdx2W57we/PN4Uc/ymXTjTfC3Llw+ul5InBJqkRdusCll8Jrr8HYsfDxx7l82mgjGDIEfv97SKnolALLJkmSJKmmffIJ3H9/nvdk003h4IPzrXJnnplHCdx3Hxx+OKy+etFJJall1l8fTj4Znn4aHnkkTyp+663w1a9C9+4wejQ88YTFU5HaFh1AkiRJUnm98UZeQnzyZLjnHnjvvTzBd//+ea6T/v2hrZ8EJFW5COjdO39dfDHccgtcdRWMHAkjRuQRTz17bsU778A++3h7cGvyvxhJkiSpyr37LsyYkW8hmTIFHn00/0Z/441h0CA44ADYay8/aEmqXR065FvphgyBN9+Eu+6CSZNgypQvMnlyLtz33BP23Rf69IGddoJ27YpOXbssmyRJkqQqsnAhvPgiPPwwTJ+eH595ZvHtIr17w6hRuWDaccf8m39JqiedOsExx+Sv++77PQ0NX2fSJLjzzrzKJuTyqWfPXDz16QO77gqbbFJs7lpi2SRJkiRVoJTgzTfbM3UqzJ4Nzz2XH2fNgvnz8zHrrAO77AKHHJI/KO2yS94nScratk307ZtHNV10UZ5cfPr0xWX9uHH5FjzIo0G33TbP+7TNNosf11+/0B+hKlk2SZIkSRVk9Oh8K9zs2fDee33+uX/ddfMHn8MOy6VSnz7QrRu0cckfSWqxLl1yQX/IIXn7k09g5sxcPM2YkYv9K66ADz9c/D1f/GL+9/eEE/KCCmqeZZMkSVIdioj+wFigARifUjp/idej9Pp+wIfA4JTSE60etA699VaeW+nYY6Gh4UUGDtyKbbbJH3a8JU6SyqtdO+jVK38tsnAhvPrq4hGlix4/+KC4nNXGskmSJKnOREQDMA74BjAPmBERd6SUZjc6bADQtfS1C/DL0qNWsUsuWfx82rTX6dt3q+LCSFIdatMGvvSl/DVgQNFpqlOkRTMJSpIkqS5ERB9gZEpp39L2mQAppZ80OuZyYFpK6cbS9gtA35TSn5d23o033jidcMIJqzS7JEkq1siRIx9PKe28rGMc2SRJklR/ugBzG23P419HLTV1TBfgc2VTRBwPHF/aXDBy5Mhnyhu17m0AvFV0iBri9Sw/r2l5eT3Lz2taft2aO8CySZIkqf40NfPPksPdW3IMKaUrgCsAIuKx5n7TqeXjNS0vr2f5eU3Ly+tZfl7T8ouIx5o7xrUrJEmS6s88YNNG25sAr6/AMZIkSf/CskmSJKn+zAC6RsQWEdEOOBy4Y4lj7gCOiWxX4J1lzdckSZK0iLfRSZIk1ZmU0mcRMRS4B2gArkopPRsRJ5Ze/xUwBdgPmAN8CAxpwamvWEWR65nXtLy8nuXnNS0vr2f5eU3Lr9lr6mp0kiRJkiRJKhtvo5MkSZIkSVLZWDZJkiRJkiSpbCybJEmSVDYR8eOIeDoinoqIeyNi46IzVbuIuDAini9d19siYp2iM1WziDg0Ip6NiIUR4XLoKygi+kfECxExJyLOKDpPtYuIqyLijYh4pugstSIiNo2I30XEc6W/86cUnamaRcTqEfFoRMwsXc9RyzzeOZskSZJULhHRMaX0bun5yUD3lNKJBceqahHRD/jf0sTuPwVIKZ1ecKyqFRHbAAuBy4HhKaXHCo5UdSKiAXgR+AYwj7zC5aCU0uxCg1WxiNgDeB+4NqW0bdF5akFEbARslFJ6IiLWAh4HBvrndMVERABrppTej4jVgIeAU1JK05s63pFNkiRJKptFRVPJmoC/2VxJKaV7U0qflTanA5sUmafapZSeSym9UHSOKtcbmJNSejml9AlwE3BQwZmqWkrp/4C/FZ2jlqSU/pxSeqL0/D3gOaBLsamqV8reL22uVvpa6v/xlk2SJEkqq4g4LyLmAkcCPyo6T435NnBX0SFU97oAcxttz8MP8apgEfElYCfgkYKjVLWIaIiIp4A3gKkppaVeT8smSZIkLZeIuC8inmni6yCAlNIPU0qbAtcDQ4tNWx2au6alY34IfEa+rlqGllxPrZRoYp+jGFWRIqIDMAEYtsToWy2nlNI/Uko7kkfY9o6Ipd7y2bbVUkmSJKkmpJT2aeGhNwCTgRGrME5NaO6aRsSxwAHA3slJV5u1HH9GtWLmAZs22t4EeL2gLNJSleYWmgBcn1KaWHSeWpFSmh8R04D+QJOT2juySZIkSWUTEV0bbR4IPF9UlloREf2B04EDU0ofFp1HIk8I3jUitoiIdsDhwB0FZ5I+pzSh9ZXAcymli4vOU+0iotOi1VAjYg1gH5bxf7yr0UmSJKlsImIC0I282tcrwIkppdeKTVXdImIO0B54u7Rruiv8rbiI+CZwKdAJmA88lVLat9BQVSgi9gPGAA3AVSml84pNVN0i4kagL7AB8FdgRErpykJDVbmI+CrwIDCL/H8SwFkppSnFpapeEbE9cA3573wb4OaU0uilHm/ZJEmSJEmSpHLxNjpJkiRJkiSVjWWTJEmSJEmSysaySZIkSZIkSWVj2SRJkiRJkqSysWySJEmSJElS2Vg2SZIkSVIri4gvRUQqfV1ddB5JKqe2RQeQJEmSJNWniBgI7FjaHJNSml9YGEllY9kkSZIkSSrKQODY0vOrgflFBZFUPpZNkiRJktTKUkp/AqLoHJK0KjhnkyRJkiRJksrGskmSJEmSJEllY9kkSZIkSa2sJavRRcS0Rcc02vfvETE1Iv4SEQsi4pWI+HVEbN3M+33uXBHRNiK+FxEPRcSbEfFRRLwYEWMjYtNmzvWn0rn+1IKfs8ljI+LqUpZjG+3+Y6NrskIr9UXE0Y2+9/GIaLeMY3eNiE9Lx/45IjZYnveStHSWTZIkSZJU4SJi9Yi4DbgJ2AfoDLQDNgMGA09FxIAWnmtdYBrwC2B3YANgdaArcDLwbETsV+YfoVWklH4DXF/a7Amc29RxEbFW6bi2QAKOSSm91SohpTrgBOGSJEmSVPmuIq/c9ji5cHqVXBIdCewGtAeui4huLShNriKXTLOBa4BXgA2BQcAuwFrAxIj4akrpsfL/KABcAvyWXG7tWdp3AvDGEse9ugLn/j75mmwBDI+Ie1JK9y9xzC+AL5eeX5xSmroC7yNpKSybJEmSJKnyDQLOA85JKTW+re5XwARyEbUe8G3ggmbONRC4ARicUvq00bkuAX4KnEYur66KiB0av1+5pJSeAJ6IiIGNdt9bWqVvZc/9bkQcATxI/sx7bURsn1J6GyAiBgFHlQ5/EjhrZd9T0ud5G50kSZIkVb7/TSmdvWTxk1JaSC6HFtm3Bef6E/CdxkVT6VwJOB14uLRrO6DfCicuUEppOjC6tLkxcCXkubKAX5b2fwgMSil90uoBpRpn2SRJkiRJlW/s0l5IKc0B5pY2u7fgXONSSh8v5VwJ+HmjXd9sccLKcx7wf6XnB0XEUPI8TWuX9p2SUnqhkGRSjbNskiRJkqTKN72Z118rPa7bgnMtOX/Rsl7v1YLzVaTSqK+jgL+Xdl1KnssJYEJKaXwhwaQ6YNkkSZIkSZWvuUm/F5Qe27fgXHOW9WJK6W/A/NLmxi04X8VKKc0lTzze2FzguALiSHXDskmSJEmSKlxplE65fNiCYz4oPXYo4/sWZQ7wWaPt+1NKf1/awZJWnmWTJEmSJNWXL7TgmDVLj++v5HsV+pkzIr4A3MjnV2IfHBH7FRRJqguWTZIkSZJUX76yrBcjYj1gndLm600csuiWvXbNnCeA9ZY3XJmNBbqVnt8JLFqB79cR0bmYSFLts2ySJEmSpPqy13K8PqOJ1+eXHjeIiNWWcZ5tWTxCamka3x4YzRy7XCLiYOC7pc1ZwKHAiNL2F8mFU1nfU1Jm2SRJkiRJ9eX7EbGsicRPbfR8YhOvzy49rgZ8bRnnObkFWRrfptdcMdViEbEJ8D+lzY+BQSmlBcBPgWml/QNamFHScrJskiRJkqT68mXgfyKi8TxGRPbfwG6lXU8DU5v4/rsbPf9xU8VVRHyXxaOKluWPjZ73bMHxzYqINsBvWHwL3/CU0rPwz4nWjwYWTRD+04jYvhzvK2mxts0fIkmSJEmqIb8lFy47RcQ1wKtAZ2AQ0Kd0zALgOymltJTvn0Oe+2k3YEZEXEme32lDYCD5VrwHgS2BjZeR5f5Gzy+IiE7ACyxePe61lNKs5fvxOB3oW3o+OaU0rvGLKaV5EXEccCvQHrghInZOKX28nO8jaSksmyRJkiSpvgwBOgG7Axc28fp75NvOHmvqm1NKCyLicPKop3WB7YAxSxz2CHAITc/51PhcT0fEjeSiqzPwsyUOuQYYvKxzNBYRvYBRpc2/kn/Wpt53QkSMJ4++6lF636EtfR9Jy+ZtdJIkSZJUR1JK84E9gZOAPwBvk0cyvQRcCvRIKU1u5hyPk0umS8mjnD4m35r2cOm8X0spvdnCSEcD3yPPpfQWi0c1LZeI6ADcQJ5LKgGDm8kwjDyKCuCkiDhgRd5X0r+KpkdFSpIkSZJqRURMA74OkFJyBTZJq5QjmyRJkiRJklQ2lk2SJEmSJEkqG8smSZIkSZIklY1lkyRJkiRJksrGskmSJEmSJEll42p0kiRJkiRJKhtHNkmSJEmSJKlsLJskSZIkSZJUNpZNkiRJkiRJKhvLJkmSJEmSJJWNZZMkSZIkSZLK5v8BMz7dav2e0isAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -580,19 +578,23 @@ }, { "cell_type": "code", - "execution_count": 209, + "execution_count": 51, "id": "108c36df", "metadata": {}, "outputs": [], "source": [ + "from scipy.stats import multivariate_normal\n", + "\n", "class UnscentedTranform(object):\n", - " def __init__(self, x, P, kappa):\n", + " def __init__(self, f, x, P, kappa):\n", " # dimension of state vector\n", " if hasattr(x, \"__len__\"):\n", " self.n = len(x)\n", " else:\n", " self.n = 1\n", " \n", + " self.f = f\n", + " \n", " self.m = (2 * self.n) + 1 # number of sigma points\n", " \n", " self.x = np.asarray(x)\n", @@ -602,22 +604,26 @@ " self.X = self.calculate_sigma_points()\n", " self.W = self.calculate_weights()\n", " \n", - " self.p = gaussian_pdf(self.X, self.x, self.P)\n", + " if (np.isscalar(x) == 1):\n", + " #self.p = multivariate_normal.pdf(self.X, mean=self.x, cov=self.P)\n", + " self.p = gaussian_pdf(self.X, self.x, self.P)\n", + " \n", + " self.Y = f(self.X)\n", + " \n", + " self.y, self.Pyy = self.calculate_mean_and_covariance()\n", " \n", " def calculate_sigma_points(self):\n", " X = np.zeros((self.n, self.m))\n", - " X[:, 0] = self.x\n", + " x = np.reshape(self.x, [self.n,]) \n", + " X[:, 0] = x\n", " \n", " for i in range(self.n):\n", - " if self.n == 1:\n", - " P_sqrt = np.sqrt(self.P)\n", - " else:\n", - " P_sqrt = np.linalg.cholesky(self.P[:, i])\n", + " P_sqrt = np.linalg.cholesky(self.P)\n", " \n", " scaler = np.sqrt(self.n + self.kappa)\n", " \n", - " X[:, i+1] = self.x + (scaler * P_sqrt)\n", - " X[:, i+self.n+1] = self.x - (scaler * P_sqrt)\n", + " X[:, i+1] = x + (scaler * P_sqrt[:, i])\n", + " X[:, i+self.n+1] = x - (scaler * P_sqrt[:, i])\n", " \n", " return X\n", " \n", @@ -626,6 +632,20 @@ " W[0, 0] *= 2.0 * self.kappa\n", " return W\n", " \n", + " def calculate_mean_and_covariance(self):\n", + " y = np.zeros((self.n, ))\n", + " \n", + " for i in range(self.m):\n", + " y += self.W[0, i] * self.Y[:, i]\n", + " \n", + " Pyy = np.zeros((self.n, self.n))\n", + " for i in range(self.m):\n", + " devYi = (self.Y[:, i] - y).reshape([self.n, 1])\n", + " P_i = self.W[0, i] * devYi @ np.transpose(devYi)\n", + " Pyy += P_i\n", + " \n", + " return y, Pyy\n", + " \n", " def show_summary(self):\n", " print(f'self.x = \\n{self.x} \\n\\n')\n", " print(f'self.P = \\n{self.P} \\n\\n')\n", @@ -634,12 +654,16 @@ " print(f'self.m = \\n{self.m} \\n\\n')\n", " print(f'self.X = \\n{self.X} \\n\\n')\n", " print(f'self.W = \\n{self.W} \\n\\n')\n", - " print(f'self.p= \\n{self.p}\\n\\n')" + " #print(f'self.p= \\n{self.p}\\n\\n')\n", + " print(f'np.sqrt(self.P) = \\n{np.sqrt(self.P)} \\n\\n')\n", + " print(f'self.Y = \\n{self.Y} \\n\\n')\n", + " print(f'self.y = \\n{self.y} \\n\\n')\n", + " print(f'self.Pyy = \\n{self.Pyy} \\n\\n')" ] }, { "cell_type": "code", - "execution_count": 210, + "execution_count": 52, "id": "af9caeab", "metadata": {}, "outputs": [ @@ -648,7 +672,7 @@ "output_type": "stream", "text": [ "self.x = \n", - "0.0 \n", + "[[0.]] \n", "\n", "\n", "self.P = \n", @@ -675,26 +699,111 @@ "[[0. 0.5 0.5]] \n", "\n", "\n", - "self.p= \n", - "[[0.56418958 0.34219828 0.34219828]]\n", + "np.sqrt(self.P) = \n", + "[[0.70710678]] \n", + "\n", + "\n", + "self.Y = \n", + "[[0. 0.5 0.5]] \n", + "\n", + "\n", + "self.y = \n", + "[0.5] \n", + "\n", + "\n", + "self.Pyy = \n", + "[[0.]] \n", "\n", "\n" ] } ], "source": [ - "x = 0.0\n", - "P = 0.5\n", + "x = np.array([[0.0]])\n", + "P = np.array([[0.5]])\n", + "kappa = 0.0\n", + "\n", + "unscented_transform = UnscentedTranform(f, x, P, kappa)\n", + "\n", + "unscented_transform.show_summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "462b5619", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.x = \n", + "[[2.]\n", + " [1.]] \n", + "\n", + "\n", + "self.P = \n", + "[[0.1 0. ]\n", + " [0. 0.1]] \n", + "\n", + "\n", + "self.kappa = \n", + "0.0 \n", + "\n", + "\n", + "self.n = \n", + "2 \n", + "\n", + "\n", + "self.m = \n", + "5 \n", + "\n", + "\n", + "self.X = \n", + "[[2. 2.4472136 2. 1.5527864 2. ]\n", + " [1. 1. 1.4472136 1. 0.5527864]] \n", + "\n", + "\n", + "self.W = \n", + "[[0. 0.25 0.25 0.25 0.25]] \n", + "\n", + "\n", + "np.sqrt(self.P) = \n", + "[[0.31622777 0. ]\n", + " [0. 0.31622777]] \n", + "\n", + "\n", + "self.Y = \n", + "[[4. 5.98885438 4. 2.41114562 4. ]\n", + " [1. 1. 2.09442719 1. 0.30557281]] \n", + "\n", + "\n", + "self.y = \n", + "[4.1 1.1] \n", + "\n", + "\n", + "self.Pyy = \n", + "[[ 1.61 -0.01]\n", + " [-0.01 0.41]] \n", + "\n", + "\n" + ] + } + ], + "source": [ + "x = np.array([[2.0],[1.0]])\n", + "P = np.array([[0.1, 0.0],[0.0, 0.1]])\n", "kappa = 0.0\n", "\n", - "unscented_transform = UnscentedTranform(x, P, kappa)\n", + "unscented_transform = UnscentedTranform(f, x, P, kappa)\n", "\n", "unscented_transform.show_summary()" ] }, { "cell_type": "code", - "execution_count": 211, + "execution_count": 54, "id": "47ac9f8a", "metadata": {}, "outputs": [], @@ -726,6 +835,7 @@ " \n", "def add_gaussian_bel(ax, x, var, color, visualize_details=False):\n", " p = gaussian_pdf(x, x, var)\n", + " #p = norm(x, var).pdf(x)\n", " #add_absolute_position(ax, x, p, color, False)\n", " \n", " x_bel, p_bel = generate_normal_samples(x, var)\n", @@ -784,7 +894,7 @@ }, { "cell_type": "code", - "execution_count": 212, + "execution_count": 55, "id": "212e6fa7", "metadata": {}, "outputs": [ @@ -802,6 +912,12 @@ } ], "source": [ + "x = 0.0\n", + "P = 0.5\n", + "kappa = 0.0\n", + "\n", + "unscented_transform = UnscentedTranform(f, x, P, kappa)\n", + "\n", "fig, ax = make_figure(xlims=(-3, 3))\n", "\n", "add_gaussian_bel(ax, x, P, 'green')\n", @@ -812,7 +928,7 @@ }, { "cell_type": "code", - "execution_count": 213, + "execution_count": 56, "id": "21001ca1", "metadata": {}, "outputs": [], @@ -836,7 +952,7 @@ }, { "cell_type": "code", - "execution_count": 217, + "execution_count": 57, "id": "b0717ae2", "metadata": {}, "outputs": [], @@ -868,14 +984,12 @@ " self.fig, self.axes = create_plot()\n", " \n", " kappa = 0.0\n", - " unscented_transform = UnscentedTranform(x_mean, x_sigma, kappa)\n", + " unscented_transform = UnscentedTranform(model, x_mean, x_sigma, kappa)\n", " \n", " self.sigma_X = unscented_transform.X\n", " self.sigma_W = unscented_transform.W\n", " self.sigma_p = unscented_transform.p\n", " \n", - " print(self.sigma_W)\n", - " \n", " def update_plot(self):\n", " '''\n", " main function to execute the class plotting\n", @@ -981,20 +1095,13 @@ }, { "cell_type": "code", - "execution_count": 221, + "execution_count": 58, "id": "21c382d8", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0. 0.5 0.5]]\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1006,7 +1113,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 5a16ad4094e87a29769a8bc9a2380735319a7b9b Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sun, 4 Dec 2022 15:53:56 +0100 Subject: [PATCH 05/60] add ukf --- ...Introduction_Unscented_Kalman_Filter.ipynb | 1268 +++++++++++++++++ 1 file changed, 1268 insertions(+) create mode 100644 python/examples/Introduction_Unscented_Kalman_Filter.ipynb diff --git a/python/examples/Introduction_Unscented_Kalman_Filter.ipynb b/python/examples/Introduction_Unscented_Kalman_Filter.ipynb new file mode 100644 index 0000000..67e4c54 --- /dev/null +++ b/python/examples/Introduction_Unscented_Kalman_Filter.ipynb @@ -0,0 +1,1268 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "183e6446", + "metadata": {}, + "source": [ + "# Unscented Kalman Filter" + ] + }, + { + "cell_type": "markdown", + "id": "d47e226b", + "metadata": {}, + "source": [ + "The Unscented Kalman filter (UKF) algorithm is basically:" + ] + }, + { + "cell_type": "markdown", + "id": "61db0d92", + "metadata": {}, + "source": [ + "## Step 1: Create Joint State Vector ($\\vec{x}^a$)\n", + "---\n", + "\n", + "$$\n", + "\\vec{x}^a_k =\n", + "\\begin{bmatrix}\n", + "\\vec{x}_k \\\\\n", + "\\vec{v}_k \\\\\n", + "\\vec{n}_k\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "where $\\vec{v}_k$ and $\\vec{n}_k$ are vectors of process and measurement noises, respectively and since they are white Gaussian noise then this means that the mean of the noise overy time is always zero, which makes:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\vec{v}_k &= \\begin{bmatrix} 0_{q \\times 1} \\end{bmatrix} \\\\\n", + "\\vec{n}_k &= \\begin{bmatrix} 0_{m \\times 1} \\end{bmatrix}\n", + "\\end{align}\n", + "$$\n", + "\n", + "where subscription $q$ and $m$ are the process and measurement noise vectors dimensions, respectively.\n", + "\n", + "$$\n", + "\\vec{x}^a_k =\n", + "\\begin{bmatrix} \n", + "\\vec{x}_k \\\\\n", + "0_{q \\times 1} \\\\\n", + "0_{m \\times 1}\n", + "\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "34a2809b", + "metadata": {}, + "source": [ + "## Step 2: Create Joint State Covariance ($P^a$)\n", + "---\n", + "\n", + "$$\n", + "P^a_{k-1|k-1} =\n", + "\\begin{bmatrix}\n", + "P_{k-1|k-1} & 0_{n \\times q} & 0_{n \\times m} \\\\\n", + "0_{q \\times n} & Q_{k} & 0_{q \\times m} \\\\\n", + "0_{m \\times n} & 0_{m \\times q} & R_{k}\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "where $Q_k$ and $R_k$ are the process and measurement noise covariances, respectively. And $n$ is the state vector dimension." + ] + }, + { + "cell_type": "markdown", + "id": "adc8070a", + "metadata": {}, + "source": [ + "## Step 3: Calculating UT Weights\n", + "---\n", + "\n", + "Now the dimension $n_a$ of the augmented state shall be used instead of just $n$:\n", + "\n", + "$$\n", + "n^a = n + q + m\n", + "$$\n", + "\n", + "then; \n", + "\n", + "$$\n", + "\\begin{align}\n", + " W_0 &= \\frac{\\kappa}{n^a + \\kappa} \\\\\n", + " W_i &= \\frac{0.5}{n^a + \\kappa} \\\\\n", + " W_{i+n^a} &= \\frac{0.5}{n^a + \\kappa}\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $\\kappa$ is a design parameter and usually set to:\n", + "\n", + "$$\n", + "\\kappa = 3 - n^a\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "a8693ff7", + "metadata": {}, + "source": [ + "## Step 4: Calculating UT Sigma Points\n", + "---\n", + "\n", + "$$\n", + "\\begin{align}\n", + " X_0^a &= \\bar{x}^a \\\\\n", + " X_i^a &= \\bar{x}^a + \\left( \\sqrt{(n^a+\\kappa) P^a_{k-1|k-1}} \\right)_i \\\\\n", + " X_{i+n^a}^a &= \\bar{x}^a - \\left( \\sqrt{(n^a+\\kappa) P^a_{k-1|k-1}} \\right)_i\n", + "\\end{align}\n", + "$$\n", + "\n", + "then $X^a$ would actually consists of three parts, which are:\n", + "\n", + "$$\n", + "X^a =\n", + "\\begin{bmatrix} \n", + "X^{xx} \\\\ X^{vv} \\\\ X^{nn}\n", + "\\end{bmatrix}\n", + "= \n", + "\\begin{bmatrix} \n", + "X^{xx}_0 & X^{xx}_1 & \\dots & X^{xx}_{2n^a} \\\\\n", + "X^{vv}_0 & X^{vv}_1 & \\dots & X^{vv}_{2n^a}\\\\\n", + "X^{nn}_0 & X^{nn}_1 & \\dots & X^{nn}_{2n^a}\n", + "\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "b0f3865c", + "metadata": {}, + "source": [ + "## Step 5: Propagate joint sigma points ($X^a_{k-1|k-1}$) through Nonlinear Prediction Model ($F[...]$)\n", + "---\n", + "\n", + "$$\n", + "X^{xx}_{k|k-1} = F[X^{xx}_{k-1|k-1}, X^{vv}_{k-1}]\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "17372d1d", + "metadata": {}, + "source": [ + "## Step 6: Calculate Predicted State Mean and Covariance\n", + "---\n", + "\n", + "$$\n", + "\\hat{x}_{k|k-1} = \\sum_{i=0}^{2n^a} W_i X^{xx}_{k|k-1}\n", + "$$\n", + "\n", + "$$\n", + "P_{k|k-1} = \\sum_{i=0}^{2n^a} W_i \\left( X^{xx}_{i, k|k-1} - \\hat{x}_{k|k-1} \\right) \\left( X^{xx}_{i, k|k-1} - \\hat{x}_{k|k-1} \\right)^T\n", + "$$\n", + "\n", + "$i$th index stands for the column index." + ] + }, + { + "cell_type": "markdown", + "id": "971baf7a", + "metadata": {}, + "source": [ + "## Step 7: Propagate Predicted Sigma Points ($X^x_{k|k-1}$) through Nonlinear Measurement Model ($H[...]$)\n", + "---\n", + "\n", + "$$\n", + "Y_{k|k-1} = H[X^{xx}_{k|k-1}, X^{nn}_{k-1}]\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ede07a5", + "metadata": {}, + "source": [ + "## Step 8: Calculate Predicted Measurement Mean and Covariance\n", + "---\n", + "\n", + "$$\n", + "\\hat{y}_{k|k-1} = \\sum_{i=0}^{2n^a} W_i Y_{k|k-1}\n", + "$$\n", + "\n", + "$$\n", + "S_{k|k-1} = \\sum_{i=0}^{2n^a} W_i \\left( Y_{i,k|k-1} - \\hat{y}_{k|k-1} \\right) \\left( Y_{i, k|k-1} - \\hat{y}_{k|k-1} \\right)^T\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "19549a01", + "metadata": {}, + "source": [ + "## Step 9: Calculate the Cross-Correlation Matrix ($P_xy$) :\n", + "---\n", + "\n", + "$$\n", + "P_{xy, k|k-1} = \\sum_{i=0}^{2n^a} W_i \\left( X^x_{i, k|k-1} - \\hat{x}_{k|k-1} \\right) \\left( Y_{i, k|k-1} - \\hat{y}_{k|k-1} \\right)^T\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "4206e66a", + "metadata": {}, + "source": [ + "## Step 10: Calculate Kalman Gain\n", + "---\n", + "\n", + "$$\n", + "K = P_{xy, k|k-1} S_{k|k-1}^{-1}\n", + "$$\n", + "\n", + "Can be optimized more by solving $K$ for the equation:\n", + "\n", + "$$\n", + "S_{k|k-1} K = P_{xy, k|k-1}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "1503b512", + "metadata": {}, + "source": [ + "## Step 11: Update State Vector and Covariance\n", + "\n", + "$$\n", + "\\hat{x}_{k|k} = \\hat{x}_{k|k-1} + K \\left( y_k - \\hat{y}_{k|k-1} \\right)\n", + "$$\n", + "\n", + "$$\n", + "P_{k|k} = P_{k|k-1} - K P_{xy, k|k-1} K^T\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "8f473285", + "metadata": {}, + "source": [ + "# Implementation" + ] + }, + { + "cell_type": "code", + "execution_count": 398, + "id": "2aa5bdf8", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.stats as stats\n", + "import math\n", + "import sys" + ] + }, + { + "cell_type": "markdown", + "id": "e8af85c9", + "metadata": {}, + "source": [ + "## Joint State Vector and Covaraince Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 399, + "id": "37eec130", + "metadata": {}, + "outputs": [], + "source": [ + "def augment_vectors(x, v):\n", + " return np.row_stack((x, v))\n", + "\n", + "def augment_covariances(P, Q):\n", + " prows, pcols = np.shape(P)[0], np.shape(P)[1]\n", + " qrows, qcols = np.shape(Q)[0], np.shape(Q)[1]\n", + " \n", + " nrows = prows + qrows\n", + " ncols = pcols + qcols\n", + " \n", + " Pa = np.zeros((nrows, ncols))\n", + " Pa[0:prows, 0:pcols] = P\n", + " Pa[prows:nrows, pcols:ncols] = Q\n", + " \n", + " return Pa" + ] + }, + { + "cell_type": "code", + "execution_count": 400, + "id": "8e921b79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.]\n", + " [2.]\n", + " [3.]\n", + " [4.]]\n", + "[[1. 1. 0. 0.]\n", + " [1. 1. 0. 0.]\n", + " [0. 0. 2. 2.]\n", + " [0. 0. 2. 2.]]\n" + ] + } + ], + "source": [ + "x = np.array([[1.], [2.]])\n", + "v = np.array([[3.], [4.]])\n", + "\n", + "P = np.array([[1., 1.], [1., 1.]])\n", + "Q = np.array([[2., 2.], [2., 2.]])\n", + "\n", + "xa = augment_vectors(x, v)\n", + "Pa = augment_covariances(P, Q)\n", + "\n", + "print(xa)\n", + "print(Pa)" + ] + }, + { + "cell_type": "markdown", + "id": "a77b6353", + "metadata": {}, + "source": [ + "## Unscented Kalman Filter (UKF)" + ] + }, + { + "cell_type": "code", + "execution_count": 401, + "id": "9aeddf21", + "metadata": {}, + "outputs": [], + "source": [ + "class UKF(object):\n", + " def __init__(self, dim_x, dim_z, Q, R, kappa=0.0):\n", + " \n", + " '''\n", + " UKF class constructor\n", + " inputs:\n", + " dim_x : state vector x dimension\n", + " dim_z : measurement vector z dimension\n", + " \n", + " - step 1: setting dimensions\n", + " - step 2: setting number of sigma points to be generated\n", + " - step 3: setting scaling parameters\n", + " - step 4: calculate scaling coefficient for selecting sigma points\n", + " - step 5: calculate weights\n", + " '''\n", + " \n", + " # setting dimensions\n", + " self.dim_x = dim_x # state dimension\n", + " self.dim_z = dim_z # measurement dimension\n", + " self.dim_v = np.shape(Q)[0]\n", + " self.dim_n = np.shape(R)[0]\n", + " self.dim_a = self.dim_x + self.dim_v + self.dim_n # assuming noise dimension is same as x dimension\n", + " \n", + " # setting number of sigma points to be generated\n", + " self.n_sigma = (2 * self.dim_a) + 1\n", + " \n", + " # setting scaling parameters\n", + " self.kappa = 3 - self.dim_a #kappa\n", + " self.alpha = 0.001\n", + " self.beta = 2.0\n", + "\n", + " alpha_2 = self.alpha**2\n", + " self.lambda_ = alpha_2 * (self.dim_a + self.kappa) - self.dim_a\n", + " \n", + " # setting scale coefficient for selecting sigma points\n", + " # self.sigma_scale = np.sqrt(self.dim_a + self.lambda_)\n", + " self.sigma_scale = np.sqrt(self.dim_a + self.kappa)\n", + " \n", + " # calculate unscented weights\n", + " # self.W0m = self.W0c = self.lambda_ / (self.dim_a + self.lambda_)\n", + " # self.W0c = self.W0c + (1.0 - alpha_2 + self.beta)\n", + " # self.Wi = 0.5 / (self.dim_a + self.lambda_)\n", + " \n", + " self.W0 = self.kappa / (self.dim_a + self.kappa)\n", + " self.Wi = 0.5 / (self.dim_a + self.kappa)\n", + " \n", + " # initializing augmented state x_a and augmented covariance P_a\n", + " self.x_a = np.zeros((self.dim_a, ))\n", + " self.P_a = np.zeros((self.dim_a, self.dim_a))\n", + " \n", + " self.idx1, self.idx2 = self.dim_x, self.dim_x + self.dim_v\n", + " \n", + " self.P_a[self.idx1:self.idx2, self.idx1:self.idx2] = Q\n", + " self.P_a[self.idx2:, self.idx2:] = R\n", + " \n", + " print(f'P_a = \\n{self.P_a}\\n')\n", + " \n", + " def predict(self, f, x, P): \n", + " self.x_a[:self.dim_x] = x\n", + " self.P_a[:self.dim_x, :self.dim_x] = P\n", + " \n", + " xa_sigmas = self.sigma_points(self.x_a, self.P_a)\n", + " \n", + " xx_sigmas = xa_sigmas[:self.dim_x, :]\n", + " xv_sigmas = xa_sigmas[self.idx1:self.idx2, :]\n", + " \n", + " y_sigmas = np.zeros((self.dim_x, self.n_sigma)) \n", + " for i in range(self.n_sigma):\n", + " y_sigmas[:, i] = f(xx_sigmas[:, i], xv_sigmas[:, i])\n", + " \n", + " y, Pyy = self.calculate_mean_and_covariance(y_sigmas)\n", + " \n", + " self.x_a[:self.dim_x] = y\n", + " self.P_a[:self.dim_x, :self.dim_x] = Pyy\n", + " \n", + " return y, Pyy, xx_sigmas\n", + " \n", + " def correct(self, h, x, P, z):\n", + " self.x_a[:self.dim_x] = x\n", + " self.P_a[:self.dim_x, :self.dim_x] = P\n", + " \n", + " xa_sigmas = self.sigma_points(self.x_a, self.P_a)\n", + " \n", + " xx_sigmas = xa_sigmas[:self.dim_x, :]\n", + " xn_sigmas = xa_sigmas[self.idx2:, :]\n", + " \n", + " y_sigmas = np.zeros((self.dim_z, self.n_sigma))\n", + " for i in range(self.n_sigma):\n", + " y_sigmas[:, i] = h(xx_sigmas[:, i], xn_sigmas[:, i])\n", + " \n", + " y, Pyy = self.calculate_mean_and_covariance(y_sigmas)\n", + " \n", + " Pxy = self.calculate_cross_correlation(x, xx_sigmas, y, y_sigmas)\n", + "\n", + " K = Pxy @ np.linalg.pinv(Pyy)\n", + " \n", + " x = x + (K @ (z - y))\n", + " P = P - (K @ Pyy @ K.T)\n", + " \n", + " return x, P, xx_sigmas\n", + " \n", + " \n", + " def sigma_points(self, x, P):\n", + " \n", + " '''\n", + " generating sigma points matrix x_sigma given mean 'x' and covariance 'P'\n", + " '''\n", + " \n", + " nx = np.shape(x)[0]\n", + " \n", + " x_sigma = np.zeros((nx, self.n_sigma)) \n", + " x_sigma[:, 0] = x\n", + " \n", + " S = np.linalg.cholesky(P)\n", + " \n", + " for i in range(nx):\n", + " x_sigma[:, i + 1] = x + (self.sigma_scale * S[:, i])\n", + " x_sigma[:, i + nx + 1] = x - (self.sigma_scale * S[:, i])\n", + " \n", + " return x_sigma\n", + " \n", + " \n", + " def calculate_mean_and_covariance(self, y_sigmas):\n", + " ydim = np.shape(y_sigmas)[0]\n", + " \n", + " # mean calculation\n", + " y = self.W0 * y_sigmas[:, 0]\n", + " for i in range(1, self.n_sigma):\n", + " y += self.Wi * y_sigmas[:, i]\n", + " \n", + " # covariance calculation\n", + " d = (y_sigmas[:, 0] - y).reshape([-1, 1])\n", + " Pyy = self.W0 * (d @ d.T)\n", + " for i in range(1, self.n_sigma):\n", + " d = (y_sigmas[:, i] - y).reshape([-1, 1])\n", + " Pyy += self.Wi * (d @ d.T)\n", + " \n", + " return y, Pyy\n", + " \n", + " def calculate_cross_correlation(self, x, x_sigmas, y, y_sigmas):\n", + " xdim = np.shape(x)[0]\n", + " ydim = np.shape(y)[0]\n", + " \n", + " n_sigmas = np.shape(x_sigmas)[1]\n", + " \n", + " dx = (x_sigmas[:, 0] - x).reshape([-1, 1])\n", + " dy = (y_sigmas[:, 0] - y).reshape([-1, 1])\n", + " Pxy = self.W0 * (dx @ dy.T)\n", + " for i in range(1, n_sigmas):\n", + " dx = (x_sigmas[:, i] - x).reshape([-1, 1])\n", + " dy = (y_sigmas[:, i] - y).reshape([-1, 1])\n", + " Pxy += self.Wi * (dx @ dy.T)\n", + " \n", + " return Pxy" + ] + }, + { + "cell_type": "markdown", + "id": "4a1e773e", + "metadata": {}, + "source": [ + "First we want to compare UKF and KF on linear problem which we expect that both should provide the same estimate.\n", + "\n", + "This is the first check to evaluate that the implementation of UKF is correct and if they gave different outputs then this could be indication that something wrong with the implementation of UKF.\n", + "\n", + "The problem is a very simple linear problem:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "x_{k}\n", + "&= f(x_{k-1}, v) \\\\\n", + "&= x_{k-1} + v_k\n", + "\\end{align}\n", + "$$\n", + "\n", + "$$\n", + "\\begin{align}\n", + "y_{k}\n", + "&= h(x_{k}, n) \\\\\n", + "&= x_{k} + n_k\n", + "\\end{align}\n", + "$$\n", + "\n", + "And the problem initializations would be:\n", + "\n", + "$$\n", + "\\vec{x}_0 = \\begin{bmatrix} 1 & 2 \\end{bmatrix}^T\n", + "$$\n", + "\n", + "$$\n", + "P_0 = \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + "Q = \\begin{bmatrix} 0.5 & 0 \\\\ 0 & 0.5 \\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + "\\vec{z} = \\begin{bmatrix} 1.2 & 1.8 \\end{bmatrix}^T\n", + "$$\n", + "\n", + "$$\n", + "R = \\begin{bmatrix} 0.3 & 0 \\\\ 0 & 0.3 \\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 402, + "id": "91e23cf6", + "metadata": {}, + "outputs": [], + "source": [ + "x0 = np.array([1.0, 2.0])\n", + "P0 = np.array([[1.0, 0.0], [0.0, 1.0]])\n", + "Q = np.array([[0.5, 0.0], [0.0, 0.5]])\n", + "\n", + "z = np.array([1.2, 1.8])\n", + "R = np.array([[0.3, 0.0], [0.0, 0.3]])" + ] + }, + { + "cell_type": "code", + "execution_count": 403, + "id": "1da0a648", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P_a = \n", + "[[0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0.5 0. 0. 0. ]\n", + " [0. 0. 0. 0.5 0. 0. ]\n", + " [0. 0. 0. 0. 0.3 0. ]\n", + " [0. 0. 0. 0. 0. 0.3]]\n", + "\n", + "x = \n", + "[1. 2.]\n", + "\n", + "P = \n", + "[[1.5 0. ]\n", + " [0. 1.5]]\n", + "\n", + "x = \n", + "[1.16667 1.83333]\n", + "\n", + "P = \n", + "[[ 0.25 -0. ]\n", + " [-0. 0.25]]\n", + "\n" + ] + } + ], + "source": [ + "def f(x, v):\n", + " return (x + v)\n", + "\n", + "def h(x, n):\n", + " return (x + n)\n", + "\n", + "nx = np.shape(x)[0]\n", + "nz = np.shape(z)[0]\n", + "nv = np.shape(x)[0]\n", + "nn = np.shape(z)[0]\n", + "\n", + "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))\n", + "\n", + "x1, P1, _ = ukf.predict(f, x0, P0)\n", + "\n", + "print(f'x = \\n{x1.round(5)}\\n')\n", + "print(f'P = \\n{P1.round(5)}\\n')\n", + "\n", + "x2, P2, _ = ukf.correct(h, x1, P1, z)\n", + "\n", + "print(f'x = \\n{x2.round(5)}\\n')\n", + "print(f'P = \\n{P2.round(5)}\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 404, + "id": "8d371939", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x = \n", + "[1. 2.]\n", + "\n", + "P = \n", + "[[1.5 0. ]\n", + " [0. 1.5]]\n", + "\n", + "x = \n", + "[1.16667 1.83333]\n", + "\n", + "P = \n", + "[[0.25 0. ]\n", + " [0. 0.25]]\n", + "\n" + ] + } + ], + "source": [ + "def KF_predict(F, x, P, Q):\n", + " x = (F @ x)\n", + " P = F @ P @ F.T + Q\n", + " return x, P\n", + "\n", + "def KF_correct(H, z, R, x, P):\n", + " Pxz = P @ H.T \n", + " S = H @ P @ H.T + R\n", + " \n", + " K = Pxz @ np.linalg.pinv(S)\n", + " \n", + " x = x + K @ (z - H @ x)\n", + " I = np.eye(P.shape[0])\n", + " P = (I - K @ H) @ P\n", + " return x, P\n", + "\n", + "F = np.array([[1.0, 0.0], [0.0, 1.0]])\n", + "H = np.array([[1.0, 0.0], [0.0, 1.0]])\n", + "\n", + "x1, P1 = KF_predict(F, x0, P0, Q)\n", + "\n", + "print(f'x = \\n{x1.round(5)}\\n')\n", + "print(f'P = \\n{P1.round(5)}\\n')\n", + "\n", + "x2, P2 = KF_correct(H, x1, P1, z, R)\n", + "\n", + "print(f'x = \\n{x2.round(5)}\\n')\n", + "print(f'P = \\n{P2.round(5)}\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "8fc48263", + "metadata": {}, + "source": [ + "Next step is to check with a 2-Dimensional nonlinear problem and visualize the uncertainty ellipses and sigma points and compare against Monto-carlo.\n", + "\n", + "Lets assume the same example we demonstrated in the Extended Kalman filter article:\n", + "\n", + "## Example: Target Tracking in 2D\n", + "\n", + "Lets practice an example of a tracking application and see how the equations are formulated.\n", + "\n", + "Assume that we want to track a single target moving in the surrounding, and the states to track are x- and y-positions, and x-, and y-velocities.\n", + "\n", + "$$\n", + "\\vec{x} = \\begin{bmatrix} p_x \\\\ p_y \\\\ v_x \\\\ v_y \\end{bmatrix}\n", + "$$\n", + "\n", + "Hence, the prediction model would be a linear **constant velocity model** (CV-model):\n", + "\n", + "$$\n", + "\\begin{bmatrix} p_{x, k|k-1} \\\\ p_{y, k|k-1} \\\\ v_{x, k|k-1} \\\\ v_{y, k|k-1} \\end{bmatrix} = \n", + "\\begin{bmatrix} p_{x, k-1|k-1} + T \\space (v_{x, k-1|k-1} + \\nu_{vx, k}) \\\\ p_{y, k-1|k-1} + T \\space (v_{y, k-1|k-1} + \\nu_{vy, k}) \\\\ v_{x, k-1|k-1} \\\\ v_{y, k-1|k-1} \\end{bmatrix}\n", + "$$\n", + "\n", + "We assumed that we only know the process noise with respect to velocity x and y $\\nu_{vx, k}$ and $\\nu_{vy, k}$, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 405, + "id": "458845ec", + "metadata": {}, + "outputs": [], + "source": [ + "def f_2(x, nu):\n", + " xo = np.zeros((np.shape(x)[0],))\n", + " xo[0] = x[0] + x[2] + nu[0]\n", + " xo[1] = x[1] + x[3] + nu[1]\n", + " xo[2] = x[2] + nu[0]\n", + " xo[3] = x[3] + nu[1]\n", + " return xo" + ] + }, + { + "cell_type": "markdown", + "id": "c928c953", + "metadata": {}, + "source": [ + "Now for the most important part, assuming we have a range sensor that measures for the range $r$ and bearing angle $\\beta$ of a target. The state that we are estimating is the cartesian coordinates of the target in $x$ and $y$ components.\n", + "\n", + "![](images/sensorA_and_sensorB.PNG)\n", + "\n", + "The measurement model will be the trignometric equations used to convert from cartesian to polar coordinates:\n", + "\n", + "$$\n", + "\\vec{z}_{k|k-1} = h(\\vec{x}_{k|k-1}, n_k)\n", + "$$\n", + "\n", + "$$\n", + "\\begin{bmatrix} r \\\\ \\beta \\end{bmatrix} = \\begin{bmatrix} h_1 \\\\ h_2 \\end{bmatrix} =\n", + "\\begin{bmatrix} \\sqrt{p_{x,{k|k-1}}^2 + p_{y,{k|k-1}}^2} + n^r_k \\\\ \\tan^{-1} \\left( \\frac{p_{y,{k|k-1}}}{p_{x,{k|k-1}}} \\right) + n^{\\beta}_k \\end{bmatrix}\n", + "$$\n", + "\n", + "\n", + "However, this time I would introduce a small difference compared to the EKF example in order to demonstrate the power of UKF and assume that the measurement noise is known with respect to cartesian position error, which means we know the position errorness from the sensor $n_x$ and $n_y$.\n", + "\n", + "So noises will be added directly to the cartesian position states and the measurement model for UKF would be:\n", + "\n", + "$$\n", + "\\begin{bmatrix} r \\\\ \\beta \\end{bmatrix} = \\begin{bmatrix} h_1 \\\\ h_2 \\end{bmatrix} =\n", + "\\begin{bmatrix} \\sqrt{(p_{x,{k|k-1}} + n^x_k)^2 + (p_{y,{k|k-1}} + n^y_k)^2} \\\\ \\tan^{-1} \\left( \\frac{p_{y,{k|k-1}} + n^y_k}{p_{x,{k|k-1}} + n^x_k} \\right) \\end{bmatrix}\n", + "$$\n", + "\n", + "Lets assume that our predicted state and covariance are:\n", + "\n", + "$$\n", + " \\vec{x}_{k|k-1} = \\begin{bmatrix} p_{x,k|k-1} \\\\ p_{y, k|k-1}\\end{bmatrix} = \\begin{bmatrix} 10 \\\\ 5\\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + " P_{k|k-1} = \\begin{bmatrix} q_{11} & q_{12} \\\\ q_{21} & q_{22}\\end{bmatrix} = \\begin{bmatrix} 0.3 & 0.0 \\\\ 0.0 & 0.3\\end{bmatrix}\n", + "$$\n", + "\n", + "And the received measurement is:\n", + "\n", + "$$\n", + " \\vec{z}_{k} = \\begin{bmatrix} r_{k} \\\\ \\beta_{k}\\end{bmatrix} = \\begin{bmatrix} 12.0 \\\\ 0.55\\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + " R = \\begin{bmatrix} r_{11} & r_{12} \\\\ r_{21} & r_{22}\\end{bmatrix} = \\begin{bmatrix} 0.1 & 0 \\\\ 0 & 0.1\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 406, + "id": "35b2885c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "range: 12.076837334335508\n", + "bearing: 0.4821640110688151\n" + ] + } + ], + "source": [ + "class RangeMeasurement:\n", + " def __init__(self, position):\n", + " self.range = np.sqrt(position[0]**2 + position[1]**2)\n", + " self.bearing = np.arctan(position[1] / (position[0] + sys.float_info.epsilon))\n", + " self.position = np.array([position[0],position[1]])\n", + "\n", + " def actual_position(self):\n", + " return self.position\n", + " \n", + " def asArray(self):\n", + " return np.array([self.range,self.bearing])\n", + " \n", + " def show(self):\n", + " print(f'range: {self.range}')\n", + " print(f'bearing: {self.bearing}')\n", + " \n", + "measurement = RangeMeasurement((10.7, 5.6)) # ground-truth\n", + "measurement.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 407, + "id": "7bf9823b", + "metadata": {}, + "outputs": [], + "source": [ + "def h_2(x, n):\n", + " '''\n", + " nonlinear measurement model for range sensor\n", + " x : input state vector [2 x 1] ([0]: p_x, [1]: p_y)\n", + " z : output measurement vector [2 x 1] ([0]: range, [1]: bearing )\n", + " '''\n", + " z = np.zeros((2,))\n", + " z[0] = np.sqrt((x[0] + n[0])**2 + (x[1] + n[1])**2)\n", + " z[1] = np.arctan((x[1] + n[1]) / ((x[0] + n[0]) + sys.float_info.epsilon))\n", + " return z" + ] + }, + { + "cell_type": "code", + "execution_count": 408, + "id": "194f373a", + "metadata": {}, + "outputs": [], + "source": [ + "x0 = np.array([10., 5., 0., 0.])\n", + "\n", + "P0 = np.array([[0.3, 0.1, 0.0, 0.0],\n", + " [0.1, 0.3, 0.0, 0.0],\n", + " [0.0, 0.0, 0.1, 0.0],\n", + " [0.0, 0.0, 0.0, 0.1]])\n", + "\n", + "Q = np.array([[0.2, 0.0],\n", + " [0.0, 0.2]])\n", + "\n", + "z = measurement.asArray()\n", + "R = np.array([[0.1, 0.0],[0.0, 0.1]])" + ] + }, + { + "cell_type": "code", + "execution_count": 409, + "id": "c752a547", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P_a = \n", + "[[0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0.2 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0.2 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.1]]\n", + "\n", + "=====Iteration 1====\n", + "x = \n", + "[10.548 5.476 0. 0. ]\n", + "\n", + "P = \n", + "[[0.073 0.007 0. 0. ]\n", + " [0.007 0.073 0. 0. ]\n", + " [0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0.1 ]]\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "nx = np.shape(x0)[0]\n", + "nz = np.shape(z)[0]\n", + "nv = np.shape(x0)[0]\n", + "nn = np.shape(z)[0]\n", + "\n", + "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))\n", + "\n", + "\n", + "print('=====Iteration 1====')\n", + "x, P, x_sigmas = ukf.correct(h_2, x0, P0, z)\n", + "print(f'x = \\n{x.round(3)}\\n')\n", + "print(f'P = \\n{P.round(3)}\\n')\n", + "print('\\n\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "aad87119", + "metadata": {}, + "source": [ + "## Visualize 2D State Ellipse and Sigma Points" + ] + }, + { + "cell_type": "code", + "execution_count": 410, + "id": "c4c05b70", + "metadata": {}, + "outputs": [], + "source": [ + "# prepare helper functions for visualizing the ellipses\n", + "from matplotlib.patches import Ellipse\n", + "\n", + "def create_covariance_ellipse(pos, cov):\n", + " # https://www.visiondummy.com/2014/04/draw-error-ellipse-representing-covariance-matrix\n", + " eig_values, eig_vectors = np.linalg.eig(cov)\n", + " \n", + " scale_95 = np.sqrt(5.991)\n", + " radius_1 = scale_95 * eig_values[0]\n", + " radius_2 = scale_95 * eig_values[1]\n", + " angle = np.arctan2(eig_vectors[1, 1], eig_vectors[0, 1])\n", + " \n", + " return radius_1, radius_2, angle\n", + "\n", + "def draw_ellipse(ax, mu, radius_1, radius_2, angle, color):\n", + " # https://matplotlib.org/stable/gallery/shapes_and_collections/ellipse_demo.html\n", + " ellipse = Ellipse(\n", + " mu,\n", + " width=radius_1 * 2,\n", + " height=radius_2 * 2,\n", + " angle=np.rad2deg(angle) + 90,\n", + " facecolor=color,\n", + " alpha=0.4)\n", + " ax.add_artist(ellipse)\n", + " return ax\n", + "\n", + "def plot_ellipse(ax, x, P, color):\n", + " x = x[0:2].reshape(2,)\n", + " P = P[0:2, 0:2]\n", + " r1, r2, angle = create_covariance_ellipse(x, P)\n", + " draw_ellipse(ax, x, r1, r2, angle, color)\n", + " \n", + "def get_correlated_dataset(n, cov, mu, scale):\n", + " # https://carstenschelp.github.io/2018/09/14/Plot_Confidence_Ellipse_001.html\n", + " latent = np.random.randn(n, 2)\n", + " cov = latent.dot(cov)\n", + " scaled = cov * scale\n", + " scaled_with_offset = scaled + mu\n", + " # return x and y of the new, correlated dataset\n", + " return scaled_with_offset[:, 0], scaled_with_offset[:, 1]\n", + "\n", + "def plot_samples(ax, samples_num, x, P, color, markersize, label):\n", + " scale = 1, 1\n", + " x, y = get_correlated_dataset(samples_num, P, x, scale)\n", + " ax.scatter(x, y, s=markersize, marker='x', c=color, label=label)\n", + " \n", + "def plot_mean(ax, x, size, color, label):\n", + " ax.scatter(x[0], x[1], s=size, marker='o', c=color, label=label)\n", + " \n", + "def plot_state(ax, x, P, samples_num, markersize, color, label):\n", + " x = x[0:2].reshape(2,)\n", + " P = P[0:2, 0:2]\n", + " \n", + " plot_ellipse(ax, x, P, color)\n", + " plot_samples(ax, samples_num, x, P, color, markersize, label+'_possibilities')\n", + " plot_mean(ax, x, 100, color, label+'_mean')\n", + " \n", + "def create_viewer(title, xlabel, ylabel, xlim=None, ylim=None):\n", + " fig, viewer = plt.subplots(figsize=(20, 10))\n", + " \n", + " viewer.set_title(title, fontsize=20, color='green', fontweight='bold')\n", + " \n", + " viewer.axvline(c='grey', lw=2)\n", + " viewer.axhline(c='grey', lw=2)\n", + "\n", + " viewer.set_xlabel(xlabel, fontsize=20, fontweight ='bold')\n", + " viewer.set_ylabel(ylabel, fontsize=20, fontweight ='bold')\n", + " \n", + " if (xlim != None):\n", + " viewer.set_xlim(xlim[0], xlim[1])\n", + " \n", + " if (ylim != None):\n", + " viewer.set_ylim(ylim[0], ylim[1])\n", + " \n", + " return viewer\n", + "\n", + "def visualize_estimate(viewer, label, color, x, P):\n", + " plot_state(viewer, x=x, P=P, samples_num=500, markersize=1, color=color, label=label)\n", + " \n", + "def update_plotter():\n", + " plt.grid(visible=True)\n", + " plt.legend(loc='upper right')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 411, + "id": "d8c90468", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10. 10.9486833 10. 10. 10. ]\n", + " [ 5. 5.31622777 5.89442719 5. 5. ]]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "viewer = create_viewer('State Space Uncertainties', 'x (m)', 'y (m)', xlim=(8,12), ylim=(4,6))\n", + "\n", + "print(x_sigmas[:2, :5])\n", + "\n", + "sigma_xlist = x_sigmas[0, :]\n", + "sigma_ylist = x_sigmas[1, :]\n", + "\n", + "viewer.scatter(sigma_xlist, sigma_ylist, s=80, marker='x', c='blue', label='sigma points Xx from initial state')\n", + "\n", + "visualize_estimate(viewer, 'initial state', 'g', x0, P0)\n", + "visualize_estimate(viewer, 'estimated state', 'r', x, P)\n", + "\n", + "update_plotter()" + ] + }, + { + "cell_type": "markdown", + "id": "1eb31fae", + "metadata": {}, + "source": [ + "## Example 2: Simulating Trajectory" + ] + }, + { + "cell_type": "markdown", + "id": "94c129ee", + "metadata": {}, + "source": [ + "Lastly, we try another example similar to example 1 but with generating a trajectory of poses and execute both prediction and measurement update steps from the UKF.\n", + "\n", + "This time, we should how the velocity states are also learned by the UKF only using the position measurements from the range sensor." + ] + }, + { + "cell_type": "code", + "execution_count": 412, + "id": "ae655b52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10. 11. 12. 13. 14. 15. 16.]\n", + "[5. 5. 5. 6. 6.5 7. 7. ]\n", + "P_a = \n", + "[[0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0.2 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0.2 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.1]]\n", + "\n", + "[[ 9.98405896e+00 1.08047174e+01 1.18787037e+01 1.29815388e+01\n", + " 1.39923109e+01 1.49897415e+01 1.59948532e+01]\n", + " [ 4.99180483e+00 5.02019308e+00 5.00968983e+00 5.80678516e+00\n", + " 6.47086869e+00 7.01145685e+00 7.09081134e+00]\n", + " [-1.19557802e-02 5.95841251e-01 9.32617542e-01 1.05312342e+00\n", + " 1.02324204e+00 1.00497457e+00 1.00492111e+00]\n", + " [-6.14637546e-03 1.94302206e-02 -1.23620739e-03 5.61868485e-01\n", + " 6.34049502e-01 5.68019265e-01 2.22795425e-01]]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# generate trajectory\n", + "\n", + "trajectory = [[10.0, 5.0], [11.0, 5.0], [12.0, 5.0], [13.0, 6.0], [14.0, 6.5], [15.0, 7.0], [16.0, 7.0]]\n", + "trajectory = np.asarray(trajectory)\n", + "\n", + "traj_xlist = trajectory[:, 0]\n", + "traj_ylist = trajectory[:, 1]\n", + "\n", + "print(traj_xlist)\n", + "print(traj_ylist)\n", + "\n", + "measurements = []\n", + "for pose in trajectory:\n", + " meas = RangeMeasurement(pose)\n", + " measurements.append(meas.asArray())\n", + "\n", + "measurements = np.asarray(measurements)\n", + "\n", + "\n", + "\n", + "x0 = np.array([10., 5., 0., 0.])\n", + "\n", + "P0 = np.array([[0.1, 0.0, 0.0, 0.0],\n", + " [0.0, 0.1, 0.0, 0.0],\n", + " [0.0, 0.0, 0.1, 0.0],\n", + " [0.0, 0.0, 0.0, 0.1]])\n", + "\n", + "Q = np.array([[0.2, 0.0],\n", + " [0.0, 0.2]])\n", + "\n", + "R = np.array([[0.1, 0.0],[0.0, 0.1]])\n", + "\n", + "nx = np.shape(x0)[0]\n", + "nz = np.shape(R)[0]\n", + "nv = np.shape(x0)[0]\n", + "nn = np.shape(R)[0]\n", + "\n", + "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))\n", + "\n", + "viewer = create_viewer('Tracking Target Trajectory', 'x (m)', 'y (m)', xlim=(8,20), ylim=(4,8))\n", + "viewer.scatter(traj_xlist, traj_ylist, s=80, marker='o', c='blue', label='actual target poses')\n", + "\n", + "x, P = x0, P0\n", + "\n", + "estimates = []\n", + "\n", + "for iteration, z in enumerate(measurements):\n", + " x, P, _ = ukf.predict(f_2, x, P)\n", + " x, P, _ = ukf.correct(h_2, x, P, z)\n", + " visualize_estimate(viewer, f'', 'g', x, P)\n", + " \n", + " estimates.append(x)\n", + "\n", + "estimates = np.asarray(estimates).T\n", + "print(estimates)\n", + "\n", + "estimates_px = estimates[0, :]\n", + "estimates_py = estimates[1, :]\n", + "\n", + "estimates_vx = estimates[2, :]\n", + "estimates_vy = estimates[3, :]\n", + "\n", + "viewer.plot(estimates_px, estimates_py)\n", + "\n", + "update_plotter()" + ] + }, + { + "cell_type": "code", + "execution_count": 413, + "id": "5550245b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "viewer = create_viewer('Velocity Profile', 'iteration', 'velocity (m/s)')\n", + "plt.rcParams.update({'font.size': 22})\n", + "viewer.plot(estimates_vx, color = 'blue', label='x_velocity')\n", + "viewer.plot(estimates_vy, color = 'red', label='y_velocity')\n", + "update_plotter()" + ] + }, + { + "cell_type": "markdown", + "id": "fd3064cb", + "metadata": {}, + "source": [ + "# References" + ] + }, + { + "cell_type": "markdown", + "id": "ccd8f3a0", + "metadata": {}, + "source": [ + "[1] [S. J. Julier and J. K. Uhlmann. A New Extension of the Kalman Filter\n", + "to Nonlinear Systems. In Proc. of AeroSense: The 11th Int. Symp. on\n", + "Aerospace/Defence Sensing, Simulation and Controls., 1997.](https://www.cs.unc.edu/~welch/kalman/media/pdf/Julier1997_SPIE_KF.pdf)\n", + "\n", + "[2] [E. A. Wan and R. van der Merwe, “The Unscented KalmanFilter for Nonlinear Estimation,” in Proc. of IEEE Symposium2000 (AS-SPCC), Lake Louise, Alberta, Canada, Oct. 2000.](https://groups.seas.harvard.edu/courses/cs281/papers/unscented.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7aefb34f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 3d1b9aecbef28f4d81e6ed71e3d2f0e34c8ae693 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sun, 4 Dec 2022 15:54:43 +0100 Subject: [PATCH 06/60] add ukf images --- python/examples/images/posts/ukf/figure_1.png | Bin 0 -> 55037 bytes python/examples/images/posts/ukf/figure_2.png | Bin 0 -> 55598 bytes python/examples/images/posts/ukf/figure_3.png | Bin 0 -> 42131 bytes 3 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 python/examples/images/posts/ukf/figure_1.png create mode 100644 python/examples/images/posts/ukf/figure_2.png create mode 100644 python/examples/images/posts/ukf/figure_3.png diff --git a/python/examples/images/posts/ukf/figure_1.png b/python/examples/images/posts/ukf/figure_1.png new file mode 100644 index 0000000000000000000000000000000000000000..06a747a4c75733a94583a196cbee0bb4609530ae GIT binary patch literal 55037 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 literal 0 HcmV?d00001 diff --git a/python/examples/images/posts/ukf/figure_3.png b/python/examples/images/posts/ukf/figure_3.png new file mode 100644 index 0000000000000000000000000000000000000000..aac8956a7db06af9cc0c70a0b019f6900d76f7f8 GIT binary patch literal 42131 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%0DC&26q_RgU$uKCFaGsf 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 Date: Tue, 6 Dec 2022 21:32:20 +0100 Subject: [PATCH 07/60] optimize unscented transformation cpp code --- LICENSE | 2 +- README.md | 6 ++++- cpp/kalman_filter/unscented_transform.h | 32 +++++++++++++----------- res/images/codingcorner_cover_image.png | Bin 0 -> 34256 bytes 4 files changed, 23 insertions(+), 17 deletions(-) create mode 100644 res/images/codingcorner_cover_image.png diff --git a/LICENSE b/LICENSE index b89b682..eeba7bc 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2022 mohanadhammad +Copyright (c) 2022 CodingCorner (Mohanad Youssef) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md index f11a896..4fab006 100644 --- a/README.md +++ b/README.md @@ -1 +1,5 @@ -# KalmanFilter \ No newline at end of file +# KalmanFilter + +**Author**: Mohanad Youssef ([CodingCorner Website](codingcorner.org)) + +![](res/images/codingcorner_cover_image.png) diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index 011dfac..55837d4 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -49,7 +49,8 @@ namespace kf { std::cout << "DIM_N : " << DIM << "\n"; std::cout << "DIM_M : " << SIGMA_DIM << "\n"; - std::cout << "_weights : \n" << _weights << "\n"; + std::cout << "_weight0 : \n" << _weight0 << "\n"; + std::cout << "_weighti : \n" << _weighti << "\n"; std::cout << "_sigmaX : \n" << _sigmaX << "\n"; std::cout << "_sigmaY : \n" << _sigmaY << "\n"; std::cout << "_vecY : \n" << _vecY << "\n"; @@ -72,7 +73,8 @@ namespace kf const Matrix & matPyy() const { return _matPyy; } private: - Matrix<1, SIGMA_DIM> _weights; /// @brief unscented transform weights + float32_t _weight0; /// @brief unscented transform weight 0 for mean + float32_t _weighti; /// @brief unscented transform weight 0 for none mean samples Matrix _sigmaX; /// @brief input sigma points Matrix _sigmaY; /// @brief output sigma points @@ -87,14 +89,12 @@ namespace kf /// void updateWeights(float32_t kappa) { - const float32_t denoTerm{ kappa + static_cast(DIM) }; + static_assert(DIM > 0, "DIM is Zero which leads to numerical issue."); - _weights(0, 0) = kappa / denoTerm; + const float32_t denoTerm{ kappa + static_cast(DIM) }; - for (int32_t i{ 1 }; i < SIGMA_DIM; ++i) - { - _weights(0, i) = 0.5F / denoTerm; - } + _weight0 = kappa / denoTerm; + _weighti = 0.5F / denoTerm; } /// @@ -152,19 +152,21 @@ namespace kf void updateTransformedMeanAndCovariance() { // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] - _vecY = Vector::Zero(); - for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + _vecY = _weight0 * util::getColumnAt(0, _sigmaY); + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - _vecY += _weights(0, i) * util::getColumnAt(i, _sigmaY); // y += W[0, i] Y[:, i] + _vecY += _weighti * util::getColumnAt(i, _sigmaY); // y += W[0, i] Y[:, i] } // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T - _matPyy = Matrix::Zero(); - for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + Vector devYi{ util::getColumnAt(0, _sigmaY) - _vecY }; // Y[:, 0] - \bar{ y } + _matPyy = _weight0 * devYi * devYi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T + + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - const Vector devYi{ util::getColumnAt(i, _sigmaY) - _vecY }; // Y[:, i] - \bar{y} + devYi = util::getColumnAt(i, _sigmaY) - _vecY; // Y[:, i] - \bar{y} - Matrix Pi{ _weights(0, i) * devYi * devYi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + const Matrix Pi{ _weighti * devYi * devYi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T _matPyy += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T } diff --git a/res/images/codingcorner_cover_image.png b/res/images/codingcorner_cover_image.png new file mode 100644 index 0000000000000000000000000000000000000000..4501cd2291df5d8e5c5dd964e6e0ab70696fc288 GIT binary patch literal 34256 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 U*UP-r+t>F_Oir{!`2DB<1q(Wsf&c&j literal 0 HcmV?d00001 From 17adb8d3d5a5e47fa58b551c02ded1fc314a28e7 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Tue, 6 Dec 2022 21:35:04 +0100 Subject: [PATCH 08/60] update readme file --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 4fab006..914349d 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # KalmanFilter -**Author**: Mohanad Youssef ([CodingCorner Website](codingcorner.org)) +**Author**: Mohanad Youssef ([codingcorner.org](https://codingcorner.org/)) ![](res/images/codingcorner_cover_image.png) From 568661107ba02182d9dee0e371be16e49aa66d36 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Wed, 7 Dec 2022 19:00:19 +0100 Subject: [PATCH 09/60] refactor unscented transform class --- cpp/Examples/unscented_transform/main.cpp | 22 +++++++- cpp/kalman_filter/kalman_filter.h | 8 +-- cpp/kalman_filter/unscented_transform.h | 68 +++++++++++------------ 3 files changed, 58 insertions(+), 40 deletions(-) diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index 21c06c0..4b4f99e 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -59,9 +59,18 @@ void runExample1() Matrix P; P << 0.5F; - kf::UnscentedTransform UT(function1, x, P, 0.0F); + kf::UnscentedTransform UT; + UT.compute(x, P, 0.0F); + + Vector vecY; + Matrix matPyy; + + UT.transform(function1, vecY, matPyy); UT.showSummary(); + std::cout << "vecY: \n" << vecY << "\n"; + std::cout << "matPyy: \n" << matPyy << "\n"; + std::cout << " End of Example 1: ===========================" << std::endl; } @@ -75,8 +84,17 @@ void runExample2() Matrix P; P << 0.1F, 0.0F, 0.0F, 0.1F; - kf::UnscentedTransform UT(function2, x, P, 0.0F); + kf::UnscentedTransform UT; + UT.compute(x, P, 0.0F); + + Vector vecY; + Matrix matPyy; + + UT.transform(function2, vecY, matPyy); UT.showSummary(); + std::cout << "vecY: \n" << vecY << "\n"; + std::cout << "matPyy: \n" << matPyy << "\n"; + std::cout << " End of Example 2: ===========================" << std::endl; } diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index 4f7aef8..95d2990 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -71,9 +71,9 @@ namespace kf /// @param matQ process noise covariance matrix /// template - void predictEkf(PredictionModelCallback predictionModel, const Matrix & matJacobF, const Matrix & matQ) + void predictEkf(PredictionModelCallback predictionModelFunc, const Matrix & matJacobF, const Matrix & matQ) { - m_vecX = predictionModel(m_vecX); + m_vecX = predictionModelFunc(m_vecX); m_matP = matJacobF * m_matP * matJacobF.transpose() + matQ; } @@ -85,13 +85,13 @@ namespace kf /// @param matJcobH measurement jacobian matrix /// template - void correctEkf(MeasurementModelCallback measurementModel,const Vector & vecZ, const Matrix & matR, const Matrix & matJcobH) + void correctEkf(MeasurementModelCallback measurementModelFunc,const Vector & vecZ, const Matrix & matR, const Matrix & matJcobH) { const Matrix matI{ Matrix::Identity() }; // Identity matrix const Matrix matSk{ matJcobH * m_matP * matJcobH.transpose() + matR }; // Innovation covariance const Matrix matKk{ m_matP * matJcobH.transpose() * matSk.inverse() }; // Kalman Gain - m_vecX = m_vecX + matKk * (vecZ - measurementModel(m_vecX)); + m_vecX = m_vecX + matKk * (vecZ - measurementModelFunc(m_vecX)); m_matP = (matI - matKk * matJcobH) * m_matP; } diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index 55837d4..3a4640f 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -24,27 +24,37 @@ namespace kf public: static constexpr size_t SIGMA_DIM{ (2 * DIM) + 1 }; - UnscentedTransform() = delete; + UnscentedTransform() = default; + ~UnscentedTransform() {} - template - explicit UnscentedTransform( - NonLinearFunctionCallback nonlinearFunction,const Vector & vecX, const Matrix & matPxx, const float32_t kappa=0.0F) + void compute(const Vector & vecX, const Matrix & matPxx, const float32_t kappa = 0.0F) { // 1. calculate weights updateWeights(kappa); // 2. update sigma points _sigmaX updateSigmaPoints(vecX, matPxx, kappa); + } + + /// + /// @brief algorithm to execute transforming sigma points through nonlinear function + /// and calculate the updated weights and covariance. + /// @param nonlinearFunction nonlinear function callback + /// @param vecY output mean vector (weighted mean vector) + /// @param matPyy output covariance matrix (weighted covariance matrix) + /// + template + void transform(NonLinearFunctionCallback nonlinearFunction, Vector & vecY, Matrix & matPyy) + { + Matrix sigmaY; // 3. transform sigma points X through the nonlinear model f(X) to obtain Y sigma points - transformSigmaPoints(nonlinearFunction); + transformSigmaPoints(nonlinearFunction, sigmaY); // 4. calculate weight mean and covariance from the transformed sigma points Y and weights - updateTransformedMeanAndCovariance(); + updateTransformedMeanAndCovariance(sigmaY, vecY, matPyy); } - ~UnscentedTransform() {} - void showSummary() { std::cout << "DIM_N : " << DIM << "\n"; @@ -52,9 +62,6 @@ namespace kf std::cout << "_weight0 : \n" << _weight0 << "\n"; std::cout << "_weighti : \n" << _weighti << "\n"; std::cout << "_sigmaX : \n" << _sigmaX << "\n"; - std::cout << "_sigmaY : \n" << _sigmaY << "\n"; - std::cout << "_vecY : \n" << _vecY << "\n"; - std::cout << "_matPyy : \n" << _matPyy << "\n"; } Matrix<1, SIGMA_DIM> & weights() { return _weights; } @@ -63,28 +70,14 @@ namespace kf Matrix & sigmaX() { return _sigmaX; } const Matrix & sigmaX() const { return _sigmaX; } - Matrix & sigmaY() { return _sigmaY; } - const Matrix & sigmaY() const { return _sigmaY; } - - Vector & vecY() { return _vecY; } - const Vector & vecY() const { return _vecY; } - - Matrix & matPyy() { return _matPyy; } - const Matrix & matPyy() const { return _matPyy; } - private: float32_t _weight0; /// @brief unscented transform weight 0 for mean float32_t _weighti; /// @brief unscented transform weight 0 for none mean samples Matrix _sigmaX; /// @brief input sigma points - Matrix _sigmaY; /// @brief output sigma points - - Vector _vecY; /// @brief output y mean vector (weighted mean vector) - Matrix _matPyy; /// @brief output Pyy covariance matrix (weighted covariance matrix) /// /// @brief algorithm to calculate the weights used to draw the sigma points - /// /// @param kappa design scaling parameter for sigma points selection /// void updateWeights(float32_t kappa) @@ -136,39 +129,46 @@ namespace kf /// /// @brief transform sigma points X through the nonlinear function /// @param nonlinearFunction nonlinear function to be used + /// @param sigmaY output transformed sigma points from the nonlinear function /// template - void transformSigmaPoints(NonLinearFunctionCallback nonlinearFunction) + void transformSigmaPoints(NonLinearFunctionCallback nonlinearFunction, Matrix & sigmaY) { for (size_t i{ 0 }; i < SIGMA_DIM; ++i) { const Vector x{ util::getColumnAt(i, _sigmaX) }; const Vector y{ nonlinearFunction(x) }; // y = f(x) - util::copyToColumn(i, _sigmaY, y); // Y[:, i] = y + util::copyToColumn(i, sigmaY, y); // Y[:, i] = y } } - void updateTransformedMeanAndCovariance() + /// + /// @brief calculate weighted mean and covariance given a set of sigma points with associated weights. + /// @param sigmaY input transformed sigma points from the nonlinear function + /// @param vecY output weighted mean vector + /// @param matPyy output weighted covariance matrix + /// + void updateTransformedMeanAndCovariance(const Matrix & sigmaY, Vector & vecY, Matrix & matPyy) { // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] - _vecY = _weight0 * util::getColumnAt(0, _sigmaY); + vecY = _weight0 * util::getColumnAt(0, sigmaY); for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - _vecY += _weighti * util::getColumnAt(i, _sigmaY); // y += W[0, i] Y[:, i] + vecY += _weighti * util::getColumnAt(i, sigmaY); // y += W[0, i] Y[:, i] } // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T - Vector devYi{ util::getColumnAt(0, _sigmaY) - _vecY }; // Y[:, 0] - \bar{ y } - _matPyy = _weight0 * devYi * devYi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T + Vector devYi{ util::getColumnAt(0, sigmaY) - vecY }; // Y[:, 0] - \bar{ y } + matPyy = _weight0 * devYi * devYi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - devYi = util::getColumnAt(i, _sigmaY) - _vecY; // Y[:, i] - \bar{y} + devYi = util::getColumnAt(i, sigmaY) - vecY; // Y[:, i] - \bar{y} const Matrix Pi{ _weighti * devYi * devYi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T - _matPyy += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + matPyy += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T } } }; From 076533323d4be3639a70d5624826a2236527cb22 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Fri, 9 Dec 2022 13:50:31 +0100 Subject: [PATCH 10/60] adding test in ukf python example --- ...Introduction_Unscented_Kalman_Filter.ipynb | 250 ++++++++++++------ 1 file changed, 167 insertions(+), 83 deletions(-) diff --git a/python/examples/Introduction_Unscented_Kalman_Filter.ipynb b/python/examples/Introduction_Unscented_Kalman_Filter.ipynb index 67e4c54..45c9d70 100644 --- a/python/examples/Introduction_Unscented_Kalman_Filter.ipynb +++ b/python/examples/Introduction_Unscented_Kalman_Filter.ipynb @@ -257,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 398, + "execution_count": 1, "id": "2aa5bdf8", "metadata": {}, "outputs": [], @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 399, + "execution_count": 2, "id": "37eec130", "metadata": {}, "outputs": [], @@ -303,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 400, + "execution_count": 3, "id": "8e921b79", "metadata": {}, "outputs": [ @@ -346,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 401, + "execution_count": 4, "id": "9aeddf21", "metadata": {}, "outputs": [], @@ -559,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 402, + "execution_count": 5, "id": "91e23cf6", "metadata": {}, "outputs": [], @@ -574,7 +574,7 @@ }, { "cell_type": "code", - "execution_count": 403, + "execution_count": 6, "id": "1da0a648", "metadata": {}, "outputs": [ @@ -634,7 +634,7 @@ }, { "cell_type": "code", - "execution_count": 404, + "execution_count": 7, "id": "8d371939", "metadata": {}, "outputs": [ @@ -721,7 +721,7 @@ }, { "cell_type": "code", - "execution_count": 405, + "execution_count": 25, "id": "458845ec", "metadata": {}, "outputs": [], @@ -730,8 +730,8 @@ " xo = np.zeros((np.shape(x)[0],))\n", " xo[0] = x[0] + x[2] + nu[0]\n", " xo[1] = x[1] + x[3] + nu[1]\n", - " xo[2] = x[2] + nu[0]\n", - " xo[3] = x[3] + nu[1]\n", + " xo[2] = x[2] + nu[2]\n", + " xo[3] = x[3] + nu[3]\n", " return xo" ] }, @@ -788,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 406, + "execution_count": 26, "id": "35b2885c", "metadata": {}, "outputs": [ @@ -824,7 +824,7 @@ }, { "cell_type": "code", - "execution_count": 407, + "execution_count": 27, "id": "7bf9823b", "metadata": {}, "outputs": [], @@ -836,36 +836,26 @@ " z : output measurement vector [2 x 1] ([0]: range, [1]: bearing )\n", " '''\n", " z = np.zeros((2,))\n", - " z[0] = np.sqrt((x[0] + n[0])**2 + (x[1] + n[1])**2)\n", - " z[1] = np.arctan((x[1] + n[1]) / ((x[0] + n[0]) + sys.float_info.epsilon))\n", + " px = x[0] + n[0]\n", + " py = x[1] + n[1]\n", + " \n", + " z[0] = np.sqrt(px**2 + py**2)\n", + " z[1] = np.arctan(py / (px + sys.float_info.epsilon))\n", " return z" ] }, { - "cell_type": "code", - "execution_count": 408, - "id": "194f373a", + "cell_type": "markdown", + "id": "14f64538", "metadata": {}, - "outputs": [], "source": [ - "x0 = np.array([10., 5., 0., 0.])\n", - "\n", - "P0 = np.array([[0.3, 0.1, 0.0, 0.0],\n", - " [0.1, 0.3, 0.0, 0.0],\n", - " [0.0, 0.0, 0.1, 0.0],\n", - " [0.0, 0.0, 0.0, 0.1]])\n", - "\n", - "Q = np.array([[0.2, 0.0],\n", - " [0.0, 0.2]])\n", - "\n", - "z = measurement.asArray()\n", - "R = np.array([[0.1, 0.0],[0.0, 0.1]])" + "##" ] }, { "cell_type": "code", - "execution_count": 409, - "id": "c752a547", + "execution_count": 28, + "id": "194f373a", "metadata": {}, "outputs": [ { @@ -873,45 +863,68 @@ "output_type": "stream", "text": [ "P_a = \n", - "[[0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0.2 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0.2 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0.1 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0.1]]\n", + "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0.05 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0.05 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0.1 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.1 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0.01 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.01]]\n", "\n", - "=====Iteration 1====\n", "x = \n", - "[10.548 5.476 0. 0. ]\n", - "\n", + " [2. 1. 0. 0.]\n", "P = \n", - "[[0.073 0.007 0. 0. ]\n", - " [0.007 0.073 0. 0. ]\n", - " [0. 0. 0.1 0. ]\n", - " [0. 0. 0. 0.1 ]]\n", - "\n", - "\n", - "\n", - "\n" + " [[ 0.11 0. 0.05 -0. ]\n", + " [ 0. 0.11 -0. 0.05]\n", + " [ 0.05 -0. 0.15 0. ]\n", + " [-0. 0.05 0. 0.15]]\n", + "x = \n", + " [ 2.554 0.356 0.252 -0.293]\n", + "P = \n", + " [[ 0.01 -0.001 0.005 -0. ]\n", + " [-0.001 0.01 -0. 0.005]\n", + " [ 0.005 -0. 0.129 -0. ]\n", + " [-0. 0.005 -0. 0.129]]\n" ] } ], "source": [ + "x0 = np.array([2.0, 1.0, 0., 0.])\n", + "\n", + "P0 = np.array([[0.01, 0.0, 0.0, 0.0],\n", + " [0.0, 0.01, 0.0, 0.0],\n", + " [0.0, 0.0, 0.05, 0.0],\n", + " [0.0, 0.0, 0.0, 0.05]])\n", + "\n", + "Q = np.array([[0.05, 0.0, 0.0, 0.0],\n", + " [0.0, 0.05, 0.0, 0.0],\n", + " [0.0, 0.0, 0.1, 0.0],\n", + " [0.0, 0.0, 0.0, 0.1]])\n", + "\n", + "R = np.array([[0.01, 0.0],\n", + " [0.0, 0.01]])\n", + "\n", + "z = np.array([2.5, 0.05])\n", + "\n", "nx = np.shape(x0)[0]\n", - "nz = np.shape(z)[0]\n", + "nz = np.shape(R)[0]\n", "nv = np.shape(x0)[0]\n", - "nn = np.shape(z)[0]\n", + "nn = np.shape(R)[0]\n", "\n", "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))\n", "\n", + "x, P, _ = ukf.predict(f_2, x0, P0)\n", "\n", - "print('=====Iteration 1====')\n", - "x, P, x_sigmas = ukf.correct(h_2, x0, P0, z)\n", - "print(f'x = \\n{x.round(3)}\\n')\n", - "print(f'P = \\n{P.round(3)}\\n')\n", - "print('\\n\\n')" + "print(f'x = \\n {x.round(3)}')\n", + "print(f'P = \\n {P.round(3)}')\n", + "\n", + "x, P, _ = ukf.correct(h_2, x, P, z)\n", + "\n", + "print(f'x = \\n {x.round(3)}')\n", + "print(f'P = \\n {P.round(3)}')" ] }, { @@ -924,7 +937,7 @@ }, { "cell_type": "code", - "execution_count": 410, + "execution_count": 29, "id": "c4c05b70", "metadata": {}, "outputs": [], @@ -1016,7 +1029,74 @@ }, { "cell_type": "code", - "execution_count": 411, + "execution_count": 30, + "id": "c752a547", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P_a = \n", + "[[0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0.2 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0.2 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.1]]\n", + "\n", + "=====Iteration 1====\n", + "x = \n", + "[10.548 5.476 0. 0. ]\n", + "\n", + "P = \n", + "[[0.073 0.007 0. 0. ]\n", + " [0.007 0.073 0. 0. ]\n", + " [0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0.1 ]]\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "x0 = np.array([10., 5., 0., 0.])\n", + "\n", + "P0 = np.array([[0.3, 0.1, 0.0, 0.0],\n", + " [0.1, 0.3, 0.0, 0.0],\n", + " [0.0, 0.0, 0.1, 0.0],\n", + " [0.0, 0.0, 0.0, 0.1]])\n", + "\n", + "Q = np.array([[0.05, 0.0, 0.0, 0.0],\n", + " [0.0, 0.05, 0.0, 0.0],\n", + " [0.0, 0.0, 0.1, 0.0],\n", + " [0.0, 0.0, 0.0, 0.1]])\n", + "\n", + "z = measurement.asArray()\n", + "R = np.array([[0.1, 0.0],[0.0, 0.1]])\n", + "\n", + "nx = np.shape(x0)[0]\n", + "nz = np.shape(z)[0]\n", + "nv = np.shape(x0)[0]\n", + "nn = np.shape(z)[0]\n", + "\n", + "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))\n", + "\n", + "\n", + "print('=====Iteration 1====')\n", + "x, P, x_sigmas = ukf.correct(h_2, x0, P0, z)\n", + "print(f'x = \\n{x.round(3)}\\n')\n", + "print(f'P = \\n{P.round(3)}\\n')\n", + "print('\\n\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, "id": "d8c90468", "metadata": {}, "outputs": [ @@ -1030,7 +1110,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "

" ] @@ -1077,7 +1157,7 @@ }, { "cell_type": "code", - "execution_count": 412, + "execution_count": 34, "id": "ae655b52", "metadata": {}, "outputs": [ @@ -1088,28 +1168,30 @@ "[10. 11. 12. 13. 14. 15. 16.]\n", "[5. 5. 5. 6. 6.5 7. 7. ]\n", "P_a = \n", - "[[0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0.2 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0.2 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0.1 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0.1]]\n", + "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0.05 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0.05 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0.1 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.1 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.1 ]]\n", "\n", - "[[ 9.98405896e+00 1.08047174e+01 1.18787037e+01 1.29815388e+01\n", - " 1.39923109e+01 1.49897415e+01 1.59948532e+01]\n", - " [ 4.99180483e+00 5.02019308e+00 5.00968983e+00 5.80678516e+00\n", - " 6.47086869e+00 7.01145685e+00 7.09081134e+00]\n", - " [-1.19557802e-02 5.95841251e-01 9.32617542e-01 1.05312342e+00\n", - " 1.02324204e+00 1.00497457e+00 1.00492111e+00]\n", - " [-6.14637546e-03 1.94302206e-02 -1.23620739e-03 5.61868485e-01\n", - " 6.34049502e-01 5.68019265e-01 2.22795425e-01]]\n" + "[[ 9.99002177e+00 1.07534723e+01 1.18187060e+01 1.29357641e+01\n", + " 1.39725527e+01 1.49855172e+01 1.59963238e+01]\n", + " [ 4.99492550e+00 5.02034824e+00 5.01847395e+00 5.77733437e+00\n", + " 6.43401214e+00 6.99288321e+00 7.10338182e+00]\n", + " [-3.99129308e-03 4.34381627e-01 7.92808821e-01 9.74963925e-01\n", + " 1.00964375e+00 1.01150534e+00 1.01105322e+00]\n", + " [-2.02979888e-03 1.37478208e-02 5.02139716e-03 4.28073680e-01\n", + " 5.56148927e-01 5.57674915e-01 3.07029381e-01]]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1148,8 +1230,10 @@ " [0.0, 0.0, 0.1, 0.0],\n", " [0.0, 0.0, 0.0, 0.1]])\n", "\n", - "Q = np.array([[0.2, 0.0],\n", - " [0.0, 0.2]])\n", + "Q = np.array([[0.05, 0.0, 0.0, 0.0],\n", + " [0.0, 0.05, 0.0, 0.0],\n", + " [0.0, 0.0, 0.1, 0.0],\n", + " [0.0, 0.0, 0.0, 0.1]])\n", "\n", "R = np.array([[0.1, 0.0],[0.0, 0.1]])\n", "\n", @@ -1190,13 +1274,13 @@ }, { "cell_type": "code", - "execution_count": 413, + "execution_count": 35, "id": "5550245b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 9357dc4cfe5e45d7742f240bde1f9500dc41b062 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Fri, 9 Dec 2022 14:22:14 +0100 Subject: [PATCH 11/60] cpp implementation of ukf with example --- cpp/Examples/CMakeLists.txt | 1 + cpp/Examples/ukf_range_sensor/CMakeLists.txt | 26 ++ cpp/Examples/ukf_range_sensor/main.cpp | 120 ++++++++ cpp/kalman_filter/kalman_filter.h | 2 +- cpp/kalman_filter/unscented_kalman_filter.h | 292 +++++++++++++++++++ 5 files changed, 440 insertions(+), 1 deletion(-) create mode 100644 cpp/Examples/ukf_range_sensor/CMakeLists.txt create mode 100644 cpp/Examples/ukf_range_sensor/main.cpp create mode 100644 cpp/kalman_filter/unscented_kalman_filter.h diff --git a/cpp/Examples/CMakeLists.txt b/cpp/Examples/CMakeLists.txt index cf08794..85cae8f 100644 --- a/cpp/Examples/CMakeLists.txt +++ b/cpp/Examples/CMakeLists.txt @@ -3,3 +3,4 @@ set(EXAMPLE_EXECUTABLE_PREFIX "example_") add_subdirectory(kf_state_estimation) add_subdirectory(ekf_range_sensor) add_subdirectory(unscented_transform) +add_subdirectory(ukf_range_sensor) diff --git a/cpp/Examples/ukf_range_sensor/CMakeLists.txt b/cpp/Examples/ukf_range_sensor/CMakeLists.txt new file mode 100644 index 0000000..aeb72e7 --- /dev/null +++ b/cpp/Examples/ukf_range_sensor/CMakeLists.txt @@ -0,0 +1,26 @@ +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an MIT - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/MIT. +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ukf_range_sensor) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) +target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp new file mode 100644 index 0000000..204342a --- /dev/null +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -0,0 +1,120 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "kalman_filter/types.h" +#include "kalman_filter/unscented_kalman_filter.h" + +static constexpr size_t DIM_X{ 4 }; +static constexpr size_t DIM_V{ 4 }; +static constexpr size_t DIM_Z{ 2 }; +static constexpr size_t DIM_N{ 2 }; + +void runExample1(); + +Vector funcF(const Vector & x, const Vector & v) +{ + Vector y; + y[0] = x[0] + x[2] + v[0]; + y[1] = x[1] + x[3] + v[1]; + y[2] = x[2] + v[2]; + y[3] = x[3] + v[3]; + return y; +} + +Vector funcH(const Vector & x, const Vector & n) +{ + Vector y; + + float32_t px{ x[0] + n[0] }; + float32_t py{ x[1] + n[1] }; + + y[0] = std::sqrt((px * px) + (py * py)); + y[1] = std::atan(py / (px + std::numeric_limits::epsilon())); + return y; +} + +int main(int argc, char ** argv) +{ + // example 1 + runExample1(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + Vector x; + x << 2.0F, 1.0F, 0.0F, 0.0F; + + Matrix P; + P << 0.01F, 0.0F, 0.0F, 0.0F, + 0.0F, 0.01F, 0.0F, 0.0F, + 0.0F, 0.0F, 0.05F, 0.0F, + 0.0F, 0.0F, 0.0F, 0.05F; + + Matrix Q; + Q << 0.05F, 0.0F, 0.0F, 0.0F, + 0.0F, 0.05F, 0.0F, 0.0F, + 0.0F, 0.0F, 0.1F, 0.0F, + 0.0F, 0.0F, 0.0F, 0.1F; + + Matrix R; + R << 0.01F, 0.0F, 0.0F, 0.01F; + + Vector z; + z << 2.5, 0.05; + + kf::UnscentedKalmanFilter ukf; + + ukf.vecX() = x; + ukf.matP() = P; + + ukf.setCovarianceQ(Q); + ukf.setCovarianceR(R); + + ukf.predict(funcF); + + std::cout << "x = \n" << ukf.vecX() << std::endl; + std::cout << "P = \n" << ukf.matP() << std::endl; + + // Expectation from the python results: + // ===================================== + // x = + // [2.0 1.0 0.0 0.0] + // P = + // [[0.11 0.00 0.05 0.00] + // [0.00 0.11 0.00 0.05] + // [0.05 0.00 0.15 0.00] + // [0.00 0.05 0.00 0.15]] + + ukf.correct(funcH, z); + + std::cout << "x = \n" << ukf.vecX() << std::endl; + std::cout << "P = \n" << ukf.matP() << std::endl; + + // Expectations from the python results: + // ====================================== + // x = + // [ 2.554 0.356 0.252 -0.293] + // P = + // [[ 0.01 -0.001 0.005 -0. ] + // [-0.001 0.01 - 0. 0.005 ] + // [ 0.005 - 0. 0.129 - 0. ] + // [-0. 0.005 - 0. 0.129]] + + std::cout << " End of Example 1: ===========================" << std::endl; +} + diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index 95d2990..56defed 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -95,7 +95,7 @@ namespace kf m_matP = (matI - matKk * matJcobH) * m_matP; } - private: + protected: Vector m_vecX{ Vector::Zero() }; /// @brief estimated state vector Matrix m_matP{ Matrix::Zero() }; /// @brief state covariance matrix }; diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h new file mode 100644 index 0000000..7d82ffd --- /dev/null +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -0,0 +1,292 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an MIT - style +/// license that can be found in the LICENSE file or at +/// https ://opensource.org/licenses/MIT. +/// +/// @author Mohanad Youssef +/// @file unscented_kalman_filter.h +/// + +#ifndef __UNSCENTED_KALMAN_FILTER_LIB_H__ +#define __UNSCENTED_KALMAN_FILTER_LIB_H__ + +#include "util.h" +#include "kalman_filter.h" + +namespace kf +{ + template + class UnscentedKalmanFilter : public KalmanFilter + { + public: + static constexpr int32_t DIM_A{ DIM_X + DIM_V + DIM_N }; + static constexpr int32_t SIGMA_DIM{ 2 * DIM_A + 1 }; + + UnscentedKalmanFilter() : KalmanFilter() + { + // 1. calculate weights + const float32_t kappa{ static_cast(3 - DIM_A) }; + updateWeights(kappa); + } + + ~UnscentedKalmanFilter() {} + + void setCovarianceQ(const Matrix & matQ) + { + const size_t S_IDX{ DIM_X }; + const size_t L_IDX{ S_IDX + DIM_V }; + + for (size_t i{ S_IDX }; i < L_IDX; ++i) + { + for (size_t j{ S_IDX }; j < L_IDX; ++j) + { + m_matPa(i, j) = matQ(i - S_IDX, j - S_IDX); + } + } + } + + void setCovarianceR(const Matrix & matR) + { + const size_t S_IDX{ DIM_X + DIM_V }; + const size_t L_IDX{ S_IDX + DIM_N }; + + for (size_t i{ S_IDX }; i < L_IDX; ++i) + { + for (size_t j{ S_IDX }; j < L_IDX; ++j) + { + m_matPa(i, j) = matR(i - S_IDX, j - S_IDX); + } + } + } + + void updateAugmentedStateAndCovariance() + { + updateAugmentedVecX(); + updateAugmentedMatP(); + } + + template + void predict(PredictionModelCallback predictionModelFunc) + { + // self.x_a[:self.dim_x] = x + // self.P_a[:self.dim_x, : self.dim_x] = P + updateAugmentedStateAndCovariance(); + + const float32_t kappa{ static_cast(3 - DIM_A) }; + + // xa_sigmas = self.sigma_points(self.x_a, self.P_a) + Matrix matSigmaXa{ calculateSigmaPoints(m_vecXa, m_matPa, kappa) }; + + // xx_sigmas = xa_sigmas[:self.dim_x, :] + Matrix sigmaXx{ matSigmaXa.block(0, 0) }; + + // xv_sigmas = xa_sigmas[self.dim_x : self.dim_x + self.dim_v, :] + Matrix sigmaXv{ matSigmaXa.block(DIM_X, 0) }; + + // y_sigmas = np.zeros((self.dim_x, self.n_sigma)) + // for i in range(self.n_sigma): + // y_sigmas[:, i] = f(xx_sigmas[:, i], xv_sigmas[:, i]) + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + const Vector sigmaXxi{ util::getColumnAt(i, sigmaXx) }; + const Vector sigmaXvi{ util::getColumnAt(i, sigmaXv) }; + + const Vector Yi{ predictionModelFunc(sigmaXxi, sigmaXvi) }; // y = f(x) + + util::copyToColumn(i, sigmaXx, Yi); // Y[:, i] = y + } + + // y, Pyy = self.calculate_mean_and_covariance(y_sigmas) + calculateWeightedMeanAndCovariance(sigmaXx, m_vecX, m_matP); + + //// self.x_a[:self.dim_x] = y + //// self.P_a[:self.dim_x, : self.dim_x] = Pyy + //updateAugmentedStateAndCovariance(); + } + + template + void correct(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) + { + // self.x_a[:self.dim_x] = x + // self.P_a[:self.dim_x, : self.dim_x] = P + updateAugmentedStateAndCovariance(); + + const float32_t kappa{ static_cast(3 - DIM_A) }; + + // xa_sigmas = self.sigma_points(self.x_a, self.P_a) + Matrix matSigmaXa{ calculateSigmaPoints(m_vecXa, m_matPa, kappa) }; + + // xx_sigmas = xa_sigmas[:self.dim_x, :] + Matrix sigmaXx{ matSigmaXa.block(0, 0) }; + + // xn_sigmas = xa_sigmas[self.dim_x + self.dim_v :, :] + Matrix sigmaXn{ matSigmaXa.block(DIM_X + DIM_V, 0) }; + + // y_sigmas = np.zeros((self.dim_z, self.n_sigma)) + // for i in range(self.n_sigma) : + // y_sigmas[:, i] = h(xx_sigmas[:, i], xn_sigmas[:, i]) + Matrix sigmaY; + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + const Vector sigmaXxi{ util::getColumnAt(i, sigmaXx) }; + const Vector sigmaXni{ util::getColumnAt(i, sigmaXn) }; + + const Vector Yi{ measurementModelFunc(sigmaXxi, sigmaXni) }; // y = f(x) + + util::copyToColumn(i, sigmaY, Yi); // Y[:, i] = y + } + + // y, Pyy = self.calculate_mean_and_covariance(y_sigmas) + Vector vecY; + Matrix matPyy; + calculateWeightedMeanAndCovariance(sigmaY, vecY, matPyy); + + // TODO: calculate cross correlation + const Matrix matPxy{ calculateCrossCorrelation(sigmaXx, m_vecX, sigmaY, vecY) }; + + // kalman gain + const Matrix matK{ matPxy * matPyy.inverse() }; + + m_vecX += matK * (vecZ - vecY); + m_matP -= matK * matPyy * matK.transpose(); + + //// self.x_a[:self.dim_x] = x + //// self.P_a[:self.dim_x, : self.dim_x] = P + //updateAugmentedStateAndCovariance(); + } + + private: + using KalmanFilter::m_vecX; // from Base KalmanFilter class + using KalmanFilter::m_matP; // from Base KalmanFilter class + + float32_t m_weight0; /// @brief unscented transform weight 0 for mean + float32_t m_weighti; /// @brief unscented transform weight i for none mean samples + + Vector m_vecXa{ Vector::Zero() }; /// @brief augmented state vector (incl. process and measurement noise means) + Matrix m_matPa{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + + void updateAugmentedVecX() + { + for (size_t i{ 0 }; i < DIM_X; ++i) + { + m_vecXa[i] = m_vecX[i]; + } + } + + void updateAugmentedMatP() + { + for (size_t i{ 0 }; i < DIM_X; ++i) + { + for (size_t j{ 0 }; j < DIM_X; ++j) + { + m_matPa(i, j) = m_matP(i, j); + } + } + } + + /// + /// @brief algorithm to calculate the weights used to draw the sigma points + /// @param kappa design scaling parameter for sigma points selection + /// + void updateWeights(float32_t kappa) + { + static_assert(DIM_A > 0, "DIM_A is Zero which leads to numerical issue."); + + const float32_t denoTerm{ kappa + static_cast(DIM_A) }; + + m_weight0 = kappa / denoTerm; + m_weighti = 0.5F / denoTerm; + } + + /// + /// @brief algorithm to calculate the deterministic sigma points for + /// the unscented transformation + /// + /// @param vecX mean of the normally distributed state + /// @param matPxx covariance of the normally distributed state + /// @param kappa design scaling parameter for sigma points selection + /// + Matrix calculateSigmaPoints(const Vector & vecXa, const Matrix & matPa, const float32_t kappa) + { + const float32_t scalarMultiplier{ std::sqrt(DIM_A + kappa) }; // sqrt(n + \kappa) + + // cholesky factorization to get matrix Pxx square-root + Eigen::LLT> lltOfPa(matPa); + Matrix matSa{ lltOfPa.matrixL() }; // sqrt(P_{a}) + + matSa *= scalarMultiplier; // sqrt( (n + \kappa) * P_{a} ) + + Matrix sigmaXa; + + // X_0 = \bar{xa} + util::copyToColumn< DIM_A, SIGMA_DIM >(0, sigmaXa, vecXa); + + for (size_t i{ 0 }; i < DIM_A; ++i) + { + const size_t IDX_1{ i + 1 }; + const size_t IDX_2{ i + DIM_A + 1 }; + + util::copyToColumn< DIM_A, SIGMA_DIM >(IDX_1, sigmaXa, vecXa); + util::copyToColumn< DIM_A, SIGMA_DIM >(IDX_2, sigmaXa, vecXa); + + const Vector vecShiftTerm{ util::getColumnAt< DIM_A, DIM_A >(i, matSa) }; + + util::addColumnFrom< DIM_A, SIGMA_DIM >(IDX_1, sigmaXa, vecShiftTerm); // X_i^a = \bar{xa} + sqrt( (n^a + \kappa) * P^{a} ) + util::subColumnFrom< DIM_A, SIGMA_DIM >(IDX_2, sigmaXa, vecShiftTerm); // X_{i+n}^a = \bar{xa} - sqrt( (n^a + \kappa) * P^{a} ) + } + + return sigmaXa; + } + + template + void calculateWeightedMeanAndCovariance(const Matrix & sigmaX, Vector & vecX, Matrix & matPxx) + { + // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] + vecX = m_weight0 * util::getColumnAt(0, sigmaX); + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + vecX += m_weighti * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] + } + + // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // Y[:, 0] - \bar{ y } + matPxx = m_weight0 * devXi * devXi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T + + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + devXi = util::getColumnAt(i, sigmaX) - vecX; // Y[:, i] - \bar{y} + + const Matrix Pi{ m_weighti * devXi * devXi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + + matPxx += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + } + } + + Matrix calculateCrossCorrelation( + const Matrix & sigmaX, const Vector & vecX, + const Matrix & sigmaY, const Vector & vecY) + { + Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // X[:, 0] - \bar{ x } + Vector devYi{ util::getColumnAt(0, sigmaY) - vecY }; // Y[:, 0] - \bar{ y } + + // P_0 = W[0, 0] (X[:, 0] - \bar{x}) (Y[:, 0] - \bar{y})^T + Matrix matPxy{ + m_weight0 * (devXi * devYi.transpose()) + }; + + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + devXi = util::getColumnAt(i, sigmaX) - vecX; // X[:, i] - \bar{x} + devYi = util::getColumnAt(i, sigmaY) - vecY; // Y[:, i] - \bar{y} + + matPxy += m_weighti * (devXi * devYi.transpose()); // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + } + + return matPxy; + } + }; +} + +#endif // __UNSCENTED_KALMAN_FILTER_LIB_H__ From ad59ab8b2242aa9af9c7cfeffe79bdf81f634b92 Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Sat, 10 Dec 2022 01:36:26 +0100 Subject: [PATCH 12/60] Create LICENSE.md --- LICENSE.md | 674 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 674 insertions(+) create mode 100644 LICENSE.md diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. From 97b0a507ed9d4d39125e3aef20df11ac081c30f6 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sat, 10 Dec 2022 01:38:52 +0100 Subject: [PATCH 13/60] LICENSE CHANGED TO GPL-L3 --- LICENSE | 21 --------- cpp/Examples/ekf_range_sensor/main.cpp | 4 +- cpp/Examples/kf_state_estimation/main.cpp | 4 +- cpp/Examples/ukf_range_sensor/main.cpp | 4 +- cpp/Examples/unscented_transform/main.cpp | 4 +- cpp/kalman_filter/CMakeLists.txt | 6 +-- cpp/kalman_filter/kalman_filter.h | 4 +- cpp/kalman_filter/types.h | 4 +- cpp/kalman_filter/unscented_kalman_filter.h | 4 +- cpp/kalman_filter/unscented_transform.h | 47 ++++++++++++++++++--- cpp/kalman_filter/util.h | 4 +- 11 files changed, 60 insertions(+), 46 deletions(-) delete mode 100644 LICENSE diff --git a/LICENSE b/LICENSE deleted file mode 100644 index eeba7bc..0000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2022 CodingCorner (Mohanad Youssef) - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp index 83d4034..dcbabba 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp index e6bf39e..d76d632 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp index 204342a..fc0e336 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index 4b4f99e..450417a 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/kalman_filter/CMakeLists.txt index 4ca0bcb..83c2b18 100644 --- a/cpp/kalman_filter/CMakeLists.txt +++ b/cpp/kalman_filter/CMakeLists.txt @@ -10,9 +10,9 @@ ## file(GLOB LIBRARY_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" - ) + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" + ) set(LIBRARY_NAME kalman_filter_lib) diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index 56defed..1b215e3 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file kalman_filter.h diff --git a/cpp/kalman_filter/types.h b/cpp/kalman_filter/types.h index fb7bd37..86cd8f2 100644 --- a/cpp/kalman_filter/types.h +++ b/cpp/kalman_filter/types.h @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file types.h diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h index 7d82ffd..9937e45 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file unscented_kalman_filter.h diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index 3a4640f..0931963 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file unscented_transform.h @@ -24,18 +24,53 @@ namespace kf public: static constexpr size_t SIGMA_DIM{ (2 * DIM) + 1 }; - UnscentedTransform() = default; - ~UnscentedTransform() {} - - void compute(const Vector & vecX, const Matrix & matPxx, const float32_t kappa = 0.0F) + UnscentedTransform() { // 1. calculate weights updateWeights(kappa); + } + + ~UnscentedTransform() {} + + float32_t weight0() const { return _weight0; } + float32_t weighti() const { return _weighti; } + /// + /// @brief algorithm to execute weight and sigma points calculation + /// @param vecX input mean vector + /// @param matPxx input covariance matrix + /// @param kappa design parameter + /// + void compute(const Vector & vecX, const Matrix & matPxx, const float32_t kappa = 0.0F) + { // 2. update sigma points _sigmaX updateSigmaPoints(vecX, matPxx, kappa); } + template + void calculateWeightedMeanAndCovariance(const Matrix & sigmaX, Vector & vecX, Matrix & matPxx) + { + // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] + vecX = _weight0 * util::getColumnAt(0, sigmaX); + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + vecX += _weighti * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] + } + + // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // Y[:, 0] - \bar{ y } + matPxx = _weight0 * devXi * devXi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T + + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + devXi = util::getColumnAt(i, sigmaX) - vecX; // Y[:, i] - \bar{y} + + const Matrix Pi{ _weighti * devXi * devXi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + + matPxx += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + } + } + /// /// @brief algorithm to execute transforming sigma points through nonlinear function /// and calculate the updated weights and covariance. diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h index 1d65541..421d7eb 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/kalman_filter/util.h @@ -1,9 +1,9 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an MIT - style +/// Use of this source code is governed by an GPL - style /// license that can be found in the LICENSE file or at -/// https ://opensource.org/licenses/MIT. +/// https ://https://opensource.org/licenses/GPL-3.0. /// /// @author Mohanad Youssef /// @file util.h From 3ef02a56f872fd1203a76dc9ef27589e496db8f6 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sat, 10 Dec 2022 02:05:43 +0100 Subject: [PATCH 14/60] updating license to GPL-3.0 --- cpp/Examples/ekf_range_sensor/CMakeLists.txt | 18 +++++++------- cpp/Examples/ekf_range_sensor/main.cpp | 2 +- .../kf_state_estimation/CMakeLists.txt | 18 +++++++------- cpp/Examples/kf_state_estimation/main.cpp | 2 +- cpp/Examples/ukf_range_sensor/main.cpp | 2 +- .../unscented_transform/CMakeLists.txt | 18 +++++++------- cpp/Examples/unscented_transform/main.cpp | 2 +- cpp/kalman_filter/CMakeLists.txt | 24 +++++++++---------- cpp/kalman_filter/kalman_filter.h | 2 +- cpp/kalman_filter/monto_carlo.h | 0 cpp/kalman_filter/types.h | 2 +- cpp/kalman_filter/unscented_kalman_filter.h | 2 +- cpp/kalman_filter/unscented_transform.h | 2 +- cpp/kalman_filter/util.h | 2 +- 14 files changed, 48 insertions(+), 48 deletions(-) delete mode 100644 cpp/kalman_filter/monto_carlo.h diff --git a/cpp/Examples/ekf_range_sensor/CMakeLists.txt b/cpp/Examples/ekf_range_sensor/CMakeLists.txt index ec887bd..9147fa8 100644 --- a/cpp/Examples/ekf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ekf_range_sensor/CMakeLists.txt @@ -1,12 +1,12 @@ -## -## Copyright 2022 CodingCorner -## -## Use of this source code is governed by an MIT - style -## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/MIT. -## -## @author Mohanad Youssef -## @file CMakeLists.h +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/GPL-3.0. +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB PROJECT_FILES diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp index dcbabba..d520ec3 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/Examples/kf_state_estimation/CMakeLists.txt b/cpp/Examples/kf_state_estimation/CMakeLists.txt index f5142ab..7d2112d 100644 --- a/cpp/Examples/kf_state_estimation/CMakeLists.txt +++ b/cpp/Examples/kf_state_estimation/CMakeLists.txt @@ -1,12 +1,12 @@ -## -## Copyright 2022 CodingCorner -## -## Use of this source code is governed by an MIT - style -## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/MIT. -## -## @author Mohanad Youssef -## @file CMakeLists.h +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/GPL-3.0. +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB PROJECT_FILES diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp index d76d632..e056c8f 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp index fc0e336..bd1b0aa 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/Examples/unscented_transform/CMakeLists.txt b/cpp/Examples/unscented_transform/CMakeLists.txt index 7a68665..ddf4c0d 100644 --- a/cpp/Examples/unscented_transform/CMakeLists.txt +++ b/cpp/Examples/unscented_transform/CMakeLists.txt @@ -1,12 +1,12 @@ -## -## Copyright 2022 CodingCorner -## -## Use of this source code is governed by an MIT - style -## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/MIT. -## -## @author Mohanad Youssef -## @file CMakeLists.h +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/GPL-3.0. +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB PROJECT_FILES diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index 450417a..b212c6f 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/kalman_filter/CMakeLists.txt index 83c2b18..84e1cd1 100644 --- a/cpp/kalman_filter/CMakeLists.txt +++ b/cpp/kalman_filter/CMakeLists.txt @@ -1,18 +1,18 @@ -## -## Copyright 2022 CodingCorner -## -## Use of this source code is governed by an MIT - style -## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/MIT. -## -## @author Mohanad Youssef -## @file CMakeLists.h +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/GPL-3.0. +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB LIBRARY_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" - ) + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" + ) set(LIBRARY_NAME kalman_filter_lib) diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index 1b215e3..0f2e723 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/kalman_filter/monto_carlo.h b/cpp/kalman_filter/monto_carlo.h deleted file mode 100644 index e69de29..0000000 diff --git a/cpp/kalman_filter/types.h b/cpp/kalman_filter/types.h index 86cd8f2..3c5913d 100644 --- a/cpp/kalman_filter/types.h +++ b/cpp/kalman_filter/types.h @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h index 9937e45..33040bf 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index 0931963..c7e89bf 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h index 421d7eb..c856e77 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/kalman_filter/util.h @@ -1,7 +1,7 @@ /// /// Copyright 2022 CodingCorner /// -/// Use of this source code is governed by an GPL - style +/// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at /// https ://https://opensource.org/licenses/GPL-3.0. /// From 5f69b2bc1d47a401f802335a1817b515f2694359 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sat, 10 Dec 2022 02:08:01 +0100 Subject: [PATCH 15/60] update readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 914349d..648488d 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,6 @@ # KalmanFilter +**LICENSE**: [GPL-3.0 license](LICENSE.md) **Author**: Mohanad Youssef ([codingcorner.org](https://codingcorner.org/)) ![](res/images/codingcorner_cover_image.png) From 07d6cce25ff22023b6ef304a92eb896d7091f810 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sat, 10 Dec 2022 02:09:34 +0100 Subject: [PATCH 16/60] updating readme again --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 648488d..a11bcd6 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,7 @@ # KalmanFilter **LICENSE**: [GPL-3.0 license](LICENSE.md) + **Author**: Mohanad Youssef ([codingcorner.org](https://codingcorner.org/)) ![](res/images/codingcorner_cover_image.png) From e42f235afebc975ef88d4d3e168e705f051c1991 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sat, 10 Dec 2022 02:25:11 +0100 Subject: [PATCH 17/60] adding more doxygen comments --- cpp/kalman_filter/unscented_kalman_filter.h | 40 +++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h index 33040bf..9bc4e61 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -33,6 +33,10 @@ namespace kf ~UnscentedKalmanFilter() {} + /// + /// @brief adding process noise covariance Q to the augmented state covariance matPa + /// in the middle element of the diagonal. + /// void setCovarianceQ(const Matrix & matQ) { const size_t S_IDX{ DIM_X }; @@ -47,6 +51,10 @@ namespace kf } } + /// + /// @brief adding measurement noise covariance R to the augmented state covariance matPa + /// in the third element of the diagonal. + /// void setCovarianceR(const Matrix & matR) { const size_t S_IDX{ DIM_X + DIM_V }; @@ -61,12 +69,19 @@ namespace kf } } + /// + /// @brief adding vecX and matP to the augmented state vector and covariance vecXa and matPa + /// void updateAugmentedStateAndCovariance() { updateAugmentedVecX(); updateAugmentedMatP(); } + /// + /// @brief state prediction step of the unscented Kalman filter (UKF). + /// @param predictionModelFunc callback to the prediction/process model function + /// template void predict(PredictionModelCallback predictionModelFunc) { @@ -106,6 +121,11 @@ namespace kf //updateAugmentedStateAndCovariance(); } + /// + /// @brief measurement correction step of the unscented Kalman filter (UKF). + /// @param measurementModelFunc callback to the measurement model function + /// @param vecZ actual measurement vector. + /// template void correct(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) { @@ -167,6 +187,9 @@ namespace kf Vector m_vecXa{ Vector::Zero() }; /// @brief augmented state vector (incl. process and measurement noise means) Matrix m_matPa{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + /// + /// @brief add state vector m_vecX to the augment state vector m_vecXa + /// void updateAugmentedVecX() { for (size_t i{ 0 }; i < DIM_X; ++i) @@ -175,6 +198,9 @@ namespace kf } } + /// + /// @brief add covariance matrix m_matP to the augment covariance m_matPa + /// void updateAugmentedMatP() { for (size_t i{ 0 }; i < DIM_X; ++i) @@ -240,6 +266,12 @@ namespace kf return sigmaXa; } + /// + /// @brief calculate the weighted mean and covariance given a set of sigma points + /// @param sigmaX matrix of sigma points where each column contain single sigma point + /// @param vecX output weighted mean + /// @param matP output weighted covariance + /// template void calculateWeightedMeanAndCovariance(const Matrix & sigmaX, Vector & vecX, Matrix & matPxx) { @@ -264,6 +296,14 @@ namespace kf } } + /// + /// @brief calculate the cross-correlation given two sets sigma points X and Y and their means x and y + /// @param sigmaX first matrix of sigma points where each column contain single sigma point + /// @param vecX mean of the first set of sigma points + /// @param sigmaY second matrix of sigma points where each column contain single sigma point + /// @param vecY mean of the second set of sigma points + /// @return matPxy, the cross-correlation matrix + /// Matrix calculateCrossCorrelation( const Matrix & sigmaX, const Vector & vecX, const Matrix & sigmaY, const Vector & vecY) From 14c6474b1b4f0f30db08d517c598363d26703a17 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Mon, 19 Dec 2022 22:34:51 +0100 Subject: [PATCH 18/60] python implement of sr-ukf --- .../Square_Root_Unscented_Kalman_Filter.ipynb | 1035 +++++++++++++++++ 1 file changed, 1035 insertions(+) create mode 100644 python/examples/Square_Root_Unscented_Kalman_Filter.ipynb diff --git a/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb b/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb new file mode 100644 index 0000000..b1c40d2 --- /dev/null +++ b/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb @@ -0,0 +1,1035 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8b4b93b6", + "metadata": {}, + "source": [ + "# Square-root UKF" + ] + }, + { + "cell_type": "markdown", + "id": "9ddc1e5b", + "metadata": {}, + "source": [ + "## 1. Square-root Covariance update with QR-Decomposition" + ] + }, + { + "cell_type": "markdown", + "id": "819616b1", + "metadata": {}, + "source": [ + "Knowing that:\n", + "\n", + "$$ \\tag{1}\n", + "A+B = \\begin{bmatrix} \\sqrt{A}^T & \\sqrt{B}^T \\end{bmatrix} \\begin{bmatrix} \\sqrt{A} \\\\ \\sqrt{B} \\end{bmatrix}\n", + "$$\n", + "\n", + "$$ \\tag{2}\n", + "Q, R = qr \\left( \\begin{bmatrix} \\sqrt{A} \\\\ \\sqrt{B} \\end{bmatrix} \\right)\n", + "$$\n", + "\n", + "where $Q$ is an orthogonal matrix, and $R$ is upper triangular.\n", + "\n", + "Substitue the $QR$ decomposition $(2)$ into $(1)$:\n", + "\n", + "$$ \\tag{3}\n", + "A + B = R^T Q^T Q R\n", + "$$\n", + "\n", + "From the properties of the orthogonal matrix is that its inverse is equal to its transpose **(Theorem 4.1, 4.2)** in [1].\n", + "\n", + "$$ \\tag{4}\n", + "Q^T = Q^{-1}\n", + "$$\n", + "\n", + "Note: one can relate that this is a similar property as the rotation matrix.\n", + "\n", + "Because of this property the dot product of the orthogonal matrix with its transpose is equal to identiy matrix.\n", + "\n", + "$$ \\tag{5}\n", + "Q.Q^T = I\n", + "$$\n", + "\n", + "substituding $(5)$ into $(3)$ yielf;\n", + "\n", + "$$ \\tag{6}\n", + "A + B = R^T R\n", + "$$\n", + "\n", + "then;\n", + "\n", + "$$ \\tag{7}\n", + "\\sqrt{A + B} = R^T\n", + "$$\n", + "\n", + "and we can prove this by example, given:\n", + "\n", + "$$ \\tag{8}\n", + "A = \\begin{bmatrix} 100 & 2 \\\\ 2 & 9 \\end{bmatrix}\n", + "$$\n", + "\n", + "and,\n", + "\n", + "$$ \\tag{9}\n", + "B = \\begin{bmatrix} 9 & 3 \\\\ 3 & 4 \\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6147381c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy import linalg" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5fe7c504", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " A + B = \n", + " [[109 5]\n", + " [ 5 13]]\n" + ] + } + ], + "source": [ + "A = np.array([[100, 2], [2, 9]])\n", + "B = np.array([[9, 3], [3, 4]])\n", + "\n", + "print(f' A + B = \\n {A + B}')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "92d18f4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sqrt(A) = \n", + "[[10. 0.2 ]\n", + " [ 0. 2.99332591]]\n", + "sqrt(B) = \n", + "[[3. 1. ]\n", + " [0. 1.73205081]]\n" + ] + } + ], + "source": [ + "sqrtA = np.linalg.cholesky(A).T # transpose to get the upper triangular matrix as expected by QR decomposition\n", + "sqrtB = np.linalg.cholesky(B).T # transpose to get the upper triangular matrix as expected by QR decomposition\n", + "\n", + "print(f'sqrt(A) = \\n{sqrtA}')\n", + "print(f'sqrt(B) = \\n{sqrtB}')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53086a01", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10. 0.2 ]\n", + " [ 0. 2.99332591]\n", + " [ 3. 1. ]\n", + " [ 0. 1.73205081]]\n", + "Q=\n", + "[[-0.95782629 0.07239628]\n", + " [-0. -0.83762115]\n", + " [-0.28734789 -0.24132093]\n", + " [-0. -0.48467906]]\n", + "R=\n", + "[[-10.44030651 -0.47891314]\n", + " [ 0. -3.57360353]]\n" + ] + } + ], + "source": [ + "C = np.concatenate((sqrtA, sqrtB), axis=0) # building the compound (joint) matrix\n", + "print(C)\n", + "Q, R = np.linalg.qr(C)\n", + "print(f'Q=\\n{Q}')\n", + "print(f'R=\\n{R}')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4e05ab25", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R.T @ R = \n", + "[[109. 5.]\n", + " [ 5. 13.]]\n", + "\n" + ] + } + ], + "source": [ + "A_plus_B = R.T @ R\n", + "print(f'R.T @ R = \\n{A_plus_B}\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "2e677a7b", + "metadata": {}, + "source": [ + "## 2. Rank 1 Cholesky Update/Downdate" + ] + }, + { + "cell_type": "markdown", + "id": "814d3adc", + "metadata": {}, + "source": [ + "$$\n", + "A = LL^T\n", + "$$\n", + "\n", + "$$\n", + "A'= A + \\beta \\nu \\nu^T\n", + "$$\n", + "\n", + "$A$ is positive definite matrix as well as $A'$.\n", + "\n", + "$$\n", + "A' = L' L'^T\n", + "$$\n", + "\n", + "$$\n", + "LL^T = L'L'^T + \\beta \\nu \\nu^T\n", + "$$\n", + "\n", + "$$\n", + "L' = \\sqrt{LL^T + \\beta \\nu \\nu^T}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "04b88ded", + "metadata": {}, + "outputs": [], + "source": [ + "def cholupdate(L, W, beta):\n", + " r = np.shape(W)[1]\n", + " m = np.shape(L)[0]\n", + " \n", + " for i in range(r):\n", + " #L_out = cholupdate(L_out, W[:, i], beta)\n", + " L_out = np.copy(L)\n", + " b = 1.0\n", + " \n", + " for j in range(m):\n", + " Ljj_pow2 = L[j, j]**2\n", + " wji_pow2 = W[j, i]**2\n", + " \n", + " L_out[j, j] = np.sqrt(Ljj_pow2 + (beta / b) * wji_pow2)\n", + " upsilon = (Ljj_pow2 * b) + (beta * wji_pow2)\n", + " \n", + " for k in range(j+1, m):\n", + " W[k, i] -= (W[j, i] / L[j,j]) * L[k,j]\n", + " L_out[k, j] = ((L_out[j, j] / L[j, j]) * L[k,j]) + (L_out[j, j] * beta * W[j, i] * W[k, i] / upsilon)\n", + " \n", + " b += beta * (wji_pow2 / Ljj_pow2)\n", + " \n", + " L = np.copy(L_out)\n", + " \n", + " return L_out" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c720900c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A + beta * (v @ v.T) = \n", + "[[109 8]\n", + " [ 8 13]]\n", + "\n" + ] + } + ], + "source": [ + "beta = 1\n", + "\n", + "A = np.array([[100, 2], [2, 9]])\n", + "\n", + "v = np.array([[3], [2]])\n", + "\n", + "A2 = A + beta * (v @ v.T)\n", + "\n", + "print(f'A + beta * (v @ v.T) = \\n{A2}\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "82da6bea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L2 @ L2.T = \n", + "[[109. 5.18 ]\n", + " [ 5.18 10.1236]]\n", + "\n" + ] + } + ], + "source": [ + "L = np.linalg.cholesky(A)\n", + "\n", + "L2 = cholupdate(L, v, 1.)\n", + "\n", + "print(f'L2 @ L2.T = \\n{L2 @ L2.T}\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "df0f7a9c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A + beta * (W @ W.T) = \n", + "[[110. 7.]\n", + " [ 7. 14.]]\n", + "\n", + "L2 @ L2.T = \n", + "[[110. 7.]\n", + " [ 7. 14.]]\n", + "\n" + ] + } + ], + "source": [ + "beta = 1\n", + "A = np.array([[100., 2.], [2., 9.]])\n", + "W = np.array([[3., 1.], [1., 2.]])\n", + "\n", + "A1 = A + beta * (W @ W.T)\n", + "print(f'A + beta * (W @ W.T) = \\n{A1}\\n')\n", + "\n", + "L1 = np.linalg.cholesky(A)\n", + " \n", + "L2 = cholupdate(L1, W, 1.0)\n", + "A2 = L2 @ L2.T\n", + "print(f'L2 @ L2.T = \\n{A2}\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "68c0b587", + "metadata": {}, + "source": [ + "## 3. Backward Substitution" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d779bc17", + "metadata": {}, + "outputs": [], + "source": [ + "def backsubs(A, B):\n", + " # x_ik = (b_ik - Sum_aij_xjk) / a_ii\n", + " \n", + " N = np.shape(A)[0]\n", + " \n", + " X = np.zeros((B.shape[0], B.shape[1]))\n", + " \n", + " for k in range(B.shape[1]):\n", + " for i in range(N-1, -1, -1):\n", + " sum_aij_xj = B[i, k]\n", + "\n", + " for j in range(N-1, i, -1):\n", + " sum_aij_xj -= A[i, j] * X[j, k]\n", + "\n", + " X[i, k] = sum_aij_xj / A[i, i]\n", + " \n", + " return X" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "1e4ab129", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-24.]\n", + " [-13.]\n", + " [ 2.]]\n" + ] + } + ], + "source": [ + "A = np.array([[1., -2., 1.],\n", + " [0., 1., 6.],\n", + " [0., 0., 1.]])\n", + "\n", + "b = np.array([[4.0], [-1.0], [2.0]])\n", + "\n", + "x = backsubs(A, b)\n", + "\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "id": "651604ab", + "metadata": {}, + "source": [ + "## 4. Square-root UKF" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "d58dbdcb", + "metadata": {}, + "outputs": [], + "source": [ + "class SquareRootUKF(object):\n", + " def __init__(self, x, P, Q, R): \n", + " self.dim_x = np.shape(x)[0]\n", + " self.n_sigmas = (2 * self.dim_x) + 1\n", + " \n", + " self.kappa = 3 - self.dim_x\n", + " \n", + " self.sigma_scale = np.sqrt(self.dim_x + self.kappa)\n", + " \n", + " self.W0 = self.kappa / (self.dim_x + self.kappa)\n", + " self.Wi = 0.5 / (self.dim_x + self.kappa)\n", + " \n", + " self.x = x\n", + " \n", + " # lower triangular matrices\n", + " self.sqrt_P = np.linalg.cholesky(P)\n", + " self.sqrt_Q = np.linalg.cholesky(Q)\n", + " self.sqrt_R = np.linalg.cholesky(R)\n", + " \n", + " def predict(self, f):\n", + " # generate sigma points\n", + " sigmas_X = self.sigma_points(self.x, self.sqrt_P)\n", + " \n", + " # propagate sigma points through the nonlinear function\n", + " for i in range(self.n_sigmas):\n", + " sigmas_X[:, i] = f(sigmas_X[:, i])\n", + " \n", + " # calculate weighted mean\n", + " x_minus = self.W0 * sigmas_X[:, 0]\n", + " for i in range(1, self.n_sigmas):\n", + " x_minus += self.Wi * sigmas_X[:, i]\n", + " \n", + " # build compound matrix for square-root covariance update \n", + " C = (sigmas_X[:, 1:].T - x_minus) * np.sqrt(self.Wi) \n", + " C = np.concatenate((C, self.sqrt_Q.T), axis=0)\n", + " \n", + " # calculate square-root covariance S using QR decomposition of compound matrix C\n", + " # including the process noise covariance\n", + " _ , S_minus = np.linalg.qr(C)\n", + " \n", + " # Rank-1 cholesky update\n", + " x_dev = sigmas_X[:, 0] - x_minus\n", + " x_dev = np.reshape(x_dev, [-1, 1])\n", + " S_minus = cholupdate(S_minus.T, x_dev, self.W0)\n", + " \n", + " # overwrite member x and S\n", + " self.x = x_minus\n", + " self.sqrt_P = S_minus\n", + " \n", + " \n", + " def correct(self, h, z):\n", + " # generate sigma points X\n", + " sigmas_X = self.sigma_points(self.x, self.sqrt_P)\n", + " \n", + " # propagate sigma points X through the nonlinear function\n", + " # to get output sigma points Y\n", + " dim_z = np.shape(z)[0]\n", + " sigmas_Y = np.zeros((dim_z, self.n_sigmas))\n", + " for i in range(self.n_sigmas):\n", + " sigmas_Y[:, i] = h(sigmas_X[:, i])\n", + " \n", + " # calculate weighted mean y\n", + " y_bar = self.W0 * sigmas_Y[:, 0]\n", + " for i in range(1, self.n_sigmas):\n", + " y_bar += self.Wi * sigmas_Y[:, i]\n", + " \n", + " # build compound matrix for square-root covariance update \n", + " C = (sigmas_Y[:, 1:].T - y_bar) * np.sqrt(self.Wi) \n", + " C = np.concatenate((C, self.sqrt_R.T), axis=0)\n", + " \n", + " # calculate square-root covariance S using QR decomposition of compound matrix C\n", + " # including the process noise covariance\n", + " _ , S_y = np.linalg.qr(C)\n", + " \n", + " # Rank-1 cholesky update\n", + " y_dev = sigmas_Y[:, 0] - y_bar\n", + " y_dev = np.reshape(y_dev, [-1, 1])\n", + " S_y = cholupdate(S_y.T, y_dev, self.W0)\n", + " \n", + " # calculate cross-correlation\n", + " Pxy = self.calculate_cross_correlation(self.x, sigmas_X, y_bar, sigmas_Y)\n", + " \n", + " # Kalman gain calculation with two nested least-squares: (Pxy \\ Sy^T) \\ Sy\n", + " Pyy = S_y @ S_y.T\n", + " K = Pxy @ np.linalg.inv(Pyy)\n", + " \n", + " # update state vector x\n", + " self.x += K @ (z - y_bar)\n", + " \n", + " # update state square-root covariance Sk\n", + " # S_y must be upper triangular matrix at this place\n", + " U = K @ S_y\n", + " \n", + " #self.sqrt_P = r_rank_cholupdate_v2(self.sqrt_P, U, -1.0)\n", + " self.sqrt_P = cholupdate(self.sqrt_P, U, -1.0)\n", + " \n", + " \n", + " def sigma_points(self, x, sqrt_P):\n", + " \n", + " '''\n", + " generating sigma points matrix x_sigma given mean 'x' and square-root covariance 'S'\n", + " '''\n", + " \n", + " sigmas_X = np.zeros((self.dim_x, self.n_sigmas)) \n", + " sigmas_X[:, 0] = x\n", + "\n", + " for i in range(self.dim_x):\n", + " idx_1 = i + 1\n", + " idx_2 = i + self.dim_x + 1\n", + " \n", + " sigmas_X[:, idx_1] = x + (self.sigma_scale * sqrt_P[:, i])\n", + " sigmas_X[:, idx_2] = x - (self.sigma_scale * sqrt_P[:, i])\n", + " \n", + " return sigmas_X\n", + " \n", + " \n", + " def calculate_cross_correlation(self, x, x_sigmas, y, y_sigmas):\n", + " xdim = np.shape(x)[0]\n", + " ydim = np.shape(y)[0]\n", + " \n", + " n_sigmas = np.shape(x_sigmas)[1]\n", + " \n", + " dx = (x_sigmas[:, 0] - x).reshape([-1, 1])\n", + " dy = (y_sigmas[:, 0] - y).reshape([-1, 1])\n", + " Pxy = self.W0 * (dx @ dy.T)\n", + " for i in range(1, n_sigmas):\n", + " dx = (x_sigmas[:, i] - x).reshape([-1, 1])\n", + " dy = (y_sigmas[:, i] - y).reshape([-1, 1])\n", + " Pxy += self.Wi * (dx @ dy.T)\n", + " \n", + " return Pxy" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "65371877", + "metadata": {}, + "outputs": [], + "source": [ + "def linear_func(x):\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6e6581a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P+Q = \n", + "[[ 5. -0.8]\n", + " [-0.8 5. ]]\n" + ] + } + ], + "source": [ + "x = np.array([0., 0.])\n", + "P = np.array([[2.0, -0.8], [-0.8, 2.0]])\n", + "\n", + "Q = np.array([[3, 0], [0, 3]])\n", + "R = np.array([[1, 0], [0, 1]])\n", + "\n", + "sr_ukf = SquareRootUKF(x, P, Q, R)\n", + "\n", + "sr_ukf.predict(linear_func)\n", + "print(f'P+Q = \\n{P+Q}')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "048dbb99", + "metadata": {}, + "outputs": [], + "source": [ + "x0 = np.array([1.0, 2.0])\n", + "P0 = np.array([[1.0, 0.5], [0.5, 1.0]])\n", + "Q = np.array([[0.5, 0.0], [0.0, 0.5]])\n", + "\n", + "z = np.array([1.2, 1.8])\n", + "R = np.array([[0.3, 0.0], [0.0, 0.3]])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "61444e4d", + "metadata": {}, + "outputs": [], + "source": [ + "def KF_predict(F, x, P, Q):\n", + " x = (F @ x)\n", + " P = F @ P @ F.T + Q\n", + " return x, P\n", + "\n", + "def KF_correct(H, z, R, x, P):\n", + " Pxz = P @ H.T \n", + " S = H @ P @ H.T + R\n", + " \n", + " K = Pxz @ np.linalg.pinv(S)\n", + " \n", + " x = x + K @ (z - H @ x)\n", + " I = np.eye(P.shape[0])\n", + " P = (I - K @ H) @ P\n", + " return x, P" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6eed9c84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x1 = \n", + "[1. 2.]\n", + "\n", + "P1 = \n", + "[[1.5 0.5]\n", + " [0.5 1.5]]\n", + "\n", + "x2 = \n", + "[1.15385 1.84615]\n", + "\n", + "P2 = \n", + "[[0.24582 0.01505]\n", + " [0.01505 0.24582]]\n", + "\n" + ] + } + ], + "source": [ + "F = np.array([[1.0, 0.0], [0.0, 1.0]])\n", + "H = np.array([[1.0, 0.0], [0.0, 1.0]])\n", + "\n", + "x1, P1 = KF_predict(F, x0, P0, Q)\n", + "\n", + "print(f'x1 = \\n{x1.round(5)}\\n')\n", + "print(f'P1 = \\n{P1.round(5)}\\n')\n", + "\n", + "x2, P2 = KF_correct(H, x1, P1, z, R)\n", + "\n", + "print(f'x2 = \\n{x2.round(5)}\\n')\n", + "print(f'P2 = \\n{P2.round(5)}\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2c347ab3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x1 = \n", + "[1. 2.]\n", + "\n", + "P1 = \n", + "[[1.5 0.5]\n", + " [0.5 1.5]]\n", + "\n", + "x2 = \n", + "[1.15385 1.84615]\n", + "\n", + "P2 = \n", + "[[0.24582 0.01505]\n", + " [0.01505 0.24582]]\n", + "\n", + "S2 = \n", + "[[0.4958 0. ]\n", + " [0.03036 0.49487]]\n", + "\n" + ] + } + ], + "source": [ + "sr_ukf = SquareRootUKF(x0, P0, Q, R)\n", + "\n", + "sr_ukf.predict(linear_func)\n", + "\n", + "x1 = sr_ukf.x\n", + "P1 = sr_ukf.sqrt_P @ sr_ukf.sqrt_P.T\n", + "\n", + "print(f'x1 = \\n{x1.round(5)}\\n')\n", + "print(f'P1 = \\n{P1.round(5)}\\n')\n", + "\n", + "sr_ukf.correct(linear_func, z)\n", + "\n", + "x2 = sr_ukf.x\n", + "P2 = sr_ukf.sqrt_P @ sr_ukf.sqrt_P.T\n", + "\n", + "print(f'x2 = \\n{x2.round(5)}\\n')\n", + "print(f'P2 = \\n{P2.round(5)}\\n')\n", + "print(f'S2 = \\n{sr_ukf.sqrt_P.round(5)}\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2d7d9c11", + "metadata": {}, + "outputs": [], + "source": [ + "class UKF(object):\n", + " def __init__(self, dim_x, dim_z, Q, R, kappa=0.0):\n", + " \n", + " '''\n", + " UKF class constructor\n", + " inputs:\n", + " dim_x : state vector x dimension\n", + " dim_z : measurement vector z dimension\n", + " \n", + " - step 1: setting dimensions\n", + " - step 2: setting number of sigma points to be generated\n", + " - step 3: setting scaling parameters\n", + " - step 4: calculate scaling coefficient for selecting sigma points\n", + " - step 5: calculate weights\n", + " '''\n", + " \n", + " # setting dimensions\n", + " self.dim_x = dim_x # state dimension\n", + " self.dim_z = dim_z # measurement dimension\n", + " self.dim_v = np.shape(Q)[0]\n", + " self.dim_n = np.shape(R)[0]\n", + " self.dim_a = self.dim_x + self.dim_v + self.dim_n # assuming noise dimension is same as x dimension\n", + " \n", + " # setting number of sigma points to be generated\n", + " self.n_sigma = (2 * self.dim_a) + 1\n", + " \n", + " # setting scaling parameters\n", + " self.kappa = 3 - self.dim_a #kappa\n", + " self.alpha = 0.001\n", + " self.beta = 2.0\n", + "\n", + " alpha_2 = self.alpha**2\n", + " self.lambda_ = alpha_2 * (self.dim_a + self.kappa) - self.dim_a\n", + " \n", + " # setting scale coefficient for selecting sigma points\n", + " # self.sigma_scale = np.sqrt(self.dim_a + self.lambda_)\n", + " self.sigma_scale = np.sqrt(self.dim_a + self.kappa)\n", + " \n", + " # calculate unscented weights\n", + " # self.W0m = self.W0c = self.lambda_ / (self.dim_a + self.lambda_)\n", + " # self.W0c = self.W0c + (1.0 - alpha_2 + self.beta)\n", + " # self.Wi = 0.5 / (self.dim_a + self.lambda_)\n", + " \n", + " self.W0 = self.kappa / (self.dim_a + self.kappa)\n", + " self.Wi = 0.5 / (self.dim_a + self.kappa)\n", + " \n", + " # initializing augmented state x_a and augmented covariance P_a\n", + " self.x_a = np.zeros((self.dim_a, ))\n", + " self.P_a = np.zeros((self.dim_a, self.dim_a))\n", + " \n", + " self.idx1, self.idx2 = self.dim_x, self.dim_x + self.dim_v\n", + " \n", + " self.P_a[self.idx1:self.idx2, self.idx1:self.idx2] = Q\n", + " self.P_a[self.idx2:, self.idx2:] = R\n", + " \n", + " print(f'P_a = \\n{self.P_a}\\n')\n", + " \n", + " def predict(self, f, x, P): \n", + " self.x_a[:self.dim_x] = x\n", + " self.P_a[:self.dim_x, :self.dim_x] = P\n", + " \n", + " xa_sigmas = self.sigma_points(self.x_a, self.P_a)\n", + " \n", + " xx_sigmas = xa_sigmas[:self.dim_x, :]\n", + " xv_sigmas = xa_sigmas[self.idx1:self.idx2, :]\n", + " \n", + " y_sigmas = np.zeros((self.dim_x, self.n_sigma)) \n", + " for i in range(self.n_sigma):\n", + " y_sigmas[:, i] = f(xx_sigmas[:, i], xv_sigmas[:, i])\n", + " \n", + " y, Pyy = self.calculate_mean_and_covariance(y_sigmas)\n", + " \n", + " self.x_a[:self.dim_x] = y\n", + " self.P_a[:self.dim_x, :self.dim_x] = Pyy\n", + " \n", + " return y, Pyy, xx_sigmas\n", + " \n", + " def correct(self, h, x, P, z):\n", + " self.x_a[:self.dim_x] = x\n", + " self.P_a[:self.dim_x, :self.dim_x] = P\n", + " \n", + " xa_sigmas = self.sigma_points(self.x_a, self.P_a)\n", + " \n", + " xx_sigmas = xa_sigmas[:self.dim_x, :]\n", + " xn_sigmas = xa_sigmas[self.idx2:, :]\n", + " \n", + " y_sigmas = np.zeros((self.dim_z, self.n_sigma))\n", + " for i in range(self.n_sigma):\n", + " y_sigmas[:, i] = h(xx_sigmas[:, i], xn_sigmas[:, i])\n", + " \n", + " y, Pyy = self.calculate_mean_and_covariance(y_sigmas)\n", + " \n", + " Pxy = self.calculate_cross_correlation(x, xx_sigmas, y, y_sigmas)\n", + " print(f'Pxy = \\n {Pxy}')\n", + "\n", + " K = Pxy @ np.linalg.pinv(Pyy)\n", + " print(f'K = \\n {K}')\n", + " \n", + " x = x + (K @ (z - y))\n", + " \n", + " print(f'S = \\n{np.linalg.cholesky(P)}')\n", + " P = P - (K @ Pyy @ K.T)\n", + " \n", + " return x, P, xx_sigmas\n", + " \n", + " \n", + " def sigma_points(self, x, P):\n", + " \n", + " '''\n", + " generating sigma points matrix x_sigma given mean 'x' and covariance 'P'\n", + " '''\n", + " \n", + " nx = np.shape(x)[0]\n", + " \n", + " x_sigma = np.zeros((nx, self.n_sigma)) \n", + " x_sigma[:, 0] = x\n", + " \n", + " S = np.linalg.cholesky(P)\n", + " \n", + " for i in range(nx):\n", + " x_sigma[:, i + 1] = x + (self.sigma_scale * S[:, i])\n", + " x_sigma[:, i + nx + 1] = x - (self.sigma_scale * S[:, i])\n", + " \n", + " return x_sigma\n", + " \n", + " \n", + " def calculate_mean_and_covariance(self, y_sigmas):\n", + " ydim = np.shape(y_sigmas)[0]\n", + " \n", + " # mean calculation\n", + " y = self.W0 * y_sigmas[:, 0]\n", + " for i in range(1, self.n_sigma):\n", + " y += self.Wi * y_sigmas[:, i]\n", + " \n", + " # covariance calculation\n", + " d = (y_sigmas[:, 0] - y).reshape([-1, 1])\n", + " Pyy = self.W0 * (d @ d.T)\n", + " for i in range(1, self.n_sigma):\n", + " d = (y_sigmas[:, i] - y).reshape([-1, 1])\n", + " Pyy += self.Wi * (d @ d.T)\n", + " \n", + " return y, Pyy\n", + " \n", + " def calculate_cross_correlation(self, x, x_sigmas, y, y_sigmas):\n", + " xdim = np.shape(x)[0]\n", + " ydim = np.shape(y)[0]\n", + " \n", + " n_sigmas = np.shape(x_sigmas)[1]\n", + " \n", + " dx = (x_sigmas[:, 0] - x).reshape([-1, 1])\n", + " dy = (y_sigmas[:, 0] - y).reshape([-1, 1])\n", + " Pxy = self.W0 * (dx @ dy.T)\n", + " for i in range(1, n_sigmas):\n", + " dx = (x_sigmas[:, i] - x).reshape([-1, 1])\n", + " dy = (y_sigmas[:, i] - y).reshape([-1, 1])\n", + " Pxy += self.Wi * (dx @ dy.T)\n", + " \n", + " return Pxy" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "526a1642", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P_a = \n", + "[[0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0.5 0. 0. 0. ]\n", + " [0. 0. 0. 0.5 0. 0. ]\n", + " [0. 0. 0. 0. 0.3 0. ]\n", + " [0. 0. 0. 0. 0. 0.3]]\n", + "\n", + "x = \n", + "[1. 2.]\n", + "\n", + "P = \n", + "[[1.5 0.5]\n", + " [0.5 1.5]]\n", + "\n", + "Pxy = \n", + " [[1.5 0.5]\n", + " [0.5 1.5]]\n", + "K = \n", + " [[0.81939799 0.05016722]\n", + " [0.05016722 0.81939799]]\n", + "S = \n", + "[[1.22474487 0. ]\n", + " [0.40824829 1.15470054]]\n", + "x = \n", + "[1.15385 1.84615]\n", + "\n", + "P = \n", + "[[0.24582 0.01505]\n", + " [0.01505 0.24582]]\n", + "\n", + "S = \n", + "[[0.49580177 0. ]\n", + " [0.03035521 0.49487166]]\n" + ] + } + ], + "source": [ + "def f(x, v):\n", + " return (x + v)\n", + "\n", + "def h(x, n):\n", + " return (x + n)\n", + "\n", + "nx = np.shape(x0)[0]\n", + "nz = np.shape(z)[0]\n", + "nv = np.shape(x0)[0]\n", + "nn = np.shape(z)[0]\n", + "\n", + "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))\n", + "\n", + "x1, P1, _ = ukf.predict(f, x0, P0)\n", + "\n", + "print(f'x = \\n{x1.round(5)}\\n')\n", + "print(f'P = \\n{P1.round(5)}\\n')\n", + "\n", + "x2, P2, _ = ukf.correct(h, x1, P1, z)\n", + "\n", + "print(f'x = \\n{x2.round(5)}\\n')\n", + "print(f'P = \\n{P2.round(5)}\\n')\n", + "\n", + "print(f'S = \\n{np.linalg.cholesky(P2)}')\n", + "\n", + "# K = \n", + "# [[0.81939799 0.05016722]\n", + "# [0.05016722 0.81939799]]" + ] + }, + { + "cell_type": "markdown", + "id": "a335951b", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "[1] [The Orthogonal matrix and its applications](http://libres.uncg.edu/ir/uncg/f/shugart_sue_1953.pdf)\n", + "\n", + "[2] [R. Van der Merwe and E. A. Wan, \"The square-root unscented Kalman filter for state and parameter-estimation,\" 2001 IEEE International Conference on Acoustics, Speech, and Signal Processing. Proceedings (Cat. No.01CH37221), 2001, pp. 3461-3464 vol.6, doi: 10.1109/ICASSP.2001.940586.](https://www.researchgate.net/publication/3908304_The_Square-Root_Unscented_Kalman_Filter_for_State_and_Parameter-Estimation)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5a30e9f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a8ccc17", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 3eaa1c6b7b6646a241fc2afd7f29f5b159c6fede Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Tue, 20 Dec 2022 11:36:55 +0100 Subject: [PATCH 19/60] optimize kalman gain in sr-ukf using least squares --- .../Square_Root_Unscented_Kalman_Filter.ipynb | 101 ++++++++++++++---- 1 file changed, 82 insertions(+), 19 deletions(-) diff --git a/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb b/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb index b1c40d2..a732384 100644 --- a/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb +++ b/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb @@ -242,7 +242,6 @@ " m = np.shape(L)[0]\n", " \n", " for i in range(r):\n", - " #L_out = cholupdate(L_out, W[:, i], beta)\n", " L_out = np.copy(L)\n", " b = 1.0\n", " \n", @@ -364,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "id": "d779bc17", "metadata": {}, "outputs": [], @@ -390,8 +389,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "1e4ab129", + "execution_count": 11, + "id": "7a6b1cb4", "metadata": {}, "outputs": [ { @@ -411,9 +410,71 @@ "\n", "b = np.array([[4.0], [-1.0], [2.0]])\n", "\n", - "x = backsubs(A, b)\n", + "x1 = backsubs(A, b)\n", + "print(x1)" + ] + }, + { + "cell_type": "markdown", + "id": "23e63117", + "metadata": {}, + "source": [ + "## 4. Forward Substitution" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a87f986f", + "metadata": {}, + "outputs": [], + "source": [ + "def forwardsubs(A, B):\n", + " # x_ik = (b_ik - Sum_aij_xjk) / a_ii\n", + " \n", + " N = np.shape(A)[0]\n", + " X = np.zeros((B.shape[0], B.shape[1]))\n", + " \n", + " for k in range(B.shape[1]):\n", + " for i in range(N):\n", + " sum_aij_xj = B[i, k]\n", + " \n", + " for j in range(i):\n", + " sum_aij_xj -= A[i, j] * X[j, k]\n", + " \n", + " X[i, k] = sum_aij_xj / A[i, i]\n", + " \n", + " return X" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1e4ab129", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 4.]\n", + " [ 7.]\n", + " [-44.]]\n" + ] + } + ], + "source": [ + "A = np.array([[1., -2., 1.],\n", + " [0., 1., 6.],\n", + " [0., 0., 1.]])\n", + "\n", + "A = A.T\n", + "\n", + "b = np.array([[4.0], [-1.0], [2.0]])\n", + "\n", + "x2 = forwardsubs(A, b)\n", "\n", - "print(x)" + "print(x2)" ] }, { @@ -421,12 +482,12 @@ "id": "651604ab", "metadata": {}, "source": [ - "## 4. Square-root UKF" + "## 5. Square-root UKF" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "id": "d58dbdcb", "metadata": {}, "outputs": [], @@ -513,9 +574,11 @@ " # calculate cross-correlation\n", " Pxy = self.calculate_cross_correlation(self.x, sigmas_X, y_bar, sigmas_Y)\n", " \n", - " # Kalman gain calculation with two nested least-squares: (Pxy \\ Sy^T) \\ Sy\n", - " Pyy = S_y @ S_y.T\n", - " K = Pxy @ np.linalg.inv(Pyy)\n", + " # Kalman gain calculation with two nested least-squares\n", + " # Step1: Forward-substitution -> K = Sy \\ Pxy (since S_y is lower-triangular)\n", + " # Step2: Backward-substitution -> K = Sy.T \\ K (since S_y.T is upper-triangular)\n", + " K = forwardsubs(S_y, Pxy)\n", + " K = backsubs(S_y.T, K)\n", " \n", " # update state vector x\n", " self.x += K @ (z - y_bar)\n", @@ -566,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "65371877", "metadata": {}, "outputs": [], @@ -577,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "6e6581a4", "metadata": {}, "outputs": [ @@ -606,7 +669,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "048dbb99", "metadata": {}, "outputs": [], @@ -621,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "id": "61444e4d", "metadata": {}, "outputs": [], @@ -645,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "id": "6eed9c84", "metadata": {}, "outputs": [ @@ -687,7 +750,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "id": "2c347ab3", "metadata": {}, "outputs": [ @@ -739,7 +802,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "id": "2d7d9c11", "metadata": {}, "outputs": [], @@ -906,7 +969,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "id": "526a1642", "metadata": {}, "outputs": [ From 3182145a2e16171c17dda345fc52e4f5d3101bb2 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Tue, 20 Dec 2022 22:40:59 +0100 Subject: [PATCH 20/60] implement least square solving example --- cpp/Examples/CMakeLists.txt | 1 + .../test_least_squares/CMakeLists.txt | 26 ++++ cpp/Examples/test_least_squares/main.cpp | 112 ++++++++++++++++++ cpp/kalman_filter/unscented_transform.h | 10 +- cpp/kalman_filter/util.h | 101 ++++++++++++++++ 5 files changed, 244 insertions(+), 6 deletions(-) create mode 100644 cpp/Examples/test_least_squares/CMakeLists.txt create mode 100644 cpp/Examples/test_least_squares/main.cpp diff --git a/cpp/Examples/CMakeLists.txt b/cpp/Examples/CMakeLists.txt index 85cae8f..d490d53 100644 --- a/cpp/Examples/CMakeLists.txt +++ b/cpp/Examples/CMakeLists.txt @@ -4,3 +4,4 @@ add_subdirectory(kf_state_estimation) add_subdirectory(ekf_range_sensor) add_subdirectory(unscented_transform) add_subdirectory(ukf_range_sensor) +add_subdirectory(test_least_squares) diff --git a/cpp/Examples/test_least_squares/CMakeLists.txt b/cpp/Examples/test_least_squares/CMakeLists.txt new file mode 100644 index 0000000..94bcb75 --- /dev/null +++ b/cpp/Examples/test_least_squares/CMakeLists.txt @@ -0,0 +1,26 @@ +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https ://opensource.org/licenses/GPL-3.0. +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_test_least_squares) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) +target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/test_least_squares/main.cpp b/cpp/Examples/test_least_squares/main.cpp new file mode 100644 index 0000000..34d0b4d --- /dev/null +++ b/cpp/Examples/test_least_squares/main.cpp @@ -0,0 +1,112 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https ://https://opensource.org/licenses/GPL-3.0. +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "kalman_filter/types.h" +#include "kalman_filter/util.h" + +void runExample1(); +void runExample2(); +void runExample3(); +void runExample4(); + +int main(int argc, char ** argv) +{ + runExample1(); + runExample2(); + runExample3(); + runExample4(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + Matrix<3, 3> A; + A << 3.0, 2.0, 1.0, + 2.0, 3.0, 4.0, + 1.0, 4.0, 3.0; + + Matrix<2, 3> B; + B << 5.0, 6.0, 7.0, + 8.0, 9.0, 10.0; + + util::JointRows<3, 2, 3> jmat(A, B); + auto AB = jmat.jointMatrix(); + + std::cout << "Joint Rows: AB = \n" << AB << std::endl; + + std::cout << " End of Example 1: ===========================" << std::endl; +} + +void runExample2() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + Matrix<3, 3> A; + A << 3.0, 2.0, 1.0, + 2.0, 3.0, 4.0, + 1.0, 4.0, 3.0; + + Matrix<3, 2> B; + B << 5.0, 6.0, + 7.0, 8.0, + 9.0, 10.0; + + util::JointCols<3, 3, 2> jmat(A, B); + auto AB = jmat.jointMatrix(); + + std::cout << "Joint Columns: AB = \n" << AB << std::endl; + + std::cout << " End of Example 2: ===========================" << std::endl; +} + +void runExample3() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + Matrix<3, 3> A; + A << 1.0, -2.0, 1.0, + 0.0, 1.0, 6.0, + 0.0, 0.0, 1.0; + + Matrix<3, 1> b; + b << 4.0, -1.0, 2.0; + + auto x = util::backwardSubstitute<3, 1>(A, b); + + std::cout << "Backward Substitution: x = \n" << x << std::endl; + + std::cout << " End of Example 2: ===========================" << std::endl; +} + +void runExample4() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + Matrix<3, 3> A; + A << 1.0, 0.0, 0.0, + -2.0, 1.0, 0.0, + 1.0, 6.0, 1.0; + + Matrix<3, 1> b; + b << 4.0, -1.0, 2.0; + + auto x = util::forwardSubstitute<3, 1>(A, b); + + std::cout << "Forward Substitution: x = \n" << x << std::endl; + + std::cout << " End of Example 2: ===========================" << std::endl; +} diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index c7e89bf..be276ab 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -24,12 +24,7 @@ namespace kf public: static constexpr size_t SIGMA_DIM{ (2 * DIM) + 1 }; - UnscentedTransform() - { - // 1. calculate weights - updateWeights(kappa); - } - + UnscentedTransform() {} ~UnscentedTransform() {} float32_t weight0() const { return _weight0; } @@ -43,6 +38,9 @@ namespace kf /// void compute(const Vector & vecX, const Matrix & matPxx, const float32_t kappa = 0.0F) { + // 1. calculate weights + updateWeights(kappa); + // 2. update sigma points _sigmaX updateSigmaPoints(vecX, matPxx, kappa); } diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h index c856e77..96a549c 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/kalman_filter/util.h @@ -57,6 +57,107 @@ namespace util return vecXi; } + + template + Matrix forwardSubstitute(const Matrix & matA, const Matrix & matB) + { + Matrix matX; + + for (int32_t k{ 0 }; k < COLS; ++k) + { + for (int32_t i{ 0 }; i < ROWS; ++i) + { + float32_t accumulation{ matB(i, k) }; + for (int32_t j{ 0 }; j < i; ++j) + { + accumulation -= matA(i, j) * matX(j, k); + } + + matX(i, k) = accumulation / matA(i, i); + } + } + return matX; + } + + template + Matrix backwardSubstitute(const Matrix & matA, const Matrix & matB) + { + Matrix matX; + + for (int32_t k{ 0 }; k < COLS; ++k) + { + for (int32_t i{ ROWS - 1 }; i >= 0; --i) + { + float32_t accumulation{ matB(i, k) }; + + for (int32_t j{ ROWS - 1 }; j > i; --j) + { + accumulation -= matA(i, j) * matX(j, k); + } + + matX(i, k) = accumulation / matA(i, i); + } + } + return matX; + } + + template + class JointRows + { + public: + JointRows() = delete; + ~JointRows() {} + + explicit JointRows(const Matrix & matM1, const Matrix & matM2) + { + for (int32_t j{ 0 }; j < COLS; ++j) + { + for (int32_t i{ 0 }; i < ROWS1; ++i) + { + m_matJ(i, j) = matM1(i, j); + } + + for (int32_t i{ 0 }; i < ROWS2; ++i) + { + m_matJ(i + ROWS1, j) = matM2(i, j); + } + } + } + + const Matrix & jointMatrix() const { return m_matJ; } + + private: + Matrix m_matJ; + }; + + template + class JointCols + { + public: + JointCols() = delete; + ~JointCols() {} + + explicit JointCols(const Matrix & matM1, const Matrix & matM2) + { + for (int32_t i{ 0 }; i < ROWS; ++i) + { + for (int32_t j{ 0 }; j < COLS1; ++j) + { + m_matJ(i, j) = matM1(i, j); + } + + for (int32_t j{ 0 }; j < COLS2; ++j) + { + m_matJ(i, j + COLS1) = matM2(i, j); + } + } + } + + const Matrix & jointMatrix() const { return m_matJ; } + + private: + Matrix m_matJ; + }; } #endif // __KALMAN_FILTER_UTIL_H__ From d8a0c85dca027b6a50c3195043be66a3244a137b Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Wed, 21 Dec 2022 11:38:16 +0100 Subject: [PATCH 21/60] Update README.md --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index a11bcd6..b002ea6 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,13 @@ # KalmanFilter +This is an open source C++ Kalman filter library based on Eigen3 library for matrix operations. + +The library has a generic template based classes for most of Kalman filter variants including: + +1. Kalman Filter +2. Extended Kalman Filter +3. Unscented Kalman Filter + **LICENSE**: [GPL-3.0 license](LICENSE.md) **Author**: Mohanad Youssef ([codingcorner.org](https://codingcorner.org/)) From d153dd32889a671a1a340645d9ffd5f040f40b59 Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Wed, 21 Dec 2022 11:42:36 +0100 Subject: [PATCH 22/60] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index b002ea6..63715b5 100644 --- a/README.md +++ b/README.md @@ -2,11 +2,12 @@ This is an open source C++ Kalman filter library based on Eigen3 library for matrix operations. -The library has a generic template based classes for most of Kalman filter variants including: +The library has generic template based classes for most of Kalman filter variants including: 1. Kalman Filter 2. Extended Kalman Filter 3. Unscented Kalman Filter +4. Square-root Unscented Kalman Filter **LICENSE**: [GPL-3.0 license](LICENSE.md) From 5039093fdada6f23c29b4305b5fe0c436f335c04 Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Wed, 21 Dec 2022 13:22:02 +0100 Subject: [PATCH 23/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 63715b5..7ac3e89 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# KalmanFilter +# OpenKF (The Kalman Filter Library) This is an open source C++ Kalman filter library based on Eigen3 library for matrix operations. From affcb78b309f06380d482db46fbd6a7e27bac592 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Thu, 22 Dec 2022 11:29:09 +0100 Subject: [PATCH 24/60] implement square-root ukf in C++ --- cpp/Examples/CMakeLists.txt | 1 + cpp/Examples/ekf_range_sensor/CMakeLists.txt | 2 +- cpp/Examples/ekf_range_sensor/main.cpp | 2 +- .../kf_state_estimation/CMakeLists.txt | 2 +- cpp/Examples/kf_state_estimation/main.cpp | 2 +- .../sr_ukf_linear_function/CMakeLists.txt | 26 ++ cpp/Examples/sr_ukf_linear_function/main.cpp | 99 +++++ .../test_least_squares/CMakeLists.txt | 2 +- cpp/Examples/test_least_squares/main.cpp | 2 +- cpp/Examples/ukf_range_sensor/CMakeLists.txt | 18 +- cpp/Examples/ukf_range_sensor/main.cpp | 2 +- .../unscented_transform/CMakeLists.txt | 2 +- cpp/Examples/unscented_transform/main.cpp | 2 +- cpp/kalman_filter/CMakeLists.txt | 2 +- cpp/kalman_filter/kalman_filter.h | 10 +- cpp/kalman_filter/square_root_ukf.h | 353 ++++++++++++++++++ cpp/kalman_filter/types.h | 2 +- cpp/kalman_filter/unscented_kalman_filter.h | 2 +- cpp/kalman_filter/unscented_transform.h | 2 +- cpp/kalman_filter/util.h | 51 ++- .../Square_Root_Unscented_Kalman_Filter.ipynb | 135 +++++-- 21 files changed, 667 insertions(+), 52 deletions(-) create mode 100644 cpp/Examples/sr_ukf_linear_function/CMakeLists.txt create mode 100644 cpp/Examples/sr_ukf_linear_function/main.cpp create mode 100644 cpp/kalman_filter/square_root_ukf.h diff --git a/cpp/Examples/CMakeLists.txt b/cpp/Examples/CMakeLists.txt index d490d53..322ea8f 100644 --- a/cpp/Examples/CMakeLists.txt +++ b/cpp/Examples/CMakeLists.txt @@ -5,3 +5,4 @@ add_subdirectory(ekf_range_sensor) add_subdirectory(unscented_transform) add_subdirectory(ukf_range_sensor) add_subdirectory(test_least_squares) +add_subdirectory(sr_ukf_linear_function) diff --git a/cpp/Examples/ekf_range_sensor/CMakeLists.txt b/cpp/Examples/ekf_range_sensor/CMakeLists.txt index 9147fa8..3d73cf4 100644 --- a/cpp/Examples/ekf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ekf_range_sensor/CMakeLists.txt @@ -3,7 +3,7 @@ ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/GPL-3.0. +## https://opensource.org/licenses/GPL-3.0 ## ## @author Mohanad Youssef ## @file CMakeLists.h diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp index d520ec3..a58ede7 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/kf_state_estimation/CMakeLists.txt b/cpp/Examples/kf_state_estimation/CMakeLists.txt index 7d2112d..47c762b 100644 --- a/cpp/Examples/kf_state_estimation/CMakeLists.txt +++ b/cpp/Examples/kf_state_estimation/CMakeLists.txt @@ -3,7 +3,7 @@ ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/GPL-3.0. +## https://opensource.org/licenses/GPL-3.0 ## ## @author Mohanad Youssef ## @file CMakeLists.h diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp index e056c8f..722c344 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt b/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt new file mode 100644 index 0000000..2ffbdfa --- /dev/null +++ b/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt @@ -0,0 +1,26 @@ +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_sr_ukf_linear_function) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) +target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/sr_ukf_linear_function/main.cpp b/cpp/Examples/sr_ukf_linear_function/main.cpp new file mode 100644 index 0000000..2bcdeb6 --- /dev/null +++ b/cpp/Examples/sr_ukf_linear_function/main.cpp @@ -0,0 +1,99 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "kalman_filter/types.h" +#include "kalman_filter/square_root_ukf.h" + +static constexpr size_t DIM_X{ 2 }; +static constexpr size_t DIM_V{ 2 }; +static constexpr size_t DIM_Z{ 2 }; +static constexpr size_t DIM_N{ 2 }; + +void runExample1(); + +Vector funcF(const Vector & x) +{ + return x; +} + +int main(int argc, char ** argv) +{ + // example 1 + runExample1(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + // initializations + //x0 = np.array([1.0, 2.0]) + //P0 = np.array([[1.0, 0.5], [0.5, 1.0]]) + //Q = np.array([[0.5, 0.0], [0.0, 0.5]]) + + //z = np.array([1.2, 1.8]) + //R = np.array([[0.3, 0.0], [0.0, 0.3]]) + + Vector x; + x << 1.0F, 2.0F; + + Matrix P; + P << 1.0F, 0.5F, + 0.5F, 1.0F; + + Matrix Q; + Q << 0.5F, 0.0F, + 0.0F, 0.5F; + + Vector z; + z << 1.2F, 1.8F; + + Matrix R; + R << 0.3F, 0.0F, + 0.0F, 0.3F; + + kf::SquareRootUKF srUkf; + srUkf.initialize(x, P, Q, R); + + srUkf.predict(funcF); + + std::cout << "x = \n" << srUkf.vecX() << std::endl; + std::cout << "P = \n" << srUkf.matP() << std::endl; + + // Expectation from the python results: + // ===================================== + //x1 = + // [1. 2.] + //P1 = + // [[1.5 0.5] + // [0.5 1.5]] + + srUkf.correct(funcF, z); + + std::cout << "x = \n" << srUkf.vecX() << std::endl; + std::cout << "P = \n" << srUkf.matP() << std::endl; + + // Expectations from the python results: + // ====================================== + // x = + // [1.15385 1.84615] + // P = + // [[ 0.24582 0.01505 ] + // [ 0.01505 0.24582 ]] + + std::cout << " End of Example 1: ===========================" << std::endl; +} + diff --git a/cpp/Examples/test_least_squares/CMakeLists.txt b/cpp/Examples/test_least_squares/CMakeLists.txt index 94bcb75..5a8e50c 100644 --- a/cpp/Examples/test_least_squares/CMakeLists.txt +++ b/cpp/Examples/test_least_squares/CMakeLists.txt @@ -3,7 +3,7 @@ ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/GPL-3.0. +## https://opensource.org/licenses/GPL-3.0 ## ## @author Mohanad Youssef ## @file CMakeLists.h diff --git a/cpp/Examples/test_least_squares/main.cpp b/cpp/Examples/test_least_squares/main.cpp index 34d0b4d..9b4361b 100644 --- a/cpp/Examples/test_least_squares/main.cpp +++ b/cpp/Examples/test_least_squares/main.cpp @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/ukf_range_sensor/CMakeLists.txt b/cpp/Examples/ukf_range_sensor/CMakeLists.txt index aeb72e7..f1d885d 100644 --- a/cpp/Examples/ukf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ukf_range_sensor/CMakeLists.txt @@ -1,12 +1,12 @@ -## -## Copyright 2022 CodingCorner -## -## Use of this source code is governed by an MIT - style -## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/MIT. -## -## @author Mohanad Youssef -## @file CMakeLists.h +## +## Copyright 2022 CodingCorner +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h ## file(GLOB PROJECT_FILES diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp index bd1b0aa..08c58e7 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/Examples/unscented_transform/CMakeLists.txt b/cpp/Examples/unscented_transform/CMakeLists.txt index ddf4c0d..f5b10e3 100644 --- a/cpp/Examples/unscented_transform/CMakeLists.txt +++ b/cpp/Examples/unscented_transform/CMakeLists.txt @@ -3,7 +3,7 @@ ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/GPL-3.0. +## https://opensource.org/licenses/GPL-3.0 ## ## @author Mohanad Youssef ## @file CMakeLists.h diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index b212c6f..37a20c6 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file main.cpp diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/kalman_filter/CMakeLists.txt index 84e1cd1..b5ca881 100644 --- a/cpp/kalman_filter/CMakeLists.txt +++ b/cpp/kalman_filter/CMakeLists.txt @@ -3,7 +3,7 @@ ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at -## https ://opensource.org/licenses/GPL-3.0. +## https://opensource.org/licenses/GPL-3.0 ## ## @author Mohanad Youssef ## @file CMakeLists.h diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index 0f2e723..cb4144b 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file kalman_filter.h @@ -31,11 +31,11 @@ namespace kf } - Vector & vecX() { return m_vecX; } - const Vector & vecX() const { return m_vecX; } + virtual Vector & vecX() { return m_vecX; } + virtual const Vector & vecX() const { return m_vecX; } - Matrix & matP() { return m_matP; } - const Matrix & matP() const { return m_matP; } + virtual Matrix & matP() { return m_matP; } + virtual const Matrix & matP() const { return m_matP; } /// /// @brief predict state with a linear process model. diff --git a/cpp/kalman_filter/square_root_ukf.h b/cpp/kalman_filter/square_root_ukf.h new file mode 100644 index 0000000..be360ff --- /dev/null +++ b/cpp/kalman_filter/square_root_ukf.h @@ -0,0 +1,353 @@ +/// +/// Copyright 2022 CodingCorner +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file square_root_ukf.h +/// + +#ifndef __SQUARE_ROOT_UNSCENTED_KALMAN_FILTER_LIB_H__ +#define __SQUARE_ROOT_UNSCENTED_KALMAN_FILTER_LIB_H__ + +#include "util.h" +#include "kalman_filter.h" + +namespace kf +{ + template + class SquareRootUKF : public KalmanFilter + { + public: + static constexpr int32_t SIGMA_DIM{ 2 * DIM_X + 1 }; + + SquareRootUKF() : KalmanFilter() + { + // calculate weights + const float32_t kappa{ static_cast(3 - DIM_X) }; + updateWeights(kappa); + } + + ~SquareRootUKF() {} + + Matrix & matP() override { return (m_matP = m_matSk * m_matSk.transpose()); } + //const Matrix & matP() const override { return (m_matP = m_matSk * m_matSk.transpose()); } + + void initialize(const Vector & vecX, const Matrix & matP, const Matrix & matQ, const Matrix & matR) + { + m_vecX = vecX; + + { + // cholesky factorization to get matrix Pk square-root + Eigen::LLT> lltOfP(matP); + m_matSk = lltOfP.matrixL(); // sqrt(P) + } + + { + // cholesky factorization to get matrix Q square-root + Eigen::LLT> lltOfRv(matQ); + m_matRv = lltOfRv.matrixL(); // sqrt(Q) + } + + { + // cholesky factorization to get matrix R square-root + Eigen::LLT> lltOfRn(matR); + m_matRn = lltOfRn.matrixL(); // sqrt(R) + } + } + + /// + /// @brief setting the cholesky factorization of state covariance P. + /// @param matP state covariance matrix + /// + void setCovarianceP(const Matrix & matP) + { + // cholesky factorization to get matrix Q square-root + Eigen::LLT> lltOfPk(matP); + m_matSk = lltOfPk.matrixL(); + } + + /// + /// @brief setting the cholesky factorization of process noise covariance Q. + /// @param matQ process noise covariance matrix + /// + void setCovarianceQ(const Matrix & matQ) + { + // cholesky factorization to get matrix Q square-root + Eigen::LLT> lltOfRv(matQ); + m_matRv = lltOfRv.matrixL(); + } + + /// + /// @brief setting the cholesky factorization of measurement noise covariance R. + /// @param matR process noise covariance matrix + /// + void setCovarianceR(const Matrix & matR) + { + // cholesky factorization to get matrix R square-root + Eigen::LLT> lltOfRn(matQ); + m_matRn = lltOfRn.matrixL(); // sqrt(R) + } + + /// + /// @brief state prediction step of the unscented Kalman filter (UKF). + /// @param predictionModelFunc callback to the prediction/process model function + /// + template + void predict(PredictionModelCallback predictionModelFunc) + { + const float32_t kappa{ static_cast(3 - DIM_X) }; + + // x_sigmas = self.sigma_points(self.x, self.S) + Matrix matSigmaX{ calculateSigmaPoints(m_vecX, m_matSk, kappa) }; + + // y_sigmas = np.zeros((self.dim_x, self.n_sigma)) + // for i in range(self.n_sigma): + // y_sigmas[:, i] = f(x_sigmas[:, i]) + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + const Vector Xi{ util::getColumnAt(i, matSigmaX) }; + const Vector Yi{ predictionModelFunc(Xi) }; // y = f(x) + + util::copyToColumn(i, matSigmaX, Yi); // Y[:, i] = y + } + + // calculate weighted mean of the predicted state + calculateWeightedMean(matSigmaX, m_vecX); + + // update of cholesky factorized state covariance Sk + m_matSk = updatePredictedCovariance(matSigmaX, m_vecX, m_matRv); + } + + /// + /// @brief measurement correction step of the unscented Kalman filter (UKF). + /// @param measurementModelFunc callback to the measurement model function + /// @param vecZ actual measurement vector. + /// + template + void correct(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) + { + const float32_t kappa{ static_cast(3 - DIM_X) }; + + // x_sigmas = self.sigma_points(self.x, self.S) + Matrix matSigmaX{ calculateSigmaPoints(m_vecX, m_matSk, kappa) }; + + // y_sigmas = np.zeros((self.dim_x, self.n_sigma)) + // for i in range(self.n_sigma): + // y_sigmas[:, i] = f(x_sigmas[:, i]) + Matrix matSigmaY; + + for (size_t i{ 0 }; i < SIGMA_DIM; ++i) + { + const Vector Xi{ util::getColumnAt(i, matSigmaX) }; + const Vector Yi{ measurementModelFunc(Xi) }; // y = f(x) + + util::copyToColumn(i, matSigmaY, Yi); // Y[:, i] = y + } + + // calculate weighted mean of the predicted state + Vector vecY; + calculateWeightedMean(matSigmaY, vecY); + + // update of cholesky factorized state covariance Sk + const Matrix matSy{ + updatePredictedCovariance(matSigmaY, vecY, m_matRn) + }; + + // cross-correlation + const Matrix matPxy{ + calculateCrossCorrelation(matSigmaX, m_vecX, matSigmaY, vecY) + }; + + // Kalman Gain + Matrix matKk; + matKk = util::forwardSubstitute(matSy, matPxy); + matKk = util::backwardSubstitute(matSy.transpose(), matKk); + + // state vector correction + m_vecX += matKk * (vecZ - vecY); + + // state covariance correction + const Matrix matU{ matKk * matSy }; + m_matSk = util::cholupdate(m_matSk, matU, -1.0); + } + + private: + using KalmanFilter::m_vecX; // from Base KalmanFilter class + using KalmanFilter::m_matP; // from Base KalmanFilter class + + float32_t m_weight0; /// @brief unscented transform weight 0 for mean + float32_t m_weighti; /// @brief unscented transform weight i for none mean samples + + Matrix m_matSk{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + Matrix m_matRv{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + Matrix m_matRn{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + + /// + /// @brief algorithm to calculate the weights used to draw the sigma points + /// @param kappa design scaling parameter for sigma points selection + /// + void updateWeights(float32_t kappa) + { + static_assert(DIM_X > 0, "DIM_X is Zero which leads to numerical issue."); + + const float32_t denoTerm{ kappa + static_cast(DIM_X) }; + + m_weight0 = kappa / denoTerm; + m_weighti = 0.5F / denoTerm; + } + + /// + /// @brief algorithm to calculate the deterministic sigma points for + /// the unscented transformation + /// + /// @param vecXk mean of the normally distributed state + /// @param matSk covariance of the normally distributed state + /// @param kappa design scaling parameter for sigma points selection + /// + Matrix calculateSigmaPoints(const Vector & vecXk, const Matrix & matSk, const float32_t kappa) + { + const Matrix matS{ matSk * std::sqrt(DIM_X + kappa) }; // sqrt(n + \kappa) * Sk + + Matrix sigmaX; + + // X_0 = \bar{xa} + util::copyToColumn< DIM_X, SIGMA_DIM >(0, sigmaX, vecXk); + + for (size_t i{ 0 }; i < DIM_X; ++i) + { + const size_t IDX_1{ i + 1 }; + const size_t IDX_2{ i + DIM_X + 1 }; + + util::copyToColumn< DIM_X, SIGMA_DIM >(IDX_1, sigmaX, vecXk); + util::copyToColumn< DIM_X, SIGMA_DIM >(IDX_2, sigmaX, vecXk); + + const Vector vecShiftTerm{ util::getColumnAt< DIM_X, DIM_X >(i, matS) }; + + util::addColumnFrom< DIM_X, SIGMA_DIM >(IDX_1, sigmaX, vecShiftTerm); // X_i = \bar{x} + sqrt(n + \kappa) * Sk + util::subColumnFrom< DIM_X, SIGMA_DIM >(IDX_2, sigmaX, vecShiftTerm); // X_{i+n} = \bar{x} - sqrt(n + \kappa) * Sk + } + + return sigmaX; + } + + /// + /// @brief calculate the weighted mean and covariance given a set of sigma points + /// @param sigmaX matrix of sigma points where each column contain single sigma point + /// @param vecX output weighted mean + /// + template + void calculateWeightedMean(const Matrix & sigmaX, Vector & vecX) + { + // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] + vecX = m_weight0 * util::getColumnAt(0, sigmaX); + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + vecX += m_weighti * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] + } + } + + /// + /// @brief calculate the cross-correlation given two sets sigma points X and Y and their means x and y + /// @param sigmaX first matrix of sigma points where each column contain single sigma point + /// @param vecX mean of the first set of sigma points + /// @param sigmaY second matrix of sigma points where each column contain single sigma point + /// @param vecY mean of the second set of sigma points + /// @return matPxy, the cross-correlation matrix + /// + Matrix calculateCrossCorrelation( + const Matrix & sigmaX, const Vector & vecX, + const Matrix & sigmaY, const Vector & vecY) + { + Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // X[:, 0] - \bar{ x } + Vector devYi{ util::getColumnAt(0, sigmaY) - vecY }; // Y[:, 0] - \bar{ y } + + // P_0 = W[0, 0] (X[:, 0] - \bar{x}) (Y[:, 0] - \bar{y})^T + Matrix matPxy{ + m_weight0 * (devXi * devYi.transpose()) + }; + + for (size_t i{ 1 }; i < SIGMA_DIM; ++i) + { + devXi = util::getColumnAt(i, sigmaX) - vecX; // X[:, i] - \bar{x} + devYi = util::getColumnAt(i, sigmaY) - vecY; // Y[:, i] - \bar{y} + + matPxy += m_weighti * (devXi * devYi.transpose()); // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + } + + return matPxy; + } + + template + Matrix updatePredictedCovariance( + const Matrix & matSigmaX, const Vector & meanX, const Matrix & matU) + { + constexpr int32_t DIM_ROW{ SIGMA_DIM + DIM - 1 }; + constexpr int32_t DIM_COL{ DIM }; + + // build compound matrix for square - root covariance update + // sigmas_X[:, 0] is not added because W0 could be zero which will lead + // to undefined outcome from sqrt(W0). + Matrix matC{ buildCompoundMatrix(matSigmaX, meanX, matU) }; + + // calculate square - root covariance S using QR decomposition of compound matrix C + // including the process noise covariance + // _, S_minus = np.linalg.qr(C) + Eigen::HouseholderQR< Matrix > qr(matC); + + // get the upper triangular matrix from the factorization + // might need to reimplement QR factorization it as it seems to use dynamic memory allocation + Matrix matR{ + util::getBlock( + qr.matrixQR().triangularView(), 0, 0) + }; + + // Rank - 1 cholesky update + // x_dev = sigmas_X[:, 0] - x_minus + // x_dev = np.reshape(x_dev, [-1, 1]) + // S_minus = cholupdate(S_minus.T, x_dev, self.W0) + // TODO: implement cholupdate, the one from Eigen is not straight forward to use + Vector devX0 = util::getColumnAt(0, matSigmaX) - meanX; + matR = util::cholupdate(matR.transpose(), devX0, m_weight0); + + return matR; + } + + Matrix + buildCompoundMatrix( + const Matrix & matSigmaX, const Vector & meanX, const Matrix & matU) + { + // build compoint/joint matrix for square-root covariance update + + constexpr int32_t DIM_ROW{ SIGMA_DIM + DIM_V - 1 }; + constexpr int32_t DIM_COL{ DIM_X }; + + Matrix matC; + + // C = (sigmas_X[:, 1 : ].T - x_minus) * np.sqrt(self.Wi) + const float32_t sqrtWi{ std::sqrt(m_weighti) }; + for (int32_t i{ 0 }; i < DIM_X; ++i) + { + for (int32_t j{ 1 }; j < SIGMA_DIM; ++j) + { + matC(j - 1, i) = sqrtWi * (matSigmaX(i, j) - meanX[i]); + } + } + + // C = np.concatenate((C, self.sqrt_Q.T), axis=0) + for (int32_t i{ 0 }; i < DIM_X; ++i) + { + for (int32_t j{ 0 }; j < DIM_X; ++j) + { + matC(j + SIGMA_DIM - 1, i) = matU(i, j); + } + } + + return matC; + } + }; +} + +#endif // __UNSCENTED_KALMAN_FILTER_LIB_H__ diff --git a/cpp/kalman_filter/types.h b/cpp/kalman_filter/types.h index 3c5913d..166fc80 100644 --- a/cpp/kalman_filter/types.h +++ b/cpp/kalman_filter/types.h @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file types.h diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h index 9bc4e61..b6171fb 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file unscented_kalman_filter.h diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index be276ab..a2568cb 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file unscented_transform.h diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h index 96a549c..d072f09 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/kalman_filter/util.h @@ -3,7 +3,7 @@ /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at -/// https ://https://opensource.org/licenses/GPL-3.0. +/// https://opensource.org/licenses/GPL-3.0 /// /// @author Mohanad Youssef /// @file util.h @@ -58,6 +58,55 @@ namespace util return vecXi; } + template + Matrix getBlock(const Matrix & matA, int32_t startRowIdx, int32_t startColIdx) + { + Matrix matB; + + for (int32_t i = startRowIdx; i < startRowIdx + N_ROWS; ++i) + { + for (int32_t j = startColIdx; j < startColIdx + N_COLS; ++j) + { + matB(i - startRowIdx, j - startColIdx) = matA(i, j); + } + } + + return matB; + } + + template + Matrix cholupdate(Matrix matL, Matrix matW, float32_t alpha) + { + Matrix matLo; + + for (int32_t i{ 0 }; i < COLS_W; ++i) + { + matLo = matL; + + float32_t b{ 1.0F }; + + for (int32_t j{ 0 }; j < ROWS; ++j) + { + const float32_t ljjPow2{ matL(j, j) * matL(j, j) }; + const float32_t wjiPow2{ matW(j, i) * matW(j, i) }; + const float32_t upsilon{ (ljjPow2 * b) + (alpha * wjiPow2) }; + + matLo(j, j) = std::sqrt(ljjPow2 + ((alpha / b) * wjiPow2)); + + for (int32_t k{ j + 1 }; k < ROWS; ++k) + { + matW(k, i) -= (matW(j, i) / matL(j, j)) * matL(k, j); + matLo(k, j) = ((matLo(j, j) / matL(j, j)) * matL(k, j)) + (matLo(j, j) * alpha * matW(j, i) * matW(k, i) / upsilon); + } + + b += alpha * (wjiPow2 / ljjPow2); + } + + matL = matLo; + } + return matLo; + } + template Matrix forwardSubstitute(const Matrix & matA, const Matrix & matB) { diff --git a/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb b/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb index a732384..cc9da87 100644 --- a/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb +++ b/python/examples/Square_Root_Unscented_Kalman_Filter.ipynb @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "6147381c", "metadata": {}, "outputs": [], @@ -91,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "5fe7c504", "metadata": {}, "outputs": [ @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "92d18f4c", "metadata": {}, "outputs": [ @@ -141,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "53086a01", "metadata": {}, "outputs": [ @@ -174,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "4e05ab25", "metadata": {}, "outputs": [ @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "04b88ded", "metadata": {}, "outputs": [], @@ -265,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "c720900c", "metadata": {}, "outputs": [ @@ -294,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "82da6bea", "metadata": {}, "outputs": [ @@ -319,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "df0f7a9c", "metadata": {}, "outputs": [ @@ -363,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "d779bc17", "metadata": {}, "outputs": [], @@ -389,7 +389,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "7a6b1cb4", "metadata": {}, "outputs": [ @@ -424,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "a87f986f", "metadata": {}, "outputs": [], @@ -449,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "1e4ab129", "metadata": {}, "outputs": [ @@ -487,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 39, "id": "d58dbdcb", "metadata": {}, "outputs": [], @@ -510,6 +510,8 @@ " self.sqrt_P = np.linalg.cholesky(P)\n", " self.sqrt_Q = np.linalg.cholesky(Q)\n", " self.sqrt_R = np.linalg.cholesky(R)\n", + " \n", + " print(f'R = \\n{R}\\n')\n", " \n", " def predict(self, f):\n", " # generate sigma points\n", @@ -524,22 +526,29 @@ " for i in range(1, self.n_sigmas):\n", " x_minus += self.Wi * sigmas_X[:, i]\n", " \n", - " # build compound matrix for square-root covariance update \n", - " C = (sigmas_X[:, 1:].T - x_minus) * np.sqrt(self.Wi) \n", + " # build compound matrix for square-root covariance update\n", + " # sigmas_X[:, 0] is not added because W0 could be zero which will lead\n", + " # to undefined outcome from sqrt(W0).\n", + " C = (sigmas_X[:, 1:].T - x_minus) * np.sqrt(self.Wi)\n", " C = np.concatenate((C, self.sqrt_Q.T), axis=0)\n", " \n", " # calculate square-root covariance S using QR decomposition of compound matrix C\n", " # including the process noise covariance\n", - " _ , S_minus = np.linalg.qr(C)\n", + " Q , S_minus = np.linalg.qr(C)\n", + " print(f'Q = \\n{Q}\\n')\n", + " print(f'R = \\n{S_minus}\\n')\n", " \n", " # Rank-1 cholesky update\n", " x_dev = sigmas_X[:, 0] - x_minus\n", " x_dev = np.reshape(x_dev, [-1, 1])\n", + " print(f'x_dev = \\n{x_dev}\\n')\n", " S_minus = cholupdate(S_minus.T, x_dev, self.W0)\n", " \n", " # overwrite member x and S\n", " self.x = x_minus\n", " self.sqrt_P = S_minus\n", + " \n", + " print(f'S^- = \\n{S_minus}\\n')\n", " \n", " \n", " def correct(self, h, z):\n", @@ -552,16 +561,22 @@ " sigmas_Y = np.zeros((dim_z, self.n_sigmas))\n", " for i in range(self.n_sigmas):\n", " sigmas_Y[:, i] = h(sigmas_X[:, i])\n", - " \n", + " \n", + " print(f'Ys = \\n{sigmas_Y}\\n')\n", + " \n", " # calculate weighted mean y\n", " y_bar = self.W0 * sigmas_Y[:, 0]\n", " for i in range(1, self.n_sigmas):\n", " y_bar += self.Wi * sigmas_Y[:, i]\n", " \n", + " print(f'y = \\n{y_bar}\\n')\n", + " \n", " # build compound matrix for square-root covariance update \n", " C = (sigmas_Y[:, 1:].T - y_bar) * np.sqrt(self.Wi) \n", " C = np.concatenate((C, self.sqrt_R.T), axis=0)\n", " \n", + " print(f'sqrt_R.T = \\n{self.sqrt_R.T}\\n')\n", + " \n", " # calculate square-root covariance S using QR decomposition of compound matrix C\n", " # including the process noise covariance\n", " _ , S_y = np.linalg.qr(C)\n", @@ -570,15 +585,18 @@ " y_dev = sigmas_Y[:, 0] - y_bar\n", " y_dev = np.reshape(y_dev, [-1, 1])\n", " S_y = cholupdate(S_y.T, y_dev, self.W0)\n", + " print(f'Sy = \\n{S_y}\\n')\n", " \n", " # calculate cross-correlation\n", " Pxy = self.calculate_cross_correlation(self.x, sigmas_X, y_bar, sigmas_Y)\n", + " print(f'Pxy = \\n{Pxy}\\n')\n", " \n", " # Kalman gain calculation with two nested least-squares\n", " # Step1: Forward-substitution -> K = Sy \\ Pxy (since S_y is lower-triangular)\n", " # Step2: Backward-substitution -> K = Sy.T \\ K (since S_y.T is upper-triangular)\n", " K = forwardsubs(S_y, Pxy)\n", " K = backsubs(S_y.T, K)\n", + " print(f'K = \\n{K}\\n')\n", " \n", " # update state vector x\n", " self.x += K @ (z - y_bar)\n", @@ -629,7 +647,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 29, "id": "65371877", "metadata": {}, "outputs": [], @@ -640,7 +658,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 30, "id": "6e6581a4", "metadata": {}, "outputs": [ @@ -648,6 +666,26 @@ "name": "stdout", "output_type": "stream", "text": [ + "Q = \n", + "[[-0.4472136 0.10873206]\n", + " [-0. -0.4152274 ]\n", + " [ 0.4472136 -0.10873206]\n", + " [-0. 0.4152274 ]\n", + " [-0.77459667 -0.12555296]\n", + " [-0. -0.78470603]]\n", + "\n", + "R = \n", + "[[-2.23606798 0.35777088]\n", + " [ 0. -2.20726075]]\n", + "\n", + "x_dev = \n", + "[[0.]\n", + " [0.]]\n", + "\n", + "S^- = \n", + "[[ 2.23606798 0. ]\n", + " [-0.35777088 2.20726075]]\n", + "\n", "P+Q = \n", "[[ 5. -0.8]\n", " [-0.8 5. ]]\n" @@ -669,7 +707,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 31, "id": "048dbb99", "metadata": {}, "outputs": [], @@ -684,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 32, "id": "61444e4d", "metadata": {}, "outputs": [], @@ -708,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 33, "id": "6eed9c84", "metadata": {}, "outputs": [ @@ -750,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 40, "id": "2c347ab3", "metadata": {}, "outputs": [ @@ -758,6 +796,30 @@ "name": "stdout", "output_type": "stream", "text": [ + "R = \n", + "[[0.3 0. ]\n", + " [0. 0.3]]\n", + "\n", + "Q = \n", + "[[-5.77350269e-01 -1.02062073e-01]\n", + " [-3.70074342e-17 -5.30330086e-01]\n", + " [ 5.77350269e-01 1.02062073e-01]\n", + " [-3.70074342e-17 5.30330086e-01]\n", + " [-5.77350269e-01 2.04124145e-01]\n", + " [-0.00000000e+00 -6.12372436e-01]]\n", + "\n", + "R = \n", + "[[-1.22474487 -0.40824829]\n", + " [ 0. -1.15470054]]\n", + "\n", + "x_dev = \n", + "[[1.11022302e-16]\n", + " [0.00000000e+00]]\n", + "\n", + "S^- = \n", + "[[1.22474487 0. ]\n", + " [0.40824829 1.15470054]]\n", + "\n", "x1 = \n", "[1. 2.]\n", "\n", @@ -765,6 +827,31 @@ "[[1.5 0.5]\n", " [0.5 1.5]]\n", "\n", + "Ys = \n", + "[[ 1.00000000e+00 3.12132034e+00 1.00000000e+00 -1.12132034e+00\n", + " 1.00000000e+00]\n", + " [ 2.00000000e+00 2.70710678e+00 4.00000000e+00 1.29289322e+00\n", + " 2.22044605e-16]]\n", + "\n", + "y = \n", + "[1. 2.]\n", + "\n", + "sqrt_R.T = \n", + "[[0.54772256 0. ]\n", + " [0. 0.54772256]]\n", + "\n", + "Sy = \n", + "[[1.34164079 0. ]\n", + " [0.372678 1.288841 ]]\n", + "\n", + "Pxy = \n", + "[[1.5 0.5]\n", + " [0.5 1.5]]\n", + "\n", + "K = \n", + "[[0.81939799 0.05016722]\n", + " [0.05016722 0.81939799]]\n", + "\n", "x2 = \n", "[1.15385 1.84615]\n", "\n", From 8ce1e4e1644a57bbbe19c036ad3991d13a888e14 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Thu, 22 Dec 2022 11:33:08 +0100 Subject: [PATCH 25/60] reduce template arg in sqare-root ukf --- cpp/Examples/sr_ukf_linear_function/main.cpp | 8 +++---- cpp/kalman_filter/square_root_ukf.h | 24 ++++++++++---------- 2 files changed, 15 insertions(+), 17 deletions(-) diff --git a/cpp/Examples/sr_ukf_linear_function/main.cpp b/cpp/Examples/sr_ukf_linear_function/main.cpp index 2bcdeb6..df19ca1 100644 --- a/cpp/Examples/sr_ukf_linear_function/main.cpp +++ b/cpp/Examples/sr_ukf_linear_function/main.cpp @@ -16,9 +16,7 @@ #include "kalman_filter/square_root_ukf.h" static constexpr size_t DIM_X{ 2 }; -static constexpr size_t DIM_V{ 2 }; static constexpr size_t DIM_Z{ 2 }; -static constexpr size_t DIM_N{ 2 }; void runExample1(); @@ -54,18 +52,18 @@ void runExample1() P << 1.0F, 0.5F, 0.5F, 1.0F; - Matrix Q; + Matrix Q; Q << 0.5F, 0.0F, 0.0F, 0.5F; Vector z; z << 1.2F, 1.8F; - Matrix R; + Matrix R; R << 0.3F, 0.0F, 0.0F, 0.3F; - kf::SquareRootUKF srUkf; + kf::SquareRootUKF srUkf; srUkf.initialize(x, P, Q, R); srUkf.predict(funcF); diff --git a/cpp/kalman_filter/square_root_ukf.h b/cpp/kalman_filter/square_root_ukf.h index be360ff..7c09628 100644 --- a/cpp/kalman_filter/square_root_ukf.h +++ b/cpp/kalman_filter/square_root_ukf.h @@ -17,7 +17,7 @@ namespace kf { - template + template class SquareRootUKF : public KalmanFilter { public: @@ -35,7 +35,7 @@ namespace kf Matrix & matP() override { return (m_matP = m_matSk * m_matSk.transpose()); } //const Matrix & matP() const override { return (m_matP = m_matSk * m_matSk.transpose()); } - void initialize(const Vector & vecX, const Matrix & matP, const Matrix & matQ, const Matrix & matR) + void initialize(const Vector & vecX, const Matrix & matP, const Matrix & matQ, const Matrix & matR) { m_vecX = vecX; @@ -47,13 +47,13 @@ namespace kf { // cholesky factorization to get matrix Q square-root - Eigen::LLT> lltOfRv(matQ); + Eigen::LLT> lltOfRv(matQ); m_matRv = lltOfRv.matrixL(); // sqrt(Q) } { // cholesky factorization to get matrix R square-root - Eigen::LLT> lltOfRn(matR); + Eigen::LLT> lltOfRn(matR); m_matRn = lltOfRn.matrixL(); // sqrt(R) } } @@ -73,10 +73,10 @@ namespace kf /// @brief setting the cholesky factorization of process noise covariance Q. /// @param matQ process noise covariance matrix /// - void setCovarianceQ(const Matrix & matQ) + void setCovarianceQ(const Matrix & matQ) { // cholesky factorization to get matrix Q square-root - Eigen::LLT> lltOfRv(matQ); + Eigen::LLT> lltOfRv(matQ); m_matRv = lltOfRv.matrixL(); } @@ -84,10 +84,10 @@ namespace kf /// @brief setting the cholesky factorization of measurement noise covariance R. /// @param matR process noise covariance matrix /// - void setCovarianceR(const Matrix & matR) + void setCovarianceR(const Matrix & matR) { // cholesky factorization to get matrix R square-root - Eigen::LLT> lltOfRn(matQ); + Eigen::LLT> lltOfRn(matQ); m_matRn = lltOfRn.matrixL(); // sqrt(R) } @@ -182,8 +182,8 @@ namespace kf float32_t m_weighti; /// @brief unscented transform weight i for none mean samples Matrix m_matSk{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) - Matrix m_matRv{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) - Matrix m_matRn{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + Matrix m_matRv{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) + Matrix m_matRn{ Matrix::Zero() }; /// @brief augmented state covariance (incl. process and measurement noise covariances) /// /// @brief algorithm to calculate the weights used to draw the sigma points @@ -315,13 +315,13 @@ namespace kf return matR; } - Matrix + Matrix buildCompoundMatrix( const Matrix & matSigmaX, const Vector & meanX, const Matrix & matU) { // build compoint/joint matrix for square-root covariance update - constexpr int32_t DIM_ROW{ SIGMA_DIM + DIM_V - 1 }; + constexpr int32_t DIM_ROW{ SIGMA_DIM + DIM_X - 1 }; constexpr int32_t DIM_COL{ DIM_X }; Matrix matC; From aa2c9d876072752ea20d7e06d2b53ffef73ecb04 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sun, 25 Dec 2022 22:29:19 +0100 Subject: [PATCH 26/60] remove unused CMakeLists.txt --- CMakeLists.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index e69de29..0000000 From b93aa1c535714d156831e4f0522d779df81f9c9d Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sun, 25 Dec 2022 23:38:25 +0100 Subject: [PATCH 27/60] option to install the library via cmake --- cpp/CMakeLists.txt | 11 ++++- cpp/kalman_filter/CMakeLists.txt | 67 +++++++++++++++++++++++--- cpp/kalman_filter/conf/Config.cmake.in | 6 +++ cpp/kalman_filter/dummy.cpp | 2 + 4 files changed, 78 insertions(+), 8 deletions(-) create mode 100644 cpp/kalman_filter/conf/Config.cmake.in create mode 100644 cpp/kalman_filter/dummy.cpp diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index c4f853b..894feb9 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -14,10 +14,17 @@ endif(WIN32) set(CMAKE_FIND_PACKAGE_PREFER_CONFIG ON) set(CMAKE_INCLUDE_CURRENT_DIR ON) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) -set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/build/package) +#set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/build/package) set(CMAKE_CXX_STANDARD 11) -project(kalman_filter) +project(OpenKF) + +set(INCLUDE_FOLDER "include") +set(LIBRARY_INSTALL_DIR "lib") +set(INCLUDE_INSTALL_DIR "${INCLUDE_FOLDER}/${PROJECT_NAME}") +set(CONFIG_INSTALL_DIR "${LIBRARY_INSTALL_DIR}/cmake/${PROJECT_NAME}") +set(namespace "%{PROJECT_NAME}::") +set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets") enable_language(C CXX) diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/kalman_filter/CMakeLists.txt index b5ca881..7a2fa00 100644 --- a/cpp/kalman_filter/CMakeLists.txt +++ b/cpp/kalman_filter/CMakeLists.txt @@ -9,18 +9,73 @@ ## @file CMakeLists.h ## -file(GLOB LIBRARY_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" - ) +# file(GLOB LIBRARY_FILES +# "${CMAKE_CURRENT_SOURCE_DIR}/*.h" +# "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +# ) -set(LIBRARY_NAME kalman_filter_lib) +set(LIBRARY_SRC_FILES + dummy.cpp +) + +set(LIBRARY_HDR_FILES + types.h + util.h + kalman_filter.h + unscented_transform.h + unscented_kalman_filter.h + square_root_ukf.h +) + +set(LIBRARY_NAME ${PROJECT_NAME}) -add_library(${LIBRARY_NAME} ${LIBRARY_FILES}) +add_library(${LIBRARY_NAME} ${LIBRARY_SRC_FILES} ${LIBRARY_HDR_FILES}) set_target_properties(${LIBRARY_NAME} PROPERTIES LINKER_LANGUAGE CXX) target_link_libraries(${LIBRARY_NAME} PUBLIC Eigen3::Eigen) target_include_directories(${LIBRARY_NAME} PUBLIC $ + $ +) + +include(CMakePackageConfigHelpers) + +configure_package_config_file( + ${CMAKE_CURRENT_SOURCE_DIR}/conf/Config.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}Config.cmake + INSTALL_DESTINATION ${CONFIG_INSTALL_DIR} + PATH_VARS INCLUDE_FOLDER +) + +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}ConfigVersion.cmake + VERSION 1.0.0 + COMPATIBILITY SameMajorVersion +) + +install( + FILES ${LIBRARY_HDR_FILES} + DESTINATION ${INCLUDE_INSTALL_DIR} +) + +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}Config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}ConfigVersion.cmake + DESTINATION ${CONFIG_INSTALL_DIR} +) + +install( + TARGETS ${LIBRARY_NAME} + EXPORT "${TARGETS_EXPORT_NAME}" + LIBRARY DESTINATION "${LIBRARY_INSTALL_DIR}" + ARCHIVE DESTINATION "${LIBRARY_INSTALL_DIR}" + INCLUDES DESTINATION "${INCLUDE_FOLDER}" ) + +# Config +# * /lib/cmake/OpenKF/OpenKFTargets.cmake +install( + EXPORT ${TARGETS_EXPORT_NAME} + DESTINATION ${CONFIG_INSTALL_DIR} +) \ No newline at end of file diff --git a/cpp/kalman_filter/conf/Config.cmake.in b/cpp/kalman_filter/conf/Config.cmake.in new file mode 100644 index 0000000..da23610 --- /dev/null +++ b/cpp/kalman_filter/conf/Config.cmake.in @@ -0,0 +1,6 @@ +@PACKAGE_INIT@ + +set_and_check(OPENKF_INCLUDE_DIR "@PACKAGE_INCLUDE_FOLDER@") +include( "${CMAKE_CURRENT_LIST_DIR}/OpenKFTargets.cmake" ) + +check_required_components(OpenKF) \ No newline at end of file diff --git a/cpp/kalman_filter/dummy.cpp b/cpp/kalman_filter/dummy.cpp new file mode 100644 index 0000000..e13446f --- /dev/null +++ b/cpp/kalman_filter/dummy.cpp @@ -0,0 +1,2 @@ + +static void dummyFunction() {} From ca4f512e8428589ea20992bfc734d6f611004e88 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Mon, 26 Dec 2022 00:43:51 +0100 Subject: [PATCH 28/60] adding bootstrap batch file --- bootstrap-openkf.bat | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 bootstrap-openkf.bat diff --git a/bootstrap-openkf.bat b/bootstrap-openkf.bat new file mode 100644 index 0000000..ccf2a4f --- /dev/null +++ b/bootstrap-openkf.bat @@ -0,0 +1,16 @@ +@echo off + +echo Creating Build Folder +md .\cpp\build + +echo generating meta files +cmake -S .\cpp -B .\cpp\build + +echo building ... +cmake --build .\cpp\build + +echo installing ... +cmake --install .\cpp\build --config Debug +::runas /user:Administrator "cmake --install .\cpp\build --config Debug" + +pause From 021e22c32a10b7e9a07463bcf92a24691c8d65b2 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Mon, 26 Dec 2022 00:54:48 +0100 Subject: [PATCH 29/60] updated readme for bootstrap script --- README.md | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/README.md b/README.md index 7ac3e89..542ef5b 100644 --- a/README.md +++ b/README.md @@ -14,3 +14,25 @@ The library has generic template based classes for most of Kalman filter variant **Author**: Mohanad Youssef ([codingcorner.org](https://codingcorner.org/)) ![](res/images/codingcorner_cover_image.png) + +## Getting Started + +One can build the library and install the files in the system to be used in different external projects. + +You just need to execute the batch file ``bootstrap-openkf.bat`` from a **_Administrator PowerShell Terminal_**. + +```batch +>> ./bootstrap-openkf.bat +``` + +This batch file will execute cmake commands to generate meta files, build, and install the library files in the system. + +After that, the OpenKF library is ready to be used in external project. + +In the **_CMakeLists.txt_** you must include these three lines of code: + +````cmake +find_package(OpenKF) +target_link_libraries( PUBLIC OpenKF) +target_include_directories( PUBLIC ${OPENKF_INCLUDE_DIR}) +```` From ee02495064ec9bb6327bcaf471e29e20bc53febe Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Tue, 27 Dec 2022 10:31:44 +0100 Subject: [PATCH 30/60] Update README.md --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 542ef5b..e14d081 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ The library has generic template based classes for most of Kalman filter variant One can build the library and install the files in the system to be used in different external projects. -You just need to execute the batch file ``bootstrap-openkf.bat`` from a **_Administrator PowerShell Terminal_**. +You just need to execute the batch file ``bootstrap-openkf.bat`` from a **PowerShell Terminal (in Administratior Mode)**. ```batch >> ./bootstrap-openkf.bat @@ -32,7 +32,7 @@ After that, the OpenKF library is ready to be used in external project. In the **_CMakeLists.txt_** you must include these three lines of code: ````cmake -find_package(OpenKF) +find_package(OpenKF REQUIRED) target_link_libraries( PUBLIC OpenKF) target_include_directories( PUBLIC ${OPENKF_INCLUDE_DIR}) ```` From 95c5a63e37ae8ea14f8ea72475211d9012187f25 Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Tue, 27 Dec 2022 10:32:50 +0100 Subject: [PATCH 31/60] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e14d081..3bb3214 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ The library has generic template based classes for most of Kalman filter variant One can build the library and install the files in the system to be used in different external projects. -You just need to execute the batch file ``bootstrap-openkf.bat`` from a **PowerShell Terminal (in Administratior Mode)**. +You just need to execute the batch file ``bootstrap-openkf.bat`` from a PowerShell Terminal (in Administrator Mode). ```batch >> ./bootstrap-openkf.bat From 3c3a16067cab4a4d60992a8a6ca07cbd04d341c9 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Tue, 27 Dec 2022 15:51:51 +0100 Subject: [PATCH 32/60] refactoring namespaces and methods name --- cpp/Examples/ekf_range_sensor/main.cpp | 24 +- cpp/Examples/kf_state_estimation/main.cpp | 18 +- cpp/Examples/sr_ukf_linear_function/main.cpp | 16 +- cpp/Examples/test_least_squares/main.cpp | 24 +- cpp/Examples/ukf_range_sensor/main.cpp | 28 +- cpp/Examples/unscented_transform/main.cpp | 24 +- cpp/kalman_filter/kalman_filter.h | 4 +- cpp/kalman_filter/square_root_ukf.h | 4 +- cpp/kalman_filter/types.h | 14 +- cpp/kalman_filter/unscented_kalman_filter.h | 4 +- cpp/kalman_filter/util.h | 275 ++++++++++--------- 11 files changed, 221 insertions(+), 214 deletions(-) diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp index a58ede7..543fb82 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -22,8 +22,8 @@ static constexpr size_t DIM_Z{ 2 }; static kf::KalmanFilter kalmanfilter; -Vector covertCartesian2Polar(const Vector & cartesian); -Matrix calculateJacobianMatrix(const Vector & vecX); +kf::Vector covertCartesian2Polar(const kf::Vector & cartesian); +kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX); void executeCorrectionStep(); int main(int argc, char ** argv) @@ -33,21 +33,21 @@ int main(int argc, char ** argv) return 0; } -Vector covertCartesian2Polar(const Vector & cartesian) +kf::Vector covertCartesian2Polar(const kf::Vector & cartesian) { - const Vector polar{ + const kf::Vector polar{ std::sqrt(cartesian[0] * cartesian[0] + cartesian[1] * cartesian[1]), std::atan2(cartesian[1], cartesian[0]) }; return polar; } -Matrix calculateJacobianMatrix(const Vector & vecX) +kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX) { - const float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; - const float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; + const kf::float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; + const kf::float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; - Matrix matHj; + kf::Matrix matHj; matHj << (vecX[0] / valSqrtX2PlusY2), (vecX[1] / valSqrtX2PlusY2), (-vecX[1] / valX2PlusY2), (vecX[0] / valX2PlusY2); @@ -60,13 +60,13 @@ void executeCorrectionStep() kalmanfilter.vecX() << 10.0F, 5.0F; kalmanfilter.matP() << 0.3F, 0.0F, 0.0F, 0.3F; - const Vector measPosCart{ 10.4F, 5.2F }; - const Vector vecZ{ covertCartesian2Polar(measPosCart) }; + const kf::Vector measPosCart{ 10.4F, 5.2F }; + const kf::Vector vecZ{ covertCartesian2Polar(measPosCart) }; - Matrix matR; + kf::Matrix matR; matR << 0.1F, 0.0F, 0.0F, 0.0008F; - Matrix matHj{ calculateJacobianMatrix(kalmanfilter.vecX()) }; // jacobian matrix Hj + kf::Matrix matHj{ calculateJacobianMatrix(kalmanfilter.vecX()) }; // jacobian matrix Hj kalmanfilter.correctEkf(covertCartesian2Polar, vecZ, matR, matHj); diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp index 722c344..08e8e07 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -17,8 +17,8 @@ static constexpr size_t DIM_X{ 2 }; static constexpr size_t DIM_Z{ 1 }; -static constexpr float32_t T{ 1.0F }; -static constexpr float32_t Q11{ 0.1F }, Q22{ 0.1F }; +static constexpr kf::float32_t T{ 1.0F }; +static constexpr kf::float32_t Q11{ 0.1F }, Q22{ 0.1F }; static kf::KalmanFilter kalmanfilter; @@ -38,15 +38,15 @@ void executePredictionStep() kalmanfilter.vecX() << 0.0F, 2.0F; kalmanfilter.matP() << 0.1F, 0.0F, 0.0F, 0.1F; - Matrix F; // state transition matrix + kf::Matrix F; // state transition matrix F << 1.0F, T, 0.0F, 1.0F; - Matrix Q; // process noise covariance + kf::Matrix Q; // process noise covariance Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3) / 3.0F)); Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2) / 2.0F); Q(1, 1) = Q22 * T; - kalmanfilter.predict(F, Q); // execute prediction step + kalmanfilter.predictLKF(F, Q); // execute prediction step std::cout << "\npredicted state vector = \n" << kalmanfilter.vecX() << "\n"; std::cout << "\npredicted state covariance = \n" << kalmanfilter.matP() << "\n"; @@ -54,16 +54,16 @@ void executePredictionStep() void executeCorrectionStep() { - Vector vecZ; + kf::Vector vecZ; vecZ << 2.25F; - Matrix matR; + kf::Matrix matR; matR << 0.01F; - Matrix matH; + kf::Matrix matH; matH << 1.0F, 0.0F; - kalmanfilter.correct(vecZ, matR, matH); + kalmanfilter.correctLKF(vecZ, matR, matH); std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; diff --git a/cpp/Examples/sr_ukf_linear_function/main.cpp b/cpp/Examples/sr_ukf_linear_function/main.cpp index df19ca1..f810895 100644 --- a/cpp/Examples/sr_ukf_linear_function/main.cpp +++ b/cpp/Examples/sr_ukf_linear_function/main.cpp @@ -20,7 +20,7 @@ static constexpr size_t DIM_Z{ 2 }; void runExample1(); -Vector funcF(const Vector & x) +kf::Vector funcF(const kf::Vector & x) { return x; } @@ -45,28 +45,28 @@ void runExample1() //z = np.array([1.2, 1.8]) //R = np.array([[0.3, 0.0], [0.0, 0.3]]) - Vector x; + kf::Vector x; x << 1.0F, 2.0F; - Matrix P; + kf::Matrix P; P << 1.0F, 0.5F, 0.5F, 1.0F; - Matrix Q; + kf::Matrix Q; Q << 0.5F, 0.0F, 0.0F, 0.5F; - Vector z; + kf::Vector z; z << 1.2F, 1.8F; - Matrix R; + kf::Matrix R; R << 0.3F, 0.0F, 0.0F, 0.3F; kf::SquareRootUKF srUkf; srUkf.initialize(x, P, Q, R); - srUkf.predict(funcF); + srUkf.predictSRUKF(funcF); std::cout << "x = \n" << srUkf.vecX() << std::endl; std::cout << "P = \n" << srUkf.matP() << std::endl; @@ -79,7 +79,7 @@ void runExample1() // [[1.5 0.5] // [0.5 1.5]] - srUkf.correct(funcF, z); + srUkf.correctSRUKF(funcF, z); std::cout << "x = \n" << srUkf.vecX() << std::endl; std::cout << "P = \n" << srUkf.matP() << std::endl; diff --git a/cpp/Examples/test_least_squares/main.cpp b/cpp/Examples/test_least_squares/main.cpp index 9b4361b..f251ea4 100644 --- a/cpp/Examples/test_least_squares/main.cpp +++ b/cpp/Examples/test_least_squares/main.cpp @@ -34,16 +34,16 @@ void runExample1() { std::cout << " Start of Example 1: ===========================" << std::endl; - Matrix<3, 3> A; + kf::Matrix<3, 3> A; A << 3.0, 2.0, 1.0, 2.0, 3.0, 4.0, 1.0, 4.0, 3.0; - Matrix<2, 3> B; + kf::Matrix<2, 3> B; B << 5.0, 6.0, 7.0, 8.0, 9.0, 10.0; - util::JointRows<3, 2, 3> jmat(A, B); + kf::util::JointRows<3, 2, 3> jmat(A, B); auto AB = jmat.jointMatrix(); std::cout << "Joint Rows: AB = \n" << AB << std::endl; @@ -55,17 +55,17 @@ void runExample2() { std::cout << " Start of Example 2: ===========================" << std::endl; - Matrix<3, 3> A; + kf::Matrix<3, 3> A; A << 3.0, 2.0, 1.0, 2.0, 3.0, 4.0, 1.0, 4.0, 3.0; - Matrix<3, 2> B; + kf::Matrix<3, 2> B; B << 5.0, 6.0, 7.0, 8.0, 9.0, 10.0; - util::JointCols<3, 3, 2> jmat(A, B); + kf::util::JointCols<3, 3, 2> jmat(A, B); auto AB = jmat.jointMatrix(); std::cout << "Joint Columns: AB = \n" << AB << std::endl; @@ -77,15 +77,15 @@ void runExample3() { std::cout << " Start of Example 2: ===========================" << std::endl; - Matrix<3, 3> A; + kf::Matrix<3, 3> A; A << 1.0, -2.0, 1.0, 0.0, 1.0, 6.0, 0.0, 0.0, 1.0; - Matrix<3, 1> b; + kf::Matrix<3, 1> b; b << 4.0, -1.0, 2.0; - auto x = util::backwardSubstitute<3, 1>(A, b); + auto x = kf::util::backwardSubstitute<3, 1>(A, b); std::cout << "Backward Substitution: x = \n" << x << std::endl; @@ -96,15 +96,15 @@ void runExample4() { std::cout << " Start of Example 2: ===========================" << std::endl; - Matrix<3, 3> A; + kf::Matrix<3, 3> A; A << 1.0, 0.0, 0.0, -2.0, 1.0, 0.0, 1.0, 6.0, 1.0; - Matrix<3, 1> b; + kf::Matrix<3, 1> b; b << 4.0, -1.0, 2.0; - auto x = util::forwardSubstitute<3, 1>(A, b); + auto x = kf::util::forwardSubstitute<3, 1>(A, b); std::cout << "Forward Substitution: x = \n" << x << std::endl; diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp index 08c58e7..7122b55 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -22,9 +22,9 @@ static constexpr size_t DIM_N{ 2 }; void runExample1(); -Vector funcF(const Vector & x, const Vector & v) +kf::Vector funcF(const kf::Vector & x, const kf::Vector & v) { - Vector y; + kf::Vector y; y[0] = x[0] + x[2] + v[0]; y[1] = x[1] + x[3] + v[1]; y[2] = x[2] + v[2]; @@ -32,15 +32,15 @@ Vector funcF(const Vector & x, const Vector & v) return y; } -Vector funcH(const Vector & x, const Vector & n) +kf::Vector funcH(const kf::Vector & x, const kf::Vector & n) { - Vector y; + kf::Vector y; - float32_t px{ x[0] + n[0] }; - float32_t py{ x[1] + n[1] }; + kf::float32_t px{ x[0] + n[0] }; + kf::float32_t py{ x[1] + n[1] }; y[0] = std::sqrt((px * px) + (py * py)); - y[1] = std::atan(py / (px + std::numeric_limits::epsilon())); + y[1] = std::atan(py / (px + std::numeric_limits::epsilon())); return y; } @@ -56,25 +56,25 @@ void runExample1() { std::cout << " Start of Example 1: ===========================" << std::endl; - Vector x; + kf::Vector x; x << 2.0F, 1.0F, 0.0F, 0.0F; - Matrix P; + kf::Matrix P; P << 0.01F, 0.0F, 0.0F, 0.0F, 0.0F, 0.01F, 0.0F, 0.0F, 0.0F, 0.0F, 0.05F, 0.0F, 0.0F, 0.0F, 0.0F, 0.05F; - Matrix Q; + kf::Matrix Q; Q << 0.05F, 0.0F, 0.0F, 0.0F, 0.0F, 0.05F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F; - Matrix R; + kf::Matrix R; R << 0.01F, 0.0F, 0.0F, 0.01F; - Vector z; + kf::Vector z; z << 2.5, 0.05; kf::UnscentedKalmanFilter ukf; @@ -85,7 +85,7 @@ void runExample1() ukf.setCovarianceQ(Q); ukf.setCovarianceR(R); - ukf.predict(funcF); + ukf.predictUKF(funcF); std::cout << "x = \n" << ukf.vecX() << std::endl; std::cout << "P = \n" << ukf.matP() << std::endl; @@ -100,7 +100,7 @@ void runExample1() // [0.05 0.00 0.15 0.00] // [0.00 0.05 0.00 0.15]] - ukf.correct(funcH, z); + ukf.correctUKF(funcH, z); std::cout << "x = \n" << ukf.vecX() << std::endl; std::cout << "P = \n" << ukf.matP() << std::endl; diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index 37a20c6..4bc0e78 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -23,16 +23,16 @@ static constexpr size_t DIM_2{ 2 }; void runExample1(); void runExample2(); -Vector function1(const Vector & x) +kf::Vector function1(const kf::Vector & x) { - Vector y; + kf::Vector y; y[0] = x[0] * x[0]; return y; } -Vector function2(const Vector & x) +kf::Vector function2(const kf::Vector & x) { - Vector y; + kf::Vector y; y[0] = x[0] * x[0]; y[1] = x[1] * x[1]; return y; @@ -53,17 +53,17 @@ void runExample1() { std::cout << " Start of Example 1: ===========================" << std::endl; - Vector x; + kf::Vector x; x << 0.0F; - Matrix P; + kf::Matrix P; P << 0.5F; kf::UnscentedTransform UT; UT.compute(x, P, 0.0F); - Vector vecY; - Matrix matPyy; + kf::Vector vecY; + kf::Matrix matPyy; UT.transform(function1, vecY, matPyy); @@ -78,17 +78,17 @@ void runExample2() { std::cout << " Start of Example 2: ===========================" << std::endl; - Vector x; + kf::Vector x; x << 2.0F, 1.0F; - Matrix P; + kf::Matrix P; P << 0.1F, 0.0F, 0.0F, 0.1F; kf::UnscentedTransform UT; UT.compute(x, P, 0.0F); - Vector vecY; - Matrix matPyy; + kf::Vector vecY; + kf::Matrix matPyy; UT.transform(function2, vecY, matPyy); diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index cb4144b..fec25c2 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -42,7 +42,7 @@ namespace kf /// @param matF state transition matrix /// @param matQ process noise covariance matrix /// - void predict(const Matrix & matF, const Matrix & matQ) + void predictLKF(const Matrix & matF, const Matrix & matQ) { m_vecX = matF * m_vecX; m_matP = matF * m_matP * matF.transpose() + matQ; @@ -54,7 +54,7 @@ namespace kf /// @param matR measurement noise covariance matrix /// @param matH measurement transition matrix (measurement model) /// - void correct(const Vector & vecZ, const Matrix & matR, const Matrix & matH) + void correctLKF(const Vector & vecZ, const Matrix & matR, const Matrix & matH) { const Matrix matI{ Matrix::Identity() }; // Identity matrix const Matrix matSk{ matH * m_matP * matH.transpose() + matR }; // Innovation covariance diff --git a/cpp/kalman_filter/square_root_ukf.h b/cpp/kalman_filter/square_root_ukf.h index 7c09628..43e261c 100644 --- a/cpp/kalman_filter/square_root_ukf.h +++ b/cpp/kalman_filter/square_root_ukf.h @@ -96,7 +96,7 @@ namespace kf /// @param predictionModelFunc callback to the prediction/process model function /// template - void predict(PredictionModelCallback predictionModelFunc) + void predictSRUKF(PredictionModelCallback predictionModelFunc) { const float32_t kappa{ static_cast(3 - DIM_X) }; @@ -127,7 +127,7 @@ namespace kf /// @param vecZ actual measurement vector. /// template - void correct(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) + void correctSRUKF(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) { const float32_t kappa{ static_cast(3 - DIM_X) }; diff --git a/cpp/kalman_filter/types.h b/cpp/kalman_filter/types.h index 166fc80..d8525bd 100644 --- a/cpp/kalman_filter/types.h +++ b/cpp/kalman_filter/types.h @@ -15,12 +15,16 @@ #include #include -using float32_t = float; +namespace kf +{ + using float32_t = float; -template -using Matrix = Eigen::Matrix; + template + using Matrix = Eigen::Matrix; + + template + using Vector = Eigen::Matrix; +} -template -using Vector = Eigen::Matrix; #endif // __KALMAN_FILTER_TYPES_H__ diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h index b6171fb..f9d7bd1 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -83,7 +83,7 @@ namespace kf /// @param predictionModelFunc callback to the prediction/process model function /// template - void predict(PredictionModelCallback predictionModelFunc) + void predictUKF(PredictionModelCallback predictionModelFunc) { // self.x_a[:self.dim_x] = x // self.P_a[:self.dim_x, : self.dim_x] = P @@ -127,7 +127,7 @@ namespace kf /// @param vecZ actual measurement vector. /// template - void correct(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) + void correctUKF(MeasurementModelCallback measurementModelFunc, const Vector & vecZ) { // self.x_a[:self.dim_x] = x // self.P_a[:self.dim_x, : self.dim_x] = P diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h index d072f09..c9935e3 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/kalman_filter/util.h @@ -14,199 +14,202 @@ #include "types.h" -namespace util +namespace kf { - template - void copyToColumn(const size_t colIdx, Matrix & lhsSigmaX, const Vector & rhsVecX) + namespace util { - for (size_t i{ 0 }; i < ROWS; ++i) - { // rows - lhsSigmaX(i, colIdx) = rhsVecX[i]; + template + void copyToColumn(const size_t colIdx, Matrix& lhsSigmaX, const Vector& rhsVecX) + { + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + lhsSigmaX(i, colIdx) = rhsVecX[i]; + } } - } - template - void addColumnFrom(const size_t colIdx, Matrix & lhsSigmaX, const Vector & rhsVecX) - { - for (size_t i{ 0 }; i < ROWS; ++i) - { // rows - lhsSigmaX(i, colIdx) += rhsVecX[i]; + template + void addColumnFrom(const size_t colIdx, Matrix& lhsSigmaX, const Vector& rhsVecX) + { + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + lhsSigmaX(i, colIdx) += rhsVecX[i]; + } } - } - template - void subColumnFrom(const size_t colIdx, Matrix & lhsSigmaX, const Vector & rhsVecX) - { - for (size_t i{ 0 }; i < ROWS; ++i) - { // rows - lhsSigmaX(i, colIdx) -= rhsVecX[i]; + template + void subColumnFrom(const size_t colIdx, Matrix& lhsSigmaX, const Vector& rhsVecX) + { + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + lhsSigmaX(i, colIdx) -= rhsVecX[i]; + } } - } - - template - Vector getColumnAt(const size_t colIdx, const Matrix & matX) - { - assert(colIdx < COLS); // assert if colIdx is out of boundary - Vector vecXi; + template + Vector getColumnAt(const size_t colIdx, const Matrix& matX) + { + assert(colIdx < COLS); // assert if colIdx is out of boundary - for (size_t i{ 0 }; i < ROWS; ++i) - { // rows - vecXi[i] = matX(i, colIdx); - } + Vector vecXi; - return vecXi; - } + for (size_t i{ 0 }; i < ROWS; ++i) + { // rows + vecXi[i] = matX(i, colIdx); + } - template - Matrix getBlock(const Matrix & matA, int32_t startRowIdx, int32_t startColIdx) - { - Matrix matB; + return vecXi; + } - for (int32_t i = startRowIdx; i < startRowIdx + N_ROWS; ++i) + template + Matrix getBlock(const Matrix& matA, int32_t startRowIdx, int32_t startColIdx) { - for (int32_t j = startColIdx; j < startColIdx + N_COLS; ++j) + Matrix matB; + + for (int32_t i = startRowIdx; i < startRowIdx + N_ROWS; ++i) { - matB(i - startRowIdx, j - startColIdx) = matA(i, j); + for (int32_t j = startColIdx; j < startColIdx + N_COLS; ++j) + { + matB(i - startRowIdx, j - startColIdx) = matA(i, j); + } } - } - return matB; - } - - template - Matrix cholupdate(Matrix matL, Matrix matW, float32_t alpha) - { - Matrix matLo; + return matB; + } - for (int32_t i{ 0 }; i < COLS_W; ++i) + template + Matrix cholupdate(Matrix matL, Matrix matW, float32_t alpha) { - matLo = matL; - - float32_t b{ 1.0F }; + Matrix matLo; - for (int32_t j{ 0 }; j < ROWS; ++j) + for (int32_t i{ 0 }; i < COLS_W; ++i) { - const float32_t ljjPow2{ matL(j, j) * matL(j, j) }; - const float32_t wjiPow2{ matW(j, i) * matW(j, i) }; - const float32_t upsilon{ (ljjPow2 * b) + (alpha * wjiPow2) }; + matLo = matL; - matLo(j, j) = std::sqrt(ljjPow2 + ((alpha / b) * wjiPow2)); + float32_t b{ 1.0F }; - for (int32_t k{ j + 1 }; k < ROWS; ++k) + for (int32_t j{ 0 }; j < ROWS; ++j) { - matW(k, i) -= (matW(j, i) / matL(j, j)) * matL(k, j); - matLo(k, j) = ((matLo(j, j) / matL(j, j)) * matL(k, j)) + (matLo(j, j) * alpha * matW(j, i) * matW(k, i) / upsilon); + const float32_t ljjPow2{ matL(j, j) * matL(j, j) }; + const float32_t wjiPow2{ matW(j, i) * matW(j, i) }; + const float32_t upsilon{ (ljjPow2 * b) + (alpha * wjiPow2) }; + + matLo(j, j) = std::sqrt(ljjPow2 + ((alpha / b) * wjiPow2)); + + for (int32_t k{ j + 1 }; k < ROWS; ++k) + { + matW(k, i) -= (matW(j, i) / matL(j, j)) * matL(k, j); + matLo(k, j) = ((matLo(j, j) / matL(j, j)) * matL(k, j)) + (matLo(j, j) * alpha * matW(j, i) * matW(k, i) / upsilon); + } + + b += alpha * (wjiPow2 / ljjPow2); } - b += alpha * (wjiPow2 / ljjPow2); + matL = matLo; } - - matL = matLo; + return matLo; } - return matLo; - } - - template - Matrix forwardSubstitute(const Matrix & matA, const Matrix & matB) - { - Matrix matX; - for (int32_t k{ 0 }; k < COLS; ++k) + template + Matrix forwardSubstitute(const Matrix& matA, const Matrix& matB) { - for (int32_t i{ 0 }; i < ROWS; ++i) + Matrix matX; + + for (int32_t k{ 0 }; k < COLS; ++k) { - float32_t accumulation{ matB(i, k) }; - for (int32_t j{ 0 }; j < i; ++j) + for (int32_t i{ 0 }; i < ROWS; ++i) { - accumulation -= matA(i, j) * matX(j, k); - } + float32_t accumulation{ matB(i, k) }; + for (int32_t j{ 0 }; j < i; ++j) + { + accumulation -= matA(i, j) * matX(j, k); + } - matX(i, k) = accumulation / matA(i, i); + matX(i, k) = accumulation / matA(i, i); + } } + return matX; } - return matX; - } - template - Matrix backwardSubstitute(const Matrix & matA, const Matrix & matB) - { - Matrix matX; - - for (int32_t k{ 0 }; k < COLS; ++k) + template + Matrix backwardSubstitute(const Matrix& matA, const Matrix& matB) { - for (int32_t i{ ROWS - 1 }; i >= 0; --i) - { - float32_t accumulation{ matB(i, k) }; + Matrix matX; - for (int32_t j{ ROWS - 1 }; j > i; --j) + for (int32_t k{ 0 }; k < COLS; ++k) + { + for (int32_t i{ ROWS - 1 }; i >= 0; --i) { - accumulation -= matA(i, j) * matX(j, k); - } + float32_t accumulation{ matB(i, k) }; + + for (int32_t j{ ROWS - 1 }; j > i; --j) + { + accumulation -= matA(i, j) * matX(j, k); + } - matX(i, k) = accumulation / matA(i, i); + matX(i, k) = accumulation / matA(i, i); + } } + return matX; } - return matX; - } - template - class JointRows - { - public: - JointRows() = delete; - ~JointRows() {} - - explicit JointRows(const Matrix & matM1, const Matrix & matM2) + template + class JointRows { - for (int32_t j{ 0 }; j < COLS; ++j) - { - for (int32_t i{ 0 }; i < ROWS1; ++i) - { - m_matJ(i, j) = matM1(i, j); - } + public: + JointRows() = delete; + ~JointRows() {} - for (int32_t i{ 0 }; i < ROWS2; ++i) + explicit JointRows(const Matrix& matM1, const Matrix& matM2) + { + for (int32_t j{ 0 }; j < COLS; ++j) { - m_matJ(i + ROWS1, j) = matM2(i, j); + for (int32_t i{ 0 }; i < ROWS1; ++i) + { + m_matJ(i, j) = matM1(i, j); + } + + for (int32_t i{ 0 }; i < ROWS2; ++i) + { + m_matJ(i + ROWS1, j) = matM2(i, j); + } } } - } - const Matrix & jointMatrix() const { return m_matJ; } + const Matrix& jointMatrix() const { return m_matJ; } - private: - Matrix m_matJ; - }; + private: + Matrix m_matJ; + }; - template - class JointCols - { - public: - JointCols() = delete; - ~JointCols() {} - - explicit JointCols(const Matrix & matM1, const Matrix & matM2) + template + class JointCols { - for (int32_t i{ 0 }; i < ROWS; ++i) - { - for (int32_t j{ 0 }; j < COLS1; ++j) - { - m_matJ(i, j) = matM1(i, j); - } + public: + JointCols() = delete; + ~JointCols() {} - for (int32_t j{ 0 }; j < COLS2; ++j) + explicit JointCols(const Matrix& matM1, const Matrix& matM2) + { + for (int32_t i{ 0 }; i < ROWS; ++i) { - m_matJ(i, j + COLS1) = matM2(i, j); + for (int32_t j{ 0 }; j < COLS1; ++j) + { + m_matJ(i, j) = matM1(i, j); + } + + for (int32_t j{ 0 }; j < COLS2; ++j) + { + m_matJ(i, j + COLS1) = matM2(i, j); + } } } - } - const Matrix & jointMatrix() const { return m_matJ; } + const Matrix& jointMatrix() const { return m_matJ; } - private: - Matrix m_matJ; - }; + private: + Matrix m_matJ; + }; + } } #endif // __KALMAN_FILTER_UTIL_H__ From c1c5e5ded13370263102aa001f7bcd5fbc259b4d Mon Sep 17 00:00:00 2001 From: mohanadyoussef <117397029+MYCodingCorner@users.noreply.github.com> Date: Sun, 22 Jan 2023 23:55:34 +0100 Subject: [PATCH 33/60] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 3bb3214..276d419 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,8 @@ The library has generic template based classes for most of Kalman filter variant **Author**: Mohanad Youssef ([codingcorner.org](https://codingcorner.org/)) +**YouTube Channel**: [https://www.youtube.com/@al-khwarizmi](https://www.youtube.com/@al-khwarizmi) + ![](res/images/codingcorner_cover_image.png) ## Getting Started From 2aac559104e3d076d7ee43b21205a96dbe8c3465 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Fri, 26 May 2023 17:41:56 +0200 Subject: [PATCH 34/60] change copyright name and remove double underscores --- cpp/Examples/ekf_range_sensor/CMakeLists.txt | 2 +- cpp/Examples/ekf_range_sensor/main.cpp | 2 +- cpp/Examples/kf_state_estimation/CMakeLists.txt | 2 +- cpp/Examples/kf_state_estimation/main.cpp | 2 +- cpp/Examples/sr_ukf_linear_function/CMakeLists.txt | 2 +- cpp/Examples/sr_ukf_linear_function/main.cpp | 2 +- cpp/Examples/test_least_squares/CMakeLists.txt | 2 +- cpp/Examples/test_least_squares/main.cpp | 2 +- cpp/Examples/ukf_range_sensor/CMakeLists.txt | 2 +- cpp/Examples/ukf_range_sensor/main.cpp | 2 +- cpp/Examples/unscented_transform/CMakeLists.txt | 2 +- cpp/Examples/unscented_transform/main.cpp | 2 +- cpp/kalman_filter/CMakeLists.txt | 2 +- cpp/kalman_filter/kalman_filter.h | 8 ++++---- cpp/kalman_filter/square_root_ukf.h | 8 ++++---- cpp/kalman_filter/types.h | 9 ++++----- cpp/kalman_filter/unscented_kalman_filter.h | 8 ++++---- cpp/kalman_filter/unscented_transform.h | 8 ++++---- cpp/kalman_filter/util.h | 8 ++++---- 19 files changed, 37 insertions(+), 38 deletions(-) diff --git a/cpp/Examples/ekf_range_sensor/CMakeLists.txt b/cpp/Examples/ekf_range_sensor/CMakeLists.txt index 3d73cf4..09ae273 100644 --- a/cpp/Examples/ekf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ekf_range_sensor/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp index 543fb82..36d5e73 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at diff --git a/cpp/Examples/kf_state_estimation/CMakeLists.txt b/cpp/Examples/kf_state_estimation/CMakeLists.txt index 47c762b..d40497a 100644 --- a/cpp/Examples/kf_state_estimation/CMakeLists.txt +++ b/cpp/Examples/kf_state_estimation/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp index 08e8e07..942aaf3 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at diff --git a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt b/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt index 2ffbdfa..66db641 100644 --- a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt +++ b/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/Examples/sr_ukf_linear_function/main.cpp b/cpp/Examples/sr_ukf_linear_function/main.cpp index f810895..53b0708 100644 --- a/cpp/Examples/sr_ukf_linear_function/main.cpp +++ b/cpp/Examples/sr_ukf_linear_function/main.cpp @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at diff --git a/cpp/Examples/test_least_squares/CMakeLists.txt b/cpp/Examples/test_least_squares/CMakeLists.txt index 5a8e50c..d60593d 100644 --- a/cpp/Examples/test_least_squares/CMakeLists.txt +++ b/cpp/Examples/test_least_squares/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/Examples/test_least_squares/main.cpp b/cpp/Examples/test_least_squares/main.cpp index f251ea4..8c305fe 100644 --- a/cpp/Examples/test_least_squares/main.cpp +++ b/cpp/Examples/test_least_squares/main.cpp @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at diff --git a/cpp/Examples/ukf_range_sensor/CMakeLists.txt b/cpp/Examples/ukf_range_sensor/CMakeLists.txt index f1d885d..b971370 100644 --- a/cpp/Examples/ukf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ukf_range_sensor/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp index 7122b55..1e6514d 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at diff --git a/cpp/Examples/unscented_transform/CMakeLists.txt b/cpp/Examples/unscented_transform/CMakeLists.txt index f5b10e3..fad0660 100644 --- a/cpp/Examples/unscented_transform/CMakeLists.txt +++ b/cpp/Examples/unscented_transform/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index 4bc0e78..2f3b9ae 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/kalman_filter/CMakeLists.txt index 7a2fa00..79272f4 100644 --- a/cpp/kalman_filter/CMakeLists.txt +++ b/cpp/kalman_filter/CMakeLists.txt @@ -1,5 +1,5 @@ ## -## Copyright 2022 CodingCorner +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) ## ## Use of this source code is governed by an GPL-3.0 - style ## license that can be found in the LICENSE file or at diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/kalman_filter/kalman_filter.h index fec25c2..6efc155 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/kalman_filter/kalman_filter.h @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at @@ -9,8 +9,8 @@ /// @file kalman_filter.h /// -#ifndef __KALMAN_FILTER_LIB_H__ -#define __KALMAN_FILTER_LIB_H__ +#ifndef KALMAN_FILTER_LIB_H +#define KALMAN_FILTER_LIB_H #include "types.h" @@ -101,4 +101,4 @@ namespace kf }; } -#endif // __KALMAN_FILTER_LIB_H__ \ No newline at end of file +#endif // KALMAN_FILTER_LIB_H diff --git a/cpp/kalman_filter/square_root_ukf.h b/cpp/kalman_filter/square_root_ukf.h index 43e261c..bfa6c4e 100644 --- a/cpp/kalman_filter/square_root_ukf.h +++ b/cpp/kalman_filter/square_root_ukf.h @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at @@ -9,8 +9,8 @@ /// @file square_root_ukf.h /// -#ifndef __SQUARE_ROOT_UNSCENTED_KALMAN_FILTER_LIB_H__ -#define __SQUARE_ROOT_UNSCENTED_KALMAN_FILTER_LIB_H__ +#ifndef SQUARE_ROOT_UNSCENTED_KALMAN_FILTER_LIB_H +#define SQUARE_ROOT_UNSCENTED_KALMAN_FILTER_LIB_H #include "util.h" #include "kalman_filter.h" @@ -350,4 +350,4 @@ namespace kf }; } -#endif // __UNSCENTED_KALMAN_FILTER_LIB_H__ +#endif // UNSCENTED_KALMAN_FILTER_LIB_H diff --git a/cpp/kalman_filter/types.h b/cpp/kalman_filter/types.h index d8525bd..52daeb6 100644 --- a/cpp/kalman_filter/types.h +++ b/cpp/kalman_filter/types.h @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at @@ -9,8 +9,8 @@ /// @file types.h /// -#ifndef __KALMAN_FILTER_TYPES_H__ -#define __KALMAN_FILTER_TYPES_H__ +#ifndef OPENKF_TYPES_H +#define OPENKF_TYPES_H #include #include @@ -26,5 +26,4 @@ namespace kf using Vector = Eigen::Matrix; } - -#endif // __KALMAN_FILTER_TYPES_H__ +#endif // OPENKF_TYPES_H diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/kalman_filter/unscented_kalman_filter.h index f9d7bd1..7cf1be0 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/kalman_filter/unscented_kalman_filter.h @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at @@ -9,8 +9,8 @@ /// @file unscented_kalman_filter.h /// -#ifndef __UNSCENTED_KALMAN_FILTER_LIB_H__ -#define __UNSCENTED_KALMAN_FILTER_LIB_H__ +#ifndef UNSCENTED_KALMAN_FILTER_LIB_H +#define UNSCENTED_KALMAN_FILTER_LIB_H #include "util.h" #include "kalman_filter.h" @@ -329,4 +329,4 @@ namespace kf }; } -#endif // __UNSCENTED_KALMAN_FILTER_LIB_H__ +#endif // UNSCENTED_KALMAN_FILTER_LIB_H diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/kalman_filter/unscented_transform.h index a2568cb..87538c3 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/kalman_filter/unscented_transform.h @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at @@ -9,8 +9,8 @@ /// @file unscented_transform.h /// -#ifndef __UNSCENTED_TRANSFORM_H__ -#define __UNSCENTED_TRANSFORM_H__ +#ifndef UNSCENTED_TRANSFORM_H +#define UNSCENTED_TRANSFORM_H #include "types.h" #include "util.h" @@ -207,4 +207,4 @@ namespace kf }; } -#endif // __UNSCENTED_TRANSFORM_H__ +#endif // UNSCENTED_TRANSFORM_H diff --git a/cpp/kalman_filter/util.h b/cpp/kalman_filter/util.h index c9935e3..b66d479 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/kalman_filter/util.h @@ -1,5 +1,5 @@ /// -/// Copyright 2022 CodingCorner +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) /// /// Use of this source code is governed by an GPL-3.0 - style /// license that can be found in the LICENSE file or at @@ -9,8 +9,8 @@ /// @file util.h /// -#ifndef __KALMAN_FILTER_UTIL_H__ -#define __KALMAN_FILTER_UTIL_H__ +#ifndef KALMAN_FILTER_UTIL_H +#define KALMAN_FILTER_UTIL_H #include "types.h" @@ -212,4 +212,4 @@ namespace kf } } -#endif // __KALMAN_FILTER_UTIL_H__ +#endif // KALMAN_FILTER_UTIL_H From 05727efb7c5997051f9a432b993f455fb5d64c14 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sun, 4 Jun 2023 12:51:38 +0200 Subject: [PATCH 35/60] add ukf projectile example --- ...Introduction_Unscented_Kalman_Filter.ipynb | 535 ++++++++++++++++-- 1 file changed, 502 insertions(+), 33 deletions(-) diff --git a/python/examples/Introduction_Unscented_Kalman_Filter.ipynb b/python/examples/Introduction_Unscented_Kalman_Filter.ipynb index 45c9d70..55df282 100644 --- a/python/examples/Introduction_Unscented_Kalman_Filter.ipynb +++ b/python/examples/Introduction_Unscented_Kalman_Filter.ipynb @@ -721,7 +721,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 8, "id": "458845ec", "metadata": {}, "outputs": [], @@ -788,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 9, "id": "35b2885c", "metadata": {}, "outputs": [ @@ -824,7 +824,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 10, "id": "7bf9823b", "metadata": {}, "outputs": [], @@ -854,7 +854,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 11, "id": "194f373a", "metadata": {}, "outputs": [ @@ -937,7 +937,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 12, "id": "c4c05b70", "metadata": {}, "outputs": [], @@ -1029,7 +1029,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 13, "id": "c752a547", "metadata": {}, "outputs": [ @@ -1038,14 +1038,16 @@ "output_type": "stream", "text": [ "P_a = \n", - "[[0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0.2 0. 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0.2 0. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0.1 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0.1]]\n", + "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0.05 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0.05 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0.1 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.1 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0.1 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.1 ]]\n", "\n", "=====Iteration 1====\n", "x = \n", @@ -1096,7 +1098,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 14, "id": "d8c90468", "metadata": {}, "outputs": [ @@ -1110,14 +1112,12 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1157,7 +1157,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 15, "id": "ae655b52", "metadata": {}, "outputs": [ @@ -1191,14 +1191,12 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1274,20 +1272,18 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 16, "id": "5550245b", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKsAAAJ1CAYAAAAWmnPtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACg3UlEQVR4nOzdd3hU1dqG8XsBAiqKIipYsbdjQbEgHsWGKHZBPRaKFRWPR/2sqBEr9gaoIAqI2FBED1iwwLFgRWxgx4oFwQKItKzvjzWBgJQEEvYkuX/XNdeemb1nz5O4Jck7a70rxBiRJEmSJEmS8kG1rANIkiRJkiRJRSxWSZIkSZIkKW9YrJIkSZIkSVLesFglSZIkSZKkvGGxSpIkSZIkSXnDYpUkSZIkSZLyRo2sA0iSJC0roUtoD9xX7KkNYkH8ahlniMUedokF8fJl+f4VTegS2gD/AbYGVip6PhbEELqEy4GC4s8Ve91wYI/cwxGxIDYv/7SSJKksWKySJEmZCF3C00DL3MOZwNqxIE5YyLHdgDOKPbVtLIjvl3PEZS50CV8B6+ce9o0Fsf0yeM/2zFvAK24aMB54BegRC+Kb5Z2nuNAl7A08DITFHStJkioPi1WSJCkrvZlbrFoOOBa4df6DQpdQE/hXsaferuCFqvOK3X8tsxQlszywUe7WNnQJ58WCeNMyfP9jmVuomk66Pn4ptv85YMoyzCNJkpYBi1WSJCkrT5IKD/Vzj9uzgGIVcBBQr9jje8s1VTmLBfHGrDMsxsPA26QC4nZAa1Kf0wBcH7qEYSUpFoYuoQawXCyI05YiS6Ni99+KBfHC4jtjQXyN/C/4SZKkUrJYJUmSMhEL4ozQJdwPnJ17atvQJWwXC+Lo+Q5tX+z+NODBogehS1gN6AQcCGxKGgn0M/A/4JZYEN8qTabQJQTgaKAtsD2wKvAn8AnwBNA9FsQ/FvC6WkAHUmFnG2AV4A/ga2A4cFEsiDNyx/6tZ1XoEvoA7eY7bbvQJRR/bk+gK7Bz7vETsSAeNl+O5sBLxZ7aNRbEkYv9wuf1TCyIfYqd8xrgotzDasARwPu5fV9RbNoicBNwFbAbqcC4J+nrJ3QJawBnAgcAG5P+W/0CvAXcEwviU8Xe83KK9aLK2a3Y925ELIjNF9WzanHK+tqRJEllx9UAJUlSlnrP97h98QehS1iTuVMFAR6PBfG33L4mwEfA5UATYGXSaKC1SdMGR4YuoVNJg4QuYXngaWBA7j3XyJ2vLrATcA0wOnQJm8z3unWAd4A7gb2B1XOvW41U8DoHWKGkORbjtmL3Dwxdwlrz7T+62P0xS1CoWpBX53vccCHHbQOMBA5m3pFwhC5hZ+BD4BLS96Tov1XD3PFPhi6hX+gSlsnvpmV97UiSpLJlsUqSJGUmFsSPgDeKPXVM6BKWK/b4WOYdCd4bIHQJKwFPAWvmnv+JNIXwMtLIGIDqwG2hS9ithHFuBvYr9ngkcAXwULHnNgAG56a4kSuuDAa2KnbM2Ny5rs7tm1mC936I1Mvq12LPvZ17ruj2BTAQ+D63vwZwYtHBuUxHFHv9/IXAJdVsvsc/LOS4xkBt4AHSf4d+wNTQJaxMmvK5eu642aSG7lcC7xV7/fFA0TS/50hf85fF9n/J3O/FnUvyhUC5XTuSJKkMOQ1QkiRl7V7mTm1bHWhFmnIH806N+5LclLLc8w1y96cDO8aC+C1A6BKuIhWadiZ9MPd/pNXsFip0CfWAk4o99TKwZyyIs3P7PyUVMwC2IPXRGgTsTxopVORJoHUsiHMKVKFLWA+Yuqj3jwXxGeCZ3GieVXNPf7Sg/lahS+hBKoQBnBS6hKtjQSwkjeoq6v81g1QsWhItQ5dQn/R74nZAm2L7CoHHF/Ha1rEgPjFf3jNJo9SKdIwF8Z7cvqtJUwo3ze37v9AlXFfUiyp0CQcCG+b2fVtG/b7K9NqRJEllz5FVkiQpaw+S+kIVaQ8QuoTtSVPLitwXC2JRz6J/Fnu+FvBN6BJirqdRIXOLX5D6Jy3Ozsz7IV7fokJVzvxN3YtGG+0+3/OXFS9UAcSC+M38zy2lnsBfufvrkQpmMO8UwMGxIP7CkjkKuAG4Nne/6PfFSOq99d5CXvfh/IWqnOLf/9kUK6LFgjidNO2yyKqkYmB5KutrR5IklTGLVZIkKVOxIE4GHi321AGhS1ideUdVFQJ9ij2epyfSYtQrQS+k+c/342Ie15tvW2RcKXItkVwR6oFiT50auoSawKHFnrunjN5uOmlE2/1As1gQr1/EsR8v5Pni36NfixrNF7Ow7215KetrR5IklTGnAUqSpHzQm7nFqeVIo6uOKbb/uVgQvyv2eFKx+3+Q+h8tSlzM/knzPW6wmMeT5tsW2YB5+zCVl1uZ26/qAOBk0gqEkFYgfH4pzt2h+GqApbCwqY7Fv0erhi6h5nwFq4V9b8tLWV87kiSpjFmskiRJmYsF8eVcX6ii3kWXM+8KevM3C38FODJ3f2XgnVgQX5r/vKFL+AewSrHpgwvzBjCLub8btQ1dwn25XlAAJ8x3fNEKef8Dzi/2/OWhS2gTC+KsYhnWBn4u4VTA4scsdAXBWBA/DF3Ci8BepGbgxXs5Fc+dD15l7n+r6kBbciO/QpdQi3mLkr+SGtSXp7K+diRJUhmzWCVJkvLFvUDX3P3ihZpfSI3Li+sLdGbuim5Phy5hEDAGCEAjUl+pTYEuLKZJdiyIk0KXcC9wSu6p3YFXQpcwDNiEeftBfUJaTQ7gaeBd0kp4kKbivRe6hKGkPlybA4eQRg/9tqgMOd8BG+futwpdwnXABGBGLIi3z3fsbaRiFaRV+CBNl5y/v1bW+gKXMHc1wDtDl7Ar6Ws9mLkFSoCb5+sVVl55yuzakSRJZc9ilSRJyhd9gav4++8n/efvcxQL4h+hSziIVMRqQGqUfTRL5z+klef2yT1umrsV9w1wSNHIqVgQC0OXcAipaLVV7pgtc7cl8SjQPHd/BeaO2poKzF+s+i/wBbBRseeeK1rZLl/Egvh77nv0FLAa6b9vhwUc+iCpqXt55ymPa0eSJJUhG0ZKkqS8EAvij8DQBexa4EihWBDfIhWILgFeJ41cmkVq2D0K6EUauXNdCd9/GrAfcDzwLGlE0yxSX6O3c++zbSyIn8z3um+BJsDpwIukkWCzcnneI/WXKr7a4aLcBVxEGr01fyPy+fMWAnfM93RZNVYvU7EgjiT9t7oGGA1MYe5/q6eAw2JBPGYZjKoqylOm144kSSpbIToNX5IkqUIKXcK+wHO5hxOAtUvYG0uSJClvOQ1QkiSpAgldwirAdkB9UiP6Ij0sVEmSpMrAYpUkSVLFsh0w/+p1XwI3LfsokiRJZc+eVZIkSRXXT8ADQPNYECdnHUaSJKks2LNKkiRJkiRJecORVZIkSZIkScob9qxajPr168dGjRplHWOpjR8/HoC11lor4yTSwk2dOpUVV1wx6xjSQnmNKt95jSrfeY0q33mNKt9Vpmv0nXfe+SXGuPqC9lmsWoxGjRrx9ttvZx1jqXXp0gWAgoKCjJNICzd8+HCaN2+edQxpobxGle+8RpXvvEaV77xGle8q0zUaQvh6YfucBihJkiRJkqS8YbFKkiRJkiRJecNilSRJkiRJkvKGxSpJkiRJkiTlDYtVkiRJkiRJyhsWqyRJkiRJkpQ3LFZJkiRJkiQpb1iskiRJkiRJUt6wWCVJkiRJkqS8USPrAJIkSZIkVVazZs1i0qRJ/P7778yaNSvrOKrg6taty9ixY7OOMY8aNWpQt25d6tWrR40aZVNmslglSZIkSVI5KCws5Ntvv6VWrVqst9561KxZkxBC1rFUgU2ePJmVVlop6xhzxBiZMWMGEydO5Ntvv2X99denWrWln8TnNEBJkiRJksrBr7/+So0aNWjYsCG1atWyUKVKJ4RArVq1aNiwITVq1ODXX38tk/NarJIkSZIkqRxMmTKFVVZZxSKVKr0QAqussgpTp04tk/NZrJIkSZIkqRz89ddfrLDCClnHkJaJFVZYgWnTppXJuSxWSZIkSZJUDgoLC8ukf49UEVSrVo3CwsKyOVeZnEWSJEmSJP2NUwBVVZTltW6xSpIkSZIkSXnDYpUkSZIkSZLyhsUqSZIkSZKkJXT55ZcTQuDyyy/P5P3bt29PCIE+ffpk8v7lwWKVJEmSJElSJdOnTx9CCLRv3z7rKKVmsUqSJEmSJKmCuvbaaxk7diyHHXZY1lHKTF4Uq0IIm4UQzgoh9A8hfBxCKAwhxBBC66U87zEhhJdDCL+HEKaEEN4OIZwRQsiLr1uSJEmSJGlpNGzYkM0335y6detmHaXM1Mg6QM5pwFllecIQQnfgdOAv4AVgJrA30A3YO4TQJsY4uyzfU5IkSVLZiXHurbDw7/cX9FxZ7l+W71WZsuZTltJm/fPPHVlhhbnXYAhLd//mm9N5iyt+TGll9dryeu/LLjuVhx/uyW677cc99zxNmO/ACy9sz6BBfdlzzwO5664n/7Z/Yf73v2c46aT92WKL7XjyyXcXeMxvv01i110bAvDaaz+wyir15uz79deJ9OlzC88/P5jvvhtHjJENNtiMQw89nuOP78Ryyy03z7kmTZq7/eKLv3+9L700hH79uvHBB28xZcofrLbamjRtuhcdO17Ixhtv8bdsIcDMmTMZOPA+nnrqQcaOfY9p06ay2mprstlmW9O27TF06HDsnOPbt29P3759ue++++ZM+WvUqBFff/01AH379qVv375zjm/Xrh3dunVj7bXXZurUqXz11Vess846C/w+7bDDDowaNYohQ4ZwwAEHLPCY8pAvxaoPgRuAt4F3gN7AHkt6shDCEaRC1Y/A7jHGz3LPrwm8BBwGdAJuW7rYkiRJkmKE33+H8ePhhx8Wvv3pp2ZUq1byQoKyEwJUq5a2C7ufj/urVSv56xd0rgkTprLGGisC816DS3q/Rg2oVWvB3+OlucaX9v+PZf3eRa+Z/7UXXngbo0e/wSuvPMtdd3XllFMumrPviSf6MmhQXxo0WJerr+7LrFklr5btvHML1lxzbcaOHc3777/HZptt+7djnnjiQWbOnEGLFq1Zfvl6TJ+env/00w/o2LElP/88njXXXIcmTZpTWFjIBx+8wTXXnMMLLwzhzjuHstxyNeeca9asudtp0+b9um+77SJ69+5KtWrVaNx4N9ZYY20+/fR9Bg3qx9Chj3DTTQPZffdW82T7449fOeOMVrz33khq1qzFdts1o169NZgwYTzvvPMaX3750TzFqgVp3bo1r7/+Oq+++iobbbQRu+2225x9u+22G3Xq1KFDhw7cdttt9OzZkyuuuOJv53j99dcZNWoUG264IS1btlzct71M5UWxKsZ4T/HHJa2WLkLRFX5BUaEq9z4/hRBOA4YDF4YQ7ogxFi7oBJIkSVJVFyP89tuiC1Djx6fbX3/9/fV16sBaa0HDhrDTTvDXXz+x/vrrlEmhIuuiSFnuz7csS//nWMU1fPgYmjdfo8zON3YsbLxxmZ2uEqrNk08+wg477EC3bpfRuvXuNGvWjLFjx3LVVadTo0YNBg58kKZN6y3+VPOoRvv2x3Hdddfxyit9Ofzwm/92xHPPpZFG//53e7baKj03bdo0DjroEH7+eTzXXHMN5513HjVqpLLJpEmTOOqoo3j++ecZPPiaeVb+W2ONudt//GPuewwdOpTevbuy4oorMnToUHbfffc5+2644QbOP/98Onc+lk8//ZQ11ph73R1ySHvee28kTZs2ZeDAgay11lpz9k2YMIG33357sd+BG2+8kT59+vDqq6+y2267LXClwE6dOnH77bfTq1cvLr300r+NGOvRowcAp512GtWqLdtuSnlRrCpLIYR1gB2AGcCj8++PMY4IIXwPrA3sAry2bBNKkiRJ2SoqQi2uAPXDDwsuQq20UipArbUW7LLL3PvFtw0bpuOKGz78c5o3X/BUE6kq+s9/YPTorFOUznbbwa23lt35Nt10U+6++26OPfZYjj76aF577TXatGnDn3/+SdeuXWnWrNkSnbdDhw5cd911PPDAA1x//fVzik4AY8aM4a233qJBgwbzjBjq06cP48aN48gjj+Siiy6a53z16tWjb9++NGrUiO7du1NQULDYgTY33XQTAGedddY8hSqA8847j8cee4w33niDXr160blzZwBGjx7Nk08+SZ06dRg8eDCrr776PK+rXbs2+++/f+m/IQuw8cYb07JlS55++mkGDRrEkUceOWffL7/8wiOPPELt2rU54YQTyuT9SqPSFauAxrntRzHGaQs55i1SsaoxFqskSZJUScQIv/66+ALU+PHMmfJS3Morzy04NW369wJU0bZOnWX/tUmqvI455hiGDx9Or1692Hrrrfn9999p2bIl559//hKfc7PNNmOXXXbh9ddfZ+jQoRx88MFz9hX1bzruuOOoXr36nOeHDh0KQJs2bRZ4zrXWWotNNtmEMWPG8Nlnn7Hpppsu9P1nzZrFq6++CjCnj9T8OnTowBtvvMHw4cPnFKueeeYZAA455JC/FarKw5lnnsnTTz9Njx495ilW9e7dm+nTp9O+fXvq1SvtyLalVxmLVRvktl8v4phv5jtWkiRJyltFRaiSjIRaWBGqqNC0664LHwllEUpatspyhFJFd/vtt/Pcc8/x9ddfs8Yaa3D//fcvdYug9u3b8/rrr9O3b985xarCwkL69+8/Z39xX375JbDwYlVxEyZMWGSxauLEiUyfPp1q1aqx/vrrL/CYjTbaCIDvv/9+znNFTdE333zzxWYoCy1btmSTTTZhxIgRjBkzhi233JLCwkLuvvtuAE4//fRlkmN+lbFYVfQjduoijpmS2660iGMkSZKkchVjWj1qcQWohRWh6tadW3Bq1mzhI6FWXHHZf22SVBr/+9//+OabNK5k0qRJfPbZZ9SvX3+pznn00Udz9tln89///peJEyey2mqrMWzYMMaPH0+TJk3YqqhZVc7s2bMBaNWq1WLfe7XVVlvk/lism/zCim4xD1aSCCHQqVMnzjrrLHr06EG3bt0YOnQo48aNY8cdd2THHXfMJFdlLFYVXQVL/F89hHAKcArAmmuuyfDhw8sgVn6oTF+LKp8pU6Z4jSqveY0q33mN5o8Y4Y8/ajBxYi0mTqxZbDv3/i+/1GLSpJrMnPn3prUrrjiL+vWnU6/eDDbZZDo77zyD+vVnUK/edOrXn8Fqq01ntdVmULv2wtcKKiyE775Lt3zhNap8V9bXaN26dZk8eXKZna+y+vHHHznuuOOIMXLcccfRv39/jjrqKF555RVWXXXVJT5vtWrVaNWqFQMHDuTee++lY8eO9OrVC0iFrPn/26y11lp88skntGvXrkSr3xW9fnru04Tp06fPea5WrVrUqlWL6dOn8+GHH7LxAjrtjx07FoAGDRrMeV2DBg0A+PDDDxd47cyePftvz8+cOROAv/76a559f+WaDs6cOXOR1+ERRxxB586duf/+++ncuTO33347ACeccEKpr9+//vqrTP4fqozFqqLv5KIGMRftW+B3PcbYE+gJ0KRJk9i8efMyC5eVESNGAFAZvhZVXsOHD/caVV7zGlW+8xotfzHCxIklGwk1Y8bfX7/KKnNHPDVuPO8IqOLT8VZYoQbpV/XKNSTKa1T5rqyv0bFjx7LS/CsNaB6FhYWceuqpTJgwgbPOOotbb72VatWq0a9fP/7973/zxBNPLNX5Tz75ZAYOHMjDDz/MKaecwtChQ6lZsyYdOnT423+bAw88kJdeeokhQ4aUaCpgkVq1as3ZFj9ns2bNePHFF3n88ce58sor//a6hx56CIC99957zusOPvhgLr/8coYOHcr06dP/NsJr8uTJf8tdtIpf7dq159m38sorA2n01KKuw5VWWol27drRvXt3brnlFl544QVWW2012rdvT+3atUv8fSjK0Lhx48UfuBiVsVj1VW674EmhybrzHStJkqQqrKgItbim5D/+uPAiVFGxaffd/16AKtouv/wy/9IkKa9dccUVvPTSSzRp0oTrr78egB49evDmm28yePBgbrvtNs4666wlPv8+++zDuuuuyzvvvMNll13GtGnTaN269QKbhp9yyinceuut9O3bl/XXX58LLriAFVZYYZ5jPvzwQ9566y06dOiw2Pc+55xzePHFF7n11ltp2bLlPCsb3nzzzYwcOZK6dety0kknzXm+cePGHHTQQTz11FMcdthhPPLIIzRs2HDO/r/++otXXnmlRCsCrr322sDcEVyL0qlTJ3r06MENN9wApFFVpS1UlaXKWKx6N7fdKoSw/EJWBNxxvmMlSZJUCRUWLngk1PxFqR9+gNwsinmsuurcYtMeeyy4AGURSpKWzEsvvcSVV17JyiuvzEMPPUTNmjUBWHHFFXnkkUfYaaedOP/882nWrBlNmjRZoveoVq0axx9/PNdcc82c6W0LW52vTp06DBkyhAMPPJArrriCbt26sc0229CgQQN++uknxo0bx1dffcXOO+9comJVq1atuOCCC7juuuvYfffd+ec//8laa63FBx98wIcffkjt2rXp378/a6655jyv69OnDy1btuSVV15hww03ZLfddmP11Vdn/PjxvPfee9StW5evvvpqse+/yy670KBBA0aNGjWnR9dyyy1Hs2bN/pZ/8803Z9999+W5556jWrVqdOzYcbHnL0+VrlgVY/w2hDAK2B5oA/Qrvj+EsAewDvAjMHLZJ5QkSdLSKipClWQk1MKKUEXFps02W3Bj8gYNLEJJUnn5+eefOfbYYyksLKRXr15zVsYrsvXWW3PrrbfSsWNHjjrqKEaNGkXdunWX6L3at2/PNddcA6SeUIvqR7X11lvz/vvv06NHDwYPHsyoUaP466+/WH311Vl33XU5/vjjad26dYnfu2vXruy2225069aNt956i9dee4011liD448/ngsvvJAtt9zyb6+pV68eL7/8Mr169eLBBx/kzTffZPr06ay55po0bdqUtm3blui9a9WqxTPPPEPnzp0ZOXIk7777LoWFhcyaNWuBxbaiYtX+++/PhhtuWOKvsTyEfOg+P78QwnBgD6BNjHHgQo65FjgMGBRjvGi+fa2BR0kFqX/GGD/PPb8G8BKwJfCfGONti8vSpEmT+Pbbby/FV5MfunTpAkBBQUHGSaSFs4+F8p3XqPJdZbhGCwvhl19KNhJq1qy/v75evb8XnRY0EirDmQ1VWmW4RlW5lUfPqi222KLMzictqGdVWWncuDGjR49m6NChJZpmuCClueZDCO/EGBc4ZC4vRlaFELYHehR7qqi0eE0I4f+Knowx7lLsmIbAZrntPGKMA0MIdwKnAR+EEJ4HZgJ7AysDTwDdyvJrkCRJ0sIVFaFKMhJqYUWoosLTFlssfCSURShJkkpv0KBBjB49mi222KJEKyGWt7woVpEKSDsv4PlNlvSEMcbTQwivAGeQRmlVBz4G7gXujDEufJ1fSZIklUhhIUyYsPiRUAsrQq222txi05Zb/r0A1bChRShJksrDxIkTueCCC5g0aRJDhw4F4IYbbiCEkHGyPClWxRiHA6X6bsQY2wPtF3PMAGDAkuaSJEmqqoqKUIsbCfXTTwsuQtWvP7fgtNVWCx8JlVvtW5Kkhfr444/p2rVriY+/8cYbqV+/fjkmqhwmT55M7969qVGjBhtvvDEXXXQRrVq1yjoWkCfFKkmSJC0bs2eXfCTU7Nl/f339+nMLTv/4x8JHQlmEkiSVlR9//JG+ffuW+PjLL7/cYlUJNGrUiHzsYw4WqyRJkiqFGGHSpJqMGrXwAlTRSKgFFaFWX31uwWnrrRc+Eiq3qrgkSctM8+bN87aoovJhsUqSJKkCixFeeAEuvhjeemvXv+1fffW5BadttlnwSnlrrmkRSpIk5Q+LVZIkSRXUyJHQuTO89BKstx507PgF++230ZxClEUoSZJUEVmskiRJqmDefx8uuQSeegrWWANuvx1OOQVGjvyW5s03yjqeJEnSUqmWdQBJkiSVzOefw7HHwnbbwcsvwzXXwJdfwpln2tBckiRVHo6skiRJynPffQdXXgm9e6ei1IUXwnnnwaqrZp1MkiSp7FmskiRJylO//ALXXgvdu0NhIZx+emqk3qBB1skkSZLKj8UqSZKkPPPHH3DzzXDTTfDnn9C2LRQUQKNGWSeTJEkqfxarJEmS8sS0aWkUVdeuMHEitG4NV1wBW2yRdTJJkqRlxwbrkiRJGZs5E+6+GzbeOPWi2nFHePttePRRC1WSJKnqsVglSZKUkdmz4YEHYPPNoWNH2GADGDECnn4adtgh63SSJEnZsFglSZK0jMUIgwfDdtvBccfByivDkCHw8suw++5Zp5MkSaVx+eWXE0Lg8ssvz+T927dvTwiBPn36ZPL+5cFilSRJ0jL04ovQtCkceijMmAEPPwzvvAMHHAAhZJ1OkiRVFn369CGEQPv27bOOUmoWqyRJkpaBN96AffaBvfeG8ePhnnvgo4/gyCOhmr+RSZKkJXTttdcyduxYDjvssKyjlBlXA5QkSSpHH34Il14KTzwBq68Ot94Kp54KtWtnnUySJFUGDRs2pGHDhlnHKFN+jidJklQOvvgCjj8ettkmTf276ir48ks46ywLVZIkffXVV1SvXp169eoxbdq0BR4zc+ZMGjZsSAiBMWPGlPjczzzzDCEEGjduvNBjJk2aRK1atahVqxaTJk2aZ9/EiRO55JJL2HrrralTpw4rrrgi22+/PbfccgszZ84scY4iQ4YMYf/996d+/frUrFmTddddl3bt2jF27NiFvmbmzJn07NmTPffck3r16lGrVi3WW2892rRpwwMPPDDPsQvqWdWoUSM6dOgAQN++fQkhzLm1b9+eKVOmULduXWrUqMF333230Bw77LADIQSGDh1a6q97aViskiRJKkPjx8Npp6UV/h57DM4/H8aNg86doU6drNNJkpQfGjVqxEEHHcSvv/7Kgw8+uMBjHnvsMX788UeaN2/OlltuWeJzt2jRgrXXXpvRo0fz3nvvLfCYBx98kBkzZnDwwQdTr169Oc9/8MEHbLPNNlx99dX89ttvNG/enD322IOvv/6ac845h/33358ZM2aUOMtFF13EgQceyHPPPcdWW21F69atqVu3Lv369WP77bdnyJAhf3vNr7/+yh577MGpp57KyJEjady4MYcffjgbbLABb7zxBp07d17s+7Zu3ZpmzZoBsNFGG9GuXbs5t9122406derQoUMHZs+eTc+ePRd4jtdff51Ro0ax4YYb0rJlyxJ/zWXBYpUkSVIZmDgxFaY22ij1ozrllDS6qmtXKPY7sCRJyjnzzDMB6NGjxwL3Fz1/xhlnlOq81apV47jjjgPSqKIFKXq+ePPxadOmccghhzB+/HiuueYaxo0bx3//+1+GDh3KZ599xj777MMLL7zANddcU6IcQ4cOpWvXrqy44oq89NJLjBgxggEDBvDhhx9y/fXX89dff3Hsscfy888/z/O69u3bM3LkSJo2bcqXX37JCy+8wIMPPsiIESP49NNPufPOOxf73jfeeCMnnXQSALvttht9+vSZcyt6vlOnToQQ6NWr1wJHjBV9/0877TSqLeMGm/askiRJWgqTJ8Mtt8CNN8KUKWnqX0EBbLhh1skkSXnvP/+B0aOzTlE6222XGjCWgb333pstt9ySd955hzfffJOddtppzr4PP/yQl19+mbXWWotDDz201Ofu0KED1113HQ888ADXX389NWrMLX+MGTOGt956iwYNGswzYqhPnz6MGzeOI488kosuumie89WrV4++ffvSqFEjunfvTkFBAWExy/jedNNNAJx11lnsvvvu8+w777zzeOyxx3jjjTfo1avXnNFSo0eP5sknn6ROnToMHjyY1VdffZ7X1a5dm/3337/U348F2XjjjWnZsiVPP/00gwYN4sgjj5yz75dffuGRRx6hdu3anHDCCWXyfqXhyCpJkqQl8NdfqUi14YapOLXvvvDBB9C3r4UqSZJKqlOnTsDfR1d1794dgFNOOWWeQlNJbbbZZuyyyy78/PPPf+u3VDSq6rjjjqN69epzni86rk2bNgs851prrcUmm2zCL7/8wmeffbbI9581axavvvoqMO/oreKKekoNHz58znPPPPMMAIcccsjfClXlYWGj23r37s306dM5+uij55kmuaw4skqSJKkUZs6EPn3giivgu+9Skerqq2HHHbNOJkmqcMpohFJF1rZtWy666CIefvhhbr75ZurVq8fkyZPp378/NWrU4JRTTlnic7dv357XX3+dvn37cvDBBwNQWFhI//795+wv7ssvvwQWXqwqbsKECWy66aYL3T9x4kSmT59OtWrVWH/99Rd4zEYbbQTA999/P+e5r7/+GoDNN998sRnKQsuWLdlkk00YMWIEY8aMYcstt6SwsJC7774bgNNPP32Z5JifxSpJkqQSKCyEhx+Gyy6Dzz+Hpk2hXz/Yc8+sk0mSVHGtuOKKnHDCCdxyyy3ce++9/N///R99+/ZlypQptGnThoYNGy7xuY8++mjOPvts/vvf/zJx4kRWW201hg0bxvjx42nSpAlbbbXVPMfPnj0bgFatWlG/fv1Fnnu11VZb5P4Y45z7C5suWPyYrIQQ6NSpE2eddRY9evSgW7duDB06lHHjxrHjjjuyY0afxlmskiRJWoQYYciQtJrf++/DNtvAU09Bq1awmFYVkiSpBM444wxuu+027rrrLs4555w5DcRL21h9fnXr1uXQQw/lwQcfZMCAAZx55pn06dMHWPDUvHXXXZdPPvmE0047jVatWi3Ve9evX59atWoxffp0vvrqKzbZZJO/HTNu3DgA1l577TnPFY3C+uSTT5bq/Uujffv2dO7cmfvvv5+uXbsucWP7smTPKkmSpIUYPhyaNYODDoI//4QBA+Ddd+HAAy1USZJUVjbaaCP2339/vvjiCy6++GLGjBnDVlttxR577LHU5y4qSvXt25fff/+dwYMHU7NmTf71r3/97diixuWPPvroUr9vjRo1aNasGQD9+vVb4DFFhbPmzZvPeW6//fYDYPDgwfzyyy9LlaFmzZpA6p+1KCuvvDLt2rXjjz/+4IorruDZZ59ltdVW46ijjlqq918aFqskSZLm89Zb0KJFmuL3zTfQsyeMGQP/+hcs45WbJUmqEooafV933XVA2fVK2meffVh33XV55513uOyyy5g2bRoHH3zwApuGn3LKKay77rr07duXgoIC/vzzz78d8+GHH3LfffeV6L3POeccAG699dY5zdaL3HzzzYwcOZK6dety0kknzXm+cePGHHTQQUyePJnDDjuMH374YZ7X/fXXXzz99NMlev+iEVtjx45d7LGdOnUihMANN9xAYWEhJ5xwArVr1y7R+5QHf92SJEnKGTMGjjgCdtopjaC6+ebUn+rkk2G55bJOJ0lS5dWiRQs222wzAFZaaSWOP/74MjlvtWrV5pzr9ttvBxa+Ol+dOnUYMmQI6623HldccQXrrrsue+65J//617/Ya6+92GCDDdh6663nNB9fnFatWnHBBRcwZcoUdt99d5o3b84xxxzD1ltvzbnnnkvt2rXp378/a6655jyv69OnDzvuuCOvvPIKG264Ifvuuy/HHHMMzZs3Z9NNN+W0004r0fvvsssuNGjQgFGjRtGkSRPatWvHSSedtMBi2+abb86+++4753vWsWPHEr1HebFYJUmSqrxx46BdO9h6axg2DLp0gS++gLPPhgw/VJQkqcoIIbDPPvsAaYXAlVZaqczOXbw41aBBA1q2bLnQY7feemvef/99rrnmGjbZZBNGjRrF448/zqeffkqDBg249NJL6dmzZ4nfu2vXrjz11FPsu+++fPDBBwwcOJBff/2V448/nnfeeYcDDzzwb6+pV68eL7/8MnfccQfbb789b775Jo8//jjjxo2jadOmdO3atUTvXatWLZ555hlatWrFuHHj6N+/P71792bEiBELPL6oWLX//vuz4YYblvhrLA8hH7rP57MmTZrEt99+O+sYS61Lly4AFBQUZJxEWrjhw4fPM19byjdeo5XPDz/A1VenaX7Vq8OZZ8IFF8BiFvjJW16jyndeo8p3ZX2Njh07li222KLMzleZzZgxg/XWW4+ffvqJjz76iC233DLrSHlp8uTJZVrIK65x48aMHj2aoUOHzunfVVqlueZDCO/EGJssaJ+rAUqSpCpn0iS4/nq4/XaYORNOOgkuvRTWWivrZJIkVU3du3fnp59+omXLlhaqMjBo0CBGjx7NFltssciRZ8uKxSpJklRlTJkCt90GN9wAf/wBxx4Ll18OG22UdTJJkqqeTz75hBtuuIHx48fz7LPPstxyy5V4ipuW3sSJE7nggguYNGkSQ4cOBeCGG24g5MGSxxarJElSpffXX3D33WnK34QJcOihcOWV8I9/ZJ1MkqSq64cffqB3797UqlWLbbfdlquuuoptt932b8d9/PHHpSpi3XjjjdSvX78so1ZKkydPpnfv3tSoUYONN96Yiy66iFatWmUdC7BYJUmSKrFZs6Bv39Qw/dtvYe+9U8Fq552zTiZJkpo3b05J+mj/+OOP9O3bt8Tnvfzyyy1WlUCjRo1K9P3PgsUqSZJU6RQWwsCBqQ/Vp5/CTjvBffelYpUkSapYSlrUUuVRLesAkiRJZSVGGDoUdtgBjjoKllsOnngCXn/dQpUkSVJFYbFKkiRVCi+/DLvvDq1apebp/fvDe+/BIYdAHvQJlSRJUglZrJIkSRXaqFGw//6pUPXFF3DnnfDxx2mlv+rVs04nSZKk0rJYJUmSKqSxY6FNmzTl78034YYbUrGqY8c0/U+SpHxgryVVFWV5rdtgXZIkVShffw2XXw79+sEKK0BBAZx9NtStm3UySZLmVa1aNQoLC6nuUF9VAYWFhVSrVjZjoixWSZKkCuGnn+Dqq+Guu6BaNfjPf+DCC2H11bNOJknSgtWuXZs///yTlVZaKesoUrn7888/WX755cvkXBarJElSXvv1V7jxRrj1Vpg+HU48ES69FNZZJ+tkkiQtWp06dfjtt9+oU6cOwdU+VInFGPntt99YccUVy+R89qySJEl5aepUuPZa2HDDtD300NSn6u67LVRJkiqGVVddlVmzZvHDDz8wffp0+1ep0okxMn36dH744QdmzZrFqquuWibndWSVJEnKK9OnQ8+eacrfTz/BQQfBVVfBNttknUySpNKpVq0a6667LpMmTeKbb75h1qxZWUdSBffXX39Ru3btrGPMo0aNGtStW5c11ljDnlWSJKlymTUL+vdPzdO//hqaN4dBg6Bp06yTSZK05GrUqMEaa6zBGmuskXUUVQLDhw+ncePGWccod04DlCRJmSoshIEDYeutoUOH1DD9uefgxRctVEmSJFVFFqskSVImYoRnn4Udd4Q2bdIKf48/Dm++CfvuC/ahlSRJqposVkmSpGXulVfSNL+WLWHSJOjbF95/Hw47zCKVJElSVWexSpIkLTPvvgutWsE//wmffgrdu8Mnn0DbtlC9etbpJEmSlA8sVkmSpHL36adw1FGw/fYwciRcdx188QWcfjrUrJl1OkmSJOUTVwOUJEnl5ptv4IoroE8fqF0bLrkEzj0XVlkl62SSJEnKVxarJElSmfv5Z7jmGrjzzvT4zDPhoovAVbslSZK0OBarJElSmfntN7jpJrjlFvjrL2jfHi67DNZbL+tkkiRJqigsVkmSpKX2559wxx2pF9Wvv6b+VF26wGabZZ1MkiRJFY3FKkmStMRmzIBeveCqq+DHH+GAA+Dqq2G77bJOJkmSpIrKYpUkSSq12bPhgQegoAC++gr++U949FHYbbesk0mSJKmiq5Z1AEmSVHHECIMGwTbbQLt2UK8ePPMMjBhhoUqSJEllw2KVJElarBhh2DDYaSc4/HAoLEwjqd5+G/bbD0LIOqEkSZIqC4tVkiRpkUaOhL32ghYtYMIEuO8++OADaN3aIpUkSZLKnsUqSZK0QO+/DwcfDLvuCmPHptX+PvkE2reHGna9lCRJUjmxWCVJkubx2WdwzDFpRb+XX4ZrroEvvoBOnaBWrazTSZIkqbLzc1FJkgTAd9/BFVfAvfemotRFF8H//R+sumrWySRJklSVWKySJKmKmzABunaF7t1TI/UzzoCLL4Y118w6mSRJkqoii1WSJFVRv/8ON9+cbn/+Ce3aQUEBrL9+1skkSZJUlVmskiSpipk2Dbp1S6OpJk1Kq/pdeSVsvnnWySRJkiQbrEuSVGXMnAl33QUbbwznnw877QRvvw2PPmqhSpIkSfnDYpUkSZXc7NnQv38qSJ12GmywAYwYAU8/DTvskHU6SZIkaV4WqyRJqqRihMGDYbvt4PjjYeWVYcgQePll2H33rNNJkiRJC2axSpKkSuiFF2CXXeDQQ2HGDHj4YXjnHTjgAAgh63SSJEnSwlmskiSpEnnjDdhnn3T74Qfo3Rs++giOPBKq+VNfkiRJFYC/tkqSVAl88EEaRbXLLvD++3DrrfDpp3DCCVDDtX8lSZJUgfjrqyRJFdgXX0BBAQwYkHpSXXUVnHUW1KmTdTJJkiRpyViskiSpAvr++1SYuuceWG45OP/8dKtXL+tkkiRJ0tKxWCVJUgXyyy9w3XXQrRvMng2nngqdO0PDhlknkyRJksqGxSpJkiqAyZPh5pvhpptg6lQ4/vg0/W+DDbJOJkmSJJUti1WSJOWxadPgzjvh2mvTqKrDD4crr4Qtt8w6mSRJklQ+XA1QkqQ8NHMm9OwJm2wC554L228Pb74Jjz1moUqSJEmVm8UqSZLySGEhPPhgKkideiqstx689BI8+yzsuGPW6SRJkqTyZ7FKkqQ8ECM89RQ0bgzHHAMrrJAev/oqNG+edTpJkiRp2bFYJUlSxl56CXbdFQ4+GP78M42sevddOPBACCHrdJIkSdKyZbFKkqSMvPUWtGgBe+0F336belSNGQNHHw3V/AktSZKkKiqvfhUOIRwTQng5hPB7CGFKCOHtEMIZIYRS5wwhrBNCuCOE8EkIYVoI4a8QwmchhLtCCBuWR35Jkkrio4/Sqn477ZRGUN18M3z+OZx8Miy3XNbpJEmSpGzlTbEqhNAdeABoArwMDAM2BboBA0MI1UtxrsbAB0AnYAXgWeAZYHngVOC9EMKuZfoFSJK0GOPGQdu2sPXW8Pzz0KULfPklnH021K6ddTpJkiQpP9TIOgBACOEI4HTgR2D3GONnuefXBF4CDiMVnm4r4Sm7A6sAvYAzYowzc+dbDrgLOAG4E9i27L4KSZIW7Icf4KqroFcvqF4d/u//4IILYLXVsk4mSZIk5Z98GVl1UW57QVGhCiDG+BNwWu7hhSWZDhhCqA00zT28rKhQlTvfTODS3MNtQggrLHVySZIWYtKkVJTaaKPUj+qkk+CLL+D66y1USZIkSQuTebEqhLAOsAMwA3h0/v0xxhHA90ADYJcSnHI2MKvo9AvYH3PbqcC00uaVJGlxJk9OI6k22ABuuAGOOAI+/hh69IC11so6nSRJkpTfMi9WAY1z249ijAsrHr0137ELlRs99ULuYZfc1D9gzjTAq3IPe8cY4/yvlyRpSf31F9x6axpJdemlaZW/99+H++9Pz0mSJElavHzoWbVBbvv1Io75Zr5jF+d0UkP1k4H9Qwhv557fEViV1PvqvFLmlCRpgWbNgr59U8P0b7+FffZJI6t23jnrZJIkSVLFkw/Fqjq57dRFHDMlt12pJCeMMX6ZW+2vH7A/sE6x3W8D/yvey0qSpCVRWAiPPgqXXQaffpqKU336pBFVkiRJkpZMPhSrivpKldmUvFyh6nHgD+AQ4NXc+zQDbgIeCyEUxBivWMjrTwFOAVhzzTUZPnx4WUXLXGX6WlT5TJkyxWtUea3oGo0RXn+9Hr17b8gXX9Rhgw2mcNVV49h114mEAF7Gyor/jirfeY0q33mNKt9VlWs0H4pVk3PbOos4pmjf5EUcA0AIYRXgCWBFYNcY45fFdg8OIXwEvA9cGkJ4sPjqg0VijD2BngBNmjSJzZs3X9zb5r0RI0YAUBm+FlVew4cP9xpVXhs+fDjVqjXn4ovh1Vdhww2hf384+ug6VK++ddbxJP8dVd7zGlW+8xpVvqsq12g+NFj/KrddfxHHrDvfsYvSClgdeH2+QhUAMcbPgTdIhbrmJQ0pSaraxo6F88/fhj32gHHj4K670gp/xx4L1atnnU6SJEmqPPJhZNW7ue1WIYTlF7Ii4I7zHbso6+W2vy/imN9y23olOJ8kqYr74ANo3hxmzVqJG26AM86A5ZfPOpUkSZJUOWU+sirG+C0wCqgJtJl/fwhhD1KD9B+BkSU45fjcdocQwnILON9ywA65h+OWJLMkqeoYOxb23jsVp3r0eIf/+z8LVZIkSVJ5yrxYlXNtbntdCGHjoidDCGsAPXIPu8YYC4vtuzaE8HEI4Vrm9TTwJ2mE1S0hhFrFXlMLuJ00rfBX4Nky/0okSZXGZ5+lQlW1avDCC7D22n9lHUmSJEmq9PKiWBVjHAjcCTQAPgghPBVCeBz4DNiS1DC923wvawhsltsWP9fPwOnAbOAM4MsQwpMhhKdII6k6AtOBE2KMi5oqKEmqwsaNg732gpkzU6Fqs82yTiRJkiRVDXlRrAKIMZ4OHEuaErgHsB/wOdAJOCLGOLsU5+oL7ATcD8wAWgD7AtOA3sD2McYnyjK/JKny+PbbNKJq6lR4/nnYaqusE0mSJElVRz40WJ8jxjgAGFDCY9sD7RexfxTQtkyCSZKqjB9+SIWqiRNToWrbbbNOJEmSJFUteVWskiQpSz//nApV48fDc8/Bjjsu/jWSJEmSypbFKkmSgEmTYN994auv4OmnYddds04kSZIkVU0WqyRJVd5vv0GLFvDJJ/DUU7DHHlknkiRJkqoui1WSpCpt8mTYf394/30YNCiNrpIkSZKUHYtVkqQqa+pUaNUK3noLHn003ZckSZKULYtVkqQqado0OOQQePVVGDAADjss60SSJEmSwGKVJKkKmj4dWreGF1+EPn3gqKOyTiRJkiSpiMUqSVKVMnMmHH00DB0Kd98NbdtmnUiSJElScdWyDiBJ0rIyaxYcdxw88QTcfjucckrWiSRJkiTNz2KVJKlKmD0bOnSARx6BG26AM8/MOpEkSZKkBbFYJUmq9AoLoWNH6N8frroK/u//sk4kSZIkaWEsVkmSKrUY4d//hnvugUsugc6ds04kSZIkaVEsVkmSKq0Y0yiq7t3T9oorsk4kSZIkaXEsVkmSKq1LL4Wbb4ZOneD66yGErBNJkiRJWhyLVZKkSunKK+Hqq+Hkk+G22yxUSZIkSRWFxSpJUqVz/fVw2WXQti3cdRdU86edJEmSVGH467skqVK5/Xa44AI4+mi4914LVZIkSVJF46/wkqRK4+674ayz4LDDoF8/qF4960SSJEmSSstilSSpUujbFzp2hFat4KGHYLnlsk4kSZIkaUlYrJIkVXgPPggnnAD77AMDB0LNmlknkiRJkrSkLFZJkiq0xx6D44+H3XaDwYOhdu2sE0mSJElaGharJEkV1lNPpUbqO+0E//0vrLBC1okkSZIkLS2LVZKkCum556B1a9huO3j6aVhppawTSZIkSSoLFqskSRXO8OFwyCGwxRbw7LNQt27WiSRJkiSVFYtVkqQK5dVX4cADYcMNYdgwqFcv60SSJEmSypLFKklShfHmm7D//rD22vDCC7D66lknkiRJklTWLFZJkiqEd9+F/faD+vVToapBg6wTSZIkSSoPFqskSXnvww9h331h5ZXhxRdhnXWyTiRJkiSpvFiskiTltY8/hr33hlq10oiqRo2yTiRJkiSpPFmskiTlrS++SIUqSIWqjTfONo8kSZKk8lcj6wCSJC3I11/DXnvB9OkwfDhsvnnWiSRJkiQtCxarJEl55/vvU6Hqjz/SiKp//CPrRJIkSZKWFYtVkqS88uOPqVA1YQI8/zxsv33WiSRJkiQtSxarJEl5Y8KE1KPq++/h2Wdhp52yTiRJkiRpWbNYJUnKC5MmQYsW8OWXMHQoNGuWdSJJkiRJWbBYJUnK3O+/Q8uWMGYMPPkk7Lln1okkSZIkZcVilSQpU1OmwAEHwLvvwuOPw377ZZ1IkiRJUpYsVkmSMvPnn3DQQfDGG/Dww+m+JEmSpKrNYpUkKRN//QWHHgojRkD//nDEEVknkiRJkpQPLFZJkpa5GTOgdWsYNgzuuw+OOSbrRJIkSZLyRbWsA0iSqpaZM+Hoo2HIELjrLmjfPutEkiRJkvKJxSpJ0jIzeza0bQuDBsGtt8Kpp2adSJIkSVK+sVglSVomCgvhxBPhoYfguuvgrLOyTiRJkiQpH1mskiSVuxjhtNOgb1/o0gXOPz/rRJIkSZLylcUqSVK5ijGNourZEy66CC69NOtEkiRJkvKZxSpJUrmJMY2iuuMOOOccuPpqCCHrVJIkSZLymcUqSVK5KSiAG2+E009PWwtVkiRJkhbHYpUkqVxcfTVceWVqqn7HHRaqJEmSJJWMxSpJUpm76Sa45BI47ji4+26o5k8bSZIkSSXknw+SpDLVvTv83/9BmzZw331QvXrWiSRJkiRVJBarJEllplcv6NQJDjkEHngAatTIOpEkSZKkisZilSSpTPTrB6eeCvvvDw8/DMstl3UiSZIkSRWRxSpJ0lJ7+GHo0AH22gseewxq1co6kSRJkqSKymKVJGmpDBoExx4LzZrB4MGw/PJZJ5IkSZJUkVmskiQtsaFD4aijYMcdYcgQWHHFrBNJkiRJqugsVkmSlsjzz8Phh8PWW8PTT8NKK2WdSJIkSVJlYLFKklRqI0bAwQfDZpvBc8/BKqtknUiSJElSZWGxSpJUKq+9Bq1aQaNGMGwYrLZa1okkSZIkVSYWqyRJJfb227D//tCwIbzwAqyxRtaJJEmSJFU2FqskSSXy3nvQogXUqwcvvpgKVpIkSZJU1pa4WBVCqBdCcPKHJFUBY8bAPvuk1f5efBHWXTfrRJIkSZIqqxolOSiEUB04CNgf2APYEKie2zcbGAeMAJ4Gnowxzi6XtJKkZe7TT2HvvaFGjVSo2mCDrBNJkiRJqswWWawKIawMnAucDKxZfNd859g4dzsR+CmE0BO4Ocb4R9nGlSQtS19+CXvtBbNnw/DhsMkmWSeSJEmSVNktdBpgCKET8DlwCalQFYrd/nZ4sduawKXA5yGEM8o6sCRp2fjmm1SomjYNnn8ettwy60SSJEmSqoJFjay6HYjMLU79BIwE3gS+BSbm9tUD1gV2ApoydwRW/dw5upd5aklSuRo/PhWqfvstrfq3zTZZJ5IkSZJUVSyuZ9U0oD/wIPC/GGNc1MEhhADsDvwLOA5YvixCSpKWnZ9+Sj2qfvoJhg2DHXbIOpEkSZKkqmRRxaqrgdtijL+U9GS5YtYIYEQI4VLg30uZT5K0DP3yS1r175tv4JlnYJddsk4kSZIkqapZaLEqxnjp0pw4xjiB1LtKklQB/PortGgBn30GQ4bAP/+ZdSJJkiRJVdHipgFKkqqAP/6Ali3ho4/giSfSNEBJkiRJysJSF6tCCMcBOwKTgHtijN8vdSpJ0jIzZQoccACMGgUDB8L++2edSJIkSVJVVuJiVQjhRKAzaYXAfWKM40IIfUmN1It0DCFsH2P8oYxzSpLKwbRpcPDBMHIkPPQQHHJI1okkSZIkVXXVSnFsc6ARsFyuULUecwtVIXdbAzinLANKksrH9Olw2GEwfDj07Qtt2mSdSJIkSZJKV6xqTBpV9UrucXNSgQrgg2LH7bv0sSRJ5WnGjFScevZZ6NULjjtu8a+RJEmSpGWhNMWqNXPbb3Lbf+S2z8YYtwUGkopXG5RRNklSOZg1C445Bp56Crp3hxNPzDqRJEmSJM1VmmJV3dz219x2I9JIq1G5x+/mtsuXQS5JUjmYPRvatYPHHoObb4bTT886kSRJkiTNqzTFqmm57aa57Xa57Re57Qq57W9LF0mSVB4KC+Hkk2HAALj2Wjj77KwTSZIkSdLflaZY9SVpml/bEMJHzJ3uV9SvqmFu+3MZZZMklZEY4Ywz4L77oKAALrww60SSJEmStGClKVYNLfaazXP3fwTeyd3fgTQt8AMkSXkjxjSK6q674IILUrFKkiRJkvJVaYpVNwAfkUZXBdK0wDNijDGEsAGwbe75kWWeUpK0RGKEiy6C226Ds85K0/9CWPzrJEmSJCkrNUp6YIzxtxDCDsCeQG3grRjj+NzuScCOufuflW1ESdKS6tIFrrsOOnaEW26xUCVJkiQp/y1yZFUI4aoQwnZFj2OMM2KMz8YYBxcrVBFj/D3G+E7u9seShgkhHBNCeDmE8HsIYUoI4e0QwhkhhNKMACt+vuVDCOeHEN4KIfwWQvgzhDAuhPBoCKHZkuaUpIrg2mtTsapDB+je3UKVJEmSpIphcUWgi4F3QghfhhBuCCHsWl5BQgjdgQeAJsDLwDDSyoPdgIEhhOqlPN8GwPvAdcB6wAjgv8AE4BDSCDFJqpRuuQUuvhiOOQZ69YJqS1TylyRJkqRlb3HTAB8CDgAaAecA54QQfgQGAY8Dw2OMhUsbIoRwBHA6qWH77jHGz3LPrwm8BBwGdAJuK+H5ViQVuzYCrgSujDHOLLZ/NWC1pc0tSfmoRw845xw44gjo2xeql6rUL0mSJEnZWuRn7THGY4DVgVbAfcBEoCGpsDQM+CmEcE8IoVUIoeZS5Lgot72gqFCVe/+fgNNyDy8sxXTAS0iFqn4xxsuKF6py550YY/x0KfJKUl6691444ww46CAYMABqlLgzoSRJkiTlh8UWf2KMM2OMT8cYTwIaAHsB3YHvSaOTTgCeBH4OITwQQjgihLBCSQOEENYBdgBmAI8u4P1H5N6rAbBLCc5XEzg597BrSXNIUkX3wANw0kmw337w6KNQc2k+QpAkSZKkjJSqi0mMsTDGODzGeGaMcT2gKXAj8AWwMvAv4BFgQgjh8RKetnFu+1GMcdpCjnlrvmMXZQdSEe3bGOPYEMKuIYRrQgh3hxC6hBCaljCXJFUYjz4KbdtC8+bw+ONQq1bWiSRJkiRpySzVBJEY4xvAG8D5IYStgdak/lL/IDUxL4kNctuvF3HMN/Mduyhb57afhRD6AO3m239ZCOEx4PhFFMckqcIYPDg1Um/aFJ58ElYo8dhWSZIkSco/ZbY+VIzxgxhjQYxxG2AT5vahWpw6ue3URRwzJbddqQTnq5fb7g60JY382hhYlVRA+x44gjSVUZIqtKefhjZtYPvtYehQqFNn8a+RJEmSpHxWLq13Y4xfANeX8PBQ9LIyevuiAlwN4J4Y43nF9j0ZQhgPvAm0CyFcFWP88m+BQjgFOAVgzTXXZPjw4WUULXuV6WtR5TNlyhSv0VJ4551VuPjirWnU6E8uueQ9Ro2alXWkSs9rVPnOa1T5zmtU+c5rVPmuqlyjpSpWhRDqAScCO5FGKi1oZFaMMe5ditNOzm0XNR6gaN/kRRwz//kAes2/M8b4dgjhHaAJ0Bz4W7EqxtgT6AnQpEmT2Lx58xK8bX4bMWIEAJXha1HlNXz4cK/REnr5ZbjsMth0U3jppZWoX3+3rCNVCV6jyndeo8p3XqPKd16jyndV5RotcbEqhLA5MBxYfVGHUfoRUl/ltusv4ph15zu2JOcDGLeQY8aRilUNSnA+Scorr78OBxwA664Lzz8P9etnnUiSJEmSyk5pelbdCKzB3Gl7YQG3JfFubrtVCGH5hRyz43zHLsqoYvdXW8gxRX/aTVnIfknKS++8Ay1bwpprwgsvpK0kSZIkVSalmQb4T9KoqQD8SJo+t9QNUmKM34YQRgHbA22AfsX3hxD2ANbJvefIEpzv+xDCG8DOwN7Ax/Odb9XcewG8vbT5JWlZef99aNECVlkFXnwR1l4760SSJEmSVPaWpMH6IKB1jLGsGqIDXAs8ClwXQngtxvg5QAhhDaBH7piuMcbCoheEEK4FDgMGxRjnX3nwauBJ4LIQwqsxxtG519QG7gTqAu9QguKXJOWDsWNhn31g+eVToWq99bJOJEmSJEnlozTTAF/JbT8t40IVMcaBpCJSA+CDEMJTIYTHgc+ALYEngG7zvawhsFluO//5nmLutMU3Qgj/CyEMAr4AjgK+B/5V1l+HJJWHzz6DvfeGatVSoWrDDbNOJEmSJEnlpzTFqouB6UCHEMKOizu4tGKMpwPHknpO7QHsB3wOdAKOiDHOLuX5zgMOB14FtgYOAP4EbgYaxxg/K7v0klQ+xo2DvfaCmTNTj6pNN806kSRJkiSVrxJPA4wxvhdCOAoYDLweQhgHjOfvfatijHHvJQkTYxwADCjhse2B9os5ZhBp2qIkVTjffptGVE2dCi+9BFttlXUiSZIkSSp/JS5WhRA2BHoyt8n6hsAG8x+W2y9JWgo//JAKVRMnphFV226bdSJJkiRJWjZK02D9RmBNUjGqqGAVyiOUJFVlP/+cClXjx8OwYdCkSdaJJEmSJGnZKU2xak/mFqnGA18DM8ojlCRVVRMnplX/vvoKnn4amjbNOpEkSZIkLVulKVYVTe97NMZ4VHmEkaSq7LffYL/94NNP4b//hT32yDqRJEmSJC17pVkN8MXc9svyCCJJVdnkybD//vD++/DYY2l0lSRJkiRVRaUpVl0A/AqcGELYpZzySFKVM3UqtGoFb70FDz+c7kuSJElSVVWaaYC9gN9JKwC+GkL4GvgemDnfcTHGuHcZ5ZOkSm3aNDjkEHj1VRgwAA47LOtEkiRJkpSt0hSrmjPvSoCNgPXnOyYwt7eVJGkRpk+HI46AF1+Evn3hKLsBSpIkSVKpilVFwkLuS5JKaObMVJx6+mno2ROOPz7rRJIkSZKUH0pTrPofjpqSpKU2axYceywMHgx33AEnn5x1IkmSJEnKHyUuVsUYm5djDkmqEmbPhg4d4NFH4cYboVOnrBNJkiRJUn5ZkmmAkqQlUFgIHTtC//5w1VVw7rlZJ5IkaRmaPJm6770HMaZbYeHc+wu6Zb0/HzJU9v35kGG+/c3q1IHu3eG447L+P0aq0ixWSdIyECOceSbccw9ccgl07px1IkmSloHZs9NKIv36weOP0/jPP7NOtOyEsOhbtWrlt788z120v1o1qF49u/cvp/1/PvEEdY8/Hp59NhWtVl456ytJqpIWWqwKIYwArokxPrskJw4htAAudvqgpKouxjSKqkcPOO88uOKKrBNJklTOxoxJBar+/eH772GVVeD443m/USO22WWXzAsSy2S/KqTRe+7JHq++Cl26wGuvwYABsPPOWceSqpxFjaz6JzA0hPAJMAB4NMb4yaJOFkLYCDgSOAbYssxSSlIFFWMaRXXLLWlk1XXX+furJKmSmjABHnoI+vaFd95Jo2723z/9EDzoIKhdm0nDh0Pz5lknlRYqVq8Ol10Ge++dVsTZbbf0SeP556drWtIysbhpgAHYDOgCdAkhTALeAr4BJuWOqQesCzQB6s/32tllmlaSKpirroJrr4VTToHbbrNQJUmqZKZPhyFDUoFq6NC05G3jxqlAdcwxsMYaWSeUlkyzZjB6dGo4evHFMGwY3H8/rL121smkKmFRxaodgBuBPYs9txqw30KOn/9PsBeB/1vyaJJUsV1/ffpgrl07uPNOC1WSpEoiRnjzzTTN76GHYNIkaNAA/vMfaNsWtt4664RS2VhlFXjwQdhvvzREfpttoHdvOPTQrJNJlV61he2IMb4bY9ybVJx6krmjpMJCbuSOeRJoEWPcJ8Y4upxyS1Jeu/12uOACOPro9DtNtYX+aytJUgXxzTdwzTWwxRawyy5w773pj/hnnoFvv4UbbrBQpconBOjQAUaNgkaN4LDD4LTToCotFiBlYLGrAcYYhwHDQggNgX2A3YGNgdVJRaoJwOfA/4DnY4zjyy+uJOW/u++Gs85Kv8v062d7A0lSBTZ5Mjz+eJrmN3x4GlW1++5pxZA2bVwpTVXHppvCyJGpGemNN8L//pdGXW2zTdbJpEppscWqIjHGH4D7czdJ0gLcd19qbdCqVZoZsdxyWSeSJKmUZs+Gl15KBarHH08jSDbaCC6/HI4/HjbYIOuEUjZq1kwjCPfdN0153Wmn9LhTJ/s9SGWsxMUqSdKiDRgAJ56Yfn8ZODD9PiNJUoUxdmwaEty/P3z3HdStC8cdl5ovNm3qH+NSkRYt4P334YQT4N//hueeS9NiV18962RSpWEXFUkqA489lj5g2313eOIJqF0760SSJJXAL79At26w446w5ZZplMi228Ijj8CPP6a57bvuaqFKmt8aa8BTT6VGpcOGpf9vnn8+61RSpWGxSpKW0lNPpUbqO+8M//0vrLBC1okkSVqE6dNh0KC0olnDhmmVs1mz4Oab4fvv0w+zNm385EVanBDS/z9vvplWDtx3Xzj/fJgxI+tkUoXnNEBJWgrPPQetW8N228HQoVCnTtaJJElagBjhrbdSH6qHHoJJk6BBg7QiSNu2NomWlsY228Dbb8O556bRiS++mJqvb7JJ1smkCstilSQtoZdegkMOSbMmnn02tfaQJCmvfPtt6kHVrx98/HEaLXXooakP1T77QA3/HJDKxAorwJ13pn5WJ54IjRunKbbt2jmNVloCTgOUpCXwyitw4IFpcaTnnoN69bJOJElSzpQpaQTV3nvD+uvDxRenxs/33JP6UD34ILRsaaFKKg+HHZaarzdpAh06wDHHwG+/ZZ1KqnAsVklSKb35JhxwAKyzTuqj6cIvkqTMzZ4NL7yQpvStuSa0bw9ffQUFBfDFF/C//6XRHg4DlsrfOuuk/x+vvhoefTT1i3jttaxTSRWKxSpJKoV334X99ksFqhdfTO0+JEnKzNixcNFF0KhRmtb35JNw7LFpCPDnn6di1YYbZp1SqnqqV0+jGl95BapVS0tGX3llKixLWqwSF6tCCGNDCOeGEBxDIKlK+vDDtMjLyiunQtXaa2edSJJUJU2cmHrh7LRTapx4ww2pwfPDD8MPP0DPntCsmX1ypHywyy7p086jjoLLLoM994Rvvsk6lZT3SjOyajPgeuC7EMKjIYSWIfgTUFLV8PHHqfVHrVppVPf662edSJJUpcyYAYMGpX44DRvCmWem526+Gb77DoYMgSOPhOWXzzqppPnVrQsPPJAWOnj3Xdh2W3jssaxTSXltSaYBLgccDgwBvgohXB5C8M82SZXW55+nQlUIqVC18cZZJ5IkVQkxwltvQadOqUB1+OEwciT8+98wenS6nX22c9KliuL449P/t5tuCq1bwymnwNSpWaeS8lJpilX9gD9y90Putg5wKfBFCOHZEELrEMJyZZxRkjLz9depUDV9emqmvvnmWSeSJFV6334L116bpvjttFNaxW/ffWHo0DSK6sYb08gMSRXPRhulPlYXXpj+327SJBWwJM2jxMWqGGN7YE3gMOAhYCpzi1bVgH2Ah4HvQwg3hhDs5CipQvvuO9hrL/jjDxg2DP7xj6wTSZIqrSlT0hShffZJc80vvhjq14deveDHH+Ghh2D//aFGjayTSlpayy2XCtLPP59+0dx5Z7jlFigszDqZlDdKNQ0wxjgjxjg4xngMsAZwNDAImMHcwlV94Gzg4xDCtWWcV5KWiR9/TCOqJkyAZ5+Fxo2zTiRJqnQKC9P88nbt0lS+du1g3Li0gt/nn8PLL8NJJ8Eqq2SdVFJ52GsveO89aNkSzjkHWrWCn37KOpWUF5bmo5nppCLViqQ+VrHYvpA79/khhJ9ijLcuxftI0jI1YUIqVH3/fSpU7bRT1okkSZXKxx+nUVT9+6cpfyuvDMccA23buoqfVNXUrw9PPAF33gnnnptW9uzbNxWwpCqs1A3WQwjrhhCuAL4BHgP2LdqVu70HDABm5R6fUjZRJan8TZoELVrAl1/CU0+lvxkkSVpqEydC9+5pus8WW8B116X55Q89lIbz9uwJu+1moUqqikKA009PCyqssUaa8nvOOalpqlRFlXhkVQjhIOBUYD9Skav4T9LZwJPArTHGl3PHvwvcAGxQZmklqRz9/jvstx+MGQNPPgl77pl1IklShTZjRmqK3q8f/Pe/MHNmGjVx001pJJWr+Ekq7h//gDffhPPOSz2sXnoJHnzQFX5UJZVmGuBg0lS/4kWq34DeQLcY49fzHf9ubltzidNJ0jIyeXL6EGv0aBg0KBWtJEkqtRjh7bdTgerBB9OIqjXXhDPPTNP8XMVP0qIsvzx065Z+Ge3QAXbYAW67DU480ZGXqlKWtGfVp8DtQJ8Y458LOeZ7oO8Snl+Slpk//4SDDkofZD38MBx4YNaJJEkVznffpR5U/frB2LFQqxYcemgqULVo4Sp+kkrnoIPg/ffTvyEnn5waqfbsCauumnUyaZko7U/NYcBtMcanF3dgjPEToMMSpZKkZeSvv9LfEv/7HzzwABxxRNaJJEkVxtSp8PjjqUD1wgtpVFWzZukPyjZtXMVP0tJZay147jm48Ubo3BneeCP9wvrPf2adTCp3pWmwvmWMsWVJClWSVBHMmAGtW8OwYXDvvfCvf2WdSJKU9woL4cUXoX37NL2vbVv44gu47DL4/HN45ZU0CsJClaSyUK0anH8+vPZaGrHZvDkUFMCsWVknk8pVaUZWDQ0hROCaGGPv+XeGEPYCDgVijPGsMsonSeVi5kw4+mgYMgTuuiv9zSFJ0kJ98kkaQXX//fDtt7DyyulTjrZt02iqaqVeZFuSSm7HHWHUqNT/7oor4Pnn0yirRo2yTiaVi9L8VG2Uu9VdyP7GQKfcTZLy1uzZ6W+LQYNSv8pTT806kSQpL02cCD16wC67pNW4unZNq3U9+CD8+CP06pWm41iokrQsrLQS9OkDAwbAhx/CdtulhqtSJVSWP1ld9U9S3isshBNOgIceguuvh3//O+tEkqS8MmMGDB6cmhg2bAhnnJFW4rjxxtREfejQNDR3+eWzTiqpqvrXv9IS1ltskf496tABpkzJOpVUphY5DTCEsPsCnt5oAc+vALTJ3S8si2CSVNZihI4d0yyOK66A887LOpEkKS/ECO+8k35APPgg/PILrLEGdOqUhuJuu61LxkvKLxtskFYIuuIKuPpqePXVNOKqSZOsk0llYnE9q4YDsdjjAHTM3RZm4lJmkqQyFyOcdVaasXHxxXDJJVknkiRl7rvvUs+Xfv1gzJjUvPiQQ1KBqkULWG65rBNK0sIttxxceSXssw8cdxzsumsqXJ17rtOTVeGVtMF6WMj94mLu9uJSJZKkMhZjWkTljjvgnHPgqqv8gFySqqypU1PTwn79UoPiGFOD9LvvhjZtYNVVs04oSaWzxx7w3ntpJdLzz09LXfftm6YySxVUScqtJf2TLgBvAf+35HEkqewVFKRWI6efnrYWqiSpiikshJdeSn1dGjSA44+Hzz6DSy9N21degVNOsVAlqeKqVw8GDoSePdO/adtsk5a9liqoxY2s2jO3DaQRUxG4C3hkvuNmAt/FGL8p23iStHSuvjqNjj7ppDSyykKVJFUhn3wC99+fbt98k1bSOuqoNM1vt92cJiOpcgkhja7abbfUhP3AA+HMM9OqQrVrZ51OKpVFFqtijCOK7of0F14Avij+vCTlqxtvTL2pjj8e7rrLv0kkqUqYNCkt5d63L7zxRvrHv0UL6No19aNaYYWsE0pS+dpiC3j9dbjoIrj1Vhg+PC2FveWWWSeTSqzEf7rFGKvlbjeXZyBJKgvduqXV/o48Eu69F6pXzzqRJKnczJwJTz4JRxyRerScfnrqTXXDDamJ+tNPp1EGFqokVRW1a8Mtt6SpgD/+CDvskD69jXHxr5XywEJHVoUQ1svdnRRjnFLs8WI5HVBSlnr1SiOeDzkE+veHGiVdSkKSVHHECKNGpUbpAwbAL7/A6qunQlXbtrDdds79lqQDDoD334d27eC00+DZZ+Gee2C11bJOJi3Sov6E+4rUo+r/gFuKPV6cuJjzSlK56dcPTj0V9t8/zQJx1XFJqmS+/x4eeCBN8xszBmrWTJ9OtG0L++3nP/ySNL8GDdII01tvhQsvhG23Tb389txzsS+VsrIkqwGGEtwkaZl7+OG00NNee8Fjj0GtWlknkiSVialTU4GqRQtYd1244AJYZZU0peXHH+GRR1IjYQtVkrRg1arBOeekXlYrrgh77w2dO6dp1FIeKu0IKAtRkvLSoEFw7LHQrBkMHgzLL591IknSUikshP/9L42gGjgQpkyB9defu3LGJptknVCSKp7tt4d33oH//AeuuQZeeCFNpd5ww6yTSfNYVLGqQ2775nyPJSmvDBmSViLfccd0f8UVs04kSVpin36apqfcfz98/TWstFJaLaNtW/jnP13aVZKWVp06qW9VixZwyimpx9+dd6ZPfqU8sdBiVYyx76IeS1I+GDYsLf60zTZpKv5KK2WdSJJUapMmpal8ffumKSrVqsG++6ZP/Q891FX8JKk8HHkk7LxzKlIdd1xqvt6tG6y8ctbJpBL1rJKkvDRiROqpu9lm6WfrKqtknUiSVGIzZ8JTT0Hr1tCwYVqlavJkuP56+PZbeOYZOOYYC1WSVJ7WXx+GD4fLL0+9ARs3hjffXNyrpHJX4mJVCKFNCOHx3G2D+fatX2zfkWUfU5Lm9dpr0KoVNGqURle5+q4kVQAxwqhRcNZZsPbacPDBqS/VaaelHioffADnnQdrrZV1UkmqOmrUgIKC9O/xrFmpCey118Ls2VknUxVWmgbrHYCWwOgY47jiO2KMX4cQGgI7ASsAj5RdREma11tvwf77pw/iX3gB1lgj60SSpEUaPx7694d+/eCjj6BmzVSoatsWWrZ0FT9JygfNmsF778Gpp8LFF6dPhO+/P324IC1jpZkG+A8gAi8vZP9rpNUCt17aUJK0MKNHw377pZFUL76YClaSpDz0559pSsl++8G668IFF6Q+KHfeCT/+CI8+CgcdZKFKkvLJKqvAQw9B797wxhupMezgwVmnUhVUmmJV0diFiQvZ/3tu62QcSeXio49Sv906dVKhat11s04kSZpHYWFqKHjCCbDmmqlh7yefpE/oP/00zeHu2BFWXTXrpJKkhQkh/Ts+alTquXHooXD66TBtWtbJVIWUZhrgX8ByQOOF7N8ut52+NIEkaUE+/RT23jt9AP/CC+nnpiQpT3z2WZrid//98PXX6VOFNm3SNL/dd0+r+0mSKpbNNksfMnTuDDfdlHpaPfggbO1kKpW/0vzmMI40ze+gEMIRxXeEEA4HDiFNE/yy7OJJEnz5Jey1V/rA/oUXYJNNsk4kSeLXX+Guu2DXXWHTTeGaa9IfNv37w08/wb33QvPmFqokqSKrVQtuvDEtvf3LL7DjjtCtW1owQypHpRlZ9SKwLanA9UgIYTSpgLUBaVRVIBWrXijbiJKqsm++SYWqadPgpZdgiy2yTiRJVdjMmfDMM2kU1ZNPwowZsOWWcN11cOyxNuGVpMqqRQt4/33o0AHOPBOeey59KFG/ftbJVEmVpljVDegI1CYVphozt0hVZBrQvazCSaravv8+Fap++y31qNpmm6wTSVIVFGNa3aJvXxgwACZMSH+cdOwI7dpB48apv4kkqXJbYw3473/hjjvgvPPSL+f9+sE++2SdTJVQicdlxxjHAScDs4uemm87Gzg5d5wkLZWffko9qn76KY063n77rBNJUhUzfjzccEP6Y2T77dMqfrvvnlaFGj8ebrstPW+hSpKqjhDg3/+GN99MKwe2aJFWe50xI+tkqmRK1UQgxjgA2BV4DJhAKlBNAAYCu8QYHyzzhJKqnF9+SR/QfPstDB0KO++cdSJJqiL+/DONnmrZMi25ev75qVl6jx7www8wcCAcfHBa7UKSVHVtuy28/Taccgpcfz00a5YW25DKSGmmAQIQY3wbaFMOWSSJX39NH9B8/jkMGQL//GfWiSSpkisshJdfTlM5Hn0UJk+G9daDiy5Kq/ltumnWCSVJ+WiFFdJCGy1awEknpWnh3bunnx2OutVSKnWxCiCEEIAtgHrAJGBsjC4HIGnpTJ1anZYt4aOP0iyTvfbKOpEkVWKffQb3359uX32VRlC1bp36UO2+u6v4SZJK5vDDYaed4LjjoH37tBDHXXdB3bpZJ1MFVurfQkIIF5Km/n0AjMhtJ4QQLsoVsSSp1KZMgQsv3IZRo+CRR9IMFElSGfv1V7j77jRdY9NN4aqrYJNNoH9/+PFHuO8+aN7cQpUkqXTWWQdeeCH9XHn0UdhuOxg5MutUqsBK9ZtICKEPcDVpRFUodqsHXAX0K+N8kqqA2bPTh/ljxqzMgAFwyCFZJ5KkSmTmzLR605FHQsOGaRW/336D665LzQGfew6OPRZWXDHrpJKkiqx6dejcOU0th9TP48or0y/7UimVuFgVQjgQaJt7OP+Uv0gqWh0TQjiojLJJqiIuuSSt+Hf22Z/Sxo54krT0YoR334Wzz06fdh90ELz0UmqE+/bb8OGHqXn62mtnnVSSVNk0bQqjR8NRR8Fll6XeHt9+m3UqVTCl6Vl1UrH7nwEDgB+BBsAxQFH3zROBp8oknaRK77HHoGvX9PfTgQf+AGyWdSRJqrBqTpwIN96YmqV/8EFate+gg1IfqpYtoWbNrCNKkqqCunXTFPP99oMzzkirB95zT+pvJZVAaaYB7kgaQfUesE2M8YoYY88Y4xXAtrnnQ+44SVqsMWNSD8ZddoHbb886jSRVcF270vTII+G889IKTT16wA8/pE8FDj7YQpUkadkKIa0M+O67sPHGcMQR6RPqqVOzTqYKoDTFqvq57ZMxxhnFd8QYpwNPznecJC3U77/DoYemFikDB0KtWlknkqQKbOBAuOgiftltN/j4Y3j9dTjtNFhttayTSZKquo03hldegQsvTKOrmjRJ0wSlRShNsWpabrvOQvYXPf/XkseRVBUUFsLxx8O4cWmxEFumSNJSGD06TfNr2pQxnTvDZk6nliTlmZo14dprYdiw9Kn1zjvDrbemHovSApSmWPU5aZpf2xBChxBCDYAQQo0QwgnA8aRpgp+XfUxJlclVV8FTT8HNN6dFQiRJS+inn9IUv3r14PHHiU71kyTls733hvffT30Uzz4bWrVKP8uk+ZSmWPV0blsduAf4M4TwE/An0Iu5zdqHll08SZXNkCFw+eVpZFWnTlmnkaQKbMaM1P/jl19g8GBo0CDrRJIkLV79+vDEE9C9O7z4Ymq+/uyzWadSnilNsep2YELufiAVp1bPbUPu+Ym54yTpbz7/HI49Nv08uvvu1HNRkrQEYoTTT4dXX4U+fWD77bNOJElSyYWQfo69/XYqXrVsCeeeC9OnZ51MeaLExaoY4wTgYOCXhRwyATg4d9wSCSEcE0J4OYTwewhhSgjh7RDCGSGE0hTVFnbua0IIMXf7v6U9n6TSmTIFDjsMqleHQYNg+eWzTiRJFdgdd0Dv3nDJJXDkkVmnkSRpyfzjH/DWW3DGGalHSNOm8MknWadSHihVESjG+AawMfBv4BHg+dz2LGCTGOPrSxokhNAdeABoArwMDAM2BboBA0MI1Zfi3DsC55N6aklaxmKEE0+EMWPgoYegUaOsE0lSBTZsWOrzceih0KVL1mkkSVo6yy8P3bqlKe3ffJNGC/fubfP1Kq7UI5ZijJNjjN1ijEfHGFvktnfEGP9Y0hAhhCOA04EfgW1ijAfGGA8DNgHGAocBS9TdJoRQC+gD/AQMXtKMkpbcTTfBI4/ANdfAvvtmnUaSKrDPPoOjjoKttoL774dqSz34XJKk/HDwwfDee7DLLnDSSenn3a+/Zp1KGcmX33Auym0viDF+VvRkjPEn4LTcwwuXcDrgFcCWQEfg96VKKanUXngBLrgAWreG88/POo0kVWC//w6HHJIKVIMHQ506WSeSJKlsrb12GkHctWvqHbLddvDKK1mnUgZqLGxHCOHFJTxnjDHuXdKDQwjrADsAM4BHF3CyESGE74G1gV2A10px7p2Bc4EBMcanciO4JC0jX3+dPhDZfHO4914bqkvSEps9G445Jo2sGjYMNtgg60SSJJWPatXSp9177QX/+hfssQdcemnq01hjoSUMVTKL+i/dnNL3eApL8JrGue1HMcZpCznmLVKxqjElLFaFEGoDfYFJpJ5akpahadPg8MNh5sz0ochKK2WdSJIqsIsvhqFD4c47oXnzrNNIklT+dtwR3n0XOnVKPRqffx4eeADWXz/rZFoGSjKtLpTitiSKPhr8ehHHfDPfsSVxNbAZcGaMcWErGEoqBzHCaafBqFHp58mmm2adSJIqsP794frr0xLfHTtmnUaSpGVnpZWgb9/0R8UHH8C228LDD2edSsvAokZW/Y9ls3peUcOFqYs4ZkpuW6KxGSGEXYH/AE/EGL2SpWWsR4/0M6WgAA48MOs0klSBvflmajLbvDncemvWaSRJysYxx0DTpml79NHw7LNw++32b6zEFlqsijE2X0YZikZklUlhLISwPHAf8AdphcElOccpwCkAa665JsOHDy+LaHmhMn0tyk8ffFCXs8/elqZNJ7H77h9SmktuypQpXqPKa16jWpZqTpjADqedRmG9eoz6z3+Y+eqri32N16jyndeo8p3XaH4LV15Jo759Wa9PH6YNG8aYSy5hymabZR1rmaoq12g+dCebnNsuqiRatG/yIo4pcg2wKXBCjPGHJQkUY+wJ9ARo0qRJbF4JekOMGDECgMrwtSh/jR+feiBuuCEMHVqfVVZpXqrXDx8+3GtUec1rVMvMtGmpoez06TB8OM3+8Y8SvcxrVPnOa1T5zmu0AthnHzjpJFY47jianHkmXHMNnHNOasxeBVSVa7TUxaoQQgAOAnYDVgceBkYCdQFijN8s/NUL9FVuu6guaevOd+yiHAYUAu1CCO3m27d5bntaCOFA4PMY40klzClpEWbMgNatYfLktFDVKqtknUiSKqgY4eST4e234YknoISFKkmSqow99oD33ktT5c87L/0B0rcvNGiQdTKVkVIVq0IImwCDgC2KPf0BsDzwGFAYQtg+xvh+KU77bm67VQhh+YWsCLjjfMcuTjVgj0Xs3zB3W6WE55O0GP/5D4wcmfod+neVJC2FG25IjWSvvhoOPjjrNJIk5ad69eCxx6BXr/THyDbbwH33QatWWSdTGSjxOLkQwqrAMOYWqoqv/vcUaYpe0airEosxfguMAmoCbRbwvnsA6wA/kkZwLe58jWKMYUE3oG/usPNyz21XmqySFuy++9Jq6uedB0cemXUaSarA/vtfuPBCOOoouOiirNNIkpTfQoBTTkmjkRs2TKs7nXUW/PVX1sm0lEozqfM/wHq5+8ULVcQYZwEv5Z7fewlyXJvbXhdC2LjoyRDCGkCP3MOuMcbCYvuuDSF8HEK4FkmZefttOO002HvvNF1ckrSExoxJqxxtvz3ce2/6BVySJC3ellvCG2+kQtXtt8POO6efq6qwSlOsOjS3/RHYcgH7P8pt11vAvkWKMQ4E7gQaAB+EEJ4KITwOfJZ7ryeAbvO9rCGwWW4rKQM//wyHH56mhj/0ENTIhyUbJKkimjQpTflbYYXUp2qFFbJOJElSxVK7Ntx6KwwZAj/8AE2awN13p16QqnBKU6zaCIjA/THGjxew/4/cdok6msUYTweOJU0J3APYD/gc6AQcEWOcvSTnlVQ+Zs1Ks1QmTIDHH4f69bNOJEkV1MyZaQ71t9/CoEGwzjpZJ5IkqeI64AB4/33YbTfo2BGOOAImTsw6lUqpNMWqomOnLmT/UrfdjzEOiDE2izGuHGNcMca4Q4yxe/Hpf8WObZ/rO9W+FOcves2NS5tVquouuACGD08fVmy/fdZpJKkCO/dceOEF6NkTmjbNOo0kSRVfgwbwzDNw442pH+S226Y/XlRhlKZY9UNuu8/8O0IIKwCH5R5+t7ShJOW3Bx+Em2+GTp2gbdus00hSBdarF9xxRypYtWuXdRpJkiqPatXSz9eRI9P0+r32gs6d04hm5b3SFKteITVQ3y2E8FSx5/cH3iD1qorAy2UXT1K+ef99OPHENKr25puzTiNJFdjLL8MZZ0DLlnDddVmnkSSpctphBxg1Cjp0SCtC7b47fPll1qm0GKUpVnUnFaMADsjdD8BezG24HkmN0iVVQpMmwWGHwaqrwqOPwnLLZZ1Ikiqor79OPTQ22CANV61ePetEkiRVXnXqQO/e8PDDMHYsbLcdDBiQdSotQomLVTHGN4EupALVnKdz26LnusQYR5VRNkl5ZPZsOPbY1P934MA0DVyStASmTEkr/82YAU8+CausknUiSZKqhiOPhPfeg222SX/ctG0LkydnnUoLUJqRVcQYrwCOJK3YB3OLVKOAo2KMV5ZhNkl5pKAg9Si84w77/0rSEisshPbt4cMP06e7m22WdSJJkqqW9ddPzdYvvxweeAAaN4Y338w6leZTqmIVQIxxYIxxR6AOsA5QJ8bYJMb4aJmnk5QXnngCrr469ao65ZSs00hSBXbllfDYY2l1ov32yzqNJElVU40a6dP4ESNSw/VmzaBr1/ShkvJCiYtVIYQbQgibFj2OMU6LMY6PMU4rn2iS8sHHH6fRsTvuCN26QQiLf40kaQEeeyx9itu+PfznPxmHkSRJ7LYbjB6dGvNedBHsuy98/33WqUTpRladC4wNIfwvhHB8CKF2eYWSlB/++CP9u127dvobq7b/10vSkhk9OlX+mzaFu+6y8i9JUr5YddU0Nb93b3j9ddh2Wxg8OOtUVV6ppwECzYA+wA8hhG4hhMZlG0lSPihqq/LZZ/DII7DuulknkqQK6uef4ZBDoF49ePxxqFUr60SSJKm4EOCEE2DUKFhvPTj0UDjjDJjmRLKslKZYNYnUUL3oVhc4DXg7hPBOCOHUEMJK5ZBRUga6doVBg+CGG6B586zTSFIFNWMGHHEETJiQPqV1KVVJkvLXZpvByJFw7rnQo0fqhfLhh1mnqpJKU6xqABwEPAT8mXuuqHC1HdCDNNrqvrIMKGnZe+YZuOQSOOYY26pI0hKLMX0q+8orcN99sP32WSeSJEmLU6tWWgjlmWfgl1+gSRPo3j39XNcyU+JiVYxxVoxxSIzxGGBNoB3wHDCbuUWrFYC25RFU0rLx5ZepSLX11tCrl21VJGmJdesG99wDnTvDUUdlnUaSJJXGfvvB++/DXntBp05pSv8vv2SdqspYkp5VxBinxhjvjzG2BP4JfAlYZpQquKlTU0N1SFMAV1gh2zySVGE9/zycfXb6xfaKK7JOI0mSlsQaa8CQIXDrrfDss7DNNvDCC1mnqhKWqFgVQlg116PqZeBVYIOyjSVpWYsRTj4ZPvgABgyADTfMOpEkVVCffQZHHglbbAH33w/VlujXLUmSlA9CgLPOgjffhLp1Yd994cILU19KlZsS//YUQqgZQjgihDAI+IHUo2pX5m26Phm4pzyCSipft94KDz4IV10FLVtmnUaSKqjff0+jqapVgyefhJVce0aSpEph223hnXfSJ/zXXQfNmsHnn2edqtIqzUd9PwKPAAcDNZlboAJ4HTgJaBhjPLVME0oqdy+9BOedl6YAXnRR1mkkqYKaPRuOPTaNrBo4EDZw4LkkSZXKCivA3XfDY4/BF19A48bQt6/N18tBaYpVq+S2RQWqX4Bbga1ijLvGGO+NMf65oBdKyl/ffpv6/m6yCfTpY0N1SVpinTunvhZ33AHNm2edRpIklZfDD4f33ksr/bZvnz6s+v33rFNVKkvSROF54Ghg7RjjOTHGsWWcSdIy8tdfcMQRaTtoEKy8ctaJJKmC6t8/TQk47TTo2DHrNJIkqbytuy68+CJceSU88ghstx2MHJl1qkqjNMWqq4ANY4wtYoyPxBhnllcoSeUvxrQC61tvQb9+sPnmWSeSpArqzTfhpJPSaKrbbss6jSRJWlaqV4dLLoGXX06P//nP1AR49uxsc1UCJS5WxRgvizF+XZ5hJC07PXtC795p1sqhh2adRpIqqPHj0z+ia60Fjz4Kyy2XdSJJkrSsNW0Ko0en1YAvvRT23jv1W9EScy1lqQoaORLOPDOt+telS9ZpJKmCmjYtFaomT04r/9Wvn3UiSZKUlbp14YEHUsP1d95Jqwc+/njWqSosi1VSFfPjj9C6dZpiPWBAGrkqSSqlGNPS1W+9lfpV/eMfWSeSJElZCwHatoV334WNNkoNgk89Ff50LbrSslglVSEzZkCbNvDbb6mh+qqrZp1IkiqoG25In55edRUcckjWaSRJUj7ZeGN49VW44ALo1Qt22CGtHqgSs1glVSHnnguvvJJ6VW2zTdZpJKmCGjIELrwQjjoKLr446zSSJCkf1awJXbvCsGHw+++w005pIZYYs05WIViskqqIfv2gWzc45xw4+uis00hSBTV2LPzrX9C4Mdx7bxruL0mStDB77w3vvw/77Qf/+Q+0agU//5x1qrxnsUqqAkaNSlOl99wTrrsu6zSSVEFNmgQHHQQrrABPPJG2kiRJi1O/PgwenEYPvPhimuby7LNZp8prFqukSu6XX+Cww2D11eHhh6FGjawTSVIFNGtWWo76229T07911806kSRJqkhCgDPOSIuz1K+flmY/91yYPj3rZHnJYpVUic2alab8/fRTWjV19dWzTiRJFdS558ILL0DPntC0adZpJElSRbX11qlgdfrpcPPN6feKTz7JOlXesVglVWKdO6e/rXr0gCZNsk4jSRXUPffA7benpn/t2mWdRpIkVXTLLw/du6e2Al9/Ddtvn3ph2nx9DotVUiX16KNw/fXQsSOccELWaSSpgnrllfTJ53772fRPkiSVrUMOSc3Xd9kFTjwxTYv57besU+UFi1VSJfThh9ChQxpRetttWaeRpArq66/h8MNhgw3goYds+idJksre2mvDc8/Btdem3i3bbps+LKviLFZJlcxvv6WG6iutBAMHQs2aWSeSpApo6tT0aeeMGfDkk7DKKlknkiRJlVX16nDhhfDqq7DccrDHHnD55akJcRVlsUqqRAoL4fjj4auv0jTAtdbKOpEkVUCFhak31QcfpGVUN9ss60SSJKkq2GknePddOO446NIFmjdPI72rIItVUiVyxRXw3//CrbfCbrtlnUaSKqgrr4THHoMbbki9qiRJkpaVlVaCvn3hgQdSP6ttt4VHHsk61TJnsUqqJJ56KhXf27VLvYAlSUvgscfSsPv27eHss7NOI0mSqqpjjoHRo2HzzeGoo1ID9ilTsk61zFiskiqBTz9NI0W33x7uvBNCyDqRJFVA770Hbdum1Snuust/TCVJUrY23BBefhk6d4b77oMddqDOp59mnWqZsFglVXCTJ6eG6jVrpsUjll8+60SSVAH9/DMcfDDUq5f+Ma1VK+tEkiRJqeH6VVfBiy/C1Klsf8YZ6X4lZ7FKqsBihBNOgI8/Tj2A118/60SSVAHNmAFHHJEKVk88AQ0aZJ1IkiRpXs2bw3vv8f3hh8Ouu2adptxZrJIqsOuvh4ED4brrYK+9sk4jSRVQjHDGGfDKK9CnD+ywQ9aJJEmSFmy11fjitNOgdu2sk5Q7i1VSBTVsGFx8MRx5JJx7btZpJKmC6t4d7rkn9YI46qis00iSJAmLVVKF9NVXcPTRsOWW0Lu3PYAlaYm88AL85z9wyCFwxRVZp5EkSVKOxSqpgpk2DQ4/HGbPhkGDoE6drBNJUgX0+efQpg1ssQXcfz9U81ciSZKkfFEj6wCSSi5GOPVUGD0annoKNt4460SSVAH98Uda+a9aNXjySVhppawTSZIkqRiLVVIF0q1bGgDQpQu0apV1GkmqgGbPhmOOgc8+S83/Ntgg60SSJEmaj8UqqYJ4+WU455w0GOCSS7JOI0kVVOfOMGQI9OiRloCWJElS3rFBg1QBfP89tG4NG24I/frZWkWSlsgDD8B110HHjnDaaVmnkSRJ0kI4skrKc9OnwxFHwJ9/wksvQd26WSeSpArorbfgxBPTaKrbb886jSRJkhbBYpWU5/79b3jjDRg4ELbcMus0klQBjR8Phx4KDRvCo4/CcstlnUiSJEmLYLFKymP33AM9e8KFF6bRVZKkUpo2DQ47DH7/HUaOhPr1s04kSZKkxbBYJeWpN96AM86AFi3gqquyTiNJFVCMcMop8OabMGgQbL111okkSZJUArZplvLQTz+lkVRrrQUDBkD16lknkqQK6MYboX//VPE/9NCs00iSJKmEHFkl5ZmZM+Goo2DiRHjtNVhttawTSVIFNGQIXHBB+gf14ouzTiNJkqRSsFgl5Znzz4cRI+D++6Fx46zTSFIFNHYs/OtfsN12cO+9EELWiSRJklQKTgOU8siAAXDrrWkFwOOOyzqNJFVAkybBwQfDCivA4MFpK0mSpArFkVVSnhg9Gk46CXbfPbVZkSSV0qxZadrfN9/A8OGw7rpZJ5IkSdISsFgl5YFJk+Dww6FePXjkEVhuuawTSVIFdO658Pzzaepf06ZZp5EkSdISslglZWz27NRa5fvv4X//gzXXzDqRJFVA99wDt98OZ58NHTpknUaSJElLwWKVlLFLL4XnnoOePWHnnbNOI0kV0CuvwOmnw377wfXXZ51GkiRJS8kG61KGHn8crr0WTj453SRJpfTNN2ke9QYbwEMPQQ0/h5MkSaroLFZJGRkzBtq1S6Op7rgj6zSSVAFNnZpW/psxA558ElZZJetEkiRJKgN+/Chl4Pff4bDD0orqAwdCrVpZJ5KkCqawMFX8P/gAhgyBzTbLOpEkSZLKiMUqaRkrLIS2beGLL+DFF2GddbJOJEkV0FVXwWOPwU03QcuWWaeRJElSGbJYJS1jV1+dZqvceivsvnvWaSSpAnr8cSgoSCOrzj476zSSJEkqY/askpahoUPT31fHHgv//nfWaSSpAnrvPTj+eNhlF7jrLggh60SSJEkqYxarpGXk889TkWrbbaFnT/++kqRS+/nn1FB91VXT6KratbNOJEmSpHLgNEBpGZg6Na2sXq1a+vtqhRWyTiRJFcyMGdC6dSpYvfIKNGyYdSJJkiSVE4tVUjmLEU48ET76CJ5+GjbYIOtEklTBxAidOsHLL8ODD8IOO2SdSJIkSeXIYpVUzm6+GR5+GK69Flq0yDqNJFVA3btDr15w8cVw9NFZp5EkSVI5s2eVVI5efBHOPx+OOAIuuCDrNJJUAb3wAvznP6lX1ZVXZp1GkiRJy4DFKqmcfPMNHHUUbL453HefDdUlqdS++ALatEn/kPbvnxr/SZIkqdLztz6pHEyblhqqz5gBgwbBSitlnUiSKpg//oCDDkqV/ief9B9SSZKkKsSeVVIZixFOPx3eeQcGD4ZNN806kSRVMLNnwzHHwKefwrBhsOGGWSeSJEnSMmSxSipjd94JffrAZZelFiuSpFK65BIYMiQ1Vt9zz6zTSJIkaRlzGqBUhl59Fc46Cw44AAoKsk4jSRXQgAHQtSt07JiGqUqSJKnKsVgllZEffoDWrWH99e0DLElL5K234MQTYY894Lbbsk4jSZKkjDgNUCoDM2akQtUff6T2KquumnUiSapgxo+HQw+FBg3g0UehZs2sE0mSJCkjFqv+v737jrKqvPc//v5KV8RrF2ONmmiMLZZ4Y2JDrz+zDAqKorGbELHGhnotV0VFY7+KWBFrLCi2xGsHWywYo8aIMSbWgNGIBZT+/P7YZ2QYZ2AGhnn2OfN+rXXWPmfvPft8Duw1zHx49rOlVnDUUfDMM3DbbfD97+dOI0lVZsoU6NMHPvus+Ga67LK5E0mSJCkjyyppAY0YAZdfDsceC7vvnjuNJFWZlGDAAHj+eRg1CtZfP3ciSZIkZeasOtICGDu2mAO4Vy8YMiR3GkmqQuefDzfeCIMHF5cBSpIkqd2zrJLm00cfQd++sPzycOut0NFxipLUMr//PRx/PPTrByedlDuNJEmSSsJfr6X5MGMG9O8P//oXPP00LLNM7kSSVGVefx323BM23LC4njoidyJJkiSVRKlGVkXEXhHxZER8FhGTImJsRBwaEc3OGRGdIqJXRFwQEc9GxPiImBYRH0TEyIjYeuF9ArUXJ5wAjz0GV14JG2+cO40kVZmJE6F3b+jaFe65BxZdNHciSZIklUhpRlZFxFDgEGAK8CgwHegFXAb0ioh+KaWZzTjUVsDDlecTgBeBycD3gF2BXSNicErp1Fb+CGonbr0VLrgADj0U9tsvdxpJqjIzZhR3o3jnHRg9GlZeOXciSZIklUwpRlZFxK4URdUEYP2U0k4ppT7AWsDrQB/gsGYebhZwJ7BlSqln5Vh7pJTWA/oDM4FTImKbVv8gqnmvvAIHHQRbbAEXXpg7jSRVoWOPhUceKYam/uhHudNIkiSphEpRVgEnVpbHp5TerFuZUvoQGFh5eUJzLgdMKT2WUtotpfRkI9tuA0ZUXu69YJHV3kycCH36wBJLwB13QOfOuRNJUpW59lq45BI46ig44IDcaSRJklRS2cuqiFgJ2BiYBtzRcHtKaQzwAbACsHkrvOVLleVKrXAstRMzZ8LPfw7vvQcjR0LPnrkTSVKVefppGDgQ/uu/4De/yZ1GkiRJJZa9rAI2qixfSyl91cQ+LzTYd0GsVVmOb4VjqZ04/XR44IFiQIBXrUhSC737LvTtC6utVkz817E0U2ZKkiSphMpQVq1eWb4zl33ebbDvfImIFYD9Ky/vXJBjqf245x4YPLi4YuXgg3OnkaQqM3ky7LwzTJ0K994LSy6ZO5EkSZJKrgz/tdm9spw8l30mVZaLz++bRERH4CZgCeDRlNJ983sstR9vvAH77AObbAKXXw4RuRNJUhVJCfbfv7g7xf33w9pr504kSZKkKlCGsqru1/+0kN/nCqAX8B7zmFw9IgYAAwCWX355Ro8evZCjtZ1a+iwL25dfduCQQ37AIot04thjX+TZZ6fmjlTzJk2a5DmqUvMcbZlVr7+e1UeO5G8DB/J+t27gn91C5zmqsvMcVdl5jqrs2ss5Woay6ovKsvtc9qnb9sVc9mlSRFwCHARMAHqllCbMbf+U0lXAVQCbbLJJ2nrrrefnbUtlzJgxANTCZ2kLKcFuu8H778PDD8M22/xn7kjtwujRoz1HVWqeoy1w110wYgTsuy9rDh3Kmg5NbROeoyo7z1GVneeoyq69nKNlKKverixXncs+KzfYt9ki4gLgCOAjiqLqzZYeQ+3POecUv2ddcAFss03uNJJUZV5+ubiGevPN4corvYZakiRJLVKGCdZfqizXjYhuTeyzaYN9myUifgMcDfwb2D6l9Jf5i6j25MEH4aSToH9/OOqo3Gkkqcp89FExofqSSxatf9euuRNJkiSpymQvq1JK7wF/BDoD/Rpuj4itgJUoLuH7Q3OPGxHnAMcBEymKqpdbJbBq2t//DnvuCeutB9dc42AASWqRadNg113hww/h7ruhZ8/ciSRJklSFspdVFUMqy3MjYs26lRGxHHB55eU5KaVZ9bYNiYhxETGEBiJiMHA88ClFUdWiEVlqn778Evr2LearuusuWGyx3IkkqYqkBIcdBk8+CcOHF7dRlSRJkuZDGeasIqU0MiKGAQOBVyPiEWA6xd37egB3A5c1+LKewHcry69FRG/g5MrLvwGHR+PDY8allM5prc+g6pYS/PKXxd3Vf/c7WGON3IkkqcpcfjlcfTWceGIxRFWSJEmaT6UoqwBSSodExFPAocBWQAdgHDAcGFZ/VNU8LFXv+SaVR2PGAJZVAuCSS+CWW2DwYNhxx9xpJKnKPPYYHHkk/OxncOaZudNIkiSpypWmrAJIKd0C3NLMffcH9m9k/QhgRCvGUo0bPRqOPbaYD/i//zt3GkmqMm+9Bf36wdprw003wSJlmWFAkiRJ1cqfKNWuvf8+7L47rLkm3HCDv2NJUot8/jn07l08v+ce6NEjbx5JkiTVhFKNrJLa0tSpxU2rvvoKRo3ydyxJapGZM+HnP4c33oCHHnKyP0mSJLUayyq1W4cdBs8/X9z5b511cqeRpCpzyilw//0wdChsu23uNJIkSaohXvSkdumqq+Caa4o5qvr0yZ1GkqrMLbfAkCHwq1/BwIG500iSJKnGWFap3Xn22WJU1Q47wBln5E4jSVXmhRfgoINgyy3hf/8XInInkiRJUo2xrFK7MmFCMU/VyisXAwM6dMidSJKqyPjxsMsusMIKMHIkdO6cO5EkSZJqkHNWqd2YPr2489/EifCHP8BSS+VOJElVZMqU4rrpzz6DZ56BZZfNnUiSJEk1yrJK7cYxx8CTTxYjqjbYIHcaSaoiKcGAAfDcc8VdKdZfP3ciSZIk1TAvA1S7cOONcOmlcNRRsOeeudNIUpW54ILiG+kZZ3hXCkmSJC10llWqeX/8YzEgYKut4Nxzc6eRpCrz+9/DoEHQrx+cfHLuNJIkSWoHLKtU0z7+GPr2hWWWgdtvh06dcieSpCry+uvFcNQNN4TrrvPOf5IkSWoTzlmlmjVzZvE71vjxxVxVyy2XO5EkVZGJE6F3b+jaFe6+GxZbLHciSZIktROWVapZJ50EjzwC11wDm22WO40kVZEZM2CPPeCdd+Dxx2GVVXInkiRJUjtiWaWaNHJkMT/Vr34FBx2UO40kVZnjjoOHH4Zrr4UttsidRpIkSe2Mc1ap5rz2Guy/P2y+OVxySe40klRlhg+Hiy+GX/8aDjwwdxpJkiS1Q5ZVqimfflrcVb17d7jzTujSJXciSaoiTz8NBx8M228P552XO40kSZLaKS8DVM2YNQv22Qf+8Y9iipUVV8ydSJKqyLvvFrdPXW01uO026OiPCJIkScrDn0RVMwYPhvvvh0svhR//OHcaSaoikyfDzjvDlCkwZgwsuWTuRJIkSWrHLKtUE+6/H047DfbdFw49NHcaSaoiKcEBB8DLL8Pvfgdrr507kSRJkto5yypVvTffhL33ho02giuugIjciSSpipx5JtxxRzFH1Y475k4jSZIkOcG6qtukSbDLLsXUKnfdBd265U4kSVVk1Cg49dRiwr9jjsmdRpIkSQIcWaUqVnflyrhx8OCDxZzAkqRmeuWVoqT64Q/hqqsclipJkqTSsKxS1TrvPBg5Es49F7bbLncaSaoiH30EvXvDEksUo6u6ds2dSJIkSfqaZZWq0iOPwIknQr9+cNxxudNIUhWZNg122w0+/BCeeAJ69sydSJIkSZqDZZWqzttvQ//+sM46MHy4V65IUrOlBIcfXpRUN98Mm26aO5EkSZL0DU6wrqry1VfQty/MmFFcudK9e+5EklRFhg0r5qc68UTYa6/caSRJkqRGObJKVSMlOPhgeOkluO8+WGut3IkkqYo89hgccQT87Gdw5pm500iSJElNcmSVqsbQoXDDDXDaabDTTrnTSFIVeeutYpK/tdeGm26CRfznX5IkSeXlT6uqCk8+CUcdVQwIOOWU3GkkqYp8/nlx5z+Ae+6BHj3y5pEkSZLmwcsAVXoffFAMCFh9dbjxRgcESFKzzZwJe+8Nb7wBDz0Ea6yRO5EkSZI0T5ZVKrWpU4s7rE+aBI8+CksskTuRJFWRU04pJvm77DLYdtvcaSRJkqRmsaxSqR15JDz7LNxxB6y7bu40klRFfvtbGDIEBgyAQw7JnUaSJElqNi+oUmldey1ceSUMGlSMrpIkNdPYsXDggbDllnDppRCRO5EkSZLUbJZVKqXnny8GAmy3HZx1Vu40klRFxo+HXXaB5ZeHkSOhc+fciSRJkqQW8TJAlc6//gW77go9e8Ktt0JHz1JJap4pU6BPH/j0U3jmGVh22dyJJEmSpBazBlCpzJgBe+wBH39c/J619NK5E0lSlUipmJ/quefgrrtg/fVzJ5IkSZLmi2WVSmXQIBg9Gm64ATbaKHcaSaoiF14IN94IZ5xRjK6SJEmSqpRzVqk0brkFLroIDj8c9tkndxpJqiIPPFC0/f36wckn504jSZIkLRDLKpXCyy/DL34BP/kJXHBB7jSSVEXGjYP+/YvL/q67zjv/SZIkqepZVim7Tz4prlhZckm4/Xbo1Cl3IkmqEhMnQu/e0LUr3HMPLLZY7kSSJEnSAnPOKmU1cybstRe8/z488QSssELuRJJUJeruSPH22/D447DKKrkTSZIkSa3CskpZnXoqPPggXHklbL557jSSVEWOOw4efhiuvRa22CJ3GkmSJKnVeBmgshk1Cs4+u5irasCA3GkkqYoMHw4XXwxHHgkHHpg7jSRJktSqLKuUxeuvw777wqabwqWX5k4jSVXk6afh4INh++3h/PNzp5EkSZJanWWV2tznnxcTqnfrBnfeWcwLLElqhnffhb59YdVV4bbboKNX80uSJKn2+FOu2tSsWcWIqr/9DR59FFZeOXciSaoSkyfDLrvAlCkwenRxC1VJkiSpBllWqU0NGVLcXf2ii2CrrXKnkaQqkRIccAD86U9w//2wzjq5E0mSJEkLjWWV2swDD8App8BeexVzAkuSmumss+COO+C88+CnP82dRpIkSVqonLNKbeKtt4qSav314eqrISJ3IkmqEqNGFU3/PvvAMcfkTiNJkiQtdJZVWugmTy4mVI+Au+6CRRfNnUiSqsQrrxQl1WabwVVX2fRLkiSpXfAyQC1UKcEvfgF//nNxGeC3v507kSRViY8+gt69YYkl4O67vXWqJEmS2g3LKi1UF10Et94KZ58NO+yQO40kVYlp02C33eDDD+GJJ6Bnz9yJJEmSpDZjWaWF5vHHYdAg6NsXTjghdxpJqhIpwRFHFCXVzTfDppvmTiRJkiS1Kees0kLx7ruw++6w1lowYoTTrEhSsw0bBldeWbT8e+2VO40kSZLU5iyr1OqmTIFdd4WpU4tpVhZfPHciSaoSjz1WjKraaSc488zcaSRJkqQsvAxQrSolOOQQGDu2KKq++93ciSSpSvz979CvX/GN8+aboUOH3IkkSZKkLBxZpVZ1xRVw3XVw8smw886500hSlfj88+LOfynBvfdCjx65E0mSJEnZOLJKreaZZ+DII2HHHeG003KnkaQqMWsW7L03jBsHDz4Ia6yRO5EkSZKUlWWVWsX48cVd1ldZxatXJKlFTjkF7rsPLr0UevXKnUaSJEnKzrJKC2zatGKalc8+KwYFLLlk7kSSVCV++1s4+2wYMAAOPTR3GkmSJKkULKu0wI4+Gp5+uvida731cqeRpCoxdiwceCD85CfFqKqI3IkkSZKkUnCCdS2Q66+HoUPhmGOgf//caSSpSowfD7vsAssvD3feCZ07504kSZIklYYjqzTfXnwRfvUr2HZbOOec3GkkqUpMmQJ9+sCnnxbDUpddNnciSZIkqVQsqzRfPvoI+vYtBgXceit09EySpHlLCQ4+GJ57rhhRtcEGuRNJkiRJpWPFoBabMaO45O/DD+GppxwUIEnNduGFxfXTp59eNP6SJEmSvsGySi124onw2GMwfDhssknuNJJUJR54AAYNgt12g5NPzp1GkiRJKi0nWFeL3HYbnH8+DBwIBxyQO40kVYlx44ohqeuvDyNGwCL+8ytJkiQ1xZ+W1WyvvlrcZf1HP4KLL86dRpKqxMSJ0Ls3dOkC99wDiy2WO5EkSZJUal4GqGaZOLG4eVWPHnDHHd5lXZKaZcYM2GMPePvt4vrpVVbJnUiSJEkqPcsqzdOsWbD33vDOOzB6NKy4Yu5EklQlBg2Chx+Ga66BH/84dxpJkiSpKlhWaZ5OPx1+/3sYOhS22CJ3GkmqEtddBxddBEceCQcdlDuNJEmSVDWcs0pzde+9cMYZsP/+xaTqkqRmeOYZOPhg2G674q4UkiRJkprNskpNeuMN2Gcf2HhjGDYMInInkqQq8O67xSR/q6xS3EK1o4OYJUmSpJbwJ2g16osvit+1OneGu+6Crl1zJ5KkKvDll7DLLjBlSjHJ31JL5U4kSZIkVR3LKn1DSnDAAcXIqocf9uZVktQsdd88//QnuP9+WGed3IkkSZKkqmRZpW8491y4885impVtt82dRpKqxFlnwe23w29+Az/9ae40kiRJUtVyzirN4aGH4KSTYI894Oijc6eRpCoxahSccgrsvTcce2zuNJIkSVJVs6zS1/7xD+jfH773Pbj2WidUl6RmefXV4m4Um20GV1/tN09JkiRpAVlWCSjmBO7Tp5hyZdQoWGyx3IkkqQp8/DH07g1LLFF88/RuFJIkSdICc84qkRIMGACvvFLMCbzmmrkTSVIVmDYNdtsNxo+HJ5+EFVfMnUiSJEmqCaUqqyJiL2AgsD7QARgHXAcMSynNyn28WnXppXDzzXDGGc4JrDYwa1YxlG/yZJg0afZy0iSWeumlYnvnztCly5zLxtYt4uBQZXTkkTBmDNx0E2y6ae40kiRJUs0oTVkVEUOBQ4ApwKPAdKAXcBnQKyL6pZRm5jperXriiWIi9d69i4nVpa81LJUaFEuNlU3N2nfy5Cbfcv2WZuzYsekia24l18LcVn8f5y6qXcOGwRVXwPHHw89/njuNJEmSVFNKUVZFxK4UxdIEYMuU0puV9csDjwN9gMOAS3Icr1a9/z706wdrrAE33OAglapVVyrNb5nU1PYvv2xZjkUXhe7diwnPunef/Xz55edc33B7ved/fPllfvD978PUqcUlVtOmzX7ecNmSbV9+CRMnzvvrW1unTuUo0Bpb16mTZdr8evxxOOII2GknOOus3GkkSZKkmlOKsgo4sbI8vq5YAkgpfRgRA4HRwAkRcWkzL99r7ePVnKlTi6lWvvwSRo8u5gbWQla/VGqNMqnu+fyWSg3LooalUlPPG1u36KKt0nZ+Pn06bLnlAh9nvqQE06e3bknW3G2TJsG//z33r5s+vfU/c1mKs8a2dexYyjKt6z//CYcfDmutVVw/3aFD7kiSJElSzcleVkXESsDGwDTgjobbU0pjIuID4FvA5sAzbXm8WnX44fDcc3DnnbDOOrnTlExTpdKCjlxqaam02GKNF0N1pVJLyqS6561UKtWkiNmFSRml9M3Sq61Ktc8+m/fXzZjRup+37u+jDMVZ3XLWLNY76aTi7+Lee6FHj9b9zJIkSZKAEpRVwEaV5Wsppa+a2OcFinJpI+ZdLrX28WrO1VcXjxNPhL59c6dZALNmzZ4DqTVHK81PqdSwGFp8cejZc/5GKXXvDt26WSppThFFadKlS3F+lc2sWU0XWgu7VJs8ed5fN7N1pihcdJFF4KGHvG2qJEmStBCVoaxavbJ8Zy77vNtg37Y8Xk157jk47DDYYQcYPLiN3rSuVGrNS98WpFSqXwzVlUrzM0rJUkmabZFFoGvX4lFGM2e2Sjn2J2CjXr1yfxpJkiSpppWhrOpeWTZ9izCYVFk2ZzhBqx7vn//8J6effnoz3rb8Jk1ajO23/5xFF53JBhtcxZlnTplzh1mz6Dx9Op2nTaPTtGl0rntU1s2xvrF106bRqd76r9e18PKgqZ07M71TJ6Z17jzHY3qnTkxbfHGmLb000+vW19tvev39K+vr1k3v2LFlpdI87lqnhWfMmDG5I0hzdW+N/Jug2uX3UZWd56jKznNUZdceztEylFV1M+imshwvIgYAAwB69uzZGpmy2+rRx5n44pL8+Ksn+M6Kf6X7LZMXqFRKMLtAqlcSTe3ShS8WX/zr9Y0VSHOsb7CuxaWSJEmSJEmqKWUoq76oLLvPZZ+6bV/MZZ9WO15K6SrgKoBNNtkk/c///E8z3rbcnr/wd6z05fsstUp3llp5GVhs1fm/81v37kS3bnSJoEvuD6aaMnr0aLbeeuvcMaQmeY6q7DxHVXaeoyo7z1GVXS2do6eddlqT28pQVr1dWa46l31WbrBvWx6v6k2fDnsvfxNLrfMJzz67ee44kiRJkiRJTSpDWfVSZbluRHRr4g5+mzbYty2PV/U6dYI99/wtKQVgWSVJkiRJksor++RAKaX3gD8CnYF+DbdHxFbASsAE4A9tfbxascgi0KFDa00LJkmSJEmStHBkL6sqhlSW50bEmnUrI2I54PLKy3NSSrPqbRsSEeMiYgjf1OLjSZIkSZIkKb8yXAZISmlkRAwDBgKvRsQjwHSgF9ADuBu4rMGX9QS+W1m2xvEkSZIkSZKUWSnKKoCU0iER8RRwKLAV0AEYBwwHhrV0FFRrH0+SJEmSJEkLX2nKKoCU0i3ALc3cd39g/9Y6niRJkiRJkvIry5xVkiRJkiRJkmWVJEmSJEmSysOySpIkSZIkSaVhWSVJkiRJkqTSsKySJEmSJElSaVhWSZIkSZIkqTQsqyRJkiRJklQallWSJEmSJEkqDcsqSZIkSZIklYZllSRJkiRJkkrDskqSJEmSJEmlYVklSZIkSZKk0rCskiRJkiRJUmlYVkmSJEmSJKk0LKskSZIkSZJUGpZVkiRJkiRJKg3LKkmSJEmSJJWGZZUkSZIkSZJKI1JKuTOUWkR8BLyTO0crWQb4OHcIaS48R1V2nqMqO89RlZ3nqMrOc1RlV0vn6KoppWUb22BZ1Y5ExNiU0ia5c0hN8RxV2XmOquw8R1V2nqMqO89RlV17OUe9DFCSJEmSJEmlYVklSZIkSZKk0rCsal+uyh1AmgfPUZWd56jKznNUZec5qrLzHFXZtYtz1DmrJEmSJEmSVBqOrJIkSZIkSVJpWFbVuIjYKyKejIjPImJSRIyNiEMjwr97ZRUR342IIyPipogYFxGzIiJFxG65s0kAEdEpInpFxAUR8WxEjI+IaRHxQUSMjIitc2eUIuLwiLg9Il6PiH9HxPSI+CgiHomIvSMicmeU6ouIsyv/3qeIODZ3HikiRtQ7Jxt7jMudUQKIiG4RMSgiXoiITyPiy4j4R0TcERFb5M7X2jrmDqCFJyKGAocAU4BHgelAL+AyoFdE9EspzcwYUe3bQODI3CGkudgKeLjyfALwIjAZ+B6wK7BrRAxOKZ2aKZ8EcDywHPBn4BmKc3RVYFuKf/N3i4i+KaVZ+SJKhYjYFBgEJMAiVWXzNPC3RtaPb+sgUkMRsTrwELAm8C9gDDAVWA3YGXiZ4hyuGZZVNSoidqUoqiYAW6aU3qysXx54HOgDHAZcki2k2rs/A+cBYylKgGspygGpLGYBdwKXpJSerL8hIvYAbgZOiYjHU0qP5wgoAf2Bl1JKk+uvjIh1Kf6jamdgP+C6DNmkr0VEF2AE8CHwPLBLzjxSI65JKY3IHUJqKCIWo/gP1DWAwcDglNL0etuXBpbOFG+h8VKw2nViZXl8XVEFkFL6kGJEC8AJXg6oXFJK16SUBqWUbk8pvZU7j9RQSumxlNJuDYuqyrbbKH7pAti7TYNJ9aSUnmpYVFXWvwYMrbzcvm1TSY06g2Jk6sHAZ5mzSFI1OZmiqLohpXRq/aIKIKX075TSX/NEW3gsKmpQRKwEbAxMA+5ouD2lNAb4AFgB2Lxt00lSzXipslwpawqpaTMqyylZU6jdi4gfAscAt6SU7sudR5KqRUR0Bn5ZeXlOzixtzcsAa9NGleVrKaWvmtjnBeBblX2faZNUklRb1qosnctCpVOZ2+LgykvLAWUTEV2B64FPcK5Klds2EbE+0J3ictWngIed80+ZbUxxid97KaXXI+JHwE6VdROA/0sp/SFnwIXFsqo2rV5ZvjOXfd5tsK8kqZkiYgVg/8rLOzNGkQCIiAMo5v3rRDHa70cUI+iHpJRG5cymdu8s4LtA/5TSx7nDSHOxbyPr/hIR/VNKr7Z5GqmwXmX5ZkSMoJiHsr5TI+JOYJ+5DFSpSpZVtal7ZfmNOSzqmVRZLr6Qs0hSTYmIjsBNwBLAo17SopLYgjl/gJ0BnAJcmCeOBJURAL8G7q7M9SeV0Z8obvbzKMV/9vcAfkBRtG4APBIRP0gpfZAtodqzpSrLLYEOwPnAFcC/K+sup7hL9efAgTkCLizOWVWb6m4FnLKmkKTadAXQC3gPJ1dXSaSUfpFSCmBRYF3gYuA04NmIWDFjNLVTEdGN4i6Un1PcoVoqpZTSxSmlS1NKf0kpTU4pjU8p/Q7YDHgWWI7ZN6+S2lpdZ9MRuDaldFxK6a2U0qcppXsp7qyagP0i4tu5Qi4MllW16YvKsvtc9qnb9sVc9pEk1RMRlwAHUcwR0CulNCFzJGkOKaWvKr9wHUfxy9UGwGWZY6l9Ohv4DnB0Ssm5/VR1UkrTgCGVlz/NmUXtWv3f169uuDGlNJZiZOAiwNZtlKlNWFbVprcry1Xnss/KDfaVJM1FRFwAHAF8RFFUvZk5kjQv11WWP4uITlmTqD3qA8yi+N/+0fUfwP+r7DOwsu6abCmluRtXWX4rawq1Z2/Xe/6PJvapW7/Cwo3StpyzqjbV3U593Yjo1sREa5s22FeS1ISI+A1wNMX8ANunlP6SOZLUHJ9SzF3VkWLOiw+zplF7tAjFxP9N+Xbl8R9tkkZquaUry0lz3UtaeP5Y7/nSFP9p2tAylWVNnaeOrKpBKaX3KE7qzkC/htsjYiuKOwVNAGryNpeS1Foi4hzgOGAiRVH1cuZIUnNtSVFUfQp4Fza1qZTSaimlaOwBXF/Z7bjKug0zRpXmZvfK8oWsKdRuVSb2f67yslfD7RGxJMUNAQDGtlWutmBZVbvqrq8+NyLWrFsZEctR3DEA4JyU0qw2TyZJVSIiBgPHU/yyv31KydGoKo2I+ElE/DwiujSybQvg2srLa1NKM9s2nSSVX0RsGBE7RUSHBus7RsTRFJf/A1zU9umkr51VWZ4aERvWrYyIrsAwijtUv0iNDUSJlLxhXK2KiMuBgcAU4BFgOkUb2wO4G9jNH16VS0T8gNnFKcD3gMWBN4FP6lamlDZv42gSABHRG7in8nIs8FoTu45LKZ3TNqmk2SJif4p5qT6lGFE9geL76BoU31MBfgf0a2JKACmLiBgB7Ecxsur8zHHUjkXELsAoip89/wq8T/F9dD1gRYp5105MKf0mV0YJICLOA44FplGMtPo3xR0rVwQ+ALaptflUnbOqhqWUDomIp4BDKeYL6EAxSeBwYJijqpRZD+CHjaxfq62DSE1Yqt7zTSqPxowBLKuUwxhgMPATiruu/QgIitLqTuCmlNLd2dJJUvm9DFxC8Uv/qsBGQKIora4DhqaUXswXTyqklI6LiGeAwynO00WBd4ELKa6Yamwuq6rmyCpJkiRJkiSVhnNWSZIkSZIkqTQsqyRJkiRJklQallWSJEmSJEkqDcsqSZIkSZIklYZllSRJkiRJkkrDskqSJEmSJEmlYVklSZIkSZKk0rCskiRJqici9o+IVO+xWu5MbaG9fm5JklQ+llWSJEnNEBFbNyhzts6dqbkiYkS93G/nziNJkjQ3HXMHkCRJKpkXgOPqvf4kV5A21l4/tyRJKhnLKkmSpHpSSq8Br+XOUV9E9Egpfb4w36OMn1uSJLVPXgYoSZJUT2NzN0VEAh5vsOvjTV1aFxFLR8T/RMQLEfFZREyLiPcj4paI2LQZ77lmRAyKiNcjYipwb2W/1SLiooh4IiLeiYgvKsf+V0Q8FhEDIqJDw+MC+9V7u1UbvNdpTX3uBhkjIvaMiAci4sPK+34aEc9FxIkR0aORz/V2veONqHyumyt5p0bEnyNiv4ZfJ0mS2jdHVkmSJLWiiNgEuB9YvsGmbwF7ArtHxK9TSpfN5TDDgZ80sv77wK8bWb8ssE3lsUtE7JRSmtXS7E2JiG7AKGCHBpuWADarPH4ZETuklN5s4jAbAS8C9UutdYEREUFK6frWyitJkqqbZZUkSdK8HQesARxcb90VwFuV558BRMTiwH3MLqo+BH5LMf/TdsCWQAfgkoj4U0rpqSbe7yfA6xQjqmYB3SrrZwAvA2OBjyrv242iCNoJCGBHoC8wktnzUO0BbFI5xkTg7Hrv9UwzPv+FzFlU/QF4GPgO0L+ybnXgnohYP6U0o5FjrF9574sqmX9J8WcBcAJgWSVJkgDLKkmSpHlKKZ1fuftf/bLqtpTS6Aa77gesUHk+Fdg0pfQeQEScSVHy/JBiKoZjgabKqmeBbVJKUxrk+D/g/yJiDeAHwHLAdOCJyutvVXbdERhZNw9VRHyf2WXV5yml85v3ySEilgJ+UW/Vk5VsMyvb/wqcWtm2DvAzilFYDSWgV0rppcrXTWH2KLG1I2LxlNIXzc0lSZJql2WVJElS66l/6V4X4N2IaGrfH8/lOOc3LKoAImJV4EYav0SwvpXmsb0lfsicPzNeX1dUVQxndlkFsAWNl1V/qCuqKt5osH1JwLJKkiRZVkmSJLWipVqyb0Qs0sTcUuOa+JpRFJf8zUuXFuSYl4afacI8Xjf1Z/B2g9dTG7z2xj+SJAmwrJIkSWpNn9R7/jkweB77pybWT264IiK+w5xF1a0U81H9M6U0KyKeB75xp8FW8EmD1yvM43XD/etMb/C6qc8uSZLaOcsqSZKk5mlYtizayD5PAbtXnvcAXkwpPd5wp8ocUv+RUmpJYbNMg9d3pJTerxxvHWCDuXxt/eyN5Z6b5ygmdq/7uXHfiLiu3oiwAxvs/3QLjy9JkjQHyypJkqTmeb/B67MiYkNgGvBSSulRijvancTsuwE+EBGjgL9Q3KlvNYo5nb4DnE7TE6w35m8Udwasu1zukojYCOgO7A90bmb2ZSNiBPAaxeimG1NKHzb1hSmlTyJiODCgsmpL4KmIeBhYi9l3A4RiHqr7mvuBJEmSGmNZJUmS1AwppXcql9ptVlm1YeUBMBR4NKX0eUT8DLiX4vK4LsxZ5izI+/8rIq4ADqmsWgk4ufL8FeAtYOMmvvwu4BSgQ+X1fvW2jQaaLKsqfg18G9iu8vo/K4/63gV2TinNmMexJEmS5sqJLCVJkppvV+A24COKUU7fkFJ6AViXokh6FviU4jK6CcAfgauB3sC58/H+RwD/DfyD4tK+fwLDgK2ASU19UUrp1Ur254AvW/qmKaWvgB2AfYAHKT7/DIp5ucZSfNYNUkoN7/AnSZLUYtGyqRIkSZIkSZKkhceRVZIkSZIkSSoNyypJkiRJkiSVhmWVJEmSJEmSSsOySpIkSZIkSaVhWSVJkiRJkqTSsKySJEmSJElSaVhWSZIkSZIkqTQsqyRJkiRJklQallWSJEmSJEkqDcsqSZIkSZIklcb/B47WCZwvuDbbAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABmMAAANtCAYAAABsbA87AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD+A0lEQVR4nOzdd3QV1d6H8eckhEAgNOlSFQsKYi9YKAICNhAFwQIIiuC1K4IdG3K9+ir2jthAVIqK0iyAHREbCqLSew8EQsp5/ziXcwkJkBCSScLzWessZvbsmfmdhAlwvuy9Q+FwOIwkSZIkSZIkSZLyRUzQBUiSJEmSJEmSJBVnhjGSJEmSJEmSJEn5yDBGkiRJkiRJkiQpHxnGSJIkSZIkSZIk5SPDGEmSJEmSJEmSpHxkGCNJkiRJkiRJkpSPDGMkSZIkSZIkSZLykWGMJEmSJEmSJElSPjKMkSRJkiRJkiRJykclgi5AkiRJUnCaD2vOFwu+yNT2z/X/UK9CvWAKyoF7P7+XQV8MytT26vmv0uPoHsEUpGwtS1rG4988zsS/J/L3ur9JSkkiTDh6/Mc+P3J09aPpMaYHr/30WqZzP+v+Gc3rNc/UFhoUyrRft3xd5t8wP7/KlyRJkvYpwxhJkiQpn3Qc2ZExf4zJ1HbDSTfwf23/b4/nrk5eTY1Ha5CWkZap/eerf6Zxtcb7skwFKLswbGelS5SmUulKNKraiBb1WtDj6B5UK1utgCrcO7+s+IXmrzVn7Za1QZciSZIkFQpOUyZJkiTlk0sbX5ql7Z3Z75ARztjjuaN+G5UliGlctbFBTC7c+/m9hAaFMr2GzRoWdFm5tiVtC0uSljDhrwkMmDKA+k/U54lvngi6rN26+qOrDWIkSZKkHTgyRpIkScon5xx6DuXjy7MhZUO0bWnSUr6Y/wUt6rfY7blv//p2lrZLGl+yz2ssik6udTLXn3R9prYjqhwRUDUFb0vaFm6YcAObUzdz++m3B11OFss3LeerRV9laW9zcBsOrXQosTGxAFRJqBJtr1CqQqa+tcrVyvc6JUmSpIJkGCNJkiTlk/gS8Vx4xIW8/OPLmdpH/Dpit2HM4o2Lmb5weqa2ECG6Ne6WL3UWNW0btKVtg7ZBl5FvTjrwJE6udTIAW9O28uvKX/ly0ZdZ+t3z+T10atiJwyofVtAl7tb89fOztLWs35IJl07Itn+3xt38vS1JkqRiz2nKJEmSpHyU3WiW935/j9T01F2eM/LXkZkWOgc4o+4Z1C5fe5/Xp8KnbYO2PN72cR5v+zjPnfMc06+YzlsXvJWlX1pGWqGcdm1r2tYsbbXL+XtXkiRJ+zdHxkiSJEn5qHm95tQqV4vFGxdH29ZsWcOkvyfR/pD22Z4z4rcRWdouPSrr+jMAs1fN5tUfX2XqwqnMXz+fdVvWkRifSL0K9Tiz/pn0Pb4v9SvW3zdvBtiSuoXXf36dj+d9zI/LfmR18mrSMtKoVLoSR1Q5gjPrn0nvY3tTpUyVHF3v038+ZdRvo/h68dcsSVrChq0bKF+qPNXLVufo6kfT5qA2nH/4+ZSLLxc9597P72XQF4MyXefV81+lx9E9AKj3eD0WbFiQ7f16ju1Jz7E9s5y7ZOMS7vzszkztr3d8fZdf90e/epRbJt2Sqe3Fc1+k97G9c/S+c6tr4668MusVJv89OVP7ziNmeozpwWs/vZap7bPun3F6ndN5/ofneeuXt/hj9R+s2bKG7k26M6zDsEx9w+EwH/35Ee/9/h5fL/qa5ZuWk5yaTIVSFahXoR5n1D2Dnkf35MiqR2apMbt7b/faT69lOtasbjM+7/H5bmtuXq/57r4ke7Rq8ype/vFlpvwzhdmrZrMmeQ0lY0tSI7EGp9c5ne5NunN63dPzdA9JkiQppwxjJEmSpHwUCoXo2qgrj3z1SKb2t399O9sw5q+1fzFj6YxMbfGxkenOdpScmsy/xv+LYbOGZRlFs3bLWtZuWcvMZTN5/JvHueuMu7ir2V15fi/j/xxPz7E9Wbl5ZZZjyzYtY9mmZUz5Zwr3T72fh858iBtOvmGX15q7Zi6Xjb6M75Z8l+XY6uTVrE5eza8rf+WNn99gdJfRdDi8Q57r350rj7uS+6bex7b0bdG2l398eZdhzLu/v5tpv3SJ0nQ+snO+1tikWpMsYUx234udJaUkccawM7Jdx2VHf675k4vfu5iZy2ZmObYqeRWrklfx/dLveezrx+hxdA+eav8UCXEJuXsTBeTxbx7n9im3syVtS6b2lPQUktYkMXfNXF7+8WU6NezEsA7DKFuybECVSpIkaX/hNGWSJElSPstuqrKxf4xlS+qWLO1v//p2lrazDz070wLnW9O2cubwM3l11qtZgpidpWakcvfnd3P9x9fvtt+evP3L25zz1jk5+vB/S9oWbpxwI7dNui3b47OWz+L4F47PNogJStUyVbnoiIsytX0x/wv+WvtXlr5LNi7h28XfZmrrcHiHTKN38sO6LeuytJUqUWqP5/Ub32+PQcwfq//gxJdOzDaI2VmYMK/OepWz3jgrU3hVWNzwyQ3cOOHGLEFMdt77/T3OHH4mKWkpBVCZJEmS9meOjJEkSZLyWZPqTWhUtRG/rvw12pa0LYmP/vwoy4iXEb9mnaJs5zDnlom38M3ibzK1xcXE0frg1tQuV5sFGxYw6a9JpIfTo8eHfjeUVge14tzDzs11/f+s+4crxl2RJfipnFCZdg3aUapEKT7951P+Wpc5uPj3V/+mWb1mmUYAJacmc97b55G0LSnLfQ6pdAhNazclIS6BxRsXM23hNNZvXZ/req845grWblnLN4u/4dslmUOT1ge15ogqR2Rq275/zQnX8OYvb0bbw4R55cdXePDMBzP1f3f2u1m+Ft2bdM91nbmxedtmJv49MUv7QRUP2uO526fIq1O+Di3qtSA2FMuvq34lFAoBkJ6RTqd3OmX5WsfHxtO2QVtqlK3BTyt+4uvFX2c6Pn3hdO769C6GtB4CQJuD21ChVAUWb1zMe7+/l6lvw8oNaXNwm+h+g0oN9vym98K7s9/liW+fyNJ+Sq1TOLLKkWzctpFP5n3CxpSN0WPfLfmO26fczqNnPZovNUmSJElgGCNJkiQViEsaX8LAKQMztY34dUSmMOaXFb/w26rfMvWpUKoCZx9ydnR/0YZFvPDDC5n61C5Xm897fJ7pg/lvFn9Di9daZFpM/e7P796rMGbw9MFZFmU/uvrRfHr5p1QsXRGA1PRULnn/EkbNHpWp372f35spjHnm+2dYtHFRpj6xoVieO+c5eh3TKxoQQGQE0Ks/vkql0pVyVe/dze6O3nvnMKZb427RtWV2dkrtUzi2xrGZRocM+2kY97W4j9iY2GjbzlOU1Shbg1YHtcpVjTm1NW0rv678ldsm35Zp3aHtdrXu0M6uOvYqnmr/FHGxcdG2Tds2ATDyt5HMXjU7U/9y8eWY2mMqTao3ibY9/s3j3Djhxkz9nvzuSW499VYqJ1SmW+NudGvcjc/nf54ljDnxwBN5vO3jOao1L+76LPN0fCVjSzK6y+hMX6dVm1dx6iun8ufaP6Ntz8x4hltPvZXqZavne42SJEnaPzlNmSRJklQALml8CSFCmdo++vMjklL+N0IkuynKLmx4IfEl4qP7H8z9gNSM1Ex97m1+b5YREifXOpnzDjsvU9us5bOynXZrd8LhMGP+GJOl/Ym2T0SDGIC42Diebv80JWNLZur3/dLvWbJxSXT/3dmZgwyAm0+5md7H9s4UxEBkCq6+J/TljLpn5KrmvLjmhGsy7S9NWson8z6J7i/ftDzLlF+XHnVpprAmrwZ9MYjQoBChQSFKP1iaE148gU//+TRLv/oV6nPZUZft8XqHHnAoT5/9dKYgBoiuk/L+7+9nOefmU27OFMQA3HDyDRxT/ZhMbVvStjDxr6wjdoIwe9Vs/lj9R6a2Lkd2yRJYVSlThRtPzhwqbU3bykdzP8r3GiVJkrT/MoyRJEmSCkDt8rU5ve7pmdq2pm3NFHSM/G1klvMuOSrzFGU7j/QA6DWuV/TD+x1f7/z2Tpa+O081tSfz189nVfKqTG2JJRM5vc7pWfpWKVOFE2qekKV9xtIZQGQ6rO3bO7r6+KtzVVN+6tqoa5aROC//+HJ0+73Z75ERzsh0/PImlxdIbTuqnFCZcV3HZQrqduWSxpdQImbXkyJ8v/T7LG07jsbaUXYjcb5fkvX8IOy8jg/A6z+/nu2z0W98vyx9c/tsSJIkSblhGCNJkiQVkEsbX5qlbftomG8Xf8vf6/7OdKxWuVo0q9ssU9uqzZmDkdxasWlFrvrvHMRsr2vnUSzb1S5fO0vbys0rAVizZU2mdWwgMo1U/Yr1c1VTfiodV5qeR/fM1Pbh3A+j72HnKcqOq3Ecjao2KrD64mPjueyoy/il7y85vu9R1Y7a7fHsfk9l932EyJR4O1uZvDJHdeS37H6v5saKzbl7NiRJkqTccM0YSZIkqYBceMSF/Ovjf7EtfVu0bdLfk1iTvIYRv47I0r9bo267DD321vZ1QnIqHA5naduXNe08dVth0Pf4vjz29WOEibz31IxUXv/pdS5vcjnTFkzL1Dc/RsWcdOBJnFzrZCDy9SlVohQVS1fkyCpH0rR200zTw+VE+fjyua6hMH5f8ltunw1JkiQpNwxjJEmSpAJSsXRF2h/SPtPUZGkZabzz2zu8MzvrlGKXHpV1JE3VMlWztHU+sjM1ytbIUQ0n1Top5wXv4n6LNiwiHA5nG8os2rBol9c4oPQBxIZiM42OSUlP4Z91/xSq0TEHVzqYtg3a8vG8j6NtL//4MmVLls1Ue1xMHF0bdd3n92/boC33Nr93n11vT+FZlTJVWLhhYaa2hRsWUqVMlSx9F23M5vubkPX3SBCy+73atHbTbKfOy06DSg32dUmSJElSlGGMJEmSVIAubXxppjAG4N4v7o1Og7Vd46qNaVytcZbzT6h5Aq/99FqmtuNrHM+tp966x3unZ6TneqH5ehXqUSWhSqYpoJK2JTF94fQsa+CsTl6d7fojx9c8HoDYmFiOq3kc3y35LtPx5394nodbPZyrunIiNpT1vaZnpGfTM6t/nfivTGHM76t/54FpD2Tq0/6Q9tkGFkXNCTVPyBLGjP9zPMfVPC5L3/F/js96/oE5CzvyW3ahS4VSFXi87eN7PDccDkdHQkmSJEn5wTVjJEmSpAJ0zqHnZJk2aucgBiKLrmfn3MPOzbIY+6AvBvHJvE+y7Z8RzuCbxd9w84SbOeml3I2Kgcioig6Hd8jSft0n17F+6/rofmp6Kv0+6pdpCjaIfEB+YLkDo/sXHXFRlmv956v/8PLMl7NMibYtfRsvzXyJL+Z/keu6AcqWLJulbfaq2Tk6t22DthxU8aBMbYs3Ls60371J972qq7C5oOEFWdoe/fpRfl7xc6a2J755gh+X/5iprXSJ0rQ5uE2+1pdTR1Y9ksMOOCxT2/g/xzN42mBS01OzPefPNX/yyJePcPjTh2cJpCRJkqR9yZExkiRJUgGKLxHPhUdcyMs/vrzLPiFCdGvcLdtjdcrX4cpjr+TZGc9G2zanbqbdm+04ssqRNK7WmANKH8CmbZuYv34+P6/4mXVb1wFQt3zdvap54GkDef3n19matjXaNmv5LA558hDaH9Ke+Nh4Pv3nU/5a91eWc3eebqvfCf14/JvHWZK0JNqWHk6n9we9GfLlEE6tcyoJJRJYumkp0xdOZ3XyakZ3Gb1XdR9ywCFZ2oZ+N5S/1v1FnfJ1iAnFEB8bz5DWQ7L0iwnF0Pf4vtw6KfsRR5VKV+LsQ8/eq7oKmy5HduHBaQ9mCqo2pGzgxBdPpN0h7ahRtgY/rfiJrxZ9leXca0+8lsoJlQuy3N26r8V9dHm3S6a22z+9nSe/e5JTap9C9TLV2Zq2lWWblvHLyl+yBGySJElSfjGMkSRJkgrYJY0v2W0Yc0bdM6hdvvYujz/a5lFmLpvJt0u+zdT+26rf+G3Vb/uszu3qV6zPK+e9wiXvX5JpKqfVyasZ/tPwXZ7Xv2l/2h/SPlNbQlwCYy8eS/PXmmdZMP3PtX/y59o/91ndzeo2IyEugeTU5GhbWkYaY+eMje6XiSuTbRgDcMUxV3D3Z3ezJW1LlmNdG3WlZGzJfVZrkGJjYnmv83uc8vIpmUY7paSnZJlSb0en1TmN+1ven/8F5kLnIzvz5cIvGfrd0EztyzYt4/3f3w+oKkmSJMlpyiRJkqQC17xec2qVq7XL45cedeluzy8dV5opl0+h9zG9iQnl7K/0cTFxtKzfMld17qhr46582O3DbBdJz1JfidL831n/t8uQ47iax/Fd7+84rkbWNUn2pcT4RB5o8cCeO+5CpdKVuLjRxdkeKy5TlG13eOXD+a73dxxb49g99g0RoufRPZlw6YRCGUg90e4Jnmj7BGXiyuT4nJNrnUy5+HL5WJUkSZL2d46MkSRJkgpYKBSia6OuPPLVI1mOxcdGpjHbkzIly/DieS9y22m3MWzWMKYtnMbcNXNZt2UdYcKUjy9P/Yr1aVy1MS3qtaBtg7YckHBAnupuf0h75l8/n9d/fp3xf47nx+U/sjp5NekZ6VQqXYmGVRpyZv0zufLYK/e4sH3DKg2ZcdUMJv01iXdnv8vXi79mSdISNqZspHx8eaqXrU6T6k046+Cz8hQi3XjKjTSo1IDnfniOGUtnsHbLWtIy0nJ8/r9O/Bevzno1c+2VGxaaRev3pUMOOIQZV87goz8/4t3Z7/LN4m9YtmkZyanJVChVgXoV6nFGnTO44pgrOLLqkUGXu1vXnXQdlx11Ga/99BpT/pnCzyt+Zk3yGlLSUyhbsiy1ytXiiCpHcHqd02nXoB0HVzo46JIlSZJUzIXCO6+SKUmSJEkCYN2WdVT9T9VMAc7gMwcz4LQBAVYlSZIkqahxmjJJkiRJ2oVHv340UxBTIqYElx11WYAVSZIkSSqKnKZMkiRJkv5r3tp5PPXdU2xL38bsVbP5YsEXmY5f0PACDix3YEDVSZIkSSqqDGMkSZIk6b8Wb1zME98+ke2x+Nh47mt+XwFXJEmSJKk4cJoySZIkSdqDECGePftZDqt8WNClSJIkSSqCHBkjSZIkSdkIEaJS6UqcUvsU+jftz+l1Tw+6JEmSJElFVCgcDoeDLkKSJEmSJEmSJKm4cmRMDmVkZLB06VISExMJhUJBlyNJkiRJkiRJkgIUDodJSkqiZs2axMTsflUYw5gcWrp0KbVr1w66DEmSJEmSJEmSVIgsWrSIWrVq7baPYUwOJSYmApEvarly5QKupnB56qmnSEpKIjExkX/9619BlyNpF1JTU5k4cSJt2rQhLi4u6HIk7YLPqlT4+ZxKRYPPqlQ0+KxKRYPPavY2btxI7dq1o/nB7hjG5ND2qcnKlStnGLOTUqVKkZqaSqlSpfzaSIVYamoqCQkJlCtXzj80pULMZ1Uq/HxOpaLBZ1UqGnxWpaLBZ3X3crK0ye4nMZMkSZIkSZIkSVKeGMZIkiRJkiRJkiTlI8MYSZIkSZIkSZKkfGQYI0mSJEmSJEmSlI8MYyRJkiRJkiRJkvKRYYwkSZIkSZIkSVI+MoyRJEmSJEmSJEnKR4YxkiRJkiRJkiRJ+cgwRpIkSZIkSZIkKR8ZxkiSJEmSJEmSJOUjwxhJkiRJkiRJkqR8VCLoAiRJkiRJkiQpCOFwmNTUVDIyMoIuRSrUUlNTKVGiBFu3biU9PT3ocvIkJiaGuLg4QqFQgd7XMEaSJEmSJEnSfiU5OZkNGzaQlJRU5D9YlgpCOBymevXqLFq0qMBDjPwQGxtLYmIi5cuXJyEhoUDuaRgjSZIkSZIkab+RlJTE4sWLiYuLo0KFCpQpU4aYmJhi8QGzlF8yMjLYtGkTZcuWJSam6K5+Eg6HycjIYPPmzWzcuJH169dTq1YtEhMT8/3ehjGSJEmSJEmS9gvJycksXryYcuXKUbNmTQMYKYcyMjLYtm0bpUqVKtJhzHZlypShSpUqLF26lMWLF1O3bt18HyFT9L9qkiRJkiRJkpQDGzZsIC4uziBGEqFQiJo1axIXF8eGDRvy/X6GMZIkSZIkSZKKvXA4TFJSEuXKlTOIkQREAply5cqRlJREOBzO13sZxkiSJEmSJEkq9lJTU0lPT6dMmTJBlyKpEElISCA9PZ3U1NR8vY9hjCRJkiRJkqRiLyMjA6BYrHchad+JjY0F/vczIr/4k0eSJEmSJEnSfsMpyiTtqKB+JhjGSJIkSZIkSZIk5SPDGEmSJEmSJEmSpHxkGCNJkiRJkiRJkpSPDGMkSZIkSZIkSZLykWGMJEmSJEmSJElSPjKMkSRJkiRJkiSpEGnevDmhUIhQKBR0KTlSr149QqEQ9erVC7qUQqtE0AVIkiRJkiRJkqTia9asWYwZMwaADh06cPTRRwdaTxAMYyRJkiRJkiRJUr6ZNWsWgwYNAiKjaAxjJEmSJEmSJEmScmH+/PlBl1DouWaMJEmSJEmSJElSPnJkjCRJkiRJklTIhMORV0ZG1u3i1JaaGmLmzBqkpIQo8d9PKrevV77juuX7Yjs2FqpUgaQkSEnJ2fchL2un7+25QdwzqHOLWr15OTe354XD/9tOT9+7e+7NfXd37o41KfcMYyRJkiRJUrETDkNKSiybNkGJEoXng2fb9s+2vbnG/qMEcGKB3KluXXjuucjXWYXDr79+S+/ep5Genkb58gfw5puzqFatVrZ9U1O30bPnycyZ8yMAAwc+zwUXXJWn+7/77rMMGdIPgF697uLqq+/b4znvvPM0jzzyLwCuvvp+evW6M9t+ixf/xejRL/L991NYtmw+mzZtoFy5ihx00JGcccb5dOx4JaVKJezyPps2/W/7xx93X9OcObMYO/YlZsz4jFWrlrBt21YqVqxKw4bH07JlJ846qysxMTmbJOvvv2czbtwrzJz5OcuWLSApaT2lSpWmZs36HHHECfTseS5nn302JUpkjhbq1avHggULqFu3bqYpy4YNG0bPnj0z9e3Zs2eWNoBwOMyvv/5K48aNAWjdujUTJ07cY83Tp0/n9NNPB6BTp068++67OXqvBc0wRpIkSZIkFSlJSbB0aebXkiU7t5UgJeWcoEuVAhUKRV4xMZl/LUxtkMH69euoWLEioVBMNIjaMZDaV9vVqkHJklCqVOT+2clLELa35wZxz6DO3fm8Jk1O4pprHmDo0AFs2LCGu+++hOef/5TY2Ngs/Z98sn80iDnzzAu58MLdBzE5qfGssy7mscduIDV1G5988gZXXz2IUCi023PHjx8OQCgUon37y7Icz8jI4Nln7+T11x8hPT0t07G1a1eydu1KZsz4jDfe+A//+c8YGjY8bs+F7kJ6ejr/93838c47TxLeqegVKxaxYsUiPv98NG+88R8efXQs1avX2eW1UlK28sgj1/LBB6+QsVNiuXlzEn/++TN//vkzY8e+zLBhw+jevfte1707jRo14vTTT2fatGlMnjyZv/76i4MPPni357zwwgvR7T59+uRLXfuCYYwkSZIkSSoUtmzJGrJk99rxfwvvWs7nZSlMH0zvTVthqKEwtRWGGgrDew/l/BEIVGpqOuPHT6d9+/bExeXv8tZbt8I//0D9+pFARoXD0Uf35/ffpzBp0iRmzpzKhx/ez7333pupz0cffcTbbz8BQN26dXn33RepUGFf3L0i5513Lu+99x5LlvzDli3/G2GRnblz5/Lbb98B0KxZM849t26m4+EwXH55d9544w0Aypcvz0UXdebEE0+kQoUKrFy5ko8/Hs/48eNZuXIx11zTgu++m8Ghhx6a5V6Jif/bPvbYrLWEw9CrV29GjhwGQIkSJejS5WKaN29BQkICs2fPZtiwV1iyZAlz587i6qub8v33M6latWqWsGnbtm20bXsW06ZNjV7r/PM7cMYZzalatSpbtmxhzpw/mDJlMj/8MCNL8LM7LVu2ZPTo0Xz66ac8+eSTAFx77bW0bNlyl+f07duXadOmEQ6HefHFF3n44Yd32XfdunWMGjUKgIMPPphWrVrluLaCZhgjSZIkSZLy1bZtsHz5rsOV7aNa1q/P+TXLlYOaNXf9qlIllZkzJ9KuXRtKlozb5YfVReUDa0kqrkKhEK+//jpNmjRhxYoVPPDAA7Rs2ZIzzjgDgKVLl9KjRw8gEhK89dZbVNg3SQwAl19+Oe+99x4Aw4cP320YM3z48Ezn7eyFF56PBjEtW7ZkxIgRVKlSJVOfa67px9ixY7noootISkqid+8rmD59+m5rzG4k1/vvv89rrw0DoEKFCkyYMIETT8w85d9tt93K+eefz2effcaSJUvo168Po0ePznKtW2+9LRrENGjQgLFjx3LEEUdk6pORkcHGjf1Zvnw5aWlpWa6xK3Xq1KFOnTqs3+EP+WOPPZYOHTrs8pxOnTpRtWpVVq5cybBhw7j//vuJi4vLtu/w4cPZunUrAFdeeSWhQvwHu2GMJEmSJEnaK+npsGLFnkeyrFqV82uWLg0HHrj7oKVGDShbdvfXSU2F339PIyEBdvH5jSTtUjgMyclBVxGshISCC6yrVavG8OHDadu2Lenp6VxyySX89NNPVKhQgcsuu4zVq1cDcO+999K0adN9eu927dpRpUoVVq1axahRo3jyyScplc3QqXA4HA1aEhISuPDCCzMdT0lJYdCgQQDUrl2bsWPHUnYXf1idf/759O/fnwcffJAvv/ySb7/9lpNOOilXdQ8ePDi6/eyzz2YJYgASExMZNWoUhx9+OKtXr2bMmDHMnj07U9CyePFinnnmGQDKli3Lxx9/TIMGDXZ530MPPTTH68/srZIlS9KrVy8GDx7MihUrGDNmDBdddFG2fbdPURYXF5ftOjSFSZEMY6ZOncojjzzCDz/8wLJlyxg9evRukzSAL774gptuuonffvuNmjVr0r9/f66++uqCKViSJEmSpCIkIwPWrNlzyLJ8ec4Xwo6L233Asv1VvryjVSQFLzl5z6FvcbdpE5QpU3D3a9OmDbfeeiv//ve/Wbx4MT179uSEE07g008/BaBFixYMHDhwn983Li6Orl27MnToUDZs2MC4cePo3Llzln5Tp05lwYIFAHTs2JHEHecRAyZOnMiyZcsAuOaaa3YZxGx3+eWX8+CDDwIwYcKEXIUxCxcuZMaMGQDUr1+fLl267LLvAQccwNVXX80DDzwAREbU7BjGjBw5km3btgGRkSW7C2IKUp8+fRgyZAgZGRm88MIL2YYx06dPZ/bs2UDke1K1atWCLjNXimQYs3nzZpo0aULPnj3p1KnTHvv/888/tG/fniuvvJI33niDL7/8kn79+lGlSpUcnS9JkiRJUnEQDsOGDXta+B6WLYuMLMmJmBioXv1/YcquRrVUqrTrBbMlSQJ44IEH+OKLL/j2228ZN24c48aNA6By5cq88cYb+TYi4/LLL2fo0KFAZNqr7MKYPU1RNnXq1Oh2SkoKY8aM2e09U3f4g3Z7oJBT33zzTXS7TZs2e5yaq23bttEwZsdzAaZNmxbd3tOAh4JUt25d2rVrx0cffcSUKVP466+/OPjggzP1ef7556Pbffr0KegSc61IhjHt2rWjXbt2Oe7/3HPPUadOHR5//HEAGjZsyIwZM/jPf/5jGCNJkiRJKhY2bdrzSJalS2HLlpxfs2rVPY9kqVoVYmPz731JUhASEiI/V/dnCQkFf8+4uDjefvttjjnmGDZs2BBtHzZsGDVr1sy3+x533HEceeSR/Pbbb0yYMIGVK1dmGmWxZcsW3n33XQBq1qyZ7SLx8+fPj27fc889ubr/2rVrc9V/+wgciEwbtieHHXZYdHvp0qWZji1atCi6vfM6MUHr168fH330EeFwmBdffJGHH344emzdunXR78khhxxCixYtgiozx4pkGJNbX3/9NW3atMnUdtZZZ/Hyyy+Tmpqa7eI/KSkppKSkRPc3btwIRBLL1Jz+96D9RDgcjv7q10YqvLY/nz6nUuHmsyoVfj6nKmhbt0ZGqixbFvrvqJXMvy5dGmLZMkhKyvncXhUrhqlRA2rWjPxao0b4v+FK+L9rsoSpVg1KltzztTIycj5VWUHyWZWKhoJ8VlNTUwmHw2RkZJCRgx9cpUvne0mFWjgceRW0SpUqccABB0TDmOrVq3P66afn6HuWF5dddhkDBgwgLS2Nt956i+uuuy56bPTo0dHPhy+55BKALPWsW7dur++9bdu23b6/nY9trwWgdOnSe/zaJOyQrCUlJWXqv+O1EhISdnmtHT8D3tP9sju+Y1tOn8E2bdpQr1495s+fz6uvvsqgQYOin+UPGzaMrVu3ApHp1cLhcLTG3MrIyIh+th2by/9hkpufXftFGLN8+XKqVauWqa1atWqkpaWxevVqatSokeWcwYMHRxdc2tHEiRMz/eYV0dAqJSWF8ePHB1yNpD2ZNGlS0CVIygGfVanw8zlVXqWlhVi3Lp5160qzdm2pbF/r1pUiKSkHich/lS6dSqVKW6OvihW3Ztrf3hYfv+sPQFavjrx++WVfvMvg+axKRUNBPKslSpSgevXqbNq0KbpGhgqfq666ir///ju6v3z5cvr06cOzzz6br/c977zzuP3228nIyGDYsGH06NEjeuzVV1+Nbnfs2DFTgLFdqVKlottTp06lcePGubr/ztdMS0vb5bEdBxesXbs223p2tGbNmuh2QkJCpv5ldlgYaNmyZRxwwAG7vVZSUlK27dvDlYyMjGzr2R6cbN/eU83bXX755dx3332sXLmSt99+OzqV2gsvvABAyZIlueCCC3J8vexs27aNLVu2MHXq1Exf95xITk7Ocd/9IowBssybtz0l29V8egMHDuSmm26K7m/cuJHatWvTpk0bypUrl3+FFkHz5s0jNTWV+Ph42rdvH3Q5knYhNTWVSZMm0bp162xHBEoqHHxWpcLP51R7kp4Oq1ZFRrNsH7US+fV/20uXRvqEwzkbzVKq1P9GrGQ3omX7r5G1hEv997V/81mVioaCfFa3bt3KokWLKFu2bKYPzlV4DBs2jFGjRgHQqFEjUlNTmTNnDiNGjODss8+mW7du+XbvcuXK0bJlSyZPnsxPP/3EokWLOPLII1mxYgWff/45AMceeywnnXRStufXq1cvuj1//nxOPfXUPNVTosT/Prrf+fPoHe+1cOHCPX5e/euvv0a3a9Wqlal/nTp1+Omnn4DIlGX169fP9hrhcJikpCQSExOz/Ux9+3o+MTEx2daz4zNXqlSpHH/G3q9fPx5++GG2bdvGG2+8weWXX860adP4448/ALjgggt2WXNObd26ldKlS3PGGWfk+mdDbkKg/SKMqV69OsuXL8/UtnLlSkqUKLHLpC8+Pp74+Pgs7XFxcf4lbifbH75QKOTXRioC/DkmFQ0+q1Lh53O6/wmHYe3a7Be83/G1fHkkkMmJEiWgRo1dL3q//VWhQojIP71yPhWZInxWpaKhIJ7V9PR0QqEQMTEx+bYQvPbe3Llzo1ODlS5dmpEjR7Jt2zZOPvlkUlJS6NevH02bNuWggw7Ktxp69OjB5MmTAXjzzTd5+OGHGTFiRHS0RPfu3Xf5e6dFixY8/fTTAIwZM4bLLrtsn9W18z2bNm0a3Z40aRKhUGiXgw4gMtvTdqecckqm6zVr1owPPvgAgHHjxtG8efNsr7F95Mv2Zyg39ULmcCkn19iuWrVqXHjhhbz11lt8+umn/P3337z00kvR41dffXWen+eYmJjoZ9u5/TmUm/77RRhzyimnRH9DbTdx4kSOP/54/0ImSZIkSfu5cBg2btzzwvdLl0JOZ7WJiYFq1XYfsNSsCZUrR/pKkrQ/S0lJ4eKLL2bz5s0APP7449HF5IcMGcINN9xAUlISXbt2Zfr06fn2mW7Hjh1JTEwkKSmJN998k4ceeojhw4cDkTCha9euuzy3Xbt2VK1alZUrVzJ69Gi+/PLLPI+O2ZU6depwwgkn8P333/PPP//wzjvv0KVLl2z7rlu3jueeew6IhCCdOnXKdLxLly7cfvvtbNu2jRdffJF+/frRoEGDfV5z2bJlo9vbv8851bdvX9566y3C4TD//ve/effddwE47LDDaNas2T6tMz8VyTBm06ZNzJs3L7r/zz//MGvWLCpVqkSdOnUYOHAgS5YsiT4oV199NU899RQ33XQTV155JV9//TUvv/wyb7/9dlBvQZIkSZJUADZv3j5dWObXzqNbcjHdN5Ur/y9M2dWIlqpVI6NeJEnSnvXv358ff/wRgE6dOnHVVVdFj11//fVMmjSJjz76iO+++44777yTIUOG5EsdCQkJdOrUiWHDhrF48WKGDh3KrFmzgEjYUqVKld2ee99993H11VcTDofp0KEDI0aM4Mwzz9zlOfPnz+fJJ5/ktttuo2rVqrmqdeDAgVxwwQVAJKw46KCDOOGEEzL12bRpE507d2bVqlUAdOjQgYYNG2bqU6tWLfr27csTTzzBpk2baNeuHePGjcvSb7s///yT1NRUGjVqlKt6d5xKbObMmbk697TTTqNx48b88ssvvPjii9H2Pn365Oo6QSuSfzWcMWMGLVq0iO5vX9ule/fuDBs2jGXLlrFw4cLo8fr16zN+/HhuvPFGnn76aWrWrMnQoUOzpICSJEmSpKIhJSX7kGXn14YNOb9mhQp7HslSvTpkM6O1JEnaSx988AFDhw4FoG7dupmmoNpu2LBhNGnShKVLl/LII4/QunVrWrVqlS/1bP+MGeC2227L1L4nffr0YebMmbzwwgusXr2aVq1accYZZ9C2bVvq1q1LXFwca9eu5ffff2f69On88MMPANx44425rrNjx4706NGDYcOGsW7dOpo2bUq3bt1o3rw5CQkJzJ49m1deeYXFixcDcOCBB0ZHyOxsyJAhfP/993z11VfMmzePo446io4dO9KsWTOqVq3K1q1bmTt3LpMnT+bbb7/llVdeyXUY07hxY6pVq8aKFSt44403qFy5MieffDIJCQnRPm3btt3l+X379qVfv37R/VKlSuXoe1KYFMkwpnnz5oTD4V0e3/6w7KhZs2a5TtwkSZIkSQUrLQ1WrNh1uLJ9RMuaNTm/ZkJC9iNYdmyrUSPST5IkFZwlS5bQs2dPAGJjY3nzzTepUKFCln6VK1fm9ddfp3Xr1mRkZHDZZZfx888/73akyt5q1qwZdevWZcGCBWz77/ykFStW5JxzzsnR+c8//zyHHnood999N8nJyUydOpWpU6fusn/lypVzvWj8di+99BKJiYk89dRTpKWlMXz48OhsUTtq0qQJY8eO3eXom/j4eCZPnkyfPn14/fXXSUtLY9SoUYwaNSrb/nuzRkuJEiV48MEH6d27N6mpqTzyyCNZ+uzuM/9LL72U2267jaSkJAAuvPBCKlWqlOs6glQkwxhJkiRJUtGSkQGrVu15JMuKFZE1XHIiPn7PI1lq1oTERNjNmraSJCkAGRkZXHrppaz57/+wuOeee3a7xkrLli0ZMGAADz30EMuXL6dHjx58+OGHu124fm+EQiEuu+wyHnjggWhbly5diM/F0Nibb76Z7t2788orrzB58mR+++236PusUKECDRo04IQTTqB169a0bt16r9fAiY2NZejQoVxxxRW88MILfP755yxevJht27ZRpUoVjjvuOC666CK6du26xwCldOnSDB8+nBtvvJFXX32Vzz77jMWLF5OUlETZsmWpX78+Rx99NJ07d+ass87aq3p79epF3bp1ee655/j+++9ZuXIlW7duzdG5iYmJnHzyyUyaNAkoelOUAYTCu4ubFLVx40bKly/Phg0bKFeuXNDlFCqPPfYYSUlJJCYmRqeMk1T4pKamMn78eNq3b59vC91JyjufVanw8znNLByGdev2HLIsWxYZ9ZITsbGRkSrZBSs7jmapWNGQRbvmsyoVDQX5rG7dupV//vmH+vXr7/VIBGl/lZGRwcaNGylXrtxejYzJqzVr1lCzZk22bdvGEUccwW+//bbPrp2Xnw25yQ0cGSNJkiRJylZS0q4XvN/xlZKSs+uFQlCt2p5HslSpAgH8G1+SJEmF1EsvvRSdNq5v374BV7N3DGMkSZIkaT+zZcueR7IsXQqbNuX8mgccsOeQpVo1cICCJEmScmPdunU89thjQGSat+7duwdc0d4xjJEkSZKkYmLbNli+fNeL3m9/rV+f82uWK5d1erCdX9Wrg7O9SJIkaV/54osvSE5OZsmSJQwdOpSVK1cCcNttt5GYmBhwdXvHMEaSJEmSCrn09MjC9nsaybJqVc6vWbr07gOWmjUj67aULZt/70uSJGlvJScnM3HixL0+v3Llypx22mn7sCLtS927d2fBggWZ2k455RRuvvnmgCrKO8MYSZIkSQpIRgasWbPnkGX58kjfnIiL2/WC9zu+ypWLrOEiSZJUFK1cuZKOHTvu9fnNmjXj888/33cFKV/Ex8dTv359unTpwi233EJcEZ7z1jBGkiRJkvaxcBg2bNjzwvfLlkFqas6uGRsbmQ5sT+uyHHCAIYskSZKKtvnz5wddwj5nGCNJkiRJuRAOw7JlZfjiixArV+46aNmyJefXrFo1+2Blx1EtVapEAhlJkiRBvXr1CIfDQZch5ZhhjCRJkiTl0Kefwm23xTJjRqsc9a9Uac8jWapVg5Il87lwSZIkSYEyjJEkSZKkPZg5EwYOhMgasTGUKJHOQQfFcOCBoV2GLDVqQOnSQVcuSZIkqTAwjJEkSZKkXZg3D+68E0aOjOzHxcFVV6VzwgmT6NbtzCK9gKgkSZKkghMTdAGSJEmSVNgsXw79+kHDhpEgJhSCSy6BP/6A//u/DCpUSAm6REmSJElFiCNjJEmSJOm/NmyARx6B//s/SE6OtLVrB4MHQ5Mmkf3U1ODqkyRJklQ0GcZIkiRJ2u9t3QrPPAMPPQRr1kTaTjoJhgyBZs2CrU2SJElS0WcYI0mSJGm/lZ4Ow4fDPffAokWRtsMPj4QyHTpEpieTJEmSpLwyjJEkSZK03wmHYdw4uP12mD070larFgwaBJdfDiX8l5IkSZKkfch/YkiSJEnar0ybBgMGwFdfRfYrVoyEMtdcA6VLB1ubJEmSpOLJMEaSJEnSfuGXX2DgQPjoo8h+6dJwww3Qvz9UqBBkZZIkSZKKO8MYSZIkScXa/Plw993wxhuR6cliY6F370hbzZpBVydJkiRpf2AYI0mSJKlYWrUKHngAnn0WUlMjbZ07w/33w6GHBlubJEmSpP2LYYwkSZKkYiUpCR57DP7zH9i0KdLWqhUMHgzHHx9sbZIkSZL2T4YxkiRJkoqFlBR44YXIyJdVqyJtxx0HDz8cCWMkSZIkKSgxQRcgSZIkSXmRkQFvvgmHHw7XXRcJYg45BN55B777ziBGkiRJRU/z5s0JhUKEQqGgS8mRevXqEQqFqFevXtClFFqOjJEkSZJUJIXD8PHHMHAg/PxzpK1GDbjnHrjiCoiLC7Y+SZIkSRGzZs1izJgxAHTo0IGjjz460HqCYBgjSZIkqcj55hu47TaYOjWyX758ZP+666BMmWBrkyRJkpTZrFmzGDRoEBAZRWMYI0mSJEmF2O+/w+23w3//Ux3x8XDttTBgABxwQKClSZIkSfut+fPnB11CoWcYI0mSJKnQW7QoMv3Ya69F1oiJiYEePeDee6F27aCrkyRJkqTdM4yRJEmSVGitWQODB8NTT0FKSqStY0d48EFo2DDY2iRJkiQpp2KCLkCSJEmSdrZ5Mzz0EBx0EDz6aCSIadYMvv4a3n/fIEaSJKmoS01NpWbNmoRCISpUqEBycvIez0lOTqZChQqEQiFq1KhBWlpanmp49tlnCYVChEIh7r777hyd8/TTT0fPeeCBB3bZ76+//mLAgAGccMIJVKlShZIlS1KtWjVatmzJE088kaP3m1OzZs3iX//6F0ceeSQVKlSgVKlS1KlThwsuuIA333yTjIyMHF9r9uzZ3HLLLRx//PFUqVKFuLg4ypUrxzHHHMP111/PBx98kO3XvV69eoRCIerVq5epfdiwYYRCIXr27Blt69mzZ/RruOML4Ndff43ut2nTJkc1T58+PXrOhRdemOP3WtAMYyRJkiQVGqmp8Nxz0KAB3HEHbNwITZrA+PHw2Wdw8slBVyhJkqR9IS4ujt69ewOwYcMGRo4cucdzRowYwYYNGwC44oorKFEibxM/XXzxxZQsWRKAN954g3A4vMdzhg8fDkAoFOKyyy7LcjwjI4Pbb7+dww8/nCFDhjBjxgxWr15NamoqK1eu5LPPPuOGG27gsMMO44cffshT/enp6Vx//fUce+yxPP3008yePZsNGzaQkpLCokWLGD16NJdeeinHHXccCxcu3O21tm7dypVXXknjxo159NFH+eGHH1i9ejVpaWkkJSXx888/M3z4cDp06MCbb76Zp7p3p1GjRpx++ukATJ48mb/++muP57zwwgvR7T59+uRbbXnlNGWSJEmSApeRAe++C3feCX/+GWmrXx/uvx+6do2sESNJkqTi5aqrruKhhx4iPT2d559/PtPoiew8//zzAMTExHDllVfm+f4VK1bk3HPP5b333uOff/5h+vTp0SAgO3PnzuW7774DoFmzZtStWzdLn+7du/PGG28AUL58eTp37syJJ55IhQoVWLlyJePHj2f8+PEsXryYFi1aMGPGDA499NC9qr93794MGzYMgBIlSnDxxRfTokULEhISmD17Nq+88gpLlixh1qxZNG3alJkzZ1K1atUs19m2bRtnnXUWU6dOjV6rQ4cONG/enKpVq7Jlyxb++OMPJk+ezIwZM3IUWm3XsmVLRo8ezaeffsqTTz4JwLXXXkvLli13eU7fvn2ZNm0a4XCYF198kYcffniXfdetW8eoUaMAOPjgg2nVqlWOaytohjGSJEmSAjVpEgwcCNv/Y2DVqnDXXXDVVfDf/6goSZKkYqhWrVqcc845jB07lm+//Zaff/6Zo446Ktu+P/30UzQIadOmTZbpsPbW5ZdfznvvvQdERr3sLozZPipm+3k7e/7556NBTMuWLRkxYgRVqlTJ1Kdfv36MHTuWiy66iKSkJK644gqmT5+e67rff//9aBBToUIFJkyYwIknnpipz6233sr555/PZ599xpIlS+jTpw+jR4/Ocq3bbrstGsQ0aNCAsWPHcsQRR2Tqk5GRQf/+/Vm+fHmupoerU6cOderUYf369dG2Y489lg4dOuzynE6dOlG1alVWrlzJsGHDuP/++4mLi8u27/Dhw9m6dSsAV155ZXS6s8LI/18mSZIkKRAzZkCrVtCmTSSIKVsWBg2CefPgX/8yiJEkSQEKhyOL2O3Pr1yMfsiLfv36Rbe3j3zJzo7H9uVUVO3atYsGJqNGjYp+sL+zcDgcDVoSEhKyrE2SkpLCoEGDAKhduzZjx47NEsRsd/7559O/f38AvvzyS7799ttc1z148ODo9rPPPpsliAFITExk1KhRVK5cGYAxY8Ywe/bsTH0WL17MM888A0DZsmX5+OOPswQxOzr00ENp1KhRruvNjZIlS9KrVy8AVqxYwZgxY3bZd/sUZXFxcXscWRU0wxhJkiRJBWruXOjcGU44AaZMgbg4uP56+PtvuPtuSEwMukJJkrTfS06O/E+R/fm1DxeY353WrVvToEEDAN58881sF7ZPTk6OrlNSs2ZNzjnnnH12/7i4OLp27QpE1q4ZN25ctv2mTp3KggULAOjYsSOJO/2ldeLEiSxbtgyAa665hrJly+72vjuOrJkwYUKual64cCEzZswAoH79+nTp0mWXfQ844ACuvvrq6P7777+f6fjIkSPZtm0bEBlZsv17EbQ+ffoQ89+5indcE2ZH06dPj4ZLHTt2zHYKtsLEMEaSJElSgVi6FK6+Go44AkaNglAILrssEs48/jjs4j8OSpIkqRgLhULRkS4bNmxgxIgRWfq8/fbbbNy4EYBevXpRosS+XX1jx2Bkx6nIdrSnKcq2T/MFkVEyY8aM2e3rp59+ivbfebTKnnzzzTfR7TZt2uxxaq62bdtmey7AtGnTotu7mzqsoNWtW5d27doBMGXKFP76668sffJrtFR+cc0YSZIkSflq/XoYMgSeeAK2bIm0nXMOPPgg7GJKcEmSpGAlJMCmTUFXEayEhAK71RVXXMFdd93F1q1beeGFF7jiiisyHd8+MiImJobevXvv8/sfd9xxHHnkkfz2229MmDCBlStXZhplsWXLFt59910gMjInu0Xi58+fH92+5557cnX/tWvX5qr/9hE4EJk2bE8OO+yw6PbSpUszHVu0aFF0e3fTkwWhX79+fPTRR4TDYV588UUefvjh6LF169ZFvyeHHHIILVq0CKrMHHNkjCRJkqR8sWULPPIIHHQQPPxwZL9pU5g6FT74wCBGkiQVYqEQlCmzf78KcCH0SpUq0blzZwC+/fbbTKNGfvrpJ7777jsgsr5LnTp18qWG7aNd0tLSePvttzMdGzt2bHRkzqWXXhqdPmtHOy5Qn1vbpwnLqaSkpOh2mTJl9th/xynTdjwXiL6vnfsVBm3btqVevXoAvPrqq6SmpkaPvfbaa9H1fa666qo9jg4qDAxjJEmSJO1TaWnw8stw6KHQvz+sWwdHHgljx8L06XD66UFXKEmSpMKmb9++0e0d1wgpqKmodgxZdp6qbE9TlEHmIGPWrFmEw+Ecvz7//PNc1brjejWbN2/eY/9NO4zy2nmtm3LlymXbrzCIiYmJfs9XrlzJmDFjosdefPFFAEqWLEmPHj0CqC73DGMkSZIk7RPhMIweDY0bQ+/esHgx1K4Nr74KP/0E551XoP/BUpIkSUXIySefzDHHHAPAG2+8QXJyMps3b+bNN98EoFatWrRv3z7f7l+zZk3OPPNMAGbOnMlvv/0GwIoVK5g0aRIAxx57LEceeWS259eqVSu6/euvv+ZbnQA1atSIbs+dO3eP/XfsU7NmzUzHdqw7t2vXFIRevXpRsmRJ4H/B3LRp06K1durUicqVKwdWX24YxkiSJEnKsy++iExBdsEF8McfUKkSPPoozJ0LPXpAbGzQFUqSJKmw2z46ZuPGjYwYMYIRI0ZEp9Hq3bs3sfn8l8ru3btHt19//XUA3nrrLdLS0rIc31nz5s2j2++//37+FPhfJ598cnR74sSJhMPh3fb/5JNPsj0X4Iwzzohu7zjyZF/bcWq3PdW7oypVqnDhhRcC8OmnnzJv3rxMI6fyc7TUvmYYI0mSJGmvzZoF7dpB8+bwzTeRdV7vvBP+/htuuglKlQq6QkmSJBUV3bp1o3z58kBkFMT2kRCxsbH06tUr3+/fsWPH6DReb775JhkZGdEpykqUKEHXrl13eW67du2oWrUqAKNHj+bLL7/Mtzrr1KnDCSecAMA///zDO++8s8u+69at47nnngMgFArRqVOnTMe7dOkSHXny4osvMm/evHypecdp3HIytdqOtod04XCYf//737z77rsAHHbYYTRr1mzfFZnPDGMkSZIk5drff8Mll8Axx8Ann0CJEtCvH/z1F9x/P/z339CSJElSjpUpUya6Jst3333H999/D8DZZ5+daTqt/JKQkBANKxYvXszQoUOZNWsWEAlbqlSpsttz77vvPiASGnTo0IEpU6bs9n7z58/n5ptvZuXKlbmudeDAgdHtvn37Rr9WO9q0aROdO3dm1apVAHTo0IGGDRtm6lOrVq1o2LFp0ybatWvH77//vsv7/vnnn3s1DVv9+vWj2zNnzszVuaeddhqNGzcGIoHR1q1bgaI1KgagRNAFSJIkSSo6VqyABx6A55+H1NRI28UXRwKYBg2CrU2SJElFX9++fXnyyScztRXkh+7du3dn2LBhANx2222Z2vekT58+zJw5kxdeeIHVq1fTqlUrzjjjDNq2bUvdunWJi4tj7dq1/P7770yfPp0ffvgBgBtvvDHXdXbs2JEePXowbNgw1q1bR9OmTenWrRvNmzcnISGB2bNn88orr7B48WIADjzwwOgImZ0NGTKE77//nq+++op58+Zx1FFH0bFjR5o1a0bVqlXZunUrc+fOZfLkyXz77be88sorNGrUKFf1Nm7cmGrVqrFixQreeOMNKleuzMknn0xCQkK0T9u2bXd5ft++fenXr190v1SpUjn6nhQmhjGSJEmS9mjjRvjPf+Cxx2D7rAJt2sDgwXDsscHWJkmSpOKjYcOGNGvWjC+++AKITMm1uw/p97VmzZpRt25dFixYwLZt2wCoWLEi55xzTo7Of/755zn00EO5++67SU5OZurUqUydOnWX/StXrkypvZzb96WXXiIxMZGnnnqKtLQ0hg8fHp1WbUdNmjRh7Nix0WnUdhYfH8/kyZPp06cPr7/+OmlpaYwaNYpRo0Zl23/H9V9yqkSJEjz44IP07t2b1NRUHnnkkSx9dreWzKWXXsptt91GUlISABdeeCGVKlXKdR1BcpoySZIkSbuUkgKPPw4HHxwZ/bJ5M5xwAkyZAhMmGMRIkiRp32vTpk10+8orr9yrD//3VigU4rLLLsvU1qVLF+Lj43N8jZtvvpkFCxYwZMgQWrduTc2aNYmPjyc+Pp5q1apx6qmncsMNN/DRRx+xdOlSKleuvFe1xsbGMnToUGbOnEnfvn1p2LAhiYmJxMfHU6tWLc4//3zeeOMNZs6cSd26dXd7rdKlSzN8+HBmzpzJtddeS6NGjahQoQKxsbGUL1+eo48+mh49ejB+/HguvfTSvaq3V69eTJo0iU6dOlGnTp1chVCJiYmcfPLJ0f2iNkUZODJGkiRJUjbS0+HNN+Huu2HBgkjboYfCQw/BBRdAKBRsfZIkSSq+3n//fSAymuKKK64o8Pvff//93H///Xm6RuXKlenfvz/9+/ffq/M///zzHPc9+uijeeaZZ/bqPjs75phjOOaYY7K0Z2RksHHjRsqVK5dtODZ//vwcXb9Vq1a0atUq13WtWbMmOlrqiCOO4LTTTsv1NYJmGCNJkiQpKhyGjz6CgQNh+7qcNWvCvfdCz55Qwn9BSJIkKR99++230bVUzj//fGrWrBlwRSoMXnrppei0cX379g24mr3jP6UkSZIkAfDllzBgAEyfHtmvUCGyf+21sMO6mpIkSVK+ueuuu6Lb119/fYCVqLBYt24djz32GAAVKlSge/fuAVe0dwxjJEmSpP3cr7/C7bfDBx9E9kuVguuuiwQxFSsGW5skSZKKt19++YUlS5awbt06RowYwaRJkwA466yzOP300wOuTkH54osvSE5OZsmSJQwdOpSVK1cCcNttt5GYmBhwdXvHMEaSJEnaTy1YAPfcA8OHR6Yni42FK66IrBNTq1bQ1UmSJGl/8Oijj/Laa69laqtcuTLPPffcbs9LTk5m4sSJe33fypUrF8l1R/YX3bt3Z8H2xSv/65RTTuHmm28OqKK8M4yRJEmS9jOrV8NDD8HTT8N/p12mUyd44AE4/PBga5MkSdL+KTY2llq1atGiRQvuvfde6tatu9v+K1eupGPHjnt9v2bNmvH555/v9fkqGPHx8dSvX58uXbpwyy23EBcXF3RJe80wRpIkSdpPbNoEjz8OjzwCGzdG2lq0gIcfhhNPDLQ0SZIk7aeGDRvGsGHDgi5Dhcz8+fODLmGfM4yRJEmSirlt2+DFF+H++2HFikjbMcdEQpjWrSEUCrY+SZIkKbfq1atHOBwOugwpxwxjJEmSpGIqIwNGjoQ774S//460HXxwZDqyzp0hJibY+iRJkiRpf2EYI0mSJBUz4TBMnAgDB8KPP0baqlWDu++G3r2hZMlg65MkSZKk/Y1hjCRJklSMfPcdDBgAn30W2U9MhP794YYboGzZQEuTJEmSpP2WYYwkSZJUDPzxR2Q6svfei+yXLAnXXAO33w6VKwdbmyRJkiTt7wxjJEmSpCJsyRK491549VVIT4+sA3P55TBoENSpE3R1kiRJkiQwjJEkSZKKpHXr4OGHYehQ2Lo10nbeefDQQ3DkkcHWJkmSVJiFw+GgS5BUiBTUzwTDGEmSJKkISU6OBDBDhsD69ZG2006LBDOnnhpoaZIkSYVaTEwMABkZGQFXIqkwSU9PB/73MyK/GMZIkiRJRUBaGrzySmT6saVLI22NGsHgwXD22RAKBVufJElSYRcXF0dsbCybN2+mTJkyQZcjqZBITk4mNjaWuLi4fL1P/kY9kiRJkvIkHIZ3341MPdanTySIqVsXhg+HWbPgnHMMYiRJknIiFAqRmJjIxo0bnapMEhCZomzjxo0kJiYSyud/WBnGSJIkSYXUp5/CSSfBRRfB3LlQuTI8/jjMmQOXXQaxsUFXKEmSVLSUL1+e1NRUli5daiAj7efC4TBLly4lNTWV8uXL5/v9nKZMkiRJKmRmzoSBA2HixMh+mTJw882RV7lywdYmSZJUlCUkJFCrVi0WL17Mli1bKFeuHAkJCcTGxub7/4qXirKMjAy2bdvG1q1b831tlfwUDodJT08nOTmZjRs3kpqaSq1atUhISMj3exvGSJIkSYXEvHlw550wcmRkPy4uMjXZnXdCtWrB1iZJklRcJCYmUrduXTZs2MD69etZs2ZN0CVJhV44HGbLli2ULl26WASXsbGxJCYmUr58+QIJYsAwRpIkSQrc8uVw333w4ouQlhZp69YN7r8fDjoo2NokSZKKo4SEBBISEqhevTqpqalkZGQEXZJUqKWmpjJ16lTOOOOMfF/oPr/FxMQQFxdX4KGSYYwkSZIUkA0b4JFH4P/+D5KTI23t2sFDD8HRRwdamiRJ0n4hFApRsmTJoMuQCr3Y2FjS0tIoVapUkQ9jgmIYI0mSJBWwrVvhmWciocv2WTFOOgmGDIFmzYKtTZIkSZK07xnGSJIkSQUkPR2GD4d77oFFiyJthx8eCWU6dIBiMPWyJEmSJCkbhjGSJElSPguHYdw4uP12mD070nbggZF1Yi6/HEr4t3JJkiRJKtb8Z58kSZKUj6ZNgwED4KuvIvsVK0ZCmWuugdKlg61NkiRJklQwDGMkSZKkfPDLLzBwIHz0UWS/dGm44Qbo3x8qVAiyMkmSJElSQTOMkSRJkvah+fPh7rvhjTci05PFxkLv3pG2mjWDrk6SJEmSFATDGEmSJGkfWLUKHngAnn0WUlMjbZ07w/33w6GHBlubJEmSJClYhjGSJElSHiQlwWOPwX/+A5s2RdpatYLBg+H444OtTZIkSZJUOBjGSJIkSXshJQVeeCEy8mXVqkjbccfBww9HwhhJkiRJkrYzjJEkSZJyISMD3n4b7rwzsj4MQIMG8OCDcOGFEBMTaHmSJEmSpELIMEaSJEnKgXAYPv4YBg6En3+OtFWvDvfcA716QVxcsPVJkiRJkgovwxhJkiRpD775Bm67DaZOjeyXLx/Zv+46KFMm2NokSZIkSYWfYYwkSZK0C7//DrffDmPGRPbj4+Haa2HAADjggEBLkyRJkiQVIYYxkiRJ0k4WLYpMP/baa5E1YmJioEcPuPdeqF076OokSZIkSUWNYYwkSZL0X2vWwODB8NRTkJISaevQAR58EI44ItDSJEmSJElFmGGMJEmS9nubN8MTT8C//w0bNkTamjWDhx+Gk08OtjZJkiRJUtFnGCNJkqT9VmoqvPwyDBoEy5dH2po0iYyOadsWQqFg65MkSZIkFQ+GMZIkSdrvZGTAu+/CnXfCn39G2urXh/vvh65dI2vESJIkSZK0rxjGSJIkab8yaRIMHAg//BDZr1IF7roL+vSBkiWDrU2SJEmSVDwZxkiSJGm/MGMGDBgAU6ZE9suWhVtugZtugsTEYGuTJEmSJBVvhjGSJEkq1ubOjUxHNmpUZD8uDvr1gzvuiIyKkSRJkiQpvxnGSJIkqVhauhTuuw9eegnS0yEUgksvjbTVqxd0dZIkSZKk/YlhjCRJkoqV9ethyBB44gnYsiXSds458OCDcNRRgZYmSZIkSdpPGcZIkiSpWNiyBZ56CgYPhnXrIm2nnBIJZk4/PdjaJEmSJEn7N8MYSZIkFWlpafDaa3DvvbB4caTtiCMiocy550amJ5MkSZIkKUiGMZIkSSqSwmEYMwZuvx3++CPSVrt2ZE2Yyy6D2NhAy5MkSZIkKcowRpIkSUXOF1/AgAHwzTeR/UqV4I47oF8/KFUq2NokSZIkSdqZYYwkSZKKjFmzYOBA+OSTyH5CAtx0E9xyC5QvH2hpkiRJkiTtkmGMJEmSCr2//4a77oK33orslygBV10VaatePdjaJEmSJEnaE8MYSZIkFVorVsADD8Dzz0NqaqTt4ovh/vuhQYNga5MkSZIkKacMYyRJklTobNwIjz4aeW3eHGlr0wYGD4Zjjw22NkmSJEmScsswRpIkSYVGSgo8+yw8+CCsXh1pO+EEePhhaNky2NokSZIkSdpbhjGSJEkKXHo6vPkm3H03LFgQaTv0UHjoIbjgAgiFgq1PkiRJkqS8MIyRJElSYMJh+OgjGDgQfv010lazJtx7L/TsCSX826okSZIkqRjwn7eSJEkKxJdfwoABMH16ZL9Chcj+tddCQkKgpUmSJEmStE8ZxkiSJKlA/for3H47fPBBZL9UKbjuukgQU7FisLVJkiRJkpQfDGMkSZJUIBYsgHvugeHDI9OTxcbCFVdE1ompVSvo6iRJkiRJyj+GMZIkScpXq1fDQw/B00/Dtm2Rtk6d4IEH4PDDg61NkiRJkqSCYBgjSZKkfLFpEzz+ODzyCGzcGGlr0QIefhhOPDHQ0iRJkiRJKlCGMZIkSdqntm2DF1+E+++HFSsibUcfHQlh2rSBUCjQ8iRJkiRJKnCGMZIkSdonMjJg5Ei48074++9I20EHRaYj69IFYmKCrU+SJEmSpKAYxkiSJClPwmGYOBEGDoQff4y0VasGd98NvXtDyZLB1idJkiRJUtAMYyRJkrTXvvsOBgyAzz6L7CcmQv/+cMMNULZsoKVJkiRJklRoGMZIkiQp1/74IzId2XvvRfZLloRrroHbb4fKlYOtTZIkSZKkwsYwRpIkSTm2ZAncey+8+iqkp0MoBJdfDoMGQd26QVcnSZIkSVLhZBgjSZKkPVq3Dh5+GIYOha1bI23nnQcPPgiNGgVbmyRJkiRJhZ1hjCRJknYpORmefDISxKxfH2k77bTI/qmnBlqaJEmSJElFhmGMJEmSskhLi0xFdu+9sHRppK1RIxg8GM4+OzI9mSRJkiRJyhnDGEmSJEWFw/Dee3DHHTB3bqStbl24/37o1g1iY4OtT5IkSZKkosgwRpIkSQB8+ikMGADffx/Zr1wZ7rwTrr4a4uODrU2SJEmSpKLMMEaSJGk/N3MmDBwIEydG9suUgZtvjrzKlQu2NkmSJEmSigPDGEmSpP3UvHmRkS8jR0b24+KgT59IW7VqwdYmSZIkSVJxYhgjSZK0n1m+HO67D158EdLSIm3dukXWhTnooGBrkyRJkiSpODKMkSRJ2k9s2ACPPAL/93+QnBxpa9cOHnoIjj460NIkSZIkSSrWDGMkSZKKua1b4ZlnIqHLmjWRtpNOgiFDoFmzYGuTJEmSJGl/YBgjSZJUTKWnw/DhcM89sGhRpO3wwyOhTIcOEAoFWp4kSZIkSfsNwxhJkqRiJhyGcePg9tth9uxI24EHwqBB0L07lPBvgJIkSZIkFSj/KS5JklSMTJsGAwbAV19F9itWjIQy11wDpUsHW5skSZIkSfsrwxhJkqRi4JdfYOBA+OijyH7p0nDDDdC/P1SoEGRlkiRJkiQpJugC9tYzzzxD/fr1KVWqFMcddxzTpk3bbf8333yTJk2akJCQQI0aNejZsydrtq9gK0mSVETNnw+XXw5NmkSCmNhY6NMH5s2LrA1jECNJkiRJUvCKZBgzcuRIbrjhBu644w5+/PFHTj/9dNq1a8fChQuz7T99+nQuv/xyevXqxW+//caoUaP4/vvv6d27dwFXLkmStG+sWgXXXw+HHgqvvx5ZJ+aiiyJrxDz3HNSsGXSFkiRJkiRpuyIZxjz22GP06tWL3r1707BhQx5//HFq167Ns88+m23/b775hnr16nHddddRv359TjvtNPr06cOMGTMKuHJJkqS8SUqCQYPgoINg6FBITYUzz4Tvv4d33omEM5IkSZIkqXApcmvGbNu2jR9++IEBAwZkam/Tpg1fbV+pdidNmzbljjvuYPz48bRr146VK1fy7rvvcvbZZ+/yPikpKaSkpET3N27cCEBqaiqpqan74J0UH+FwOPqrXxup8Nr+fPqcSoXbrp7VbdvgxRdjeOihGFatCgFw7LEZPPhgBmeeGf7vOQVbq7S/8s9UqWjwWZWKBp9VqWjwWc1ebr4eofD2T9KLiKVLl3LggQfy5Zdf0rRp02j7Qw89xGuvvcacOXOyPe/dd9+lZ8+ebN26lbS0NM477zzeffdd4uLisu1/7733MmjQoCztb731FgkJCfvmzRQTv/32G6mpqcTFxXHkkUcGXY4kScVKRgZMm1aLt946nBUrygBQo8YmLrnkd5o2XUpMkRznLEmSJElS0ZecnEy3bt3YsGED5cqV223fIjcyZrtQKJRpPxwOZ2nbbvbs2Vx33XXcfffdnHXWWSxbtoxbb72Vq6++mpdffjnbcwYOHMhNN90U3d+4cSO1a9emTZs2e/yi7m/mzZtHamoq8fHxtG/fPuhyJO1CamoqkyZNonXr1rsMoiUFb/uz2qpVa6ZMKck998Tyyy+Rv+NUrx7mzjsz6Nkznri4o4GjgyxV2m/5Z6pUNPisSkWDz6pUNPisZm/7jFo5UeTCmMqVKxMbG8vy5cszta9cuZJq1aple87gwYM59dRTufXWWwE46qijKFOmDKeffjoPPPAANWrUyHJOfHw88fHxWdrj4uL8zbaT7SFYKBTyayMVAf4ckwq/OXMq8uijpZg2LTLspVw5uO02uP76EGXKxAKxwRYoCfDPVKmo8FmVigafValo8FnNLDdfiyI3sUXJkiU57rjjmDRpUqb2SZMmZZq2bEfJycnE7DSHR2xs5EOMIjZLmyRJKsaWL4cLL4zlttvOYNq0GOLj4ZZb4O+/4fbboUyZoCuUJEmSJEl7o8iNjAG46aabuOyyyzj++OM55ZRTeOGFF1i4cCFXX301EJlibMmSJQwfPhyAc889lyuvvJJnn302Ok3ZDTfcwIknnkjNmjWDfCuSJEkArF4NZ54Js2fHEBMT5vLLw9x3Xwy1awddmSRJkiRJyqsiGcZ06dKFNWvWcN9997Fs2TIaNWrE+PHjqVu3LgDLli1j4cKF0f49evQgKSmJp556iptvvpkKFSrQsmVLhgwZEtRbkCRJitqwAc46C2bPhgMPDNO//2f07Xs6cXFFbhCzJEmSJEnKRpEMYwD69etHv379sj02bNiwLG3XXnst1157bT5XJUmSlDubN8PZZ8PMmVClCnz8cRp//50UdFmSJEmSJGkf8r9bSpIkBWTrVujQAb78EipUgEmT4PDDg65KkiRJkiTta4YxkiRJAUhNhc6dYfJkKFsWPv4YmjQJuipJkiRJkpQfDGMkSZIKWHo6XH45fPABlCoV+fXkk4OuSpIkSZIk5RfDGEmSpAKUkQF9+sCIERAXB++9B82bB12VJEmSJEnKT4YxkiRJBSQchptugpdfhpgYeOstaN8+6KokSZIkSVJ+M4yRJEkqIHffDU88Edl+5RW48MJg65EkSZIkSQXDMEaSJKkADBkCDzwQ2X76aejePdh6JEmSJElSwTGMkSRJymdPPw0DBkS2hwyBfv2CrUeSJEmSJBUswxhJkqR89Npr8K9/RbbvvBP69w+2HkmSJEmSVPAMYyRJkvLJqFFwxRWR7RtugPvuC7QcSZIkSZIUEMMYSZKkfDB+PHTrBhkZ0Ls3PPYYhEJBVyVJkiRJkoJgGCNJkrSPffYZdOoEaWnQtSs895xBjCRJkiRJ+zPDGEmSpH3om2/g3HNh61Y477zImjGxsUFXJUmSJEmSgmQYI0mStI/MmgXt2sHmzdCqFYwcCXFxQVclSZIkSZKCZhgjSZK0D/zxB7RpA+vXw6mnwpgxUKpU0FVJkiRJkqTCwDBGkiQpj/75JzISZtUqOPZY+OgjKFMm6KokSZIkSVJhYRgjSZKUB0uWwJlnRn494giYMAHKlw+6KkmSJEmSVJgYxkiSJO2lVasiI2L++QcOPhgmT4bKlYOuSpIkSZIkFTaGMZIkSXth/frIGjF//AG1a8OUKVCjRtBVSZIkSZKkwsgwRpIkKZc2bYJ27WDWLKhWLTIipm7doKuSJEmSJEmFlWGMJElSLmzZAuedB998AxUrwqRJcOihQVclSZIkSZIKM8MYSZKkHNq2DS66CD77DBITYcIEaNw46KokSZIkSVJhZxgjSZKUA+npcNll8NFHULo0fPghnHBC0FVJkiRJkqSiwDBGkiRpDzIyoHdveOcdiIuD0aPhjDOCrkqSJEmSJBUVhjGSJEm7EQ7D9dfDsGEQGwsjR8JZZwVdlSRJkiRJKkoMYyRJknbjjjvgqacgFIoEMh07Bl2RJEmSJEkqagxjJEmSduGhh2Dw4Mj2s8/CpZcGW48kSZIkSSqaDGMkSZKyMXRoZFQMwH/+A336BFuPJEmSJEkqugxjJEmSdvLKK5F1YgDuuQduvjnYeiRJkiRJUtFmGCNJkrSDkSPhyisj2zfdFAljJEmSJEmS8sIwRpIk6b8++CCyLkxGRmRasv/8B0KhoKuSJEmSJElFnWGMJEkSMGUKXHQRpKXBJZfAM88YxEiSJEmSpH3DMEaSJO33vvoKzj8fUlKgQwcYNgxi/FuSJEmSJEnaR/yYQZIk7ddmzoT27WHzZmjTBkaMgBIlgq5KkiRJkiQVJ4YxkiRpvzV7Npx1FmzYAKefDqNHQ3x80FVJkiRJkqTixjBGkiTtl/76C1q1gtWr4fjj4cMPISEh6KokSZIkSVJxZBgjSZL2O4sXw5lnwrJl0KgRfPIJlCsXdFWSJEmSJKm4MoyRJEn7lZUrIyNiFiyAQw6BSZPggAOCrkqSJEmSJBVnhjGSJGm/sXYttG4Nc+ZAnToweTJUrx50VZIkSZIkqbgzjJEkSfuFpCRo1w5+/jkSwEyeHAlkJEmSJEmS8pthjCRJKva2bIHzzoPvvoNKlSJTkx1ySNBVSZIkSZKk/YVhjCRJKta2bYNOneDzzyExESZMgEaNgq5KkiRJkiTtTwxjJElSsZWWBt26wccfQ+nSMH48HH980FVJkiRJkqT9jWGMJEkqljIyoFcveO89KFkSxo6F004LuipJkiRJkrQ/MoyRJEnFTjgM114Lw4dDbCy88w60bh10VZIkSZIkaX9lGCNJkoqVcBgGDIBnnoFQKBLInH9+0FVJkiRJkqT9mWGMJEkqVh58EP7978j2889H1oyRJEmSJEkKkmGMJEkqNh5/HO66K7L92GNw5ZWBliNJkiRJkgQYxkiSpGLipZfgxhsj2/fd979tSZIkSZKkoBnGSJKkIu/tt+GqqyLbt94Kd94ZbD2SJEmSJEk7MoyRJElF2tixcNllEA5D374wZAiEQkFXJUmSJEmS9D+GMZIkqciaNAk6d4b09Egg89RTBjGSJEmSJKnwMYyRJElF0vTp0KEDbNsGnTrBK69AjH+zkSRJkiRJhZAfWUiSpCLnhx/g7LMhORnatoW33oISJYKuSpIkSZIkKXuGMZIkqUj57Tc46yzYuBGaNYP33oOSJYOuSpIkSZIkadcMYyRJUpExbx60agVr1sCJJ8IHH0BCQtBVSZIkSZIk7Z5hjCRJKhIWLoQzz4Tly+Goo+DjjyExMeiqJEmSJEmS9swwRpIkFXrLl0dGxCxcCIceChMnQqVKQVclSZIkSZKUM4YxkiSpUFu7Ftq0gT//hLp1YfJkqFYt6KokSZIkSZJyzjBGkiQVWhs3Qtu28MsvUKMGTJkCtWsHXZUkSZIkSVLuGMZIkqRCKTkZzjkHvv8eKleOjIg5+OCgq5IkSZIkSco9wxhJklTopKTABRfAtGlQrhxMmABHHBF0VZIkSZIkSXvHMEaSJBUqaWnQtWskgElIgI8/hmOPDboqSZIkSZKkvWcYI0mSCo2MDOjZE0aPhvh4GDcOmjYNuipJkiRJkqS8MYyRJEmFQjgM/frBG29AiRIwahSceWbQVUmSJEmSJOWdYYwkSQpcOAy33grPPw+hUCSQOffcoKuSJEmSJEnaNwxjJElS4O67Dx59NLL90kvQpUuw9UiSJEmSJO1LhjGSJClQjz4K994b2X7iCbjiikDLkSRJkiRJ2ucMYyRJUmCefx5uuSWy/eCDcN11wdYjSZIkSZKUHwxjJElSIN54A/r2jWwPGAC33x5sPZIkSZIkSfnFMEaSJBW40aOhRw8Ih+Ff/4KHHgq6IkmSJEmSpPxjGCNJkgrUhAnQpQukp0cCmSeegFAo6KokSZIkSZLyj2GMJEkqMFOnQseOkJoKF10EL70EMf5tRJIkSZIkFXN+/CFJkgrE99/DOefAli1w9tmRNWNiY4OuSpIkSZIkKf8ZxkiSpHz3yy9w1lmQlAQtWsCoUVCyZNBVSZIkSZIkFQzDGEmSlK/mzoXWrWHdOjj5ZBg3DkqXDroqSZIkSZKkgmMYI0mS8s2CBdCqFaxYAUcfDePHQ9myQVclSZIkSZJUsAxjJElSvli2DM48ExYtgsMPhwkToGLFoKuSJEmSJEkqeIYxkiRpn1u9OjI12V9/Qf36MHkyVK0adFWSJEmSJEnBMIyRJEn71IYN0LYt/PYb1KwJU6bAgQcGXZUkSZIkSVJwDGMkSdI+s3kznH02/PADVKkSCWLq1w+6KkmSJEmSpGAZxkiSpH1i61bo2BG+/BIqVICJEyNrxUiSJEmSJO3vDGMkSVKepabCxRfDpElQpgx8/DEcfXTQVUmSJEmSJBUOhjGSJClP0tOhe3cYOxZKlYIPPoCTTw66KkmSJEmSpMLDMEaSJO21cBiuvhrefhtKlIB334UWLYKuSpIkSZIkqXAxjJEkSXslHIabboKXXoKYGHjrLTj77KCrkiRJkiRJKnwMYyRJ0l655x54/PHI9ssvw0UXBVqOJEmSJElSoWUYI0mScu2RR+D++yPbTz0FPXoEWo4kSZIkSVKhZhgjSZJy5ZlnoH//yPbgwXDNNcHWI0mSJEmSVNgZxkiSpBwbPvx/4csdd8CAAcHWI0mSJEmSVBQYxkiSpBx57z3o2TOyfd11/5umTJIkSZIkSbtnGCNJkvbo44+ha1fIyIArroD/+z8IhYKuSpIkSZIkqWgwjJEkSbv1+edwwQWQmgpdusALL0CMf4OQJEmSJEnKsRL74iILFizg66+/ZunSpaxcuZL169dToUIFqlSpQs2aNTnllFOoV6/evriVJEkqQN9+C+eeC1u3Rn59/XWIjQ26KkmSJEmSpKJlr8KYcDjMpEmTGDFiBJ9++imLFi3a4zm1atWiZcuWXHzxxbRp04aQc5tIklSo/fQTtG0LmzbBmWfCO+9AXFzQVUmSJEmSJBU9uZpkZMuWLTz++OMcfPDBtGvXjtdee42FCxcSDof3+Fq0aBHDhw+nffv2HHTQQfzf//0fW7Zsya/3JUmS8mDOHGjdGtavh6ZNYcwYKFUq6KokSZIkSZKKphyFMRkZGTz99NMcdNBB3HzzzcyfPz8asoRCoRy/tp+zYMECbrnlFurXr8/TTz9NRkZGfr9PSZKUQ/PnQ6tWsGoVHHMMfPQRlC0bdFWSJEmSJElFV46mKWvSpAmzZ88mHA4DZJpibHtbTux83sqVK7nuuut47rnn+OWXX3J8HUmSlD+WLo1MSbZ4MTRsCBMmQIUKQVclSZIkSZJUtOUojPntt9+io1vgfwHMoYceysknn8yJJ57IMcccQ5UqVTjggAMoV64cGzZsYO3ataxcuZIff/yRb7/9lm+//ZY///wTINO1Zs+enR/vTZIk5cKqVZERMX//DQcdBJMnQ5UqQVclSZIkSZJU9OUojNkuHA5z6KGH0qVLFy6++GIaNmy4y76VKlWiUqVKNGjQgKZNm3LNNdcAMHv2bN566y3eeecd5s2bl7fqJUnSPrF+PZx1Fvz+O9SqBVOmQM2aQVclSZIkSZJUPORozRiA0047jfHjx/PHH38waNCg3QYxu3PEEUfwwAMPMHfuXD788ENOPfXUvbqOJEnaNzZtgrPPhh9/hKpVIyNi6tULuipJkiRJkqTiI0cjY6ZNm5YvoUn79u1p3749X3311T6/tiRJ2rOtW+H88+Grr6BiRZg0CQ47LOiqJEmSJEmSipccjYzJ79ErTZs2zdfrS5KkrFJToXNn+PRTKFsWPvkEjjoq6KokSZIkSZKKnxxPUyZJkoqP9HS47DL44AMoVQo+/BBOPDHoqiRJkiRJkoonwxhJkvYzGRlw1VUwciTExcH770OzZkFXJUmSJEmSVHzlaxjz999/07dvX4499liOPPJIOnbsyKRJk/LzlpIkaTfCYbjxRnjlFYiJgbffhnbtgq5KkiRJkiSpeCuRl5PnzJnDueeeG93v2LEjQ4YMAeCPP/6gadOmbNiwgXA4DMDvv//OuHHjeOyxx7j++uvzcmtJkrQX7roLhg6NbL/6KnTqFGw9kiRJkiRJ+4M8jYz59NNPmTdvHvPmzeOvv/7i1FNPjR67/fbbWb9+PeFwmFAoRCgUAiAcDnPbbbexYMGCvFUuSZJy5eGH4cEHI9vPPAOXXx5sPZIkSZIkSfuLPIUx33//fXQ7NjaWli1bArBx40Y+/PDDTCEMEN1OTU3l1VdfzcutJUlSLjz1FAwcGNn+97+hb99g65EkSZIkSdqf5CmM+f3334FIyHLEEUdQtmxZAL766ivS0tKi/erVq0eVKlWi05UBfPHFF3m5tSRJyqFhw+DaayPbd90Ft94aaDmSJEmSJEn7nTyFMStXroxuN2zYMLr9yy+/RLfr16/PnDlzmD17NpUrVyYUChEOh5k7d25ebi1JknJg1Cjo1SuyfeONMGhQsPVIkiRJkiTtj/IUxqxevTo69dgBBxwQbZ8zZ050+8wzz6REiRJUqlSJli1bRkfHrFu3Li+3liRJe/DRR9CtG2RkwJVXwqOPwg6zh0qSJEmSJKmA5CmM2bJlS3Q7NTU1ur1jGLPjiJkqVapEtzMyMvJya0mStBuffgqdOkFaWiSQefZZgxhJkiRJkqSg5CmM2b5GDMDs2bMBSEtL49dff422N2jQILqdkpIS3a5cuXJebi1Jknbh66/hvPMgJQXOPz+yZkxsbNBVSZIkSZIk7b9K5OXkevXq8dNPPxEOh/nqq6+47bbbWLlyJRs2bIj2ady4cXR7+fLlAIRCIcMYSZLywY8/Qrt2sHkztG4NI0dCXFzQVUmSJEmSJO3f8hTGnHjiicyaNYtQKEQ4HOY///kPQHS/Tp061K1bN9p/9uzZ0TVmatWqlZdbS5Kknfz+O7RpAxs2wGmnwejREB8fdFWSJEmSJEnK0zRll156aXR7ewCz/RUKhTIdX7x4MX///Xd0/9hjj83LrSVJ0g7+/htatYLVq+G44+DDD6FMmaCrkiRJkiRJEuQxjDnttNPo1atXpgBmu4MPPpj+/ftH98eMGQNAOBwG4IwzzsjLrSVJ0n8tXhwJYpYuhSOPhAkToHz5oKuSJEmSJEnSdnmapgzgxRdfpGnTprz11lssXLiQxMREzjzzTPr3709iYmK0X1JSEpdccgkQGUVjGCNJUt6tXBkJYv75Bxo0gEmT4IADgq5KkiRJkiRJO8pzGAPQs2dPevbsuds+AwcO3Be3kiRJ/7VuXWSNmDlzoHZtmDwZatQIuipJkiRJkiTtLMfTlF111VV8+OGHbN26NT/rkSRJOZCUBO3bw08/QbVqMGUK1K0bdFWSJEmSJEnKTo7DmJdeeonzzz+fypUrc/755/Pyyy+zYsWK/KxNkiRlY8sWOO88+OYbqFQpMjXZIYcEXZUkSZIkSZJ2JVfTlIXDYZKTk/nwww/58MMPCYVCHH/88Zx33nmcd955NGrUKL/qlCRJwLZtcOGF8PnnkJgIEyZA48ZBVyVJkiRJkqTdyfHImBdffJHzzjuPhIQEwuEw4XCYjIwMvv/+e+666y6aNGnCQQcdxPXXX8+UKVNIT0/Pz7olSdrvpKXBpZfC+PFQujR89BEcf3zQVUmSJEmSJGlPchzG9OrVizFjxrB69WrGjRvHlVdeSY0aNaLBTDgcZsGCBTz11FO0adOGypUr07VrV95++23Wr1+fj29BkqTiLyMDeveGUaOgZEkYPRpOPz3oqiRJkiRJkpQTuZqmDKBUqVKcc845nHPOOQB8//33jBs3jnHjxvHLL79E+23YsIF33nmHd955h9jYWE477bTodGYHHXTQvnsHkiQVc+EwXHcdvPYaxMbCyJFw1llBVyVJkiRJkqScyvHImF054YQTuP/++/npp5+YP38+Q4cOpVWrVsTFxUVHzKSlpfHFF19w8803c8ghh9CoUSMGDhzI119/vdf3feaZZ6hfvz6lSpXiuOOOY9q0abvtn5KSwh133EHdunWJj4/n4IMP5pVXXtnr+0uSVBDCYRg4EJ5+GkKhSCDToUPQVUmSJEmSJCk38hzG7KhOnTr861//YuLEiaxevZoRI0ZwySWXUKlSpUzTmf3+++/8+9//5rTTTqN69eqMHDkyV/cZOXIkN9xwA3fccQc//vgjp59+Ou3atWPhwoW7PKdz585MmTKFl19+mTlz5vD2229z+OGH5/UtS5KUrx56CIYMiWw/9xxcckmw9UiSJEmSJCn3cj1NWU4lJibSuXNnOnfuTEZGBtOmTWPcuHF88MEHzJs3L9pv1apVzJkzJ1fXfuyxx+jVqxe9e/cG4PHHH2fChAk8++yzDB48OEv/Tz75hC+++IK///6bSpUqAVCvXr29f3OSJBWAJ56AO++MbD/6KFx1VbD1SJIkSZIkae/kWxizo5iYGJo1a0azZs149NFH+eOPP6LrzHzzzTe5uta2bdv44YcfGDBgQKb2Nm3a8NVXX2V7zrhx4zj++OP597//zeuvv06ZMmU477zzuP/++yldunS256SkpJCSkhLd37hxIwCpqamkpqbmqubiLhwOR3/1ayMVXtufT5/TouHVV0PccEPkj+m77krn2msz8Fu3f/BZlQo/n1OpaPBZlYoGn1WpaPBZzV5uvh4FEsbs7PDDD+fwww+nf//+rF69mnXr1uX43NWrV5Oenk61atUytVerVo3ly5dne87ff//N9OnTKVWqFKNHj2b16tX069ePtWvX7nLdmMGDBzNo0KAs7RMnTiQhISHH9e4PtodWKSkpjB8/PuBqJO3JpEmTgi5BezBt2oE89thxAHTo8CfHHjsbf7zuf3xWpcLP51QqGnxWpaLBZ1UqGnxWM0tOTs5x30DCmB1VrlyZypUr5/q8UCiUaT8cDmdp2y4jI4NQKMSbb75J+fLlgchUZxdeeCFPP/10tqNjBg4cyE033RTd37hxI7Vr16ZNmzaUK1cu1/UWZ/PmzSM1NZX4+Hjat28fdDmSdiE1NZVJkybRunVr4uLigi5Hu/DhhyGeeCKWcDjEVVel8+ST9QiF6gVdlgqQz6pU+PmcSkWDz6pUNPisSkWDz2r2ts+olRP7LIzJyMjg119/Zf78+WzcuJGMjIw9nnP55Zfn+j6VK1cmNjY2yyiYlStXZhkts12NGjU48MADo0EMQMOGDQmHwyxevJhDDjkkyznx8fHEx8dnaY+Li/M32062h2ChUMivjVQE+HOs8Jo8Gbp2hbQ0uPRSePbZWGJiYoMuSwHxWZUKP59TqWjwWZWKBp9VqWjwWc0sN1+LPIcx27Zt44EHHuC5555jzZo1uTp3b8KYkiVLctxxxzFp0iQ6duwYbZ80aRLnn39+tueceuqpjBo1ik2bNlG2bFkA5s6dS0xMDLVq1cp1DZIk7Wtffgnnnw8pKdCxI7z6KsTEBF2VJEmSJEmS9oU8fcyzbds22rRpw4MPPsjq1asJh8M5fuXFTTfdxEsvvcQrr7zC77//zo033sjChQu5+uqrgcgUYzsGPd26deOAAw6gZ8+ezJ49m6lTp3LrrbdyxRVXZDtFmSRJBWnmTGjfHpKToW1bePttKBH4RKKSJEmSJEnaV/L0Uc8TTzzB1KlTCYVCu1yvJTt5DWO6dOnCmjVruO+++1i2bBmNGjVi/Pjx1K1bF4Bly5axcOHCaP+yZcsyadIkrr32Wo4//ngOOOAAOnfuzAMPPJCnOiRJyqvffoM2bWDjRjjjDHjvPchmlkxJkiRJkiQVYXkKY95+++0sbXkNWnKqX79+9OvXL9tjw4YNy9J2+OGHM2nSpHyuSpKknPvrL2jdGtasgRNOgA8+gISEoKuSJEmSJEnSvpanMGbu3LmEQqFoAFOtWjXatWtHjRo1KFmy5D4pUJKk4mjRIjjzTFi2DBo3hk8+gXLlgq5KkiRJkiRJ+SFPYUx8fDxbtmwB4JBDDmHGjBkkJibuk8IkSSquVqyAVq1gwQI45BCYNAkqVQq6KkmSJEmSJOWXmLyc3KhRI8LhMKFQiBYtWhjESJK0B2vXRqYmmzsX6taFKVOgWrWgq5IkSZIkSVJ+ylMY06dPn+j2nDlz8lyMJEnFWVIStGsHv/wC1avD5MlQu3bQVUmSJEmSJCm/5SmM6datGx07diQcDjN16lQefPBBMjIy9lVtkiQVG8nJcM458N13cMABkSCmQYOgq5IkSZIkSVJByNOaMQBvv/02V199NcOGDePuu+/m2WefpUWLFtSuXZtSpUrt9ty77747r7eXJKnQS0mBTp1g6lQoVw4mTIAjjwy6KkmSJEmSJBWUPIcxq1evZuXKlQCEw2GWLl3KW2+9laNzDWMkScVdWhp06waffAIJCTB+PBx3XNBVSZIkSZIkqSDlKYxZv349rVq1Ys6cOYRCoWh7OBze47k79pckqTjKyIArroD334eSJWHsWDj11KCrkiRJkiRJUkHLUxjz2GOP8ccffxAKhQiHw9GAZU9BS07CGkmSirJwGK65Bl5/HWJjYdQoaNUq6KokSZIkSZIUhDyFMaNGjcoUwBiySJIUCWJuuw2eew5CoUggc955QVclSZIkSZKkoOQpjFmwYAHwv5Eup5xyCq1bt6Z69eqUKlXKqcgkSfulBx6ARx6JbL/wAnTtGmw9kiRJkiRJClaewpiKFSuyfPlyQqEQJ554ItOnTzeAkSTt1/7v/+Duu/+33bt3sPVIkiRJkiQpeDF5Obl58+bRUTFHH320QYwkab/24otw002R7fvvhxtuCLQcSZIkSZIkFRJ5CmNuueUW4uLiAPjiiy9IT0/fJ0VJklTUvPUW9OkT2e7fH+64I9h6JEmSJEmSVHjkKYw55phjeOqppwiFQsyZM4fzzz+fP/74Y1/VJklSkTBmDFx+OYTD0K8fPPwwOFhUkiRJkiRJ2+VpzZiWLVsCUL58edatW8fHH3/Mxx9/TM2aNalduzalSpXa5bmhUIgpU6bk5faSJAVu0iTo0gXS06F7d3jySYMYSZIkSZIkZZanMObzzz+PrhMTCoWi68csWbKEpUuX7vK8cDjs+jKSpCJv2jQ4/3zYtg06dYKXXoKYPI05lSRJkiRJUnGUpzBmu+0hzI4By/a2nRnCSJKKgxkz4OyzYcsWaNcusmZMiX3yp6okSZIkSZKKm33ysVF2AYuhiySpuPr1VzjrLEhKgubN4b33oGTJoKuSJEmSJElSYZXnMGZXI2AkSSqO/vwTWreGtWvhpJNg3DgoXTroqiRJkiRJklSY5SmM+eeff/ZVHZIkFXoLF8KZZ8Ly5dCkCXz8MSQmBl2VJEmSJEmSCrs8hTF169bdV3VIklSoLV8eCWIWLYLDDoOJE6FixaCrkiRJkpRFOLzrV0ZG4ThWWOooBO8tJi2Nmps2Qdu2Qf/OkaR85VLDkiTtwZo1kanJ5s2DevVg8mSoWjXoqiRJkrRL4TChr7/moA8+IObPPyEUKhwfUheCD76L1LG9vZ6KlFjgBCDjt9/gtdegSpWgS5KkfGEYI0nSbmzcGPkPWr/+CjVrRoKYWrWCrkqSJEnZWrwYhg+HYcMo8eefNA66HhUPoVD2r5iY3LXnx7FicK+MlBTCI0YQ+/HHkfmg33wTWrQI+rsuSftcjsKYRYsWUbt27XwrIr+vL0nS3khOhnPOgRkzoHLlSBBz8MFBVyVJkqRMtmyBMWNg2DCYNCk6MiKckMDyxo2pVr8+MbGxherD5/3qXoWljr29XigU6G/v/UF6airTjj2WFs8+S2jOnMj80HfdFXmV8P+RSyo+cvQTrUGDBlxyySX079+fww8/fJ/dfM6cOQwePJgRI0awdevWfXZdSZLyKiUFOnaEadOgfPnIGjENGwZdlSRJkoBI4PLtt5EAZsQI2LDhf8eaNYMePUg77zy+mzaN9u3bExMXF1ip/8/efYdHVa1tGL8nIQlIVemC2HtBEUXsBRQrvYkURUFERRQVCyoiKCqCCmKhCNKrDRUsWLEh2BuWD+lYkCYQkvn+WIeiggJJ2JnJ/buuubJmZybzhHO2mdnvWu+S9N9W7LUX6997j7TrroPBg6F7d3j9dRg50tYEkpJGyrY8KDMzk6eeeorDDjuMOnXqMHz4cFauXLlDL7hy5UqGDx/OOeecw6GHHsqwYcPIzMzcoZ8lSVJeyMyEpk1DAaZoUZgyBY46KupUkiRJYv58uOeeMEvm+OPhscdCIaZKFejWLWzyN306tG4NxYtHnVbS9ihaFAYNCm3KihULM+OOPBKeey7qZJKUK7ZrrV92djZTp05l6tSptGvXjjPOOIMaNWpQvXp1qlatSunSpUlJSfnL45cuXcrs2bP58MMPee+993jttddYu3YtAHE3VZMk5TPZ2dCmTeh0kZEBzz4LNWtGnUqSJKkAW7MGnnkmrIKZOjW8YQMoUgQaNgxv3k45JbSakpT4mjeHY4+FJk3g44/hggvgmmvg3nvDhzRJSlDbVIwpXbo0v/zyC7H/9cmMx+OsWbOGKVOmMGXKlL88tkSJEhQvXpzly5ezYsWKf/ysDQWYWCxGLBYjHo9TpkyZnP4ekiTlWDwOV1wRJmIVKgTjx8Ppp0edSpIkqQCKx+HDD0MBZtQoWLZs0/dOOimsfGnYEEqUiCigpDy1337w7rvQtSs8+CD06xdWyoweDfvvH3U6Sdoh2zRtZM6cOXTq1In09HTi8fjGQgqE4srmtz/++IN58+axfPnyf3wP/lqESUtLo1OnTnzzzTd59xtKkrQN4nG4/np4/PEwqfLpp+G886JOJUmSVMAsXAi9e8Ohh8Jxx8Gjj4ZCTOXKcOut8N138OabcMklFmKkZJeRAX36hDZlu+8eVskcfXSYPSdJCWibijElSpSgT58+zJkzhyuvvJKiRYtuLLBsKK5sy23Dc4oUKcIVV1zBd999R58+fShZsmRe/56SJP2rO+8M7/MBnnwyrIiXJEnSTrB2LYwbB+eeGzbqvvFG+Oqr0IbsoovglVfgp5/grrvCbHlJBct558Hs2XDyybByJbRoEQqyq1ZFnUyStst2NVTdY489ePjhh5k3bx79+/fn5JNPJi0t7R8rYLZ0S01N5fjjj6dfv378/PPP9O/fn8qVK+fV7yVJ0ja7//5QjAF46KHQdlySJEl5KB6Hjz6Cjh2hQgVo3BimTAn7wZxwAjzxRFgl8/TTcMYZ7gcjFXSVKsFrr8Htt4f/HgwZAsccA59+GnUySdpm27RnzN+VKFGCK664giuuuII1a9YwY8YMZsyYwYIFC1iyZAnLli2jVKlSlC5dmooVK1KjRg1q1qzJLrvsktv5JUnKkYEDoUuXMO7ZE666Kto8kiRJSW3RolBgGToUvvhi0/FKlaBlS2jVCg44ILJ4kvKx1FS44w449dSwau7rr+HYY8OeMu3bw/+2VJCk/GqHijGbK1y4MKeddhqnnXZabuSRJGmnGT4cOnQI465dw02SJEm5bO1aeP75UIB58UXIygrHCxeG+vWhdWs4/fRwoVWS/supp8Inn4T/drzwQvhQ9+qrYUXdrrtGnU6Stsp1vpKkAmnixPDePR4Pq2HuvjvqRJIkSUkkHg+bbV99NVSsCA0bhoJMVhYcfzw89lhoQzZiBNSqZSFG0vYpXRqeey5s/JmWBhMmwFFHwYwZUSeTpK3K8coYSZISzUsvQdOmoSV5mzbQt68r2iVJknLF4sWhwDJ0KHz22abjFSuGNmStW8OBB0aVTlIyicXg2mvhpJPCB7zvvw/jHj3ghhvca0pSvmMxRpJUoLzxBtSrB5mZYZ/YJ57wPbokSVKOrFsXWgUNHQpTpsD69eF4RkZ449W6NZx5pqtfJOWNY44JK/HatYPRo0P/6ddeC32py5WLOp0kbWQxRpJUYHzwAZx3HqxZE74OH+41AUmSpB02ezYMGRJWwvz666bjxx0XCjBNmrh/g6Sdo0QJGDkytD3s2BGmTYMjjwwf+mrVijqdJAEWYyRJBcSnn8LZZ8PKlWF/2HHjID096lSSJEkJZunSTW3IPvlk0/EKFUIbslat4OCDI4snqQCLxeCSS6BGjVAM/vxzOOssuPFG6N497C0jSRGyMYskKel9+22YDPX772G/2GeegcKFo04lSZKUIDIzwxuoevXC3i/XXhsKMenpoe/rlCkwdy7cc4+FGEnRO+SQ0BahfXuIx8N/m045Bf7v/6JOJqmAc2WMJCmp/fQTnHEGLFkCVauGawXFikWdSpIkKQF8+ummNmRLl246Xr16aEPWtCnstltk8SRpq4oUgUcfDW0RLrsMZswIHwgHDYL69aNOJ6mAshgjSUpaCxeGvWLnzQuTNKdOhVKlok4lSZKUj/3yS9h3YehQmDVr0/Hy5eHii0MbskMPjSyeJG2XRo3gmGOgWTN4/31o0AA6dIAHHrBdgqSdzjZlkqSk9MsvoRDz/few995h/8YyZaJOJUmSlA9lZsJzz4XZ4hUrwjXXhEJMejo0bAjPPw8//wy9e1uIkZR49t4b3nor7B0DMGAAHHccfP11tLkkFTiujJEkJZ0//gj7NH75JeyxB7z6avgqSZKkzXz2WVgB8/TToafrBtWqhTZkzZrB7rtHlU6Sck9aWtg75rTTwiq/Tz8N/63r3z+s+IvFok4oqQCwGCNJSiqrVsG558LHH4eVMK+8EiZCSZIkCfj1Vxg1KhRhZs7cdLxs2U1tyA4/PLJ4kpSnzjoLPvkk/Pfu1VehTZvwofHRR6F48ajTSUpyOWpT1q1bN+bMmZNbWSRJypE1a6BuXXjnnbA3zLRpcNBBUaeSJEmK2Pr18MILoeVYhQpw1VWhEJOWFlqTPfts2GTv/vstxEhKfhUqwMsvw913Q2oqjBgBRx8dZvRJUh7KUTGmR48eHHjggZx44ok8+eSTLF++PLdySZK0XTIzoXHjMKmpWDF48UU48sioU0mSJEXoiy+gSxeoVAnOOw8mTAhvmo46Ch56CBYsCMfOPz8UZiSpoEhNhZtvhjfegMqVYc4cqFED+vWDeDzqdJKSVI6KMQDxeJwZM2bQrl07ypcvT7NmzXjxxRfJzs7OjXySJP2nrCxo2TLsO1u4cPhao0bUqSRJkiLw229hc+pjj4XDDgurXRYvDv1br70WZs8Os7+vugpKl446rSRF64QTwn8X69YNxepOneDCC0NLR0nKZTkuxsRiMeLxOPF4nDVr1jB27FjOO+88KlWqRJcuXfjss89yI6ckSVuUnQ3t2sHo0WFC54QJcOqpUaeSJEnaidavhylTwjLhChXgyivhww+hUKFwgXHyZJg/H/r0cemwJP3dbrvBxInwyCOQnh5m9x15JLz5ZtTJJCWZXFkZE4vFNt42FGYWLVpEnz59qFq1KkcffTQPPfQQS5cuzY3MkiQBYfV4584waBCkpMDIkXDOOVGnkiRJ2km++gpuvBH23BPOPRfGjYN168JFxL59QxuySZPCLG/bkEnS1sVioZD9/vtwwAGhgH3aadC9e2jFIEm5IEfFmPHjx9O0aVOKFSu2sQizpcLM7Nmzufbaa6lUqRIXXHABEyZMIDMzM7d+B0lSAdWtW2jpCzB4cNiTVpIkKan9/jsMHAjHHQeHHAK9e8PChaHl2DXXwKxZoeXONdeE1mSSpG1XtSrMnAmtWoU2DLffDmeeGYrbkpRDOSrG1K9fn5EjR7J06VImT55MixYtKFGixFYLM5mZmbzwwgs0btyY8uXLc+WVV/LRRx/l1u8iSSpA7r0XevQI4/79w3tlSZKkpJSVBS+9BE2bhjZkV1wBH3wQNqC+4IKw+mX+/LAapmrVqNNKUmIrVgyGDoVhw6BoUZg+Paw4nDIl6mSSElyO25QBpKenc8EFFzBs2DCWLFnC888/T+vWrdl1113/UZjZcP/3339n4MCBHHfccdSsWZO33norN6JIkgqA/v3hppvC+N57oUOHaPNIkiTlia+/hq5dQxuyOnVgzBhYuxYOPzzs/zJ/PjzzTNgXJj096rSSlFwuvhg+/jgUuX/5JbSDvP760A5SknZArhRjNpeWlsY555zD4MGDWbx4MZMnT6ZSpUobv7+lNmbvvfcep512Gj02THGWJGkrnnoKOnYM41tvhRtuiDaPJElSrlq2DB5/HI4/Hg4+GO65J7TH2W03uOqq0D7nk0/g2muhXLmo00pScjvgAHjvPbj66nD/gQfghBPg+++jzSUpIeV6MWaDTz/9lM6dO3PJJZcwf/58AOLx+F8es3lhJjs7m9tvv53nn38+ryJJkhLc+PFwySVhfM01YS9FSZKkhJeVBVOnQvPmoQ1Zu3bh4l9qKpx3HkyYEAoyDz0ERx8dNpqWJO0cGRlhs9LJk2HXXeGjj+Coo8JqRUnaDoVy84ctX76cESNGMGjQIGbNmgVsKsBsKLpsOJaWlsauu+7KkiVL/rJSpl+/fpx33nm5GUuSlASmTIFmzcIeim3bwoMPeh1CkiQluG+/Dct+hw2DefM2HT/0UGjTBi66CMqXjy6fJGmTCy8MKxObN4e33w77eL3ySijU7LJL1OkkJYBcWRkzffp0Lr74YipUqEDHjh35+OOPt7pXTMWKFbnzzjuZO3cuCxYs4PHHHyclZVOMmTNn5kYkSVISmT4dGjSA9etDQWbgQAsxkiQpQf3xBzzxRGhzc+CB0LNnKMTsuitceWWYcf3ZZ3DddRZiJCm/qVwZXn899MyOxeDJJ6F6dfj886iTSUoAOVoZ07NnTwYPHsyPP/4I/HUVzAYbjp166qlceeWV1K1bl9TU1I3fb9u2LZMmTeLFF18E4I8//shJJElSknnvvdCdY80auOCCMHl0sz8jkiRJ+V92Nrz2GgwdChMnwp9/huMpKVCnDrRuDeefH1rhSJLyt0KF4K674LTTwgrGL78MBZl+/eCyy5w5KGmrclSMufXWWzeueoF/FmGKFSvGxRdfzJVXXskhhxyy1Z+zzz775CSGJClJzZ4drk+sWgVnnhla8qalRZ1KkiRpG82ZE2aSPPUU/PzzpuMHHxzakLVoEfaIkSQlntNPD23LWrWCl14K+3298go8/jiUKhV1Okn5UK7sGbP5XjAABx98MB06dKBVq1YUK1bsv0MUytWtayRJSeDrr6F2bVi2LHTxmDwZCheOOpUkSdJ/WLECxo4Nq2DefnvT8VKlQr/VNm3gmGOcOS1JyaBsWXjhBejTB7p2hXHj4MMPYfRoOO64qNNJymdypQoSj8dJTU3lggsuoGPHjpx22mnb9fxu3brRqVOn3IgiSUoCP/4YVsIsXQpHHx3e2xYtGnUqSZKkrcjODpvcDR0KEybA6tXheEoKnHVWaEN2wQXOLJGkZJSSAtdfDyefDE2bhg+0J54Y9gS77rrwfUkiF4oxZcqU4bLLLqNdu3ZUqlRph37Grrvuyq677prTKJKkJDB/PpxxRvh6yCHw8stQsmTUqSRJkrbg++83tSGbO3fT8YMOCgWYFi1gjz0iiydJ2omOPRZmzQr7xowbBzfcEPYLe+qpsIJGUoGXo2LM008/TaNGjUizgb8kKRcsXRpWxPz4I+y7b2i3W7p01KkkSZI2s2IFjB8fVsG8+eam4yVLhjZkrVuHC3K2IZOkgqdkybDZaa1acPXVYS+ZI4+EESPCHjOSCrQcFWPmzJlDr169AKhRowa1a9f+18f/+eef/Pnnnxvv77bbbjl5eUlSElm2LOwR8/XXUKkSvPqq+9lKkqR8Ijs7FF6GDg2FmFWrwvFYLLyBad0aLrwQihSJMqUkKT+IxcLqmOOPhyZN4Msvw6zDW26B228H986WCqwcnf133HEHsf/N9rnmmmv+sxhz880389BDDwEQi8VYv359Tl5ekpQkVq6EOnVg9mwoVy4UYqpUiTqVJEkq8H78cVMbsp9+2nT8gANCAebii8MsEkmS/u6ww+DDD+Gaa+DJJ6FHj7C/2MiRULly1OkkRSDHpdh4PL6xILOtj5ckaYM1a8JE0vfeg113hWnTwvUNSZKkSKxcCRMmhFUw06dvOl6iRNiYuXVrqFHDNmSSpP+2yy7wxBNhY9TLL4e33w5ty4YMCR+EJRUoKTn9AdtTiHEljCRpc+vWQcOGYU/DYsVCO93DD486lSRJKnDi8dCGrE0bKF8+FFymTw8Fl1q1Qq//hQvhscdC2xkLMZKk7dG0KcyaBcccA7//DnXrhj1l1q6NOpmknWinNin89ttvd+bLSZLysays0NnjhRdCe/UXXgh73UqSJO00P/0Ew4aFNmQ//LDp+H77hYJMy5a2kpEk5Y5994V33oGbb4YHHoCHHw4rZUaPtj2EVEBsVzGme/fuW/3ee++9t9XvZ2Vl8eWXX/LKK68Qi8WIx+OkpaVtX1JJUtLIzg77GY4dC2lpMGkSnHxy1KkkSVKBsGoVTJwY2pC99tqm48WLh42WW7eGmjVd/SJJyn3p6XD//XD66dCqVVgtc/TR8OijYbaipKS2XcWYO+644x9tyTbsAfP+++/z/vvv/+vzN99fpmzZstvz0pKkJBGPQ6dOoUVuamqYBHTWWVGnkiRJSS0eD7ORhwwJs0FWrgzHY7FwQax1a6hfP/T2lyQpr51zDsyeDS1ahLaYLVvCq6/CI4+EHt6SktIOtSnbUID5r2N/t2FVTCwWo0aNGjvy0pKkBHfLLWE1diwWJqTWrx91IkmSlLTmzg1tyIYOhe+/33R8331DAebii6FKlajSSZIKsj32gFdegZ494Y47QsvMGTNgzBioWjXqdJLywA4VYzasbtm8APP3FTP/JiUlhU6dOu3IS0uSElivXuEGYRV2ixbR5pEkSUlo9erQA3Xo0DDLeMPn1mLFoHHjUIQ58UTbkEmSopeaCrfdBqecAs2bw7ffQo0aYU+ZDh38WyUlmZTtfUI8Ht9429rxf7tVqVKF0aNHU7NmzVz7JSRJ+d/DD4d9CgHuuw/atYs2jyRJSiIb2pBddhmULx9mfLzySjh+2mlhtvGiRTBoEJx0khe3JEn5y8knwyefwPnnw9q10LFjaCPx229RJ5OUi7ZrZcyQIUM2juPxOJdccsnGFTG1atWiWbNmW3xeamoqxYoVY//99+eQQw7ZrlU0kqTEN3gwXH11GN9+O1x/fbR5JElSkvj5Zxg+PKyC+e67Tcf33jusgGnZEvbaK6JwkiRth913h2eegYcegi5dYPJk+PhjGDkSTjgh6nSScsF2FWNatWr1l/uXXHLJxvEhhxzyj+9LkjR2bJikCtC5cyjGSJIk7bA//wwXqIYM2bT6BaBoUWjUKBRhTjoJUra7EYQkSdGKxeCaa0I7zaZNYc6c0MKse3e48cbQ1kxSwtqhPWM2OPnkkzeuctlvv/1yJZAkKXk8/zxcdBFkZ8Pll8P999sVRJIk7YB4HN57L6yAGT0ali/f9L1TToE2baBBg7AvjCRJia5atbAq5oorYMQIuOUWeO01ePrp0I5TUkLKUTFm+vTpuRRDkpRsXn0VGjaE9etDQWbAAAsxkiRpO82fv6kN2TffbDpepcqmNmT77BNVOkmS8k7x4uFv4JlnwpVXhg/ZRx4Jw4bBWWdFnU7SDshRMUaSpC2ZMQMuvDDsO1i3brh+4mpqSZK0TdasCT3zhwyBadPCEluAXXYJMz1atw6rYWxDJklKdrFY+LtXowY0aQKffgpnnw033AA9ekBaWtQJJW2HbSrGdO/efeO4Ro0a1K5d+x/Hd0S3bt1y9HxJUv4zaxbUqQOrVkHt2qGTSCFL/5Ik6d/E4/DBB5vakC1btul7J50U2pA1bBhmCUuSVNAcdFBo13n99aHtRO/e8MYbMGoU7L131OkkbaNtujx2xx13bNwb5pprrtlYjNn8+I6wGCNJyeXLL0MB5o8/wnWTSZMgIyPqVJIkKd9asCD0vx86FL76atPxPfeEVq1CGzL3J5UkCYoUgf794Ywz4NJL4f334aij4Mknw4QFSfneNs9VjsfjWy28xOPx7X7hnBRxJEn5zw8/QK1a8MsvcMwx8PzzoZuIJEnSX6xZA88+GwowL7+8qQ1ZkSLQoEFox3LaabYhkyRpS+rXh6OPhubNQ4/wRo2gfXvo0yf8LZWUb23zu9t/K57EYrHtukmSksu8eWFyzoIFcNhh8NJLUKJE1KkkSVK+EY/Dhx+GDYgrVgx97198MRRiTjwxzOpdtChsVHzGGRZiJEn6N3vtFdqUde0a9pUZOBCOPTa0q5CUb23XypjtOS5JKhiWLIEzz4SffgpdRKZNg913jzqVJEnKFxYt2tSG7IsvNh2vVCm0IWvVCvbfP7J4kiQlrLQ06NkzrCZt0QI+/zy0qXjkkbDXmhPipXxnm4oxQ4YM2Tg+5JBDtnhcklTw/PZbaE32zTehtfurr0L58lGnkiRJkVq7Fp57LhRgXnoJsrLC8cKFQ2uVNm3ChaPU1EhjSpKUFGrVgk8+CfusTZsW9pN55ZWwWsaWFVK+sk3FmFatWm3XcUlS8luxAurUgU8/DQWYV14JBRlJklQAxePw8cehADNyZJixsUHNmmEfmMaNoWTJqBJKkpS8ypcPEyB694Zbb4VRo+CDD2D06LBaRlK+sM1tyiRJ2uDPP+GCC8J7u912C5Nv7DAiSVIBtHjxpjZkn3++6fgee4QZuq1awYEHRhZPkqQCIyUFbroJTjkFmjWD778PEyLuvRc6dbJtmZQPWIyRJG2XdeugQQOYPh2KF4eXX4bDDos6lSRJ2mnWrYPnnw8FmClTNrUhy8iAevVCG7IzzrANmSRJUTj+eJg1C9q2hYkToXPn0FN86FAoXTrqdFKBlqNizNKlSxk1atTG+5UrV6ZevXpbfOyECROYP3/+xvvNmzentP8BkKSEsn49NG8OL74IRYqE6y+ueJYkqQCIx2H27HAhZ8QI+PXXTd+rUSO0IWvSBEqViiafJEnaZNddYfz4sG/MtdfCCy/AkUeGVqKnnBJ1OqnAylEx5plnnqFTp07E/rfMbeTIkVt9bCwW+8tjixQpwmWXXZaTl5ck7UTZ2WEfwAkTID0dnnkGTjwx6lSSJClPLVkSii9Dh4aN4jaoUCG0IWvdGg46KKp0kiRpa2IxuOIKOOGEMGHi66/h9NPhttvCzRWs0k6XkpMnv/zyywDE43HKli1Lo0aNtvrYevXqUbFiReLxOABTp07NyUtLknaieByuugqGDQvv18aOhVq1ok4lSZLyxLp1MHky1K0b9n7p3DkUYjIywsWcF1+EuXPhnnssxEiSlN8dcQR89FFoI5qdDXfeGYoy8+ZFnUwqcHJUjPnyyy+BsOrlxBNPJCVl6z8uFotxwgkn/OO5kqT8LR4PewAOGBAm1gwbBhdeGHUqSZKU6z75JLQy2WOPsPfLM8+EHqXHHhveCCxcCKNHw9lnQyG3H5UkKWEULQqDB8PTT0OxYvDmm1C1atgDTtJOk6N30IsWLdrYdqx8+fL/+fiyZcsCYSXNokWLcvLSkqSd5O67oXfvMH7ssbBnjCRJShJLl4b+8UOHhj1hNihfHi6+OLQhO+SQiMJJkqRcddFFYZJF06bw8cdw/vnQqVNY7ZqREXU6KenlaGXMqlWrNo6XLVv2n4//448/tvhcSVL+1LdvaCUL0KcPuNWXJElJIDMTnn0W6tcPq2A6dQqFmPR0aNQobPL7889hNoaFGEmSksv++8O774a//xA++J9wAsyZE2UqqUDIUTGmVKlSQFjp8uabb5Kdnb3Vx2ZlZTF9+vSNK2lKliyZk5eWJOWxJ58MnUoAunffNJYkSQnqs8/C/i977BF6jk6aFAozxxwDjzwCCxaEjeHOOcc2ZJIkJbOMDHjwwTA5Y7fdYOZMOOqosFpWUp7JUTGmSpUqxONxAObNm0evXr22+thevXoxb7ONofbaa6+cvLQkKQ+NGgWXXx7GXbrArbdGm0eSJO2gX36Bhx+GatXCBr4PPhhak5UrB9dfHwo0H34IV14Ju+8edVpJkrQznX9+2DPupJNg5crQxuzSS8GORlKeyFEx5oQTTgAgFosRj8fp1q0bzZs354033mDx4sUsWbKEN954g+bNm3P77bdvfFwsFqNmzZq58gtIknLXM8+EFvHxOFxxBdx7L/xvUaMkSUoE69eHDXkbNoSKFeHqq0Nf+LQ0aNAAnnsutCG77z447LCo00qSpChVqgSvvQa33x4+/A8eDNWrhwkbknJVjtaeN2/enL59+wKbCjJjxoxhzJgx/3jshiLM5s+VJOUv06ZB48aQlRUKMo88YiFGkqSE8fnnMHQoPP00LF686fjRR0Pr1tC8uatfJEnSPxUqBHfcAaeeGlbHfPUVHHtsWFHbrp0XBqRckqOVMccccwxnnXXWxlZlGwoyW7ptKMTEYjFq1apF9erVc55ekpRr3n4b6taFdevCpNnBgyElR38lJElSnvvtN+jfP8xgPfxweOCBUIgpWzbsD/PJJ6EP/FVXWYiRJEn/7tRTYfbssH/cmjWhXUbjxrBsWcTBpOSQ48tsQ4cOpWLFihvvx2KxLd4grI6pUKECQ4cOzenLSpJy0cyZcO65sHo1nH122LPPfXslScqn1q+HKVOgUSOoUAE6doSPPgp/vOvVCz1H580LhZkjjog6rSRJSiRlyoSWpg88EFqcjh8PVavCe+9FnUxKeDkuxpQrV44ZM2Zw9NFHb1wF83cbjlerVo13332X8uXL5/RlJUm55Isv4KyzYPlyOOUUmDAB0tOjTiVJkv7hyy/hhhugcuUwi2L8+LCktWpV6NsXFiyAiRPhggvCxRNJkqQdkZISVti+8w7ssw/83//BSSdB796QnR11Oilh5cq858qVK/Phhx8yfvx4JkyYwPvvv8/i//UoLlu2LMcddxyNGjWiQYMGufFykqRcMmcOnHkm/PpraAf73HOwyy5Rp5IkSRv9/juMHh32gvngg03HS5eGFi2gVatQjJEkScpt1avDrFlh35jRo+HGG+HVV2HYMChXLup0UsLJ1SY0DRs2pGHDhrn5IyVJeWTuXDjjDFi0KHQwefFFKF486lSSJImsLJg2LRRgJk+GtWvD8UKFwoqY1q1DL3eXskqSpLxWokToZX7mmWEPuqlTw0SQ4cPDMUnbzB0BJKkAWrQovGeaOxcOOCC8l9ptt6hTSZJUwH39dSjADB8eWo5tcMQR0KYNNG8OZctGFk+SJBVQsRhceikcfzw0aQKffw61a0PXrnDnnW46K22jXD1TsrOz+eCDD/jwww9ZsmQJENqUVa9enWOPPZaUlBxvUSNJyqHffgvvmb77DqpUgVdecXWxJEmRWbYMxowJRZjNN8bdfXe46KKwCqZq1XARRJIkKUqHHBLapl57LTz2GPTsCdOnw6hRsOeeUaeT8r1cK8Y89thj9OjRgwWbz+DaTIUKFejWrRuXX355br2kJGk7rV5diPPOS+Wzz6BChdDqtXLlqFNJklTAZGWFP8JDh8KkSbBmTTiemhraj7VuDeedZxsySZKU/xQpAgMHhr7nbdvCu+/CkUfC4MFQr17U6aR8LcdLVbKzs2nWrBkdOnRg/vz5xOPxLd4WLFjAFVdcQfPmzYnH47mRXZK0HVavhh49juOjj1LYffewImbffaNOJUlSAfLtt3DzzWFp6llnhVmka9bAYYfBAw/A/Pnw7LNQv76FGEmSlL81agSzZ8Oxx4aVvvXrQ8eOmyaZSPqHHBdjbr31VsaMGUM8HicWi/3rLR6PM2bMGG699dbcyC5J2kbr1kHjxql8+WVpSpSIM3VqWF0sSZLy2B9/wBNPwAknwIEHQq9eoeiy227hgsVHH8Gnn0LnzvYNlSRJiWXvveGtt6BLl3C/f3+oUQO++SbaXFI+laNizNy5c7n//vs3Fls2+PuqmA02FGTuv/9+fv7555y8tCRpO1x7LUydmkJGxnqeey6Lo4+OOpEkSUksKyssQb3oIihfHi6/PLTwSE2Fc8+F8eNhwQJ4+GGoVs39YCRJUuJKT4feveHFF6FMGfjkk/D+5qmnok4m5Ts52jPmySefZP369RsLMfF4nHLlynHmmWdS+X+bEPz888+88sorLF68eOPj1q9fzxNPPEH37t1zGF+S9F+efhoGDAjjLl0+4vjjq0UbSJKkZPXdd+HCw7BhsPnks0MOgTZtQnGmQoXo8kmSJOWVs88Obcsuvhheey3sgffqq2G1TPHiUaeT8oUcFWOmT58OsLFF2bXXXss999xDWlraXx6XmZnJjTfeSN++fTcWZDY8V5KUdz79NEzGBbjlliyOOWZxtIEkSUo2y5fDuHEwdCi8/fam46VKQfPm4ULEMce4+kWSJCW/ihVh6lS45x7o1g2GD4f33oMxY+Coo6JOJ0UuR23Kvvvuu43FlcMPP5wHHnjgH4UYgLS0NPr06cMRRxwBhOLNd999l5OXliT9h2XLoEED+PPPsEfwrbdmRx1JkqTkEI9T+tNPSW3dOrQha9s2FGJSUqBOHRg7FhYuDDNBq1e3ECNJkgqO1FS45RZ44w2oVCmsHK5RAx56CDbbzkIqiHJUjPn999+BsBdMzZo1//PxNWvW3LiHzIbnSpJyX3Z2mIg7Zw5UqQIjRoT3Q5IkKYficVLbt+eEbt1IGTkyzHo46CC4997QmmzKFGjUCAoXjjqpJElSdE48Mewfc+GFsG4dXHMN1K0Lv/4adTIpMjkqxmRkZGwcL1u27D8fv/ljNn+uJCl39e4NzzwT9tEbPx523z3qRJIkJYmHHyZlyBDiKSlkXXZZaL3x5Zdwww2hNYckSZKC3XaDSZPCqpj0dHj2WahaFd56K+pkUiRyVIwpW7YsENqOTZkyhfnz52/1sfPmzeOFF17Y2NZsw3MlSbnr1VfDimCARx4JbeolSVIueP116NwZgM9btya7f3847jjbkEmSJG1NLAZXXRUmsOy/P8ybB6eeCj16QFZW1OmknSpHxZjq1asTj8eJxWIsX76cE044gREjRvylBdnvv//OiBEjOPHEE1mxYsXGx1evXj3H4SVJfzVvHjRrFtqUtWkTWthLkqRc8NNPof1YVhbZzZvzw/nnR51IkiQpcRx1FMycCRdfHC5a3HYb1KoFCxZEnUzaaXJUjLngggs2jmOxGHPnzqVly5aULl2aYsWKUbx4cUqXLk3Lli2ZO3fuxlUxf3+uJCnn1q0L14iWLg3vcfr3d6KuJEm5YvVqqFcv9Dg/+miyHn3UP7KSJEnbq3hxGDYMnnoKihYNq46rVoUXX4w6mbRT5KgY06hRI/bZZ5+N92OxGPF4nHg8zurVq1m1atXG+xsKMbFYjH333ZfGjRvnLLkk6S86dw6rfkuVCvvEFCkSdSJJkpJAPB6Wms6eDWXKhL7n/pGVJEnacS1bhlUyRx4ZZpSecw506RJmmUpJLEfFmNTUVEaOHElaWtrGY7FYbIs3CHvLpKenM3LkSFJScvTSkqTNjBgRVsIAPP00bFYnlyRJOXH//TBqFBQqFGY77Lln1IkkSZIS34EHhhmlHTuG+/ffDyedBD/8EG0uKQ/luCJy7LHHMnXqVHbfffeNq2D+bsPxMmXKMHXqVI5xN2lJyjWffQaXXRbGt90G554bbR5JkpLGyy/DTTeFcb9+cPLJ0eaRJElKJoULw8MPh5XHu+4KH3wQ+q6PHRt1MilP5MrylJNPPpnvv/+eHj16UK1atb+0K4vFYlSrVo27776bOXPmcNJJJ+XGS0qSgD/+gPr14c8/oXZtuP32qBNJkpQk5syBpk3DBrOXXgpXXBF1IkmSpORUt25oCXvCCbB8OTRpApdfHvbtk5JIrvUKK168ODfffDMffvgha9euZfHixSxatIi1a9fy4Ycf0rVrV4oXL55bLydJBV48Dq1bh2tFe+4JI0dCamrUqSRJSgIrV4aLAsuWQY0aoRfo/1ovS5IkKQ/suSdMnw633BLedz3xBBx7LHzxRdTJpFyTJxu3pKamUqZMGcqWLUuqVwYlKU/07g2TJ0N6emhhv/vuUSeSJCkJxOPQqlX44F++PEyYABkZUaeSJElKfoUKQY8eMG1aeB/2xRdQvXoozGxhawwp0eRJMUaSlLdeew1uvjmMH344vDeRJEm5oGdPmDgR0tLC14oVo04kSZJUsJxxRmhbdtZZoS/75ZdDs2ahV7uUwApty4PefPPNPHnxk90AU5K22/z5m1rYt24Nl10WdSJJkpLE88/DbbeF8YABcPzx0eaRJEkqqMqVgylT4IEHwmzUMWPggw9g9OjQvkxKQNtUjDn11FOJ5XKP5Fgsxvr163P1Z0pSslu3Dho1gqVLoWrVcJ3IFvaSJOWCr7+Giy4KLTA6dIC2baNOJEmSVLClpECXLnDSSWFlzI8/wgknwD33wLXXhu9LCWS7/h8bj8dz9SZJ2j7XXw8zZkCpUqGFfZEiUSeSJCkJ/PEH1K0Ly5eHD/sPPhh1IkmSJG1QowbMmgUNG8L69eHiyHnnhZmqUgLZrmJMLBbLlZskafuNGhX2hwEYPhz22SfaPJIkJYXsbGjRAr75BipVgnHjID096lSSJEnaXKlSMHYsDBwIhQvDiy/CkUfC669HnUzaZttcjMlvK2IGDBjA3nvvTeHChalWrRpvvfXWNj3vnXfeoVChQlStWjVXckjSzvD555u6pdxyS5gAIkmScsEdd4S9YjIyYNKk0J9ckiRJ+U8sBu3ahb1jDj4YFi6EM86Abt3Cihkpn9umPWNatWqV1zm2y5gxY+jUqRMDBgzghBNO4LHHHqNOnTp8+eWX7Lnnnlt93h9//EHLli0544wzWLx48U5MLEk7bvlyaNAAVq+GWrXgzjujTiRJUpKYOBHuuiuMH38cjjkm2jySJEn6b4cfDh9+CNdcA4MGhfdz06fDyJFhpbOUT21TMWbIkCF5nWO79OnTh0svvZS2/5sm3rdvX15++WUeffRRevXqtdXntWvXjubNm5OamsrkyZN3UlpJ2nHxOLRpA99+C5Urh/cVqalRp5IkKQl8/jm0bBnGnTptGkuSJCn/K1oUnnwyrIxp1w7eeiu0LRs6FM4/P+p00hZtUzEmP1m3bh0zZ87kpptu+svx2rVr8+677271eUOGDOH777/n6aefpkePHv/5OmvXrmXt2rUb7y9fvhyAzMxMMjMzdzB9ctrQei4ej/tvI+WyBx5IYeLEVNLT44wenUXJknF29DTbcH56nkr5m+eqtBP89huF6tYltmoV2aedRlbPnmzPH1jPUykxeK5KicFzVTnSsCEcdRSpLVqQMnMmXHABWVddRXbPnqENrXKN5+qWbc+/R8IVY3755ReysrIo97dezuXKlWPRokVbfM53333HTTfdxFtvvUWhQtv2K/fq1Ys7t9ALaOrUqeyyyy7bHzyJbSharV27lilTpkScRkoen322O7fffgIAl1zyKUuX/kRunGLTpk3L+Q+RlOc8V6U8kpXF8XfdRdnvv2dV2bK82aYN66ZO3aEf5XkqJQbPVSkxeK4qJ2I33cQhw4ez37PPkvrww6x44QU+uv56VlWsGHW0pOO5+lerV6/e5sfmajEmMzOTt99+mxkzZrB48WJWrlxJrVq1aNq0aW6+DACxWOwv9+Px+D+OAWRlZdG8eXPuvPNODjjggG3++V27dqVz584b7y9fvpzKlStTu3ZtSpQosePBk9CcOXPIzMwkIyODc845J+o4UlKYPx8uv7wQ2dkxWrTIpl+/Q4jFDsnRz8zMzGTatGnUqlWLtLS0XEoqKbd5rkp5K6VrV1JnzyZepAjpL7zAmUceud0/w/NUSgyeq1Ji8FxVrrnwQtZPmULqpZdS6ocfOOOGG8h65BHizZtHnSwpeK5u2YaOWtsi14ox/fv3p2fPnv9YnVKyZEkaN25MlSpVWLBgAQBnnnkmL7/88g69TunSpUlNTf3H6yxZsuQfq2UAVqxYwUcffcSsWbPo2LEjANnZ2cTjcQoVKsTUqVM5/fTT//G8jIwMMrawlC0tLc3/s/3NhiJYLBbz30bKBevWwUUXwZIlcMQR8NhjKaSnp+Taz/e/Y1Ji8FyV8sDo0fDAAwDEhgwh7ZhjcvTjPE+lxOC5KiUGz1XligsvhGOOgYsuIvbGGxRq3RqmT4dHHgn7zCjHPFf/anv+LXJ8dW/9+vU0aNCAq6++moULFxKPxzfeNr5ISgqXXHLJxuOvvfbaVluK/Zf09HSqVav2j+VQ06ZNo2bNmv94fIkSJfjss8+YPXv2xlv79u058MADmT17Nscdd9wO5ZCkvNKlC7z7LpQsCRMngp0RJUnKBbNnwyWXhPGNN0KTJpHGkSRJUh7ZYw949VW4805ISYGhQ6FaNfjkk6iTqYDLcTGmU6dOTJo0aWObsA23v2vYsCEQVk9kZ2fz4osv7vBrdu7cmSeffJLBgwfz1Vdfce211zJ37lzat28PhBZjLVu2BEIh6LDDDvvLrWzZshQuXJjDDjuMolZEJeUjo0bBQw+F8fDhsO++0eaRJCkp/PIL1K0Lf/4JZ58Nd98ddSJJkiTlpdRU6NYNXnstFGe++QaOOw4GDIDNFhFIO1OOijGfffYZjz766F8KMPGt/J/58MMPp2zZshvvT58+fYdft0mTJvTt25fu3btTtWpV3nzzTaZMmUKVKlUAWLhwIXPnzt3hny9JUfjiC2jbNoxvvhnOPz/aPJIkJYXMTGjcGP7v/2C//WDkyPDhXJIkScnvlFPCCunzzoO1a+HKK6FhQ/j996iTqQDKUTHmiSee2Fh8icfj7L777txwww0bV8n83RFHHLHx8V988UVOXpoOHTrw008/sXbtWmbOnMnJJ5+88XtDhw7912LPHXfcwezZs3P0+pKUm5Yvh/r1YfVqOPNM6N496kSSJCWJLl3g9dehWDGYPBl23TXqRJIkSdqZSpeGZ5+Fvn0hLS30hK9aNfSIl3aiHBVjpk+fTiwWIx6PU7hwYd577z3uueeerT6+cuXKQCjcuHJFkoJ4HNq0gW+/hcqVnbArSVKueeop6NcvjIcNg0MPjTaPJEmSohGLwTXXwIwZoSf83Llw8snQqxdkZ0edTgVEjooxP//8MxD2galTpw777LPPvz6+SJEiG8fLly/PyUtLUtJ44IEwKSMtDcaNgzJlok4kSVIS+PBDaNcujLt1g3r1os0jSZKk6FWrBh9/DM2bQ1ZW6BN/1lmwaFHUyVQA5KgY8+eff24cb74fzNYsXbp047hQoUI5eWlJSgpvvAE33RTG/fqFveQkSVIOLV4cii9r14ZN2G6/PepEkiRJyi9KlICnn4bBg2GXXeCVV+DII2Hq1KiTKcnlqBiz2267bRzPmTPnPx8/c+bMjXvJbP5cSSqIFiyAJk3CRIyLL4b27aNOJElSEli3LmzKOn8+HHRQ+KCdkqOPPZIkSUo2sVjoGf/RR3D44bBkSVgh07UrZGZGnU5JKkefSvbff3/i8TjxeJzp06cza9asrT522LBh/PDDD0Boa3bIIYfk5KUlKaFlZkLjxmHi7hFHwMCB4X2AJEnKoWuugbffDjMeJ08OXyVJkqQtOfhgeP99uOKKcP+ee8JeMj/9FGksJaccFWNOPfVUIBRXsrKyOOOMM7jjjjv+8phvvvmGq666irZt2xKLxYjH4395riQVRF26wDvvQMmSMGFCWBUrSZJy6PHHN81wGDkSDjww6kSSJEnK74oUgQEDYPz4cKHmvffgqKPCBRspF+WoGHPppZdu3PslFouxbNky7rrrLoCNK2ZeeuklBgwYwPr16zc+Ly0tjTZt2uTkpSUpYY0eHfaHARg2DPbbL9o8kiQlhXffhY4dw7hHDzj33GjzSJIkKbE0aACzZ0ONGrBsWWh926EDbLZvupQTOSrG7LnnnnTu3HnjapfNV75ssKEos2GvmFgsRpcuXShXrlxOXlqSEtKXX0LbtmHctStccEG0eSRJSgrz54cPz5mZ4UNz165RJ5IkSVIi2msvePNNuOmmcP/RR0Nx5quvIo2l5JDjnSzvvvtu6tat+5eCzJZuEAozdevW5c4778zpy0pSwlm+HOrXh1Wr4Iwz4H8LCSVJUk6sWRP+wC5aBIcdBkOGuBGbJEmSdlxaGvTqBS+/DGXLwqefwjHHhPeZf1uIIG2PHBdjUlNTmThxIr1792bXXXfduBLm77dSpUpx7733Mn78eFJScvyykpRQ4nG45BL45huoVAlGjYLU1KhTSZKU4OJxuPJK+OAD2HVXmDwZihWLOpUkSZKSQe3a8MkncOaZsHp1uLDTogWsWBF1MiWoQrn1g66//nquvPJKpk+fzvvvv8/SpUsBKFu2LNWrV+fUU09lF3eollRAPfhg2PctLS3sB1emTNSJJElKAv37w+DBkJICY8bAvvtGnUiSJEnJpHz5sELm3nvhtttg5MgwEWj0aKhWLep0SjC5VowBKFKkCHXq1KFOnTq5+WMlKaG9+SbccEMY9+0Lxx0XaRxJkpLD9OnQqVMY9+4NtWpFmUaSJEnJKiUl7El4yinQrBnMmQPHHx/eg15zjS1ytc1y1C/s9ttv5/vvv8+tLJKUdBYuhCZNICsrrGS94oqoE0mSlATmzoVGjcIf2ObNoXPnqBNJkiQp2dWsCbNmQb16kJkJ114LF1wAv/wSdTIliBwVY+666y4OOOAATj75ZIYMGcLKlStzK5ckJbzMTGjceNN+wgMHOllCkqQcW70a6tYNH3qPOgqeeMI/sJIkSdo5dtst9KHv3x8yMuD556Fq1dAWRfoPOSrGAMTjcd555x3atm1L+fLladmyJa+++mpuZJOkhHbjjfD221CiBEycCEWLRp1IkqQEF4/D5ZeHGYmlS8OkSeC+lJIkSdqZYjHo0AHeew8OPBDmz4fTToPu3cPKbWkrclyMicVixONx4vE4q1evZsSIEdSuXZsqVarQrVs35syZkxs5JSmhjB0LDz4Yxk89BfvvH20eSZKSwoMPwogRkJoK48ZBlSpRJ5IkSVJBVbUqfPQRtG4N2dlw++1wxhmhOCNtQY6LMRAKMhtuGwozP//8M3fffTcHHnggJ554IoMGDWLFihW58XKSlK999RVcckkY33hj6KQiSZJy6JVXoEuXMH7wQTj11EjjSJIkSRQrBkOGwPDhoSXKG2+EIs0LL0SdTPlQjooxI0eO5MILLyQjI2NjEWZLhZkZM2Zw+eWXU758eVq0aMG0adNyK78k5SsrVkD9+rBqVVih2qNH1IkkSUoCP/wATZqEGYdt2kDHjlEnkiRJkjZp0QI+/jjsafjLL3DeeXDddbBuXdTJlI/kqBjTtGlTJk6cyOLFixk2bBjnnnsuhQoV+kdhBsLeMn/++SejRo3i7LPPZs8998yVX0CS8ot4HC69FL7+GvbYA0aPhkKFok4lSVKCW7kyLDP97Tc49lgYMCD06ZYkSZLykwMOgBkz4Oqrw/0+feCEE+D776PNpXwjV9qUFS9enBYtWvDcc8+xePFiBg0aRK1atUhNTf1HYWbD/fn2zpOUZPr2De3r09LC17Jlo04kSVKCi8fDSpjPPoNy5WDiRChcOOpUkiRJ0pZlZEC/fvDMM7DbbmFPmaOOCjN2VeDlSjFmc6VKlaJNmza8/PLLLFiwgEcffZRTTjmFeDwOsHGljCQlk7fe2tTGvk8fOP74aPNIkpQU7rkHxo8PMx0mTAhLTyVJkqT87oILYPZsOPHE0NO+WTNo2zb0tVeBlevFmM0tXLiQuXPnMnfu3Lx8GUmK1MKF0LgxZGVB8+Zw5ZVRJ5IkKQlMmQK33BLGjzwSWjxIkiRJiaJyZXj9dbjtttBmd9AgqF49rPpWgZTruxl88803jBkzhjFjxvD111/n9o+XpHwlMzPsJ7xoERx2GDz+uG3sJUnKsW+/DTMc4nFo1w4uvzzqRJIkSdL2K1QIuneH006Diy6Cr74K+yD27Rve43oRqUDJlWLMTz/9xOjRoxkzZgyffvopwMa2ZMDG/WI2P16tWrXceGlJitRNN4UWZSVKhO4pRYtGnUiSpAS3fDnUrQt//BFWwzz0UNSJJEmSpJw57bTQtqx1a3jxRWjfHl59NczqLVUq4nDaWXLUpuzBBx+kRo0a7Lvvvtxyyy188sknxONx4vH4xgJMLBbbeKx8+fJcf/31fP7553zwwQe59TtIUiTGjQv7wwAMHQoHHBBpHEmSEl92Nlx8cZgxuMceYb+Y9PSoU0mSJEk5V7YsPP883H9/WDEzbhwcdRS8/37UybST5GhlzHXXXbex2AJsXP0Cm1bAZGRkcMEFF9C6dWvOOussUlLydJsaSdopvvoKLrkkjG+4AerVizaPJElJoXt3ePZZyMiASZOgfPmoE0mSJEm5JyUFrrsOTjoJmjaFH3+EE0+Enj3Dca+dJ7Vc+V/3723I4vE4xx13HAMGDGDRokWMGTOGOnXqWIiRlBRWroQGDcLX006Du++OOpEkSUlg8mS4884wHjgwbG4qSZIkJaNjj4VZs6BxY1i/Psz0PfdcWLIk6mTKQ7myZ8yGVTCVKlWiRYsWtGrVigMPPDA3frQk5SvxOFx6aVgZU7EijBoVVpZKkqQc+PLL0J4M4OqrQy9tSZIkKZmVLAmjR0OtWuE98EsvwZFHwtNPwxlnRJ1OeSDHS1UKFy5Ms2bNePnll/m///s/evbsaSFGUtLq1w/Gjt3U2rNcuagTSZKU4JYtgwsv3LTk9P77o04kSZIk7RyxGLRtCx9+CIceCosWheLMrbeGFTNKKjkqxjz++OMsWrSIESNGUKtWrb/sGSNJyebtt6FLlzDu0wdq1ow2jyRJCS8rC5o1gzlzoEoVGDMG0tKiTiVJkiTtXIceCh98AJdfHtqy3H03nHoqzJ0bdTLlohwVY9q2bUvx4sVzK4sk5VuLFm1q49msGXTsGHUiSZKSwK23hnYMRYrApElQpkzUiSRJkqRo7LILPPZYaF1WogS88w5UrRr2VlRSyHGbMklKdpmZ0KQJLFwYJio88URYRSpJknJg7Fi4554wHjQIjjoq2jySJElSftCkCcyaBdWrw++/Q716YU+ZNWuiTqYcshgjSf+ha1d4800oXhwmToSiRaNOJElSgvvkE2jTJoy7dAnLTiVJkiQF++wT+uVff324//DDcPzx8O230eZSjliMkaR/MX48PPBAGA8dCgccEGkcSZIS36+/Qt26sHo11K4NvXpFnUiSJEnKf9LT4b77YMoUKF0aZs+Go4+G4cOjTqYdZDFGkrbi66//Omm3fv1o80iSlPDWrw9tF376Kcz2GzUKUlOjTiVJkiTlX3XqhJXlp50Gq1ZBy5bQqhWsXBl1Mm0nizGStAUrV0KDBuHrqadCz55RJ5IkKQnccAO8+mro+fnMM7DbblEnkiRJkvK/ihVh2jS46y5ISYFhw6BatbBaRgnDYowk/U08DpddBl9+CRUqwOjRUKhQ1KkkSUpww4fDgw+G8bBhcNhh0eaRJEmSEklqKtx6K0yfDpUqhf1jjjsOHnkkXMxSvmcxRpL+5uGHNxVgxo2DcuWiTiRJUoL76KMw0wHCB0h7f0qSJEk75qSTwoqYCy6AdevgqqvC++vffos6mf6DxRhJ2sw778B114Xx/ffDCSdEm0eSpIS3eDHUqwdr18J558Gdd0adSJIkSUpsu+8OkyfDQw9BenoYV60aLmwp37IYI0n/s3gxNG68aW/hq6+OOpEkSQkuMxMaNYJ58+DAA+Hpp0OPa0mSJEk5E4uFVTEzZsD++8PPP8Mpp8Ddd0NWVtTptAV+EpIkQgGmaVNYsAAOOQSefDL8TZMkSTlw7bXw1ltQvHiYrVeyZNSJJEmSpORy9NEwcya0aBGKMLfeCmedBQsXRp1Mf2MxRpKAm28O+58VKwYTJoSvkiQpBwYNgv79w+yGESPgoIOiTiRJkiQlp+LFYfhwGDoUdtkFXn0VjjwSXnop6mTajMUYSQXexIlw331hPGSI14okScqx996DDh3CuHt3OP/8aPNIkiRJBUGrVvDxx6EQs3Qp1KkDN94Y2gcrchZjJBVo33wDrVuH8XXXQcOGkcaRJCnxLVgA9evDunXh6803R51IkiRJKjgOPDBMjrryynC/d2846ST48cdoc8lijKSCa9UqaNAAVqyAk0+Ge+6JOpEkSQlu7drwx3XhQjj00NAmIcWPHJIkSdJOVbgwPPJIaAdTqhS8/z5UrQrjxkWdrEDzk5GkAikeh8sugy++gAoVYMwYKFQo6lSSJCWweDzMvnvvvfCBb/Lk0LtakiRJUjTq1YPZs6FmTVi+HBo3hvbt4c8/o05WIFmMkVQgPfIIjBoVCjBjx0L58lEnkiQpwQ0cCIMGhZUwo0fDfvtFnUiSJElSlSrwxhuhfXAsBo89BsceC19+GXWyAsdijKQC5913oXPnML7vPjjxxGjzSJKU8N56C66+Oox79YKzzoo2jyRJkqRNChWCu++GqVOhXDn4/HM45pgwmSoejzpdgWExRlKBsngxNGoE69dDkyZwzTVRJ5IkKcH9/DM0bBj+uDZtCl26RJ1IkiRJ0paceSZ88gnUrh1albVtC82bhxZmynMWYyQVGBuuES1YAAcfDE8+GVZnSpKkHfTnn6EP9ZIlYUPQQYP84ypJkiTlZ+XKwYsvwj33QGpqaDF81FHw0UdRJ0t6FmMkFRi33ALTp0OxYjBxYvgqSZJ2UDwOl18OM2fC7rvDpEmwyy5Rp5IkSZL0X1JS4MYbQ7vhKlXghx+gZk3o0weys6NOl7QsxkgqECZNgt69w3jIEDjooGjzSJKU8Pr1g6efDrPpxo6FvfaKOpEkSZKk7XH88TB7NjRoAJmZcN11cP75sHRp1MmSksUYSUnv22+hVasw7tw5tLWXJEk58OqrcP31YfzAA3D66dHmkSRJkrRjSpWCcePg0UchIwOmTAktiKdPjzhY8rEYIymprVoVivsrVsBJJ4V2mJIkKQd+/BGaNIGsrDDb4eqro04kSZIkKSdiMWjfHj74ILSTWbAgTLi6/fawCbNyhcUYSUlrQyv7zz+H8uVhzBhIS4s6lSRJCWzVKqhbF379FapXh4EDwwc3SZIkSYnviCPgo4/gkkvChbXu3eGMM2DevKiTJQWLMZKSVv/+MHLkplb2FSpEnUiSpAQWj4cPZZ9+CmXLwsSJULhw1KkkSZIk5aaiRWHQIBgxAooVgzffhKpVib3wQtTJEp7FGElJacaMsD8MwH33hRZlkiQpB3r3DrMbChWCCROgUqWoE0mSJEnKK82bw6xZcPTR8OuvFKpXj8MGDYK1a6NOlrAsxkhKOkuWQKNGkJkJjRtDp05RJ5IkKcG99BJ07RrGDz8MJ54YbR5JkiRJeW+//eDdd+HaawGo8vLL8H//F3GoxFUo6gCSlJvWr4emTWH+/LDf2JNP2spekqQc+e47aNYstCm77DJo1y7qRJIkSZJ2lowM6NOH9SefzOw33+TIAw6IOlHCshgjKanceiu8/npoaTlxIhQvHnUiSZIS2IoVULcuLFsGxx8fVsU4y0GSJEkqcOLnnsv8WIwjow6SwGxTJilpTJ4M994bxoMHw8EHRxpHkqTElp0NLVvCl19CxYphn5iMjKhTSZIkSVJCshgjKSl89x20ahXG114b9oyRJEk50KNHmOmQnh6Wm1aoEHUiSZIkSUpYFmMkJbxVq6BBA1i+POwnvGF1jCRJ2kHPPgu33x7GAwfCccdFm0eSJEmSEpzFGEkJLR6H9u3hs8+gXDkYOxbS0qJOJUlSAvvqK2jRIow7doQ2baLNI0mSJElJwGKMpIT26KPw9NOQmhoKMXZQkSQpB5YtgwsvhBUr4OSToU+fqBNJkiRJUlKwGCMpYb33HnTqFMb33huuGUmSpB2UlQUXXRQ2YqtcGcaNc7mpJEmSJOUSizGSEtLSpdCoEWRmQsOG0Llz1IkkSUpw3brBlClQuDBMmgRly0adSJIkSZKShsUYSQknKwuaNYN58+DAA2HwYIjFok4lSVICGzcOevYM4yefhGrVos0jSZIkSUnGYoykhHPbbfDqq1C0KEycCMWLR51IkqQE9umn0Lp1GF93XWhVJkmSJEnKVRZjJCWUZ56BXr3CeNAgOOSQaPNIkpTQfvsN6taF1avhzDPhnnuiTiRJkiRJSclijKSEMWcOtGwZxtdcA02aRJtHkqSEtn49NG0KP/4Ie+8No0dDoUJRp5IkSZKkpGQxRlJCWL0aGjSA5cvhhBPgvvuiTiRJUoLr2hWmTYNddoHJk2H33aNOJEmSJElJy2KMpHwvHof27UNL+3LlYOxYSEuLOpUkSQls5Ei4//4wHjoUjjgi0jiSJEmSlOwsxkjK9wYOhOHDITUVxoyBihWjTiRJUgL7+GO49NIwvvlmaNQo2jySJEmSVABYjJGUr73/ftgfBsKewqecEm0eSZIS2pIlULcurFkD55wD3btHnUiSJEmSCgSLMZLyraVLoWFDyMwM+8Vcd13UiSRJSmCZmdC4Mfz8M+y/P4wYEZadSpIkSZLynMUYSflSVhY0bw7z5sGBB8LgwRCLRZ1KkqQEdt118MYbULw4PPMMlCoVdSJJkiRJKjAsxkjKl7p1g1degV12gQkToESJqBNJkpTAhgyBhx8O4+HD4eCDo80jSZIkSQWMxRhJ+c6zz0LPnmE8aBAcemi0eSRJSmjvvw/t24fxHXfAhRdGGkeSJEmSCiKLMZLylTlzoGXLML76amjaNNo8kiQltIULoX59WLcO6taF226LOpEkSZIkFUgWYyTlG6tXQ4MG8McfULMm3Hdf1IkkSUpga9eGP6wLFsAhh8CwYZDi239JkiRJioKfxiTlC/E4XHEFfPoplC0LY8dCenrUqSRJSmBXXw0zZkDJkjB5MhQvHnUiSZIkSSqwLMZIyhceeyxM2E1NhTFjYI89ok4kSVICe+wxePxxiMVg1CjYf/+oE0mSJElSgWYxRlLkPvgArrkmjHv1glNPjTSOJEmJ7e234aqrwrhnT6hTJ9o8kiRJkiSLMZKi9csv0LBh2Fe4fn24/vqoE0mSlMDmzQt/WDMzoXFjuPHGqBNJkiRJkrAYIylCWVnQrBn8/DMccAAMGRK6qUiSpB2wZk2Y2bB4MRxxBAwe7B9WSZIkSconLMZIiswdd8Arr8Auu8CECVCiRNSJJElKUPE4tG8PH34Iu+0GkydD0aJRp5IkSZIk/Y/FGEmReP556NEjjJ94Ag47LNo8kiQltIcfhqeegpQUGDsW9t476kSSJEmSpM1YjJG00/3wA1x8cRh37AjNm0ebR5KkhPb669C5cxjffz+ccUa0eSRJkiRJ/2AxRtJO9eef0KABLFsGxx8PDzwQdSJJkhLYTz9Bo0ZhI7YWLaBTp6gTSZIkSZK2wGKMpJ0mHocOHWD2bChTJnRRSU+POpUkSQlq9WqoVw9+/RWOPhoefxxisahTSZIkSZK2wGKMpJ3miSdg6NDQzn70aKhUKepEkiQlqHgcLr100wyHSZOgSJGoU0mSJEmStsJijKSd4sMP4aqrwrhnTzj99GjzSJKU0O6/P8xsKFQIxo+HPfeMOpEkSZIk6V9YjJGU5375BRo2hHXroG5duOGGqBNJkpTAXn4ZbropjPv1g5NPjjaPJEmSJOk/WYyRlKeysuCii2DuXNh//9CmzHb2kiTtoDlzoGlTyM4ObcquuCLqRJIkSZKkbWAxRlKeuvNOmDo1tLGfMAFKlow6kSRJCWrlyrDEdNkyqFED+vd3hoMkSZIkJQiLMZLyzAsvwF13hfETT8Dhh0ebR5KkhBWPQ6tW8MUXUL58mOGQkRF1KkmSJEnSNrIYIylP/PADtGgRxldeGVqVSZKkHXT33TBxIqSnh68VK0adSJIkSZK0HSzGSMp1f/4JDRps6qLSp0/UiSRJSmDPPQfduoVx//5w/PHR5pEkSZIkbTeLMZJyVTweVsLMng1lysC4cWESryRJ2gFffx2Wmsbj0KEDtG0bdSJJkiRJ0g6wGCMpVz35JAwZAikpMHo0VKoUdSJJkhLUH39A3bqwfDmcdBI8+GDUiSRJkiRJO8hijKRc89FH0LFjGN99N5x+erR5JElKWNnZYUXMN9+EmQ0uNZUkSZKkhGYxRlKu+PVXaNgQ1q2DCy+EG2+MOpEkSQnsjjvg+echIwMmTYJy5aJOJEmSJEnKAYsxknIsKwsuugj+7/9gv/3gqacgFos6lSRJCWriRLjrrjB+4gk45pho80iSJEmScsxijKQc694dXn4ZihSBCROgZMmoE0mSlKA+/xxatgzja6+Fiy+ONo8kSZIkKVdYjJGUI1OmhGIMwOOPwxFHRJtHkqSE9dtvodfnqlVh47XevaNOJEmSJEnKJRZjJO2wH38MewsDdOiwaSxJkrZTVhY0awY//AB77QVjxkChQlGnkiRJkiTlEosxknbIn39Cgwbw++9w3HHQp0/UiSRJSmA33wxTp4aen5MnQ+nSUSeSJEmSJOUiizGSdkjHjjBrVrhWNG4cZGREnUiSpAQ1evSmlmRDhsCRR0abR5IkSZKU6yzGSNpuTz4JgwdDSkq4flS5ctSJJElKULNnwyWXhPGNN0KTJpHGkSRJkiTlDYsxkrbLzJlhVQxAjx5wxhnR5pEkKWEtXQp164ben2efDXffHXUiSZIkSVIesRgjaZv99lvYJ2btWrjggjCBV5Ik7YDMzLAK5v/+D/bbD0aOhNTUqFNJkiRJkvKIxRhJ2yQ7G1q0CNeM9t0XnnoqtCmTJEk7oEsXeP11KFYMJk+GXXeNOpEkSZIkKQ95KVXSNrnrLnjxRShSBCZMgFKlok4kSVKCeuop6NcvjIcNg0MPjTaPJEmSJCnPWYyR9J9eegnuvDOMBw6EI4+MNo8kSQnrww+hXbsw7tYN6tWLNo8kSZIkaaewGCPpX/30EzRvDvE4tG8PLVtGnUiSpAS1eHEovmzYfO3226NOJEmSJEnaSSzGSNqqNWugYUP4/Xc49ljo2zfqRJIkJah166BBA5g/Hw46CIYPd/M1SZIkSSpA/AQoaauuugpmzoTdd4dx4yAjI+pEkiQlqGuugXfegRIl4JlnwldJkiRJUoFhMUbSFg0eDE8+CbEYjBoFe+4ZdSJJkhLU44+HTddiMRg5Eg44IOpEkiRJkqSdzGKMpH/4+GPo0CGM77oLatWKNo8kSQnr3XehY8cw7tEDzj032jySJEmSpEhYjJH0F7/9Flrar10L558PXbtGnUiSpAQ1f374o5qZGTZh84+qJEmSJBVYFmMkbZSdDRdfDD/9BPvsA8OGubewJEk7ZM0aqF8fFi2Cww6DIUNCmzJJkiRJUoHkZVZJG/XoAVOmQOHCMGEClCoVdSJJkhJQPB76fX7wAey6K0yeDMWKRZ1KkiRJkhQhizGSAHjpJbjjjjAeOBCqVo0yjSRJCax//7ASJiUFxoyBffeNOpEkSZIkKWIWYyTx009w0UVhIm+7dtCqVdSJJElKUNOnQ6dOYdy7N9SqFWUaSZIkSVI+YTFGKuDWrAl7Cv/2G1SvDv36RZ1IkqQENXcuNGoEWVnQvDl07hx1IkmSJElSPmExRirgrr4aZs6E3XeH8eMhIyPqRJIkJaDVq6FuXfjlFzjqKHjiCYjFok4lSZIkSconErYYM2DAAPbee28KFy5MtWrVeOutt7b62IkTJ1KrVi3KlClDiRIlOP7443n55Zd3YlopfxoyZNO1opEjYc89o04kSVICisfh8sth1iwoXRomTYJddok6lSRJkiQpH0nIYsyYMWPo1KkTt9xyC7NmzeKkk06iTp06zJ07d4uPf/PNN6lVqxZTpkxh5syZnHbaaZx//vnMmjVrJyeX8o9Zs6BDhzDu3h1q1442jyRJCatPHxgxAlJTYdw4qFIl6kSSJEmSpHwmIYsxffr04dJLL6Vt27YcfPDB9O3bl8qVK/Poo49u8fF9+/blhhtuoHr16uy///707NmT/fffn+eee24nJ5fyh99/hwYNwn4x550HN98cdSJJkhLUtGlwww1h3LcvnHpqlGkkSZIkSflUoagDbK9169Yxc+ZMbrrppr8cr127Nu++++42/Yzs7GxWrFjBbrvtttXHrF27lrVr1268v3z5cgAyMzPJzMzcgeTJKx6Pb/zqv03+l50NF12Uyo8/prDPPnEGDVpPVlbYa1jJbcP56Xkq5W+eqwnkhx8o1KQJsexsslu1Iuvyy8H/3QoEz1MpMXiuSonBc1VKDJ6rW7Y9/x4JV4z55ZdfyMrKoly5cn85Xq5cORYtWrRNP+OBBx5g1apVNG7ceKuP6dWrF3feeec/jk+dOpVd7AH+FxuKVmvXrmXKlCkRp9F/GTPmAF588WDS07Po2PFNZsxYHnUk7WTTpk2LOoKkbeC5mr+l/vknJ910EyV//53f99+ft889l+wXX4w6lnYyz1MpMXiuSonBc1VKDJ6rf7V69eptfmzCFWM2iMVif7kfj8f/cWxLRo0axR133MEzzzxD2bJlt/q4rl270rlz5433ly9fTuXKlalduzYlSpTY8eBJaM6cOWRmZpKRkcE555wTdRz9i6lTY4wenQrAgAFxWrY8MeJE2pkyMzOZNm0atWrVIi0tLeo4krbCczUBxOOkNmtGyv/9H/Fy5Sg2dSpn77FH1Km0E3meSonBc1VKDJ6rUmLwXN2yDR21tkXCFWNKly5NamrqP1bBLFmy5B+rZf5uzJgxXHrppYwbN44zzzzzXx+bkZFBRkbGP46npaX5f7a/2VAEi8Vi/tvkY//3f9CyJcTjcPnlcOmlCXf6K5f43zEpMXiu5mO9esHEiZCWRmzCBNL22ivqRIqI56mUGDxXpcTguSolBs/Vv9qef4uUPMyRJ9LT06lWrdo/lkNNmzaNmjVrbvV5o0aNonXr1owcOZJzzz03r2NK+cqaNdCwIfz2GxxzDPTrF3UiSZIS1JQpcMstYfzII3DCCdHmkSRJkiQlhIScGt+5c2cuvvhijjnmGI4//ngef/xx5s6dS/v27YHQYmz+/PkMGzYMCIWYli1b0q9fP2rUqLFxVU2RIkUoWbJkZL+HtLNccw189BHsthuMHw+FC0edSJKkBPTtt9C8eVhm2r59WGoqSZIkSdI2SMhiTJMmTfj111/p3r07Cxcu5LDDDmPKlClUqVIFgIULFzJ37tyNj3/sscdYv349V155JVdeeeXG461atWLo0KE7O760Uw0dCo8/DrEYjBwJ/ztNJEnS9li+HC68EP74I6yGcZmpJEmSJGk7JGQxBqBDhw506NBhi9/7e4Fl+vTpeR9Iyodmz4YrrgjjO+6As86KMo0kSQkqOxsuvhi+/hr22CMsM01PjzqVJEmSJCmBJNyeMZK2ze+/Q4MGYb+Yc86BW2+NOpEkSQmqe3d49lnIyIBJk6B8+agTSZIkSZISjMUYKQllZ0PLlvDDD7DXXjB8OKR4tkuStP0mT4Y77wzjgQOhevVI40iSJEmSEpOXZ6Uk1KsXPP98mMA7YQLstlvUiSRJSkBffhnakwFcfTW0bh1pHEmSJElS4rIYIyWZadPgttvCeMAAOProaPNIkpSQfv8dLrwQVq6E006D+++POpEkSZIkKYFZjJGSyNy50KwZxOPQti1ccknUiSRJSkBZWdC8OcyZA1WqwJgxkJYWdSpJkiRJUgKzGCMlibVroWFD+PVXqFYNHn446kSSJCWoW2+Fl16CIkVg0iQoUybqRJIkSZKkBGcxRkoSnTrBhx+G/WHGj4fChaNOJElSAho7Fu65J4wHDYKjjoo2jyRJkiQpKViMkZLAsGEwcCDEYjBiBOy1V9SJJElKQJ98Am3ahHGXLqH3pyRJkiRJucBijJTgPvkE2rUL49tvh7PPjjaPJEkJ6ddfoW5dWL0aateGXr2iTiRJkiRJSiIWY6QEtmwZNGgAa9ZAnTpw221RJ5IkKQGtXw+NG8NPP8G++8KoUZCaGnUqSZIkSVISsRgjJajsbGjZEr7/PrQle/ppSPGMliRp+91wA7z2GhQtCpMnhw3YJEmSJEnKRV66lRLUPffAc89BRgZMmOB1I0mSdsjw4fDgg2E8bBgcdli0eSRJkiRJSclijJSAXnllU0uy/v3h6KOjzSNJUkL66CO47LIwvvVWqF8/2jySJEmSpKRlMUZKMD//DM2ahTZll14abpIkaTstXgz16sHatXDeeXDnnVEnkiRJkiQlMYsxUgJZuxYaNoRffgmrYR55JOpEkiQloMxMaNQI5s2DAw904zVJkiRJUp7zU6eUQK69Fj74AHbdFcaPh8KFo04kSVIC6tQJ3noLSpSAyZOhZMmoE0mSJEmSkpzFGClBDB8Ojz4KsRiMGAF77x11IkmSEtCTT8KAAZv+oB50UNSJJEmSJEkFgMUYKQF8+im0axfG3bpBnTrR5pEkKSHNmAFXXhnG3buHvWIkSZIkSdoJLMZI+dyyZVC/Pvz5J5x9dijGSJKk7bRgATRoAOvWhT+sN98cdSJJkiRJUgFiMUbKx7KzoVUr+P57qFLF/YUlSdoha9eGQszChXDooTB0qH9QJUmSJEk7lZ9CpXzs3nvh2WchIwMmTIDdd486kSRJCSYeD63J3nsPSpWCyZOhePGoU0mSJEmSChiLMVI+9eqrcOutYfzII1CtWrR5JElKSI8+CoMGhZUwo0fDfvtFnUiSJEmSVABZjJHyoZ9/hqZNQ5uySy6Btm2jTiRJUgJ680245powvuceOOusaPNIkiRJkgosizFSPrN2LTRqBL/8AkcdFVbFSJKk7fTzz9CwIaxfH2Y4XH991IkkSZIkSQWYxRgpn7nuOnj//dDWfvx4KFIk6kSSJCWYP/+EevVg6VKoWjW0KYvFok4lSZIkSSrALMZI+ciIEdC/fxg//TTss0+0eSRJSjjxOFx+OcycCbvvDpMmwS67RJ1KkiRJklTAWYyR8onPPoPLLgvj226Dc8+NNo8kSQmpX78woyE1FcaOhb32ijqRJEmSJEkWY6T84I8/oH790FWldm24/faoE0mSlIBefXXT3jAPPACnnx5tHkmSJEmS/sdijBSxeBxat4Y5c2DPPWHkyDCZV5IkbYcff4TGjSErC1q1gquvjjqRJEmSJEkbWYyRIta7N0yeDOnpMH58aG8vSZK2w6pVULcu/PYbVK8OAwdCLBZ1KkmSJEmSNrIYI0Xotdfg5pvD+OGHw/UjSZK0HeJxuOQS+PRTKFsWJk6EwoWjTiVJkiRJ0l9YjJEiMm8eNG0K2dmhTdlll0WdSJKkBNS7N4wdC4UKwYQJUKlS1IkkSZIkSfoHizFSBNatg0aNYOlSqFoVBgywm4okSdvtpZega9cwfvhhOPHEaPNIkiRJkrQVFmOkCFx3Hbz3HpQqFSbxFikSdSJJkhLMd99Bs2ahTdlll0G7dlEnkiRJkiRpqyzGSDvZiBHwyCNhPHw47LNPtHkkSUo4K1ZA3bqwbBnUrBlWxbjEVJIkSZKUj1mMkXaizz+Hyy8P41tvhfPOizaPJEkJJzsbWraEL7+EihVh/HjIyIg6lSRJkiRJ/8pijLST/PEH1K8Pq1dD7dpwxx1RJ5IkKQH16AGTJ0N6OkycCBUqRJ1IkiRJkqT/ZDFG2gnicWjTJrS333PP0KosNTXqVJIkJZhnn4Xbbw/jgQPhuOOizSNJkiRJ0jayGCPtBPfdB5MmhUm848dD6dJRJ5IkKcF89RW0aBHGHTuGWQ6SJEmSJCUIizFSHnv9dejaNYwfegiqV482jyRJCWfZMrjwQlixAk45Bfr0iTqRJEmSJEnbxWKMlIfmz4emTcNew61aweWXR51IkqQEk5UFF120qdfnuHGQlhZ1KkmSJEmStovFGCmPrFsHjRrBkiVw5JEwYADEYlGnkiQpwXTrBlOmQOHCoednmTJRJ5IkSZIkabtZjJHyyPXXw4wZULIkTJgAu+wSdSJJkhLMuHHQs2cYP/kkHH10tHkkSZIkSdpBFmOkPDBqFDz8cBg//TTsu2+0eSRJSjiffgqtW4fxddeFVmWSJEmSJCUoizFSLvv8c2jbNoxvuQXOOy/aPJIkJZzffoO6dWH1ajjzTLjnnqgTSZIkSZKUIxZjpFy0fDk0aBCuHdWqBXfeGXUiSZISzPr10LQp/Pgj7L03jB4NhQpFnUqSJEmSpByxGCPlkngc2rSBb7+FypVh5EhITY06lSRJCeamm2DatLDZ2uTJsPvuUSeSJEmSJCnHLMZIueT++2HiREhLg/HjoXTpqBNJkpRgRoyABx4I46eegiOOiDaPJEmSJEm5xGKMlAumTw8TeQH69YNjj400jiRJiefjjzdtunbzzdCwYbR5JEmSJEnKRRZjpBxasACaNIHsbLj4YmjfPupEkiQlmCVLoG5dWLMGzjkHunePOpEkSZIkSbnKYoyUA5mZ0LhxuIZ0xBEwcCDEYlGnkiQpgWz4Y/rzz7D//qFVmZuuSZIkSZKSjMUYKQe6dIF33oGSJWHChLDXsCRJ2g7XXQdvvAHFi8Mzz0CpUlEnkiRJkiQp11mMkXbQ6NFhfxiAYcNgv/2izSNJUsIZMgQefjiMhw+Hgw+ONo8kSZIkSXnEYoy0A778ctMew127wgUXRJtHkqSE8/77mzZau/NOuPDCaPNIkiRJkpSHLMZI22n5cqhfH1atgjPOgLvuijqRJEkJZuHC8Md03TqoWxduvTXqRJIkSZIk5SmLMdJ2iMfhkkvgm2+gUiUYNco9hiVJ2i5r10KDBrBgARxySOj1meJbUkmSJElScvOTr7Qd+vSBCRMgLQ3Gj4cyZaJOJElSgrn6apgxA0qWhMmToXjxqBNJkiRJkpTnLMZI2+jNN+HGG8O4b1847rhI40iSlHgeewwefxxisbC8dP/9o04kSZIkSdJOYTFG2gYLFkDjxpCVBS1awBVXRJ1IkqQE8/bbcNVVYdyzJ9SpE20eSZIkSZJ2Iosx0n/IzAyFmMWL4fDDw6TeWCzqVJIkJZB586Bhw01/VDcsNZUkSZIkqYCwGCP9hxtugHfegRIlwn4xu+wSdSJJkhLImjVQr16Y1XDEETB4sLMaJEmSJEkFjsUY6V+MHRv2hwEYNszW9pIkbZd4HNq3h48+gt12g8mToWjRqFNJkiRJkrTTWYyRtuLLL+GSS8L4ppvgwgujzSNJUsJ5+GF46ilISQkzHPbeO+pEkiRJkiRFwmKMtAUrVkCDBrBqFZx+Otx1V9SJJElKMK+/Dp07h/H998MZZ0SbR5IkSZKkCFmMkf4mHg8rYr7+GvbYA0aNgkKFok4lSVIC+eknaNQIsrKgRQvo1CnqRJIkSZIkRcpijPQ3Dz4I48dDWlr4WrZs1IkkSUogq1dDvXrw669QrRo8/jjEYlGnkiRJkiQpUhZjpM28+SbccEMYP/gg1KgRbR5JkhJKPA6XXgqzZ0OZMjBpEhQpEnUqSZIkSZIiZzFG+p+FC6FJk9BR5aKLoEOHqBNJkpRg7r8fRo8O/T3Hj4fKlaNOJEmSJElSvmAxRgIyM6FxY1i0CA47DB57zI4qkiRtl5dfhptuCuN+/eDkk6PNI0mSJElSPmIxRgJuvBHefhtKlICJE6Fo0agTSZKUQObMgaZNITs7tCm74oqoE0mSJEmSlK9YjFGBN3Zs2B8G4KmnYP/9o80jSVJCWbkS6taFZcvCZmv9+7u8VJIkSZKkv7EYowLtq6/gkkvC+MYbw7UkSZK0jbKzoVUr+OILqFABJkyAjIyoU0mSJEmSlO9YjFGBtWIF1K8Pq1bBaadBjx5RJ5IkKcH07Bn6e6anh68VK0adSJIkSZKkfMlijAqkeDy0tP/663DdaNQoKFQo6lSSJCWQ556Dbt3CuH//0KJMkiRJkiRtkcUYFUj9+sG4caEAM24clCsXdSJJkhLI119DixZhdkOHDtC2bdSJJEmSJEnK1yzGqMB5+23o0iWM+/SBmjWjzSNJUkL544+wydry5XDSSfDgg1EnkiRJkiQp37MYowJl0SJo3BjWr4dmzaBjx6gTSZKUQLKzw4qYb76BSpXC8tL09KhTSZIkSZKU71mMUYGRmQlNmsDChXDoofDEExCLRZ1KkqQEcvvt8PzzULgwTJpkn09JkiRJkraRxRgVGF27wptvQvHiMHEiFC0adSJJkhLIhAnQo0cYP/44HHNMtHkkSZIkSUogFmNUIIwfDw88EMZDh8IBB0QaR5KkxPL559CqVRhfey1cfHG0eSRJkiRJSjAWY5T0vv4a2rQJ4y5doH79aPNIkpRQfvsNLrwQVq2C00+H3r2jTiRJkiRJUsKxGKOktnJlKL6sXAmnngo9e0adSJKkBJKVBc2awQ8/wF57wZgxUKhQ1KkkSZIkSUo4FmOUtOJxaNsWvvoKKlaE0aO9fiRJ0na5+WaYOhWKFIHJk6F06agTSZIkSZKUkCzGKGk99NCmCbzjxkG5clEnkiQpgYwatakl2ZAhcOSR0eaRJEmSJCmBWYxRUnrnHbj++jB+4AGoWTPaPJIkJZRZs+DSS8P4ppugSZNo80iSJEmSlOAsxijpLFoEjRrB+vWhzf1VV0WdSJKkBLJ0KdStC3/+CWefDT16RJ1IkiRJkqSEZzFGSWX9emjaFBYuhEMOgccfh1gs6lSSJCWIzMywCmbuXNhvPxg5ElJTo04lSZIkSVLCsxijpNK1K7zxBhQvDhMnQrFiUSeSJCmBdOkCr78e/oBOngy77hp1IkmSJEmSkoLFGCWNCRPg/vvDeMgQOPDAaPNIkpRQnnoK+vUL42HD4NBDo80jSZIkSVISsRijpPDNN9CmTRhffz00aBBtHkmSEsqHH0K7dmHcrRvUqxdtHkmSJEmSkozFGCW8lSuhfn1YsQJOOQV69Yo6kSRJCWTRolB8WbsWLrgAbr896kSSJEmSJCUdizFKaPE4XHYZfPklVKgAo0dDoUJRp5IkKUGsWwcNG8L8+XDQQTB8OKT49lCSJEmSpNzmp20ltIcf3lSAGTcOypePOpEkSQnkmmvgnXegRAl45pnwVZIkSZIk5TqLMUpY77wD110XxvffDyecEG0eSZISyuOPw8CBEIvByJFwwAFRJ5IkSZIkKWlZjFFCWrwYGjeG9euhSRO4+uqoE0mSlEDefRc6dgzjHj3g3HOjzSNJkiRJUpKzGKOEs349NG0KCxbAIYfAk0+GSb2SJGkbzJ8PDRpAZmbYL6Zr16gTSZIkSZKU9CzGKOHcfDNMnw7FisGECeGrJEnaBmvWQP36sGgRHH44DBnijAZJkiRJknYCizFKKBMnwn33hfGQIXDQQdHmkSQpYcTjcMUV8MEHsOuuMHmyMxokSZIkSdpJLMYoYXzzDbRuHcadO4fOKpIkaRv17w9Dh0JKCowZA/vsE3UiSZIkSZIKDIsxSgirVoX29itWwEknwT33RJ1IkqQEMn06dOoUxr17Q61aUaaRJEmSJKnAsRijfC8eh8svhy++gPLlw2TetLSoU0mSlCDmzoVGjSArC5o3D8tLJUmSJEnSTmUxRvle//4wciSkpsLYsVChQtSJJElKEKtXQ9268MsvcNRR8MQTEItFnUqSJEmSpALHYozytRkzNk3gve++0KJMkiRtg3gcLrsMZs2C0qVh0iTYZZeoU0mSJEmSVCBZjFG+tWRJ6KqSmQmNG29qdS9JkrZBnz6blpaOHw9VqkSdSJIkSZKkAstijPKl9euhaVOYPx8OOgiefNKuKpIkbbNp0+CGG8K4b1845ZRI40iSJEmSVNBZjFG+dOut8PrrUKwYTJwIxYtHnUiSpATxww/QpAlkZ0ObNnDllVEnkiRJkiSpwLMYo3xn8mS4994wHjwYDj440jiSJCWOlSuhbl34/Xc49lgYMMClpZIkSZIk5QMWY5SvfPcdtGoVxtdeG/aMkSRJ2yAeDythPvsMypULS0sLF446lSRJkiRJwmKM8pFVq6B+fVi+HE48cdPqGEmStA169YLx4yEtLRRi9tgj6kSSJEmSJOl/LMYoX4jHoV07+PxzKF8exo4N15IkSdI2eOGFsOEaQP/+ULNmtHkkSZIkSdJfWIxRvjBgAIwYAampoRBToULUiSRJShDffAPNm4eZDe3bw2WXRZ1IkiRJkiT9jcUYRe6998L+MAC9e8NJJ0WbR5KkhLF8OdStG76ecAL06xd1IkmSJEmStAUWYxSpJUugYUPIzAxfNxRlJEnSf8jOhosvhq+/DvvDjB8P6elRp5IkSZIkSVtgMUaRWb8emjWD+fPhoINg8GCIxaJOJUlSgujeHZ59FjIyYNKksOmaJEmSJEnKlyzGKDK33QavvQZFi8LEiVC8eNSJJElKEJMmwZ13hvFjj0H16tHmkSRJkiRJ/8pijCLxzDNwzz1hPHgwHHxwtHkkSUoYX3wBLVuG8TXXQKtW0eaRJEmSJEn/yWKMdrrvvtt0DalTJ2jcONI4kiQljt9/h7p1YeVKOO00uO++qBNJkiRJkqRtYDFGO9WqVdCgASxfDieeCL17R51IkqQEkZUFzZvDnDlQpQqMGQNpaVGnkiRJkiRJ28BijHaaeBzat4fPPoNy5WDsWK8hSZK0zW69FV56CYoUCXvGlCkTdSJJkiRJkrSNLMZop3n0UXj6aUhNDYWYChWiTiRJUoIYO3bTZmuDBsFRR0WbR5IkSZIkbZdCUQdQwfDee2F/GIB774WTT440jpQc4nFYuzbsHbFyZegDuGH899uqVaT88QeH/PQTKR9+CLvsAunpkJHxz69bOvZvj0lNhVgs6n8NKXl98gm0aRPGXbpAs2bR5pEkSZIkSdvNYozy3NKl0KgRZGaG/WI6d446kRSB9ev/Wiz5j8LJNn8vK2ubI6QC++fF7xaL5U5RZ0ce81/PL1TIQpES2y+/QN26sHo11K4NvXpFnUiSJEmSJO0AizHKU1lZYQLvvHlw4IEweLDXRZXPxePw5587XhzZ2vfXrMnb3EWKQLFif70VLfqX+1mFC/PjDz+w9x57kJqZGVbVrFu35a//9b14/K//ZmvW5P3vuCO2Vija2UWhLT3GQpH+y/r10KQJ/PQT7LsvjBoVVqJJkiRJkqSEYzFGeeq22+DVV0NHpAkToESJqBMpqWRm5nxlyZaOb15oyG2FCv2zaLKV4sk2fa9o0XDbhgu02ZmZfDFlClXOOYfUtLSc/R7r1/97wWZbijrbWvjZnucnWqEoitVE2/IYC0X5QkrXrvDaa+EcnzwZdtst6kiSJEmSJGkHWYxRnnnmmU3dVAYNgkMPjTaPIpSdHVrs5FbhZMP31q3L29w7Uhz5r++lp+dt5p2lUKFwK1o06iT/tH597heFcqtwlJ29KeeGPX/Wro3u32prtlQoyi+FowJSKKr0+uuk9usX7gwbBocdFm0gSZIkSZKUIxZjlCfmzIFWrcL46quhadNo82gbxePhonFu7GWy+W316rzNnZHx36tHtrdwUqQIpKTkbW7ljQ2Fol12iTrJP22pUBT1aqJELRRFXRTa0te0tFwpFMVmzqTqgAHhzq23Qv36Of6ZkiRJkiQpWhZjlOtWr4YGDeCPP6BmTbjvvqgTJakNG8JvS9ut7fnedmwIv91SUnK+suTv3ytaNFwAlRJBfi4UZWXlj6LQlh6ztULRihXR/XttTS7sP5Q6fjyxzEyyzzmHlDvvjPo3kiRJkiRJuSBhizEDBgzgvvvuY+HChRx66KH07duXk046aauPf+ONN+jcuTNffPEFFStW5IYbbqB9+/Y7MXHBEI/DFVfAp59C2bIwdmzydGXaYZtvCJ+Tllx/P7YzN4TPrcJJ4cIFor2QlJBSU0ORKBEKRfllNdG6df8sYOdCoSgGrNhjDwo/9RQprtCTJEmSJCkpJGQxZsyYMXTq1IkBAwZwwgkn8Nhjj1GnTh2+/PJL9txzz388/scff+Scc87hsssu4+mnn+add96hQ4cOlClThgYNGkTwGySvxx4Lre1TU2HMGNhjj6gTbafNN4TPzcJJXm4In5oKxYvnbuFkGzeEl6SdIr8XinJ5NVBWoUK8u9denF6yZNS/nSRJkiRJyiUJWYzp06cPl156KW3btgWgb9++vPzyyzz66KP02rBj/GYGDhzInnvuSd++fQE4+OCD+eijj7j//vstxuSiuXPL8+ijYdyrF5x6ah6+2N83hM+twkkUG8LvSPFk8+Pp6a42kaSopKaGlYRFiuTaj8zOzGTNlCm59vMkSZIkSVL0Eq4Ys27dOmbOnMlNN930l+O1a9fm3Xff3eJzZsyYQe3atf9y7KyzzmLQoEFkZmaStoX9JtauXcvazTYuXr58OQCPPPIIhQsXzumvkVRWrlzJqlVFGDr0XNatg8MP/46UlOfo0weIx0nNyiJt7VrS1q4lfd26MP7f183vp//vMWnr1v3jfvpmxzc8Ly+tT00lMyODzIwM1qWnh3F6erhlZLBuw/2/f3+z+5s/JjM9ncy0tO3bED4e31QkknJBPB5n7dq1zJkzh5gFPCnf8lyV8j/PUykxeK5KicFzVUoMnqtbtmY7tpJIuGLML7/8QlZWFuXKlfvL8XLlyrFo0aItPmfRokVbfPz69ev55ZdfqFChwj+e06tXL+7cwqa5K1asIDMzMwe/QXLZ9bffqPfqayz9sQznrJ5CqdRlVJw/n8J3riUtM5P0detI3Xzj5VyWHYuRmZbGuvT0rd4yt3T8X56TmZ5Odm636Fq3Lu9X3UjbyP+GSYnBc1XK/zxPpcTguSolBs9VKTF4rv5VUhdjNvh79S0ej/9rRW5Lj9/S8Q26du1K586dN95fvnw5lStXpnjx4q6M2UypFSs4/IvPNx3IAn7b8mMz09L+slLkL6tL/r7yZMPjNoz/fv9/4/WFCuVqi670/92kZLRhBkNGRoYzGKR8zHNVyv88T6XE4LkqJQbPVSkxeK5u2Za6bm1NwhVjSpcuTWpq6j9WwSxZsuQfq182KF++/BYfX6hQIXbfffctPicjI4OMjIx/HO/YsSMlSpTYwfTJZ9qY37iKKqykGEed+C1X33zyVvdFSUtNZdv/rykpt2VmZjJlyhTOOeec7fpDIWnn8lyV8j/PUykxeK5KicFzVUoMnqtbtnz5cm655ZZtemzCFWPS09OpVq0a06ZNo169ehuPT5s2jQsvvHCLzzn++ON57rnn/nJs6tSpHHPMMf4fJ4cOP2U3rti3LrvvvoDD6/0OdepEHUmSJEmSJEmSpHwl4YoxAJ07d+biiy/mmGOO4fjjj+fxxx9n7ty5tG/fHggtxubPn8+wYcMAaN++PY888gidO3fmsssuY8aMGQwaNIhRo0ZF+WskhfLloV278axYsRIoGnUcSZIkSZIkSZLynYQsxjRp0oRff/2V7t27s3DhQg477DCmTJlClSpVAFi4cCFz587d+Pi9996bKVOmcO2119K/f38qVqzIQw89RIMGDaL6FZJKamqc1NTsqGNIkiRJkiRJkpQvJWQxBqBDhw506NBhi98bOnToP46dcsopfPzxx3mcSpIkSZIkSZIk6a9Sog4gSZIkSZIkSZKUzCzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5SGLMZIkSZIkSZIkSXnIYowkSZIkSZIkSVIeshgjSZIkSZIkSZKUhyzGSJIkSZIkSZIk5aFCUQdIFPF4HIDly5dHnCT/WbNmDWvWrCEtLc1/Hykfy8zMZPXq1Sxfvpy0tLSo40jaCs9VKf/zPJUSg+eqlBg8V6XE4Lm6ZRuuh2+oH/ybWHxbHiXmzZtH5cqVo44hSZIkSZIkSZLykZ9//plKlSr962Msxmyj7OxsFixYQPHixYnFYlHHyVeWL19O5cqV+fnnnylRokTUcSRtheeqlBg8V6X8z/NUSgyeq1Ji8FyVEoPn6pbF43FWrFhBxYoVSUn5911hbFO2jVJSUv6zslXQlShRwhNRSgCeq1Ji8FyV8j/PUykxeK5KicFzVUoMnqv/VLJkyW163L+XaqT/b+/eg6Kq/z+Ov1YRUVQIcQ3DW8oo3lC5GFjmJRnJcaTIMjWlsnIS06isdKZMTWu0Qm1kRifzMmN0UYzJWzYploUCRpEagjc0UURFE++wvz/8scOyKyzIfo/U8zGzM+57z57z2p3ZP/Tl53wAAAAAAAAAAMAdoYwBAAAAAAAAAABwIcoY3LHGjRvr3XffVePGjY2OAqAK/FaB+oHfKnD343cK1A/8VoH6gd8qUD/wW71zJovFYjE6BAAAAAAAAAAAwL8VK2MAAAAAAAAAAABciDIGAAAAAAAAAADAhShjAAAAAAAAAAAAXIgyBgAAAAAAAAAAwIUoY3BHli5dqo4dO8rDw0PBwcH66aefjI4EoJKdO3dqxIgRatOmjUwmkzZs2GB0JACVzJ8/X6GhoWrevLnMZrOio6OVk5NjdCwAlSQmJqpXr15q0aKFWrRoofDwcG3evNnoWACqMX/+fJlMJk2bNs3oKAAqmDVrlkwmk83j3nvvNToWAAf+/vtvjRs3Ti1btlTTpk3Vu3dvZWZmGh2r3qGMQa19+eWXmjZtmmbOnKnffvtNDz30kKKiopSfn290NAAVlJSUKCgoSJ9++qnRUQDcRmpqqiZPnqy0tDRt27ZNN2/eVGRkpEpKSoyOBqACf39/ffDBB8rIyFBGRoYGDx6skSNHat++fUZHA3Ab6enpWrZsmXr16mV0FAAOdO/eXQUFBdZHdna20ZEAVHL+/Hn1799fjRo10ubNm7V//3599NFH8vb2NjpavWOyWCwWo0OgfurXr5/69u2rxMRE6ywwMFDR0dGaP3++gckA3I7JZFJycrKio6ONjgKgCmfOnJHZbFZqaqoGDBhgdBwAVfDx8dGCBQv0/PPPGx0FQCWXLl1S3759tXTpUs2dO1e9e/dWQkKC0bEA/L9Zs2Zpw4YNysrKMjoKgCq89dZb2rVrF3dEqgOsjEGtXL9+XZmZmYqMjLSZR0ZG6pdffjEoFQAA/w4XLlyQdOsfeQHcnUpLS5WUlKSSkhKFh4cbHQeAA5MnT9bw4cP1yCOPGB0FwG3k5uaqTZs26tixo0aPHq3Dhw8bHQlAJSkpKQoJCdGoUaNkNpvVp08fLV++3OhY9RJlDGqlqKhIpaWlat26tc28devWOnXqlEGpAACo/ywWi+Lj4/Xggw+qR48eRscBUEl2draaNWumxo0ba9KkSUpOTla3bt2MjgWgkqSkJGVmZnLXBuAu1q9fP61evVpbt27V8uXLderUKUVEROjs2bNGRwNQweHDh5WYmKiAgABt3bpVkyZN0iuvvKLVq1cbHa3ecTM6AOo3k8lk89xisdjNAACA8+Li4vTHH3/o559/NjoKAAe6dOmirKwsFRcXa926dZowYYJSU1MpZIC7yPHjxzV16lR9//338vDwMDoOgNuIioqy/rlnz54KDw9Xp06dtGrVKsXHxxuYDEBFZWVlCgkJ0bx58yRJffr00b59+5SYmKjx48cbnK5+YWUMasXX11cNGza0WwVTWFhot1oGAAA4Z8qUKUpJSdH27dvl7+9vdBwADri7u6tz584KCQnR/PnzFRQUpEWLFhkdC0AFmZmZKiwsVHBwsNzc3OTm5qbU1FQtXrxYbm5uKi0tNToiAAc8PT3Vs2dP5ebmGh0FQAV+fn52//EoMDBQ+fn5BiWqvyhjUCvu7u4KDg7Wtm3bbObbtm1TRESEQakAAKifLBaL4uLitH79ev3444/q2LGj0ZEAOMlisejatWtGxwBQwZAhQ5Sdna2srCzrIyQkRGPHjlVWVpYaNmxodEQADly7dk0HDhyQn5+f0VEAVNC/f3/l5OTYzA4ePKj27dsblKj+4jZlqLX4+Hg988wzCgkJUXh4uJYtW6b8/HxNmjTJ6GgAKrh06ZLy8vKsz48cOaKsrCz5+PioXbt2BiYDUG7y5Mlau3atvv32WzVv3ty68tTLy0tNmjQxOB2AcjNmzFBUVJTatm2rf/75R0lJSdqxY4e2bNlidDQAFTRv3txu3zVPT0+1bNmS/diAu8jrr7+uESNGqF27diosLNTcuXN18eJFTZgwwehoACp49dVXFRERoXnz5unJJ5/Unj17tGzZMi1btszoaPUOZQxq7amnntLZs2c1e/ZsFRQUqEePHtq0aROtKHCXycjI0KBBg6zPy++9O2HCBK1cudKgVAAqSkxMlCQNHDjQZv75558rNjb2fx8IgEOnT5/WM888o4KCAnl5ealXr17asmWLhg4danQ0AADqnRMnTujpp59WUVGRWrVqpQceeEBpaWn8uxJwlwkNDVVycrLefvttzZ49Wx07dlRCQoLGjh1rdLR6x2SxWCxGhwAAAAAAAAAAAPi3Ys8YAAAAAAAAAAAAF6KMAQAAAAAAAAAAcCHKGAAAAAAAAAAAABeijAEAAAAAAAAAAHAhyhgAAAAAAAAAAAAXoowBAAAAAAAAAABwIcoYAAAAAAAAAAAAF6KMAQAAAAAAAAAAcCHKGAAAAAA1EhsbK5PJZPPYsWOH0bHqvaNHj9p9rwMHDjQ6FgAAAIA6QBkDAAAAAAAAAADgQpQxAAAAAOocq2dk9/k7dOhgdCQAAAAABnEzOgAAAACA+iUyMlLe3t42M39/f2PC/Iu0aNFCU6dOtZl17tzZoDQAAAAA6hJlDAAAAIAaGTNmjMaMGWN0jH8dHx8fJSQkGB0DAAAAgAtwmzIAAAAAAAAAAAAXoowBAAAAUCNV7QdT/nzVqlV27xs0aJDT+8ikpaUpLi5OvXv3lq+vr9zd3WU2mxUREaH33ntPp0+frjJjhw4d7K4lSefOndPMmTPVs2dPtWjRQiaTSStXrrS+b/fu3Vq8eLHGjx+vkJAQ3X///fL29lajRo10zz33qGvXrho9erSSkpJ0/fp1u+uuXLnS5noVHTt2rMp9ZI4ePWr3+sCBA6v8nIcOHdKMGTPUv39/tW7dWu7u7vLy8lJAQIDGjh2rr7/+WqWlpbd9f8W85Y9Zs2ZJkvbs2aNx48apbdu2aty4sVq3bq2YmBilp6dXmQkAAACAPW5TBgAAAOCuUVRUpGeffVbfffed3WtnzpzRmTNn9Ouvv2rBggVKSEjQxIkTnT73n3/+qcjISBUUFNz2mOHDh+vs2bMOXysuLlZxcbFycnL05ZdfqmvXrvrmm2/UvXt3pzPUlRs3bmj69OlasmSJXdly48YNXbx4UXl5eVq7dq26du2qpKQkBQUFOX3+mTNn6oMPPlBZWZl1VlhYqPXr1yslJUVffPGFnnjiiTr7PAAAAMC/HStjAAAAANwVioqKFB4e7rCIqaykpEQvvPCCPvnkE6fPHxUVVWURU1N//fWXoqKidP78+To7pzPKysr02GOPKSEhocpVL+X++usvRUREKCMjw6nzJyYmat68eTZFTEU3b97U888/rzNnztQoNwAAAPBfxsoYAAAAAHVm6tSpkqTvv/9eBw4csHktJiZG/v7+NrOKz2NjY5WXl2fzuqenpyIjI2U2m5WTk2N3W7Pp06fr4YcfVt++favNduLECUlScHCwgoODdenSJe3Zs8fuOJPJpJ49e+q+++5Ty5Yt5e3trWvXruno0aP66aefdPXqVeuxx48f15IlS/TOO+9Ikrp162b9DhYtWmRz3ubNm+u5556zmfn4+FSbu7IPP/xQGzdutJv37dtXYWFhKioq0qZNm3T58mXra5cvX1ZMTIxycnLk4eFR5fkLCwslSYGBgRowYIAOHz6sbdu22Rxz8eJFrVmzRvHx8TXODwAAAPwXUcYAAAAAqDMJCQmSbhUrlcuYuLi42+6Bsnv3bruCISgoSD/88IN8fX2ts+TkZMXExMhisUi6tUpjzpw5Sk5OrjabyWTSihUrFBsbazMvKSmx/vnzzz9XeHi4zTUrOnLkiPr06aMLFy7YZCovY8LCwhQWFibJvozx8fGxfj+1VVJSogULFtjN3333XeteL5KUm5ur/v3726xeyc/P14oVK/Tyyy9Xe53x48drxYoVatiwoSTpjTfe0MKFC22O2blzJ2UMAAAA4CTKGAAAAACGW7dund3s448/titFHnvsMYWGhtqsaClfBdK0adMqrxEbG2tXxEi3Vt+UGzFihCSpoKBAaWlpys3N1YULF3T58mVrAeTp6WlTxmRnZ+vmzZtyc3P9X6+2b99ud1u0zp07W8ugcgEBAZo5c6amTZtmM9+wYUO1ZYyHh4cWLlxoLWIk6aWXXrIrY44ePVrzDwAAAAD8R1HGAAAAADDc7t277WZDhgxx6r3Xr1/X3r179eCDD1Z5nKMiprKsrCy99tpr2r59u7V8qU5paanOnz+vVq1aOXX8nUhPT7ebDRs2TA0a2G8HOnz4cLsyxtH7Kxs6dKjdZ/Hz87M77uLFi9WeCwAAAMAtlDEAAAAADHenm8GfPn262mN69epV5eu7d+/W4MGDbfZacVZt3lMbjr6ntm3bOjzW0by4uFjXr1+Xu7v7ba/Rvn17u5mjfWbKysqqigoAAACgAvv/PgUAAAAA9cylS5eqPcbLy6vK1+Pi4mpdqji7iuZOObqOyWRyeGxN5+VatmxpN6t4yzIAAAAANcfKGAAAAACGM5vNOnDggM1s4sSJNvu5VCUwMLDaY6oqIU6ePKmMjAybmZubm95//32NHj1afn5+atSokSQpPDxcaWlpTuWqa2az2W6Wn5/v8FhHc29vb+vnAAAAAPC/QxkDAAAAoM45WklRWlp62+NDQ0OVmppqM4uMjNSoUaOqvVZpaekdr9xwVFwMGzZM06dPt5mVlJTozz//dOqcDRo0sLmVV1Wf31mhoaF2sy1btqisrMxu35hNmzY59X4AAAAArsdtygAAAADUuWbNmtnN9u/ff9vjH3/8cbtZXFyc3WqVcjdu3ND27dv14osvKjo6utY5yznaQ+XgwYO6cuWK9fnly5f17LPPOnVLNMn+Ozh9+rTOnTt3RzkHDRqke+65x2aWl5enOXPm2Mxyc3M1d+5cu/fXxXcFAAAAoOZYGQMAAACgzgUEBNjN3nzzTf3888+69957ZTKZ5OfnpzfffFPSrVt/RUVFafPmzdbjCwsLFRoaqtDQUHXp0kVeXl66cOGCDh06pOzsbGsp8vDDD99x3m7duqlJkyY25cvBgwcVGBioIUOG6OrVq9qxY4dOnjzp9DkDAgKUmZlpfX7jxg3169dPAwcOtN5+beTIkRo0aJDT5/T09NQbb7yhGTNm2MxnzZqllJQUhYWF6ezZs9q4caPd/jft2rXTc8895/S1AAAAANQdyhgAAAAAdS4qKkomk8lmw/krV67oq6++sj7v3r27tYyRpFWrVik8PFyHDh2yOVd6errS09NdmtfDw0MTJ07UkiVLbObHjh3TihUrrM/9/f3l5eWlffv2VXvORx991KaMkW6tYsnLy7M5X03KGEmaPn26du3apY0bN9rM9+7dq7179zp8T9OmTbVu3Tp5eHjU6FoAAAAA6ga3KQMAAABQ5zp16qQpU6bU6D2tWrVSWlpajW6l1bRpUz300EM1TOfYhx9+qAEDBtz2dT8/P6WkpMjX19ep802bNk0dOnSok2wVNWzYUMnJyZo6dapTe+V07dpVv/zyi0JCQuo8CwAAAADnsDIGAAAAgEssWrRIwcHBWrlypX7//XcVFxfbbGjviK+vr5KTk5WVlaU1a9Zo165dOnLkiIqLi9WgQQN5e3urU6dOCgoK0pAhQxQZGelwf5raaNKkiX744QclJiZqzZo12r9/v0wmk9q2bauRI0cqPj5eZrPZ6fP5+Phoz549WrBggTZv3qwjR46opKSkTrI2atRICQkJmjJlij777DPt2LFDeXl5Ki4uloeHh8xms8LCwhQdHa2YmBinShsAAAAArmOyVLxvAAAAAAAAAAAAAOoUtykDAAAAAAAAAABwIcoYAAAAAAAAAAAAF6KMAQAAAAAAAAAAcCHKGAAAAAAAAAAAABeijAEAAAAAAAAAAHAhyhgAAAAAAAAAAAAXoowBAAAAAAAAAABwIcoYAAAAAAAAAAAAF6KMAQAAAAAAAAAAcCHKGAAAAAAAAAAAABeijAEAAAAAAAAAAHAhyhgAAAAAAAAAAAAXoowBAAAAAAAAAABwIcoYAAAAAAAAAAAAF/o/dwIj29IXFPAAAAAASUVORK5CYII=\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1299,6 +1295,479 @@ "update_plotter()" ] }, + { + "cell_type": "markdown", + "id": "868e08e3", + "metadata": {}, + "source": [ + "## Example: Reentring Ballistic Object (Projectile Motion)" + ] + }, + { + "cell_type": "markdown", + "id": "74bb7b82", + "metadata": {}, + "source": [ + "[Link](https://en.wikipedia.org/wiki/Projectile_motion)" + ] + }, + { + "cell_type": "markdown", + "id": "ac59d052", + "metadata": {}, + "source": [ + "$$\n", + "\\vec{x}_k =\n", + "\\begin{bmatrix}\n", + "x_k & y_k & \\dot{x}_k & \\dot{y}_k & d_k\n", + "\\end{bmatrix}^T\n", + "= \\begin{bmatrix}\n", + "x_1 & x_2 & x_3 & x_4 & x_5\n", + "\\end{bmatrix}^T\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "045a1533", + "metadata": {}, + "source": [ + "Where $x_k$ and $y_k$ are the positions of the target. $\\dot{x}_k$ and $\\dot{y}_k$ are velocities. $d_k$ is the aerodynamic properties." + ] + }, + { + "cell_type": "markdown", + "id": "a2f46277", + "metadata": {}, + "source": [ + "The vehicle state dynamics are:\n", + "\n", + "$$\n", + "\\dot{x}_1(k) = x_3(k)\n", + "$$\n", + "\n", + "$$\n", + "\\dot{x}_2(k) = x_4(k)\n", + "$$\n", + "\n", + "$$\n", + "\\dot{x}_3(k) = D(k) x_3(k) + G(k) x_1(k) + v_1(k)\n", + "$$\n", + "\n", + "$$\n", + "\\dot{x}_4(k) = D(k) x_4(k) + G(k) x_2(k) + v_2(k)\n", + "$$\n", + "\n", + "$$\n", + "\\dot{x}_5(k) = v_3(k)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "f33a6fa0", + "metadata": {}, + "source": [ + "Where $D(k)$ is the drag-related force term, $G(k)$ is the gravity-related force term and $v(k)$ are the process noise\n", + "terms." + ] + }, + { + "cell_type": "markdown", + "id": "aee6ebed", + "metadata": {}, + "source": [ + "Defining,\n", + "\n", + "$R(k) = \\sqrt{x_{1}(k)^2 + x_{2}(k)^2}$ as the distance from the center of the Earth.\n", + "\n", + "$V(k) = \\sqrt{x_{3}(k)^2 + x_{4}(k)^2}$ as absolute vehicle speed.\n", + "\n", + "then drag and gravitational terms are:\n", + "\n", + "$D(k) = -\\beta(k) e^{\\left(\\frac{R_0 - R(k)}{H_0}\\right)} V(k)$\n", + "\n", + "$G(k) = -\\frac{G m_0}{r^3(k)}$\n", + "[link](https://en.wikipedia.org/wiki/Gravitational_acceleration)\n", + "\n", + "$\\beta(k) = \\beta_0 e^{x_5(k)}$" + ] + }, + { + "cell_type": "markdown", + "id": "11427baa", + "metadata": {}, + "source": [ + "Where the parameterization of the ballistic coefficient, $\\beta(k)$, reflects the uncertainty in vehicle characteristics. $\\beta_0$ is the ballistic coefficient of the \"typical vehicle\" and it is scaled by $e^{x_5(k)}$ to ensure its value is always positive. This is vital for filter stability." + ] + }, + { + "cell_type": "markdown", + "id": "80ebabef", + "metadata": {}, + "source": [ + "The used values are:\n", + "\n", + "$$\\beta_0 = −0.59783$$\n", + "\n", + "$$H_0 = 13.406$$\n", + "\n", + "$$Gm_0 = 3.9860 × 10^5$$\n", + "\n", + "$$ R_0 = 6374.0 $$\n", + "\n", + "and reflect typical environmental and vehicle characteristics." + ] + }, + { + "cell_type": "markdown", + "id": "a5ec494d", + "metadata": {}, + "source": [ + "The motion of the vehicle is measured by a radar which is located at $(xr, yr)$. It is able to measure range $r$\n", + "and bearing $\\theta$ at a frequency of 10Hz, where\n", + "\n", + "$$\n", + "r_r(k) = \\sqrt{(x_1(k) - x_r)^2 + (x_2(k) - y_r)^2} + w_1(k)\n", + "$$\n", + "\n", + "$$\n", + "\\theta(k) = arctan \\left( \\frac{(x_2(k) - y_r)^2}{(x_1(k) - x_r)^2} \\right) + w_2(k)\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "26bd6174", + "metadata": {}, + "source": [ + "$w_1(k)$ and $w_2(k)$ are zero mean uncorrelated noise processes with variances of $1$m and $17$mrad respectively. The\n", + "high update rate and extreme accuracy of the sensor means that a large quantity of extremely high quality data is\n", + "available for the filter. The bearing uncertainty is sufficiently that the EKF is able to predict the sensor readings\n", + "accurately with very little bias." + ] + }, + { + "cell_type": "markdown", + "id": "65c282dd", + "metadata": {}, + "source": [ + "The true initial conditions for the vehicle are:\n", + "\n", + "$$\n", + "\\vec{x}(0) = \\begin{bmatrix}\n", + "6500.4 \\\\\n", + "349.14 \\\\\n", + "-1.8093 \\\\\n", + "−6.7967 \\\\\n", + "0.6932\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "and;\n", + "\n", + "$$\n", + "P(0) = \\begin{bmatrix}\n", + "10^{-6} & 0 & 0 & 0 & 0 \\\\\n", + "0 & 10^{-6} & 0 & 0 & 0 \\\\\n", + "0 & 0 & 10^{-6} & 0 & 0 \\\\\n", + "0 & 0 & 0 & 10^{-6} & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 \\\\\n", + "\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "4c1cec55", + "metadata": {}, + "source": [ + "In other words, the vehicle’s coefficient is twice the nominal coefficient." + ] + }, + { + "cell_type": "markdown", + "id": "14dc937e", + "metadata": {}, + "source": [ + "The vehicle is buffeted by random accelerations,\n", + "\n", + "$$\n", + "Q(k) = \\begin{bmatrix}\n", + "2.4064 × 10−5 & 0 & 0 \\\\\n", + "0 & 2.4064 × 10−5 & 0 \\\\\n", + "0 & 0 & 0\n", + "\\end{bmatrix}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "00b365fd", + "metadata": {}, + "source": [ + "The initial conditions assumed by the filter are,\n", + "\n", + "$$\n", + "\\vec{x}(0|0) = \\begin{bmatrix}\n", + "6500.4 \\\\\n", + "349.14 \\\\\n", + "-1.8093 \\\\\n", + "−6.7967 \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "and;\n", + "\n", + "$$\n", + "P(0|0) = \\begin{bmatrix}\n", + "10^{-6} & 0 & 0 & 0 & 0 \\\\\n", + "0 & 10^{-6} & 0 & 0 & 0 \\\\\n", + "0 & 0 & 10^{-6} & 0 & 0 \\\\\n", + "0 & 0 & 0 & 10^{-6} & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 \\\\\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "The filter uses the nominal initial condition and, to offset for the uncertainty, the variance on this initial estimate\n", + "is 1." + ] + }, + { + "cell_type": "markdown", + "id": "339b56b6", + "metadata": {}, + "source": [ + "Both filters were implemented in discrete time and observations were taken at a frequency of 10Hz.\n", + "\n", + "However, due to the intense nonlinearities of the vehicle dynamics equations, the Euler approximation of Equation 16 was\n", + "only valid for small time steps.\n", + "\n", + "The integration step was set to be 50ms which meant that two predictions were made per update.\n", + "\n", + "For the unscented filter, each sigma point was applied through the dynamics equations twice.\n", + "\n", + "For the EKF, it was necessary to perform an initial prediction step and re-linearise before the second step." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "ae60ba67", + "metadata": {}, + "outputs": [], + "source": [ + "beta_0 = 0.59783 # ballistic coefficient of the \"typical vehicle\"\n", + "H_0 = 13.406\n", + "R_0 = 6374.0\n", + "Gm0 = 3.9860e5\n", + "mu = 0.03\n", + "g = 9.81\n", + "\n", + "dt = 0.05\n", + "\n", + "def reentering_object_time_update(x, v):\n", + " x_out = np.copy(x)\n", + " \n", + " beta_k = beta_0 * np.exp(x[4]) # scaled ballistic coefficient\n", + " R_k = np.sqrt(x[0]**2 + x[1]**2) # absolute distance from the center of the Earth\n", + " V_k = np.sqrt(x[2]**2 + x[3]**2) # absolute vehicle speed\n", + " \n", + " D_k = -beta_k * np.exp((R_0 - R_k) / H_0) * V_k # drag-related force term\n", + " # G_k = -Gm0 / (R_0**3)\n", + " G_k = -g\n", + " \n", + " # x_2_dot = D_k * x[2] + G_k * x[0] # not working as in the paper\n", + " # x_3_dot = D_k * x[3] + G_k * x[1] # not working as in the paper\n", + " \n", + " x_2_dot = D_k * x[2] * V_k + G_k\n", + " x_3_dot = D_k * x[3] * V_k\n", + " \n", + " x_out[0] = x[0] + (x[2] * dt)\n", + " x_out[1] = x[1] + (x[3] * dt)\n", + " x_out[2] = x[2] + (x_2_dot * dt) + v[0]\n", + " x_out[3] = x[3] + (x_3_dot * dt) + v[1]\n", + " x_out[4] = x[4] + v[2]\n", + " \n", + " return x_out\n", + "\n", + "def range_bearing_model(x, n):\n", + " polar_r = np.sqrt(x[1]**2 + x[0]**2) + n[0]\n", + " polar_b = np.arctan2(x[0], x[1]) + n[1]\n", + " z = np.array([[polar_r], [polar_b]])\n", + " return z" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "6b5ceeb4", + "metadata": {}, + "outputs": [], + "source": [ + "actual_object_0 = np.array([[6500.4], [349.14], [-1.8093], [-6.7967], [0.6932]])\n", + "radar_pos = [R_0, 330]\n", + "\n", + "trajectory_list = []\n", + "actual_object_k = actual_object_0\n", + "actual_noise = np.zeros((3, 1))\n", + "\n", + "for i in range(300):\n", + " actual_object_k = reentering_object_time_update(actual_object_k, actual_noise)\n", + " trajectory_list.append(actual_object_k)\n", + "\n", + "# generate measurements\n", + "measurement_list = []\n", + "for i in range(0, 300, 2):\n", + " dx = trajectory_list[i][1] - radar_pos[1]\n", + " dy = trajectory_list[i][0] - radar_pos[0]\n", + " \n", + " meas_r = np.sqrt(dx**2 + dy**2) + np.random.normal(0.0, np.sqrt(1.0))\n", + " meas_b = np.arctan2(dy, dx) + np.random.normal(0.0, np.sqrt(17e-3))\n", + " meas_k = np.array([[meas_r], [meas_b]])\n", + " measurement_list.append(meas_k)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "45fcc65e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "obj_x_list = []\n", + "obj_y_list = []\n", + "for object_at_k in trajectory_list:\n", + " obj_x_list.append(object_at_k[1])\n", + " obj_y_list.append(object_at_k[0])\n", + " \n", + "meas_x_list = []\n", + "meas_y_list = []\n", + "for meas_at_k in measurement_list:\n", + " meas_x = meas_at_k[0] * np.cos(meas_at_k[1]) + radar_pos[1]\n", + " meas_y = meas_at_k[0] * np.sin(meas_at_k[1]) + radar_pos[0]\n", + " meas_x_list.append(meas_x)\n", + " meas_y_list.append(meas_y)\n", + " \n", + "plt.plot(actual_object_0[1], actual_object_0[0], 'x') # object initial position\n", + "plt.plot(radar_pos[1], radar_pos[0], 'o') # radar\n", + "plt.plot(obj_x_list, obj_y_list) # actual trajectory\n", + "plt.axhline(y = R_0, color = 'r', linestyle = '-') # earth surface\n", + "plt.scatter(meas_x_list, meas_y_list, color='grey')\n", + " \n", + "# rendering the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "f288f98a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P_a = \n", + "[[0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 2.4064e-05\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 2.4064e-05 0.0000e+00 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 1.0000e-02 0.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 1.0000e+00 0.0000e+00]\n", + " [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00\n", + " 0.0000e+00 0.0000e+00 0.0000e+00 1.7000e-02]]\n", + "\n" + ] + } + ], + "source": [ + "x0 = np.array([[6500.4], [349.14], [-1.8093], [-6.7967], [0.]])\n", + "\n", + "P0 = np.array([[10e-6, 0.0, 0.0, 0.0, 0.0],\n", + " [0.0, 10e-6, 0.0, 0.0, 0.0],\n", + " [0.0, 0.0, 10e-6, 0.0, 0.0],\n", + " [0.0, 0.0, 0.0, 10e-6, 0.0],\n", + " [0.0, 0.0, 0.0, 0.0, 1.0]])\n", + "\n", + "Q = np.array([[2.4064e-5, 0.0, 0.0],\n", + " [0.0, 2.4064e-5, 0.0],\n", + " [0.0, 0.0, 0.01]])\n", + "\n", + "R = np.array([[1.0, 0.0],[0.0, 17e-3]])\n", + "\n", + "nx = np.shape(x0)[0]\n", + "nz = np.shape(R)[0]\n", + "nv = np.shape(x0)[0]\n", + "nn = np.shape(R)[0]\n", + "\n", + "ukf = UKF(dim_x=nx, dim_z=nz, Q=Q, R=R, kappa=(3 - nx))" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "bbb62fd6", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "could not broadcast input array from shape (2,1) into shape (2,)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2948\\3010117484.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[0mz\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmeasurement_list\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mz_idx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[0mz_idx\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mP\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0m_\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mukf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcorrect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmeasurement_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mP\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mz\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[0mestimates\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2948\\3724165018.py\u001b[0m in \u001b[0;36mcorrect\u001b[1;34m(self, h, x, P, z)\u001b[0m\n\u001b[0;32m 87\u001b[0m \u001b[0my_sigmas\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdim_z\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn_sigma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 88\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn_sigma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 89\u001b[1;33m \u001b[0my_sigmas\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mh\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxx_sigmas\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mxn_sigmas\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 90\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 91\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mPyy\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcalculate_mean_and_covariance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_sigmas\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: could not broadcast input array from shape (2,1) into shape (2,)" + ] + } + ], + "source": [ + "x, P = x0, P0\n", + "x = np.reshape(x, (5,))\n", + "\n", + "estimates = []\n", + "z_idx = 0\n", + "for i in range(300):\n", + " x, P, _ = ukf.predict(reentering_object_time_update, x, P)\n", + " \n", + " if i % 2 != 0:\n", + " z = measurement_list[z_idx]\n", + " z_idx += 1\n", + " x, P, _ = ukf.correct(measurement_model, x, P, z)\n", + " \n", + " estimates.append(x)\n", + "\n", + "#estimates = np.asarray(estimates).T\n", + " " + ] + }, { "cell_type": "markdown", "id": "fd3064cb", @@ -1344,7 +1813,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.9.13" } }, "nbformat": 4, From 84900f998088500c752c9cfa092c7bf867ae4879 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Thu, 7 Mar 2024 23:14:03 +0100 Subject: [PATCH 36/60] refactoring and fix linux build --- cpp/CMakeLists.txt | 2 +- cpp/Examples/CMakeLists.txt | 1 + cpp/Examples/ekf_range_sensor/CMakeLists.txt | 57 +++--- cpp/Examples/ekf_range_sensor/main.cpp | 3 +- .../kf_state_estimation/CMakeLists.txt | 57 +++--- cpp/Examples/kf_state_estimation/main.cpp | 2 +- .../sr_ukf_linear_function/CMakeLists.txt | 57 +++--- cpp/Examples/sr_ukf_linear_function/main.cpp | 2 +- .../test_least_squares/CMakeLists.txt | 57 +++--- cpp/Examples/test_least_squares/main.cpp | 4 +- cpp/Examples/ukf_range_sensor/CMakeLists.txt | 57 +++--- cpp/Examples/ukf_range_sensor/main.cpp | 2 +- .../unscented_transform/CMakeLists.txt | 57 +++--- cpp/Examples/unscented_transform/main.cpp | 3 +- cpp/{kalman_filter => openkf}/CMakeLists.txt | 163 +++++++++--------- .../conf/Config.cmake.in | 10 +- cpp/{kalman_filter => openkf}/dummy.cpp | 4 +- .../kalman_filter/kalman_filter.h | 2 +- .../kalman_filter/square_root_ukf.h | 18 +- .../kalman_filter/unscented_kalman_filter.h | 26 +-- .../kalman_filter/unscented_transform.h | 39 +++-- cpp/{kalman_filter => openkf}/types.h | 0 cpp/{kalman_filter => openkf}/util.h | 15 ++ 23 files changed, 347 insertions(+), 291 deletions(-) rename cpp/{kalman_filter => openkf}/CMakeLists.txt (86%) rename cpp/{kalman_filter => openkf}/conf/Config.cmake.in (97%) rename cpp/{kalman_filter => openkf}/dummy.cpp (94%) rename cpp/{ => openkf}/kalman_filter/kalman_filter.h (96%) rename cpp/{ => openkf}/kalman_filter/square_root_ukf.h (93%) rename cpp/{ => openkf}/kalman_filter/unscented_kalman_filter.h (88%) rename cpp/{ => openkf}/kalman_filter/unscented_transform.h (80%) rename cpp/{kalman_filter => openkf}/types.h (100%) rename cpp/{kalman_filter => openkf}/util.h (90%) diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index 894feb9..9729a31 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -30,5 +30,5 @@ enable_language(C CXX) find_package(Eigen3 3.3 REQUIRED NO_MODULE) -add_subdirectory(kalman_filter) +add_subdirectory(openkf) add_subdirectory(examples) diff --git a/cpp/Examples/CMakeLists.txt b/cpp/Examples/CMakeLists.txt index 322ea8f..a2339e7 100644 --- a/cpp/Examples/CMakeLists.txt +++ b/cpp/Examples/CMakeLists.txt @@ -6,3 +6,4 @@ add_subdirectory(unscented_transform) add_subdirectory(ukf_range_sensor) add_subdirectory(test_least_squares) add_subdirectory(sr_ukf_linear_function) +add_subdirectory(gnss_application) \ No newline at end of file diff --git a/cpp/Examples/ekf_range_sensor/CMakeLists.txt b/cpp/Examples/ekf_range_sensor/CMakeLists.txt index 09ae273..18f799e 100644 --- a/cpp/Examples/ekf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ekf_range_sensor/CMakeLists.txt @@ -1,26 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ekf_range_sensor) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ekf_range_sensor) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/Examples/ekf_range_sensor/main.cpp index 36d5e73..b04a42f 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/Examples/ekf_range_sensor/main.cpp @@ -12,9 +12,8 @@ #include #include -#include "kalman_filter/types.h" +#include "types.h" #include "kalman_filter/kalman_filter.h" - #include "kalman_filter/unscented_transform.h" static constexpr size_t DIM_X{ 2 }; diff --git a/cpp/Examples/kf_state_estimation/CMakeLists.txt b/cpp/Examples/kf_state_estimation/CMakeLists.txt index d40497a..6bf3af1 100644 --- a/cpp/Examples/kf_state_estimation/CMakeLists.txt +++ b/cpp/Examples/kf_state_estimation/CMakeLists.txt @@ -1,26 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_kf_state_estimation) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_kf_state_estimation) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/Examples/kf_state_estimation/main.cpp index 942aaf3..59bc9c2 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/Examples/kf_state_estimation/main.cpp @@ -12,7 +12,7 @@ #include #include -#include "kalman_filter/types.h" +#include "types.h" #include "kalman_filter/kalman_filter.h" static constexpr size_t DIM_X{ 2 }; diff --git a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt b/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt index 66db641..8d2d05b 100644 --- a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt +++ b/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt @@ -1,26 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_sr_ukf_linear_function) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_sr_ukf_linear_function) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/sr_ukf_linear_function/main.cpp b/cpp/Examples/sr_ukf_linear_function/main.cpp index 53b0708..4af9909 100644 --- a/cpp/Examples/sr_ukf_linear_function/main.cpp +++ b/cpp/Examples/sr_ukf_linear_function/main.cpp @@ -12,7 +12,7 @@ #include #include -#include "kalman_filter/types.h" +#include "types.h" #include "kalman_filter/square_root_ukf.h" static constexpr size_t DIM_X{ 2 }; diff --git a/cpp/Examples/test_least_squares/CMakeLists.txt b/cpp/Examples/test_least_squares/CMakeLists.txt index d60593d..535f586 100644 --- a/cpp/Examples/test_least_squares/CMakeLists.txt +++ b/cpp/Examples/test_least_squares/CMakeLists.txt @@ -1,26 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_test_least_squares) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_test_least_squares) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/test_least_squares/main.cpp b/cpp/Examples/test_least_squares/main.cpp index 8c305fe..dd8c44b 100644 --- a/cpp/Examples/test_least_squares/main.cpp +++ b/cpp/Examples/test_least_squares/main.cpp @@ -12,8 +12,8 @@ #include #include -#include "kalman_filter/types.h" -#include "kalman_filter/util.h" +#include "types.h" +#include "util.h" void runExample1(); void runExample2(); diff --git a/cpp/Examples/ukf_range_sensor/CMakeLists.txt b/cpp/Examples/ukf_range_sensor/CMakeLists.txt index b971370..caafb00 100644 --- a/cpp/Examples/ukf_range_sensor/CMakeLists.txt +++ b/cpp/Examples/ukf_range_sensor/CMakeLists.txt @@ -1,26 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ukf_range_sensor) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ukf_range_sensor) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/Examples/ukf_range_sensor/main.cpp index 1e6514d..bc77d4f 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/Examples/ukf_range_sensor/main.cpp @@ -12,7 +12,7 @@ #include #include -#include "kalman_filter/types.h" +#include "types.h" #include "kalman_filter/unscented_kalman_filter.h" static constexpr size_t DIM_X{ 4 }; diff --git a/cpp/Examples/unscented_transform/CMakeLists.txt b/cpp/Examples/unscented_transform/CMakeLists.txt index fad0660..3ba98c1 100644 --- a/cpp/Examples/unscented_transform/CMakeLists.txt +++ b/cpp/Examples/unscented_transform/CMakeLists.txt @@ -1,26 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_unscented_transform) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${APPLICATION_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_unscented_transform) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/Examples/unscented_transform/main.cpp index 2f3b9ae..17abc4c 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/Examples/unscented_transform/main.cpp @@ -12,9 +12,8 @@ #include #include -#include "kalman_filter/types.h" +#include "types.h" #include "kalman_filter/kalman_filter.h" - #include "kalman_filter/unscented_transform.h" static constexpr size_t DIM_1{ 1 }; diff --git a/cpp/kalman_filter/CMakeLists.txt b/cpp/openkf/CMakeLists.txt similarity index 86% rename from cpp/kalman_filter/CMakeLists.txt rename to cpp/openkf/CMakeLists.txt index 79272f4..d7637e6 100644 --- a/cpp/kalman_filter/CMakeLists.txt +++ b/cpp/openkf/CMakeLists.txt @@ -1,81 +1,84 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -# file(GLOB LIBRARY_FILES -# "${CMAKE_CURRENT_SOURCE_DIR}/*.h" -# "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -# ) - -set(LIBRARY_SRC_FILES - dummy.cpp -) - -set(LIBRARY_HDR_FILES - types.h - util.h - kalman_filter.h - unscented_transform.h - unscented_kalman_filter.h - square_root_ukf.h -) - -set(LIBRARY_NAME ${PROJECT_NAME}) - -add_library(${LIBRARY_NAME} ${LIBRARY_SRC_FILES} ${LIBRARY_HDR_FILES}) - -set_target_properties(${LIBRARY_NAME} PROPERTIES LINKER_LANGUAGE CXX) -target_link_libraries(${LIBRARY_NAME} PUBLIC Eigen3::Eigen) - -target_include_directories(${LIBRARY_NAME} PUBLIC - $ - $ -) - -include(CMakePackageConfigHelpers) - -configure_package_config_file( - ${CMAKE_CURRENT_SOURCE_DIR}/conf/Config.cmake.in - ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}Config.cmake - INSTALL_DESTINATION ${CONFIG_INSTALL_DIR} - PATH_VARS INCLUDE_FOLDER -) - -write_basic_package_version_file( - ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}ConfigVersion.cmake - VERSION 1.0.0 - COMPATIBILITY SameMajorVersion -) - -install( - FILES ${LIBRARY_HDR_FILES} - DESTINATION ${INCLUDE_INSTALL_DIR} -) - -install( - FILES ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}Config.cmake - ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}ConfigVersion.cmake - DESTINATION ${CONFIG_INSTALL_DIR} -) - -install( - TARGETS ${LIBRARY_NAME} - EXPORT "${TARGETS_EXPORT_NAME}" - LIBRARY DESTINATION "${LIBRARY_INSTALL_DIR}" - ARCHIVE DESTINATION "${LIBRARY_INSTALL_DIR}" - INCLUDES DESTINATION "${INCLUDE_FOLDER}" -) - -# Config -# * /lib/cmake/OpenKF/OpenKFTargets.cmake -install( - EXPORT ${TARGETS_EXPORT_NAME} - DESTINATION ${CONFIG_INSTALL_DIR} +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +# file(GLOB LIBRARY_FILES +# "${CMAKE_CURRENT_SOURCE_DIR}/*.h" +# "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +# ) + +set(LIBRARY_SRC_FILES + dummy.cpp +) + +set(LIBRARY_HDR_FILES + types.h + util.h + kalman_filter/kalman_filter.h + kalman_filter/unscented_transform.h + kalman_filter/unscented_kalman_filter.h + kalman_filter/square_root_ukf.h + helpers/helpers.h + gnss/representation.h + gnss/geodetic.h +) + +set(LIBRARY_NAME ${PROJECT_NAME}) + +add_library(${LIBRARY_NAME} ${LIBRARY_SRC_FILES} ${LIBRARY_HDR_FILES}) + +set_target_properties(${LIBRARY_NAME} PROPERTIES LINKER_LANGUAGE CXX) +target_link_libraries(${LIBRARY_NAME} PUBLIC Eigen3::Eigen) + +target_include_directories(${LIBRARY_NAME} PUBLIC + $ + $ +) + +include(CMakePackageConfigHelpers) + +configure_package_config_file( + ${CMAKE_CURRENT_SOURCE_DIR}/conf/Config.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}Config.cmake + INSTALL_DESTINATION ${CONFIG_INSTALL_DIR} + PATH_VARS INCLUDE_FOLDER +) + +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}ConfigVersion.cmake + VERSION 1.0.0 + COMPATIBILITY SameMajorVersion +) + +install( + FILES ${LIBRARY_HDR_FILES} + DESTINATION ${INCLUDE_INSTALL_DIR} +) + +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}Config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}ConfigVersion.cmake + DESTINATION ${CONFIG_INSTALL_DIR} +) + +install( + TARGETS ${LIBRARY_NAME} + EXPORT "${TARGETS_EXPORT_NAME}" + LIBRARY DESTINATION "${LIBRARY_INSTALL_DIR}" + ARCHIVE DESTINATION "${LIBRARY_INSTALL_DIR}" + INCLUDES DESTINATION "${INCLUDE_FOLDER}" +) + +# Config +# * /lib/cmake/OpenKF/OpenKFTargets.cmake +install( + EXPORT ${TARGETS_EXPORT_NAME} + DESTINATION ${CONFIG_INSTALL_DIR} ) \ No newline at end of file diff --git a/cpp/kalman_filter/conf/Config.cmake.in b/cpp/openkf/conf/Config.cmake.in similarity index 97% rename from cpp/kalman_filter/conf/Config.cmake.in rename to cpp/openkf/conf/Config.cmake.in index da23610..43aad96 100644 --- a/cpp/kalman_filter/conf/Config.cmake.in +++ b/cpp/openkf/conf/Config.cmake.in @@ -1,6 +1,6 @@ -@PACKAGE_INIT@ - -set_and_check(OPENKF_INCLUDE_DIR "@PACKAGE_INCLUDE_FOLDER@") -include( "${CMAKE_CURRENT_LIST_DIR}/OpenKFTargets.cmake" ) - +@PACKAGE_INIT@ + +set_and_check(OPENKF_INCLUDE_DIR "@PACKAGE_INCLUDE_FOLDER@") +include( "${CMAKE_CURRENT_LIST_DIR}/OpenKFTargets.cmake" ) + check_required_components(OpenKF) \ No newline at end of file diff --git a/cpp/kalman_filter/dummy.cpp b/cpp/openkf/dummy.cpp similarity index 94% rename from cpp/kalman_filter/dummy.cpp rename to cpp/openkf/dummy.cpp index e13446f..7827c80 100644 --- a/cpp/kalman_filter/dummy.cpp +++ b/cpp/openkf/dummy.cpp @@ -1,2 +1,2 @@ - -static void dummyFunction() {} + +static void dummyFunction() {} diff --git a/cpp/kalman_filter/kalman_filter.h b/cpp/openkf/kalman_filter/kalman_filter.h similarity index 96% rename from cpp/kalman_filter/kalman_filter.h rename to cpp/openkf/kalman_filter/kalman_filter.h index 6efc155..38272ce 100644 --- a/cpp/kalman_filter/kalman_filter.h +++ b/cpp/openkf/kalman_filter/kalman_filter.h @@ -16,7 +16,7 @@ namespace kf { - template + template class KalmanFilter { public: diff --git a/cpp/kalman_filter/square_root_ukf.h b/cpp/openkf/kalman_filter/square_root_ukf.h similarity index 93% rename from cpp/kalman_filter/square_root_ukf.h rename to cpp/openkf/kalman_filter/square_root_ukf.h index bfa6c4e..e77a595 100644 --- a/cpp/kalman_filter/square_root_ukf.h +++ b/cpp/openkf/kalman_filter/square_root_ukf.h @@ -23,7 +23,8 @@ namespace kf public: static constexpr int32_t SIGMA_DIM{ 2 * DIM_X + 1 }; - SquareRootUKF() : KalmanFilter() + SquareRootUKF() + : KalmanFilter() { // calculate weights const float32_t kappa{ static_cast(3 - DIM_X) }; @@ -87,7 +88,7 @@ namespace kf void setCovarianceR(const Matrix & matR) { // cholesky factorization to get matrix R square-root - Eigen::LLT> lltOfRn(matQ); + Eigen::LLT> lltOfRn(matR); m_matRn = lltOfRn.matrixL(); // sqrt(R) } @@ -297,12 +298,17 @@ namespace kf // _, S_minus = np.linalg.qr(C) Eigen::HouseholderQR< Matrix > qr(matC); + Matrix qrMatrixUpper{ qr.matrixQR() }; + qrMatrixUpper = util::getUpperTriangulerView(qrMatrixUpper); + // get the upper triangular matrix from the factorization // might need to reimplement QR factorization it as it seems to use dynamic memory allocation - Matrix matR{ - util::getBlock( - qr.matrixQR().triangularView(), 0, 0) - }; + // Matrix matR{ + // util::getBlock( + // qr.matrixQR().triangularView(), 0, 0) + // }; + + Matrix matR{ util::getBlock(qrMatrixUpper, 0, 0) }; // Rank - 1 cholesky update // x_dev = sigmas_X[:, 0] - x_minus diff --git a/cpp/kalman_filter/unscented_kalman_filter.h b/cpp/openkf/kalman_filter/unscented_kalman_filter.h similarity index 88% rename from cpp/kalman_filter/unscented_kalman_filter.h rename to cpp/openkf/kalman_filter/unscented_kalman_filter.h index 7cf1be0..d1055fc 100644 --- a/cpp/kalman_filter/unscented_kalman_filter.h +++ b/cpp/openkf/kalman_filter/unscented_kalman_filter.h @@ -24,7 +24,8 @@ namespace kf static constexpr int32_t DIM_A{ DIM_X + DIM_V + DIM_N }; static constexpr int32_t SIGMA_DIM{ 2 * DIM_A + 1 }; - UnscentedKalmanFilter() : KalmanFilter() + UnscentedKalmanFilter() + : KalmanFilter() { // 1. calculate weights const float32_t kappa{ static_cast(3 - DIM_A) }; @@ -95,10 +96,11 @@ namespace kf Matrix matSigmaXa{ calculateSigmaPoints(m_vecXa, m_matPa, kappa) }; // xx_sigmas = xa_sigmas[:self.dim_x, :] - Matrix sigmaXx{ matSigmaXa.block(0, 0) }; + //Matrix sigmaXx{ matSigmaXa.block(0, 0) }; + Matrix sigmaXx{ matSigmaXa.block(0, 0, DIM_X, SIGMA_DIM) }; // xv_sigmas = xa_sigmas[self.dim_x : self.dim_x + self.dim_v, :] - Matrix sigmaXv{ matSigmaXa.block(DIM_X, 0) }; + Matrix sigmaXv{ matSigmaXa.block(DIM_X, 0, DIM_V, SIGMA_DIM) }; // y_sigmas = np.zeros((self.dim_x, self.n_sigma)) // for i in range(self.n_sigma): @@ -139,10 +141,10 @@ namespace kf Matrix matSigmaXa{ calculateSigmaPoints(m_vecXa, m_matPa, kappa) }; // xx_sigmas = xa_sigmas[:self.dim_x, :] - Matrix sigmaXx{ matSigmaXa.block(0, 0) }; + Matrix sigmaXx{ matSigmaXa.block(0, 0, DIM_X, SIGMA_DIM) }; // xn_sigmas = xa_sigmas[self.dim_x + self.dim_v :, :] - Matrix sigmaXn{ matSigmaXa.block(DIM_X + DIM_V, 0) }; + Matrix sigmaXn{ matSigmaXa.block(DIM_X + DIM_V, 0, DIM_N, SIGMA_DIM) }; // y_sigmas = np.zeros((self.dim_z, self.n_sigma)) // for i in range(self.n_sigma) : @@ -272,25 +274,25 @@ namespace kf /// @param vecX output weighted mean /// @param matP output weighted covariance /// - template - void calculateWeightedMeanAndCovariance(const Matrix & sigmaX, Vector & vecX, Matrix & matPxx) + template + void calculateWeightedMeanAndCovariance(const Matrix & sigmaX, Vector & vecX, Matrix & matPxx) { // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] - vecX = m_weight0 * util::getColumnAt(0, sigmaX); + vecX = m_weight0 * util::getColumnAt(0, sigmaX); for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - vecX += m_weighti * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] + vecX += m_weighti * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] } // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T - Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // Y[:, 0] - \bar{ y } + Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // Y[:, 0] - \bar{ y } matPxx = m_weight0 * devXi * devXi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - devXi = util::getColumnAt(i, sigmaX) - vecX; // Y[:, i] - \bar{y} + devXi = util::getColumnAt(i, sigmaX) - vecX; // Y[:, i] - \bar{y} - const Matrix Pi{ m_weighti * devXi * devXi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + const Matrix Pi{ m_weighti * devXi * devXi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T matPxx += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T } diff --git a/cpp/kalman_filter/unscented_transform.h b/cpp/openkf/kalman_filter/unscented_transform.h similarity index 80% rename from cpp/kalman_filter/unscented_transform.h rename to cpp/openkf/kalman_filter/unscented_transform.h index 87538c3..220c4bd 100644 --- a/cpp/kalman_filter/unscented_transform.h +++ b/cpp/openkf/kalman_filter/unscented_transform.h @@ -27,8 +27,8 @@ namespace kf UnscentedTransform() {} ~UnscentedTransform() {} - float32_t weight0() const { return _weight0; } - float32_t weighti() const { return _weighti; } + float32_t weight0() const { return _weights[0]; } + float32_t weighti() const { return _weights[1]; } /// /// @brief algorithm to execute weight and sigma points calculation @@ -49,21 +49,21 @@ namespace kf void calculateWeightedMeanAndCovariance(const Matrix & sigmaX, Vector & vecX, Matrix & matPxx) { // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] - vecX = _weight0 * util::getColumnAt(0, sigmaX); + vecX = _weights[0] * util::getColumnAt(0, sigmaX); for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - vecX += _weighti * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] + vecX += _weights[1] * util::getColumnAt(i, sigmaX); // y += W[0, i] Y[:, i] } // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T Vector devXi{ util::getColumnAt(0, sigmaX) - vecX }; // Y[:, 0] - \bar{ y } - matPxx = _weight0 * devXi * devXi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T + matPxx = _weights[0] * devXi * devXi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { devXi = util::getColumnAt(i, sigmaX) - vecX; // Y[:, i] - \bar{y} - const Matrix Pi{ _weighti * devXi * devXi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + const Matrix Pi{ _weights[1] * devXi * devXi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T matPxx += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T } @@ -92,22 +92,23 @@ namespace kf { std::cout << "DIM_N : " << DIM << "\n"; std::cout << "DIM_M : " << SIGMA_DIM << "\n"; - std::cout << "_weight0 : \n" << _weight0 << "\n"; - std::cout << "_weighti : \n" << _weighti << "\n"; + std::cout << "_weights[0] : \n" << _weights[0] << "\n"; + std::cout << "_weights[1] : \n" << _weights[1] << "\n"; std::cout << "_sigmaX : \n" << _sigmaX << "\n"; } - Matrix<1, SIGMA_DIM> & weights() { return _weights; } - const Matrix<1, SIGMA_DIM> & weights() const { return _weights; } + Matrix<1, 2> & weights() { return _weights; } + const Matrix<1, 2> & weights() const { return _weights; } Matrix & sigmaX() { return _sigmaX; } const Matrix & sigmaX() const { return _sigmaX; } private: - float32_t _weight0; /// @brief unscented transform weight 0 for mean - float32_t _weighti; /// @brief unscented transform weight 0 for none mean samples + /// @brief unscented transform weight 0 for mean + Matrix<1, 2> _weights; - Matrix _sigmaX; /// @brief input sigma points + /// @brief input sigma points + Matrix _sigmaX; /// /// @brief algorithm to calculate the weights used to draw the sigma points @@ -119,8 +120,8 @@ namespace kf const float32_t denoTerm{ kappa + static_cast(DIM) }; - _weight0 = kappa / denoTerm; - _weighti = 0.5F / denoTerm; + _weights[0] = kappa / denoTerm; + _weights[1] = 0.5F / denoTerm; } /// @@ -185,21 +186,21 @@ namespace kf void updateTransformedMeanAndCovariance(const Matrix & sigmaY, Vector & vecY, Matrix & matPyy) { // 1. calculate mean: \bar{y} = \sum_{i_0}^{2n} W[0, i] Y[:, i] - vecY = _weight0 * util::getColumnAt(0, sigmaY); + vecY = _weights[0] * util::getColumnAt(0, sigmaY); for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { - vecY += _weighti * util::getColumnAt(i, sigmaY); // y += W[0, i] Y[:, i] + vecY += _weights[1] * util::getColumnAt(i, sigmaY); // y += W[0, i] Y[:, i] } // 2. calculate covariance: P_{yy} = \sum_{i_0}^{2n} W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T Vector devYi{ util::getColumnAt(0, sigmaY) - vecY }; // Y[:, 0] - \bar{ y } - matPyy = _weight0 * devYi * devYi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T + matPyy = _weights[0] * devYi * devYi.transpose(); // P_0 = W[0, 0] (Y[:, 0] - \bar{y}) (Y[:, 0] - \bar{y})^T for (size_t i{ 1 }; i < SIGMA_DIM; ++i) { devYi = util::getColumnAt(i, sigmaY) - vecY; // Y[:, i] - \bar{y} - const Matrix Pi{ _weighti * devYi * devYi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T + const Matrix Pi{ _weights[1] * devYi * devYi.transpose() }; // P_i = W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T matPyy += Pi; // y += W[0, i] (Y[:, i] - \bar{y}) (Y[:, i] - \bar{y})^T } diff --git a/cpp/kalman_filter/types.h b/cpp/openkf/types.h similarity index 100% rename from cpp/kalman_filter/types.h rename to cpp/openkf/types.h diff --git a/cpp/kalman_filter/util.h b/cpp/openkf/util.h similarity index 90% rename from cpp/kalman_filter/util.h rename to cpp/openkf/util.h index b66d479..ce703dd 100644 --- a/cpp/kalman_filter/util.h +++ b/cpp/openkf/util.h @@ -76,6 +76,21 @@ namespace kf return matB; } + template + Matrix getUpperTriangulerView(const Matrix& matA) + { + Matrix matB; + for (int32_t i = 0; i < ROWS; ++i) + { + for (int32_t j = i; j < COLS; ++j) + { + matB(i, j) = matA(i, j); + matB(j, i) = 0.0F; + } + } + return matB; + } + template Matrix cholupdate(Matrix matL, Matrix matW, float32_t alpha) { From b2a092355f337673f958f5ac0d2480a5ed59db69 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Thu, 7 Mar 2024 23:26:18 +0100 Subject: [PATCH 37/60] fix bug in upper trianguler view --- cpp/openkf/util.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/cpp/openkf/util.h b/cpp/openkf/util.h index ce703dd..dba60a2 100644 --- a/cpp/openkf/util.h +++ b/cpp/openkf/util.h @@ -85,7 +85,10 @@ namespace kf for (int32_t j = i; j < COLS; ++j) { matB(i, j) = matA(i, j); - matB(j, i) = 0.0F; + if (i != j) + { + matB(j, i) = 0.0F; + } } } return matB; From dde2cd4be61ee9b8a33d0e85c2efca11a74c188c Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Fri, 8 Mar 2024 11:08:40 +0100 Subject: [PATCH 38/60] changing capitalization of folder examples --- cpp/{Examples => examples}/CMakeLists.txt | 16 +- .../ekf_range_sensor/CMakeLists.txt | 62 ++--- .../ekf_range_sensor/main.cpp | 148 +++++------ .../kf_state_estimation/CMakeLists.txt | 62 ++--- .../kf_state_estimation/main.cpp | 140 +++++----- .../sr_ukf_linear_function/CMakeLists.txt | 62 ++--- .../sr_ukf_linear_function/main.cpp | 194 +++++++------- .../test_least_squares/CMakeLists.txt | 62 ++--- .../test_least_squares/main.cpp | 224 ++++++++-------- .../ukf_range_sensor/CMakeLists.txt | 62 ++--- .../ukf_range_sensor/main.cpp | 240 +++++++++--------- .../unscented_transform/CMakeLists.txt | 62 ++--- .../unscented_transform/main.cpp | 198 +++++++-------- 13 files changed, 766 insertions(+), 766 deletions(-) rename cpp/{Examples => examples}/CMakeLists.txt (97%) rename cpp/{Examples => examples}/ekf_range_sensor/CMakeLists.txt (96%) rename cpp/{Examples => examples}/ekf_range_sensor/main.cpp (96%) rename cpp/{Examples => examples}/kf_state_estimation/CMakeLists.txt (96%) rename cpp/{Examples => examples}/kf_state_estimation/main.cpp (96%) rename cpp/{Examples => examples}/sr_ukf_linear_function/CMakeLists.txt (96%) rename cpp/{Examples => examples}/sr_ukf_linear_function/main.cpp (95%) rename cpp/{Examples => examples}/test_least_squares/CMakeLists.txt (96%) rename cpp/{Examples => examples}/test_least_squares/main.cpp (95%) rename cpp/{Examples => examples}/ukf_range_sensor/CMakeLists.txt (96%) rename cpp/{Examples => examples}/ukf_range_sensor/main.cpp (96%) rename cpp/{Examples => examples}/unscented_transform/CMakeLists.txt (96%) rename cpp/{Examples => examples}/unscented_transform/main.cpp (95%) diff --git a/cpp/Examples/CMakeLists.txt b/cpp/examples/CMakeLists.txt similarity index 97% rename from cpp/Examples/CMakeLists.txt rename to cpp/examples/CMakeLists.txt index a2339e7..29ec0db 100644 --- a/cpp/Examples/CMakeLists.txt +++ b/cpp/examples/CMakeLists.txt @@ -1,9 +1,9 @@ -set(EXAMPLE_EXECUTABLE_PREFIX "example_") - -add_subdirectory(kf_state_estimation) -add_subdirectory(ekf_range_sensor) -add_subdirectory(unscented_transform) -add_subdirectory(ukf_range_sensor) -add_subdirectory(test_least_squares) -add_subdirectory(sr_ukf_linear_function) +set(EXAMPLE_EXECUTABLE_PREFIX "example_") + +add_subdirectory(kf_state_estimation) +add_subdirectory(ekf_range_sensor) +add_subdirectory(unscented_transform) +add_subdirectory(ukf_range_sensor) +add_subdirectory(test_least_squares) +add_subdirectory(sr_ukf_linear_function) add_subdirectory(gnss_application) \ No newline at end of file diff --git a/cpp/Examples/ekf_range_sensor/CMakeLists.txt b/cpp/examples/ekf_range_sensor/CMakeLists.txt similarity index 96% rename from cpp/Examples/ekf_range_sensor/CMakeLists.txt rename to cpp/examples/ekf_range_sensor/CMakeLists.txt index 18f799e..6236de0 100644 --- a/cpp/Examples/ekf_range_sensor/CMakeLists.txt +++ b/cpp/examples/ekf_range_sensor/CMakeLists.txt @@ -1,31 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ekf_range_sensor) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) - -target_link_libraries(${APPLICATION_NAME} - PUBLIC - Eigen3::Eigen - OpenKF -) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ekf_range_sensor) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/ekf_range_sensor/main.cpp b/cpp/examples/ekf_range_sensor/main.cpp similarity index 96% rename from cpp/Examples/ekf_range_sensor/main.cpp rename to cpp/examples/ekf_range_sensor/main.cpp index b04a42f..bfa21e8 100644 --- a/cpp/Examples/ekf_range_sensor/main.cpp +++ b/cpp/examples/ekf_range_sensor/main.cpp @@ -1,74 +1,74 @@ -/// -/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) -/// -/// Use of this source code is governed by an GPL-3.0 - style -/// license that can be found in the LICENSE file or at -/// https://opensource.org/licenses/GPL-3.0 -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "types.h" -#include "kalman_filter/kalman_filter.h" -#include "kalman_filter/unscented_transform.h" - -static constexpr size_t DIM_X{ 2 }; -static constexpr size_t DIM_Z{ 2 }; - -static kf::KalmanFilter kalmanfilter; - -kf::Vector covertCartesian2Polar(const kf::Vector & cartesian); -kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX); -void executeCorrectionStep(); - -int main(int argc, char ** argv) -{ - executeCorrectionStep(); - - return 0; -} - -kf::Vector covertCartesian2Polar(const kf::Vector & cartesian) -{ - const kf::Vector polar{ - std::sqrt(cartesian[0] * cartesian[0] + cartesian[1] * cartesian[1]), - std::atan2(cartesian[1], cartesian[0]) - }; - return polar; -} - -kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX) -{ - const kf::float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; - const kf::float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; - - kf::Matrix matHj; - matHj << - (vecX[0] / valSqrtX2PlusY2), (vecX[1] / valSqrtX2PlusY2), - (-vecX[1] / valX2PlusY2), (vecX[0] / valX2PlusY2); - - return matHj; -} - -void executeCorrectionStep() -{ - kalmanfilter.vecX() << 10.0F, 5.0F; - kalmanfilter.matP() << 0.3F, 0.0F, 0.0F, 0.3F; - - const kf::Vector measPosCart{ 10.4F, 5.2F }; - const kf::Vector vecZ{ covertCartesian2Polar(measPosCart) }; - - kf::Matrix matR; - matR << 0.1F, 0.0F, 0.0F, 0.0008F; - - kf::Matrix matHj{ calculateJacobianMatrix(kalmanfilter.vecX()) }; // jacobian matrix Hj - - kalmanfilter.correctEkf(covertCartesian2Polar, vecZ, matR, matHj); - - std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; - std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; -} +/// +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "types.h" +#include "kalman_filter/kalman_filter.h" +#include "kalman_filter/unscented_transform.h" + +static constexpr size_t DIM_X{ 2 }; +static constexpr size_t DIM_Z{ 2 }; + +static kf::KalmanFilter kalmanfilter; + +kf::Vector covertCartesian2Polar(const kf::Vector & cartesian); +kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX); +void executeCorrectionStep(); + +int main(int argc, char ** argv) +{ + executeCorrectionStep(); + + return 0; +} + +kf::Vector covertCartesian2Polar(const kf::Vector & cartesian) +{ + const kf::Vector polar{ + std::sqrt(cartesian[0] * cartesian[0] + cartesian[1] * cartesian[1]), + std::atan2(cartesian[1], cartesian[0]) + }; + return polar; +} + +kf::Matrix calculateJacobianMatrix(const kf::Vector & vecX) +{ + const kf::float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; + const kf::float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; + + kf::Matrix matHj; + matHj << + (vecX[0] / valSqrtX2PlusY2), (vecX[1] / valSqrtX2PlusY2), + (-vecX[1] / valX2PlusY2), (vecX[0] / valX2PlusY2); + + return matHj; +} + +void executeCorrectionStep() +{ + kalmanfilter.vecX() << 10.0F, 5.0F; + kalmanfilter.matP() << 0.3F, 0.0F, 0.0F, 0.3F; + + const kf::Vector measPosCart{ 10.4F, 5.2F }; + const kf::Vector vecZ{ covertCartesian2Polar(measPosCart) }; + + kf::Matrix matR; + matR << 0.1F, 0.0F, 0.0F, 0.0008F; + + kf::Matrix matHj{ calculateJacobianMatrix(kalmanfilter.vecX()) }; // jacobian matrix Hj + + kalmanfilter.correctEkf(covertCartesian2Polar, vecZ, matR, matHj); + + std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; + std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; +} diff --git a/cpp/Examples/kf_state_estimation/CMakeLists.txt b/cpp/examples/kf_state_estimation/CMakeLists.txt similarity index 96% rename from cpp/Examples/kf_state_estimation/CMakeLists.txt rename to cpp/examples/kf_state_estimation/CMakeLists.txt index 6bf3af1..e2c1f4b 100644 --- a/cpp/Examples/kf_state_estimation/CMakeLists.txt +++ b/cpp/examples/kf_state_estimation/CMakeLists.txt @@ -1,31 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_kf_state_estimation) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) - -target_link_libraries(${APPLICATION_NAME} - PUBLIC - Eigen3::Eigen - OpenKF -) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_kf_state_estimation) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/kf_state_estimation/main.cpp b/cpp/examples/kf_state_estimation/main.cpp similarity index 96% rename from cpp/Examples/kf_state_estimation/main.cpp rename to cpp/examples/kf_state_estimation/main.cpp index 59bc9c2..e8661c1 100644 --- a/cpp/Examples/kf_state_estimation/main.cpp +++ b/cpp/examples/kf_state_estimation/main.cpp @@ -1,70 +1,70 @@ -/// -/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) -/// -/// Use of this source code is governed by an GPL-3.0 - style -/// license that can be found in the LICENSE file or at -/// https://opensource.org/licenses/GPL-3.0 -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "types.h" -#include "kalman_filter/kalman_filter.h" - -static constexpr size_t DIM_X{ 2 }; -static constexpr size_t DIM_Z{ 1 }; -static constexpr kf::float32_t T{ 1.0F }; -static constexpr kf::float32_t Q11{ 0.1F }, Q22{ 0.1F }; - -static kf::KalmanFilter kalmanfilter; - -void executePredictionStep(); -void executeCorrectionStep(); - -int main(int argc, char ** argv) -{ - executePredictionStep(); - executeCorrectionStep(); - - return 0; -} - -void executePredictionStep() -{ - kalmanfilter.vecX() << 0.0F, 2.0F; - kalmanfilter.matP() << 0.1F, 0.0F, 0.0F, 0.1F; - - kf::Matrix F; // state transition matrix - F << 1.0F, T, 0.0F, 1.0F; - - kf::Matrix Q; // process noise covariance - Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3) / 3.0F)); - Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2) / 2.0F); - Q(1, 1) = Q22 * T; - - kalmanfilter.predictLKF(F, Q); // execute prediction step - - std::cout << "\npredicted state vector = \n" << kalmanfilter.vecX() << "\n"; - std::cout << "\npredicted state covariance = \n" << kalmanfilter.matP() << "\n"; -} - -void executeCorrectionStep() -{ - kf::Vector vecZ; - vecZ << 2.25F; - - kf::Matrix matR; - matR << 0.01F; - - kf::Matrix matH; - matH << 1.0F, 0.0F; - - kalmanfilter.correctLKF(vecZ, matR, matH); - - std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; - std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; -} +/// +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "types.h" +#include "kalman_filter/kalman_filter.h" + +static constexpr size_t DIM_X{ 2 }; +static constexpr size_t DIM_Z{ 1 }; +static constexpr kf::float32_t T{ 1.0F }; +static constexpr kf::float32_t Q11{ 0.1F }, Q22{ 0.1F }; + +static kf::KalmanFilter kalmanfilter; + +void executePredictionStep(); +void executeCorrectionStep(); + +int main(int argc, char ** argv) +{ + executePredictionStep(); + executeCorrectionStep(); + + return 0; +} + +void executePredictionStep() +{ + kalmanfilter.vecX() << 0.0F, 2.0F; + kalmanfilter.matP() << 0.1F, 0.0F, 0.0F, 0.1F; + + kf::Matrix F; // state transition matrix + F << 1.0F, T, 0.0F, 1.0F; + + kf::Matrix Q; // process noise covariance + Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3) / 3.0F)); + Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2) / 2.0F); + Q(1, 1) = Q22 * T; + + kalmanfilter.predictLKF(F, Q); // execute prediction step + + std::cout << "\npredicted state vector = \n" << kalmanfilter.vecX() << "\n"; + std::cout << "\npredicted state covariance = \n" << kalmanfilter.matP() << "\n"; +} + +void executeCorrectionStep() +{ + kf::Vector vecZ; + vecZ << 2.25F; + + kf::Matrix matR; + matR << 0.01F; + + kf::Matrix matH; + matH << 1.0F, 0.0F; + + kalmanfilter.correctLKF(vecZ, matR, matH); + + std::cout << "\ncorrected state vector = \n" << kalmanfilter.vecX() << "\n"; + std::cout << "\ncorrected state covariance = \n" << kalmanfilter.matP() << "\n"; +} diff --git a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt b/cpp/examples/sr_ukf_linear_function/CMakeLists.txt similarity index 96% rename from cpp/Examples/sr_ukf_linear_function/CMakeLists.txt rename to cpp/examples/sr_ukf_linear_function/CMakeLists.txt index 8d2d05b..abc4e58 100644 --- a/cpp/Examples/sr_ukf_linear_function/CMakeLists.txt +++ b/cpp/examples/sr_ukf_linear_function/CMakeLists.txt @@ -1,31 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_sr_ukf_linear_function) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) - -target_link_libraries(${APPLICATION_NAME} - PUBLIC - Eigen3::Eigen - OpenKF -) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_sr_ukf_linear_function) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/sr_ukf_linear_function/main.cpp b/cpp/examples/sr_ukf_linear_function/main.cpp similarity index 95% rename from cpp/Examples/sr_ukf_linear_function/main.cpp rename to cpp/examples/sr_ukf_linear_function/main.cpp index 4af9909..0157d4a 100644 --- a/cpp/Examples/sr_ukf_linear_function/main.cpp +++ b/cpp/examples/sr_ukf_linear_function/main.cpp @@ -1,97 +1,97 @@ -/// -/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) -/// -/// Use of this source code is governed by an GPL-3.0 - style -/// license that can be found in the LICENSE file or at -/// https://opensource.org/licenses/GPL-3.0 -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "types.h" -#include "kalman_filter/square_root_ukf.h" - -static constexpr size_t DIM_X{ 2 }; -static constexpr size_t DIM_Z{ 2 }; - -void runExample1(); - -kf::Vector funcF(const kf::Vector & x) -{ - return x; -} - -int main(int argc, char ** argv) -{ - // example 1 - runExample1(); - - return 0; -} - -void runExample1() -{ - std::cout << " Start of Example 1: ===========================" << std::endl; - - // initializations - //x0 = np.array([1.0, 2.0]) - //P0 = np.array([[1.0, 0.5], [0.5, 1.0]]) - //Q = np.array([[0.5, 0.0], [0.0, 0.5]]) - - //z = np.array([1.2, 1.8]) - //R = np.array([[0.3, 0.0], [0.0, 0.3]]) - - kf::Vector x; - x << 1.0F, 2.0F; - - kf::Matrix P; - P << 1.0F, 0.5F, - 0.5F, 1.0F; - - kf::Matrix Q; - Q << 0.5F, 0.0F, - 0.0F, 0.5F; - - kf::Vector z; - z << 1.2F, 1.8F; - - kf::Matrix R; - R << 0.3F, 0.0F, - 0.0F, 0.3F; - - kf::SquareRootUKF srUkf; - srUkf.initialize(x, P, Q, R); - - srUkf.predictSRUKF(funcF); - - std::cout << "x = \n" << srUkf.vecX() << std::endl; - std::cout << "P = \n" << srUkf.matP() << std::endl; - - // Expectation from the python results: - // ===================================== - //x1 = - // [1. 2.] - //P1 = - // [[1.5 0.5] - // [0.5 1.5]] - - srUkf.correctSRUKF(funcF, z); - - std::cout << "x = \n" << srUkf.vecX() << std::endl; - std::cout << "P = \n" << srUkf.matP() << std::endl; - - // Expectations from the python results: - // ====================================== - // x = - // [1.15385 1.84615] - // P = - // [[ 0.24582 0.01505 ] - // [ 0.01505 0.24582 ]] - - std::cout << " End of Example 1: ===========================" << std::endl; -} - +/// +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "types.h" +#include "kalman_filter/square_root_ukf.h" + +static constexpr size_t DIM_X{ 2 }; +static constexpr size_t DIM_Z{ 2 }; + +void runExample1(); + +kf::Vector funcF(const kf::Vector & x) +{ + return x; +} + +int main(int argc, char ** argv) +{ + // example 1 + runExample1(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + // initializations + //x0 = np.array([1.0, 2.0]) + //P0 = np.array([[1.0, 0.5], [0.5, 1.0]]) + //Q = np.array([[0.5, 0.0], [0.0, 0.5]]) + + //z = np.array([1.2, 1.8]) + //R = np.array([[0.3, 0.0], [0.0, 0.3]]) + + kf::Vector x; + x << 1.0F, 2.0F; + + kf::Matrix P; + P << 1.0F, 0.5F, + 0.5F, 1.0F; + + kf::Matrix Q; + Q << 0.5F, 0.0F, + 0.0F, 0.5F; + + kf::Vector z; + z << 1.2F, 1.8F; + + kf::Matrix R; + R << 0.3F, 0.0F, + 0.0F, 0.3F; + + kf::SquareRootUKF srUkf; + srUkf.initialize(x, P, Q, R); + + srUkf.predictSRUKF(funcF); + + std::cout << "x = \n" << srUkf.vecX() << std::endl; + std::cout << "P = \n" << srUkf.matP() << std::endl; + + // Expectation from the python results: + // ===================================== + //x1 = + // [1. 2.] + //P1 = + // [[1.5 0.5] + // [0.5 1.5]] + + srUkf.correctSRUKF(funcF, z); + + std::cout << "x = \n" << srUkf.vecX() << std::endl; + std::cout << "P = \n" << srUkf.matP() << std::endl; + + // Expectations from the python results: + // ====================================== + // x = + // [1.15385 1.84615] + // P = + // [[ 0.24582 0.01505 ] + // [ 0.01505 0.24582 ]] + + std::cout << " End of Example 1: ===========================" << std::endl; +} + diff --git a/cpp/Examples/test_least_squares/CMakeLists.txt b/cpp/examples/test_least_squares/CMakeLists.txt similarity index 96% rename from cpp/Examples/test_least_squares/CMakeLists.txt rename to cpp/examples/test_least_squares/CMakeLists.txt index 535f586..2f429c7 100644 --- a/cpp/Examples/test_least_squares/CMakeLists.txt +++ b/cpp/examples/test_least_squares/CMakeLists.txt @@ -1,31 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_test_least_squares) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) - -target_link_libraries(${APPLICATION_NAME} - PUBLIC - Eigen3::Eigen - OpenKF -) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_test_least_squares) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/test_least_squares/main.cpp b/cpp/examples/test_least_squares/main.cpp similarity index 95% rename from cpp/Examples/test_least_squares/main.cpp rename to cpp/examples/test_least_squares/main.cpp index dd8c44b..8c81103 100644 --- a/cpp/Examples/test_least_squares/main.cpp +++ b/cpp/examples/test_least_squares/main.cpp @@ -1,112 +1,112 @@ -/// -/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) -/// -/// Use of this source code is governed by an GPL-3.0 - style -/// license that can be found in the LICENSE file or at -/// https://opensource.org/licenses/GPL-3.0 -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "types.h" -#include "util.h" - -void runExample1(); -void runExample2(); -void runExample3(); -void runExample4(); - -int main(int argc, char ** argv) -{ - runExample1(); - runExample2(); - runExample3(); - runExample4(); - - return 0; -} - -void runExample1() -{ - std::cout << " Start of Example 1: ===========================" << std::endl; - - kf::Matrix<3, 3> A; - A << 3.0, 2.0, 1.0, - 2.0, 3.0, 4.0, - 1.0, 4.0, 3.0; - - kf::Matrix<2, 3> B; - B << 5.0, 6.0, 7.0, - 8.0, 9.0, 10.0; - - kf::util::JointRows<3, 2, 3> jmat(A, B); - auto AB = jmat.jointMatrix(); - - std::cout << "Joint Rows: AB = \n" << AB << std::endl; - - std::cout << " End of Example 1: ===========================" << std::endl; -} - -void runExample2() -{ - std::cout << " Start of Example 2: ===========================" << std::endl; - - kf::Matrix<3, 3> A; - A << 3.0, 2.0, 1.0, - 2.0, 3.0, 4.0, - 1.0, 4.0, 3.0; - - kf::Matrix<3, 2> B; - B << 5.0, 6.0, - 7.0, 8.0, - 9.0, 10.0; - - kf::util::JointCols<3, 3, 2> jmat(A, B); - auto AB = jmat.jointMatrix(); - - std::cout << "Joint Columns: AB = \n" << AB << std::endl; - - std::cout << " End of Example 2: ===========================" << std::endl; -} - -void runExample3() -{ - std::cout << " Start of Example 2: ===========================" << std::endl; - - kf::Matrix<3, 3> A; - A << 1.0, -2.0, 1.0, - 0.0, 1.0, 6.0, - 0.0, 0.0, 1.0; - - kf::Matrix<3, 1> b; - b << 4.0, -1.0, 2.0; - - auto x = kf::util::backwardSubstitute<3, 1>(A, b); - - std::cout << "Backward Substitution: x = \n" << x << std::endl; - - std::cout << " End of Example 2: ===========================" << std::endl; -} - -void runExample4() -{ - std::cout << " Start of Example 2: ===========================" << std::endl; - - kf::Matrix<3, 3> A; - A << 1.0, 0.0, 0.0, - -2.0, 1.0, 0.0, - 1.0, 6.0, 1.0; - - kf::Matrix<3, 1> b; - b << 4.0, -1.0, 2.0; - - auto x = kf::util::forwardSubstitute<3, 1>(A, b); - - std::cout << "Forward Substitution: x = \n" << x << std::endl; - - std::cout << " End of Example 2: ===========================" << std::endl; -} +/// +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "types.h" +#include "util.h" + +void runExample1(); +void runExample2(); +void runExample3(); +void runExample4(); + +int main(int argc, char ** argv) +{ + runExample1(); + runExample2(); + runExample3(); + runExample4(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + kf::Matrix<3, 3> A; + A << 3.0, 2.0, 1.0, + 2.0, 3.0, 4.0, + 1.0, 4.0, 3.0; + + kf::Matrix<2, 3> B; + B << 5.0, 6.0, 7.0, + 8.0, 9.0, 10.0; + + kf::util::JointRows<3, 2, 3> jmat(A, B); + auto AB = jmat.jointMatrix(); + + std::cout << "Joint Rows: AB = \n" << AB << std::endl; + + std::cout << " End of Example 1: ===========================" << std::endl; +} + +void runExample2() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + kf::Matrix<3, 3> A; + A << 3.0, 2.0, 1.0, + 2.0, 3.0, 4.0, + 1.0, 4.0, 3.0; + + kf::Matrix<3, 2> B; + B << 5.0, 6.0, + 7.0, 8.0, + 9.0, 10.0; + + kf::util::JointCols<3, 3, 2> jmat(A, B); + auto AB = jmat.jointMatrix(); + + std::cout << "Joint Columns: AB = \n" << AB << std::endl; + + std::cout << " End of Example 2: ===========================" << std::endl; +} + +void runExample3() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + kf::Matrix<3, 3> A; + A << 1.0, -2.0, 1.0, + 0.0, 1.0, 6.0, + 0.0, 0.0, 1.0; + + kf::Matrix<3, 1> b; + b << 4.0, -1.0, 2.0; + + auto x = kf::util::backwardSubstitute<3, 1>(A, b); + + std::cout << "Backward Substitution: x = \n" << x << std::endl; + + std::cout << " End of Example 2: ===========================" << std::endl; +} + +void runExample4() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + kf::Matrix<3, 3> A; + A << 1.0, 0.0, 0.0, + -2.0, 1.0, 0.0, + 1.0, 6.0, 1.0; + + kf::Matrix<3, 1> b; + b << 4.0, -1.0, 2.0; + + auto x = kf::util::forwardSubstitute<3, 1>(A, b); + + std::cout << "Forward Substitution: x = \n" << x << std::endl; + + std::cout << " End of Example 2: ===========================" << std::endl; +} diff --git a/cpp/Examples/ukf_range_sensor/CMakeLists.txt b/cpp/examples/ukf_range_sensor/CMakeLists.txt similarity index 96% rename from cpp/Examples/ukf_range_sensor/CMakeLists.txt rename to cpp/examples/ukf_range_sensor/CMakeLists.txt index caafb00..b1d0037 100644 --- a/cpp/Examples/ukf_range_sensor/CMakeLists.txt +++ b/cpp/examples/ukf_range_sensor/CMakeLists.txt @@ -1,31 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ukf_range_sensor) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) - -target_link_libraries(${APPLICATION_NAME} - PUBLIC - Eigen3::Eigen - OpenKF -) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_ukf_range_sensor) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/ukf_range_sensor/main.cpp b/cpp/examples/ukf_range_sensor/main.cpp similarity index 96% rename from cpp/Examples/ukf_range_sensor/main.cpp rename to cpp/examples/ukf_range_sensor/main.cpp index bc77d4f..3f28f00 100644 --- a/cpp/Examples/ukf_range_sensor/main.cpp +++ b/cpp/examples/ukf_range_sensor/main.cpp @@ -1,120 +1,120 @@ -/// -/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) -/// -/// Use of this source code is governed by an GPL-3.0 - style -/// license that can be found in the LICENSE file or at -/// https://opensource.org/licenses/GPL-3.0 -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "types.h" -#include "kalman_filter/unscented_kalman_filter.h" - -static constexpr size_t DIM_X{ 4 }; -static constexpr size_t DIM_V{ 4 }; -static constexpr size_t DIM_Z{ 2 }; -static constexpr size_t DIM_N{ 2 }; - -void runExample1(); - -kf::Vector funcF(const kf::Vector & x, const kf::Vector & v) -{ - kf::Vector y; - y[0] = x[0] + x[2] + v[0]; - y[1] = x[1] + x[3] + v[1]; - y[2] = x[2] + v[2]; - y[3] = x[3] + v[3]; - return y; -} - -kf::Vector funcH(const kf::Vector & x, const kf::Vector & n) -{ - kf::Vector y; - - kf::float32_t px{ x[0] + n[0] }; - kf::float32_t py{ x[1] + n[1] }; - - y[0] = std::sqrt((px * px) + (py * py)); - y[1] = std::atan(py / (px + std::numeric_limits::epsilon())); - return y; -} - -int main(int argc, char ** argv) -{ - // example 1 - runExample1(); - - return 0; -} - -void runExample1() -{ - std::cout << " Start of Example 1: ===========================" << std::endl; - - kf::Vector x; - x << 2.0F, 1.0F, 0.0F, 0.0F; - - kf::Matrix P; - P << 0.01F, 0.0F, 0.0F, 0.0F, - 0.0F, 0.01F, 0.0F, 0.0F, - 0.0F, 0.0F, 0.05F, 0.0F, - 0.0F, 0.0F, 0.0F, 0.05F; - - kf::Matrix Q; - Q << 0.05F, 0.0F, 0.0F, 0.0F, - 0.0F, 0.05F, 0.0F, 0.0F, - 0.0F, 0.0F, 0.1F, 0.0F, - 0.0F, 0.0F, 0.0F, 0.1F; - - kf::Matrix R; - R << 0.01F, 0.0F, 0.0F, 0.01F; - - kf::Vector z; - z << 2.5, 0.05; - - kf::UnscentedKalmanFilter ukf; - - ukf.vecX() = x; - ukf.matP() = P; - - ukf.setCovarianceQ(Q); - ukf.setCovarianceR(R); - - ukf.predictUKF(funcF); - - std::cout << "x = \n" << ukf.vecX() << std::endl; - std::cout << "P = \n" << ukf.matP() << std::endl; - - // Expectation from the python results: - // ===================================== - // x = - // [2.0 1.0 0.0 0.0] - // P = - // [[0.11 0.00 0.05 0.00] - // [0.00 0.11 0.00 0.05] - // [0.05 0.00 0.15 0.00] - // [0.00 0.05 0.00 0.15]] - - ukf.correctUKF(funcH, z); - - std::cout << "x = \n" << ukf.vecX() << std::endl; - std::cout << "P = \n" << ukf.matP() << std::endl; - - // Expectations from the python results: - // ====================================== - // x = - // [ 2.554 0.356 0.252 -0.293] - // P = - // [[ 0.01 -0.001 0.005 -0. ] - // [-0.001 0.01 - 0. 0.005 ] - // [ 0.005 - 0. 0.129 - 0. ] - // [-0. 0.005 - 0. 0.129]] - - std::cout << " End of Example 1: ===========================" << std::endl; -} - +/// +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "types.h" +#include "kalman_filter/unscented_kalman_filter.h" + +static constexpr size_t DIM_X{ 4 }; +static constexpr size_t DIM_V{ 4 }; +static constexpr size_t DIM_Z{ 2 }; +static constexpr size_t DIM_N{ 2 }; + +void runExample1(); + +kf::Vector funcF(const kf::Vector & x, const kf::Vector & v) +{ + kf::Vector y; + y[0] = x[0] + x[2] + v[0]; + y[1] = x[1] + x[3] + v[1]; + y[2] = x[2] + v[2]; + y[3] = x[3] + v[3]; + return y; +} + +kf::Vector funcH(const kf::Vector & x, const kf::Vector & n) +{ + kf::Vector y; + + kf::float32_t px{ x[0] + n[0] }; + kf::float32_t py{ x[1] + n[1] }; + + y[0] = std::sqrt((px * px) + (py * py)); + y[1] = std::atan(py / (px + std::numeric_limits::epsilon())); + return y; +} + +int main(int argc, char ** argv) +{ + // example 1 + runExample1(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + kf::Vector x; + x << 2.0F, 1.0F, 0.0F, 0.0F; + + kf::Matrix P; + P << 0.01F, 0.0F, 0.0F, 0.0F, + 0.0F, 0.01F, 0.0F, 0.0F, + 0.0F, 0.0F, 0.05F, 0.0F, + 0.0F, 0.0F, 0.0F, 0.05F; + + kf::Matrix Q; + Q << 0.05F, 0.0F, 0.0F, 0.0F, + 0.0F, 0.05F, 0.0F, 0.0F, + 0.0F, 0.0F, 0.1F, 0.0F, + 0.0F, 0.0F, 0.0F, 0.1F; + + kf::Matrix R; + R << 0.01F, 0.0F, 0.0F, 0.01F; + + kf::Vector z; + z << 2.5, 0.05; + + kf::UnscentedKalmanFilter ukf; + + ukf.vecX() = x; + ukf.matP() = P; + + ukf.setCovarianceQ(Q); + ukf.setCovarianceR(R); + + ukf.predictUKF(funcF); + + std::cout << "x = \n" << ukf.vecX() << std::endl; + std::cout << "P = \n" << ukf.matP() << std::endl; + + // Expectation from the python results: + // ===================================== + // x = + // [2.0 1.0 0.0 0.0] + // P = + // [[0.11 0.00 0.05 0.00] + // [0.00 0.11 0.00 0.05] + // [0.05 0.00 0.15 0.00] + // [0.00 0.05 0.00 0.15]] + + ukf.correctUKF(funcH, z); + + std::cout << "x = \n" << ukf.vecX() << std::endl; + std::cout << "P = \n" << ukf.matP() << std::endl; + + // Expectations from the python results: + // ====================================== + // x = + // [ 2.554 0.356 0.252 -0.293] + // P = + // [[ 0.01 -0.001 0.005 -0. ] + // [-0.001 0.01 - 0. 0.005 ] + // [ 0.005 - 0. 0.129 - 0. ] + // [-0. 0.005 - 0. 0.129]] + + std::cout << " End of Example 1: ===========================" << std::endl; +} + diff --git a/cpp/Examples/unscented_transform/CMakeLists.txt b/cpp/examples/unscented_transform/CMakeLists.txt similarity index 96% rename from cpp/Examples/unscented_transform/CMakeLists.txt rename to cpp/examples/unscented_transform/CMakeLists.txt index 3ba98c1..458aef1 100644 --- a/cpp/Examples/unscented_transform/CMakeLists.txt +++ b/cpp/examples/unscented_transform/CMakeLists.txt @@ -1,31 +1,31 @@ -## -## Copyright 2022 Mohanad Youssef (Al-khwarizmi) -## -## Use of this source code is governed by an GPL-3.0 - style -## license that can be found in the LICENSE file or at -## https://opensource.org/licenses/GPL-3.0 -## -## @author Mohanad Youssef -## @file CMakeLists.h -## - -file(GLOB PROJECT_FILES - "${CMAKE_CURRENT_SOURCE_DIR}/*.h" - "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" -) - -set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_unscented_transform) - -add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) - -set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) - -target_link_libraries(${APPLICATION_NAME} - PUBLIC - Eigen3::Eigen - OpenKF -) - -target_include_directories(${APPLICATION_NAME} PUBLIC - $ -) +## +## Copyright 2022 Mohanad Youssef (Al-khwarizmi) +## +## Use of this source code is governed by an GPL-3.0 - style +## license that can be found in the LICENSE file or at +## https://opensource.org/licenses/GPL-3.0 +## +## @author Mohanad Youssef +## @file CMakeLists.h +## + +file(GLOB PROJECT_FILES + "${CMAKE_CURRENT_SOURCE_DIR}/*.h" + "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" +) + +set(APPLICATION_NAME ${EXAMPLE_EXECUTABLE_PREFIX}_unscented_transform) + +add_executable(${APPLICATION_NAME} ${PROJECT_FILES}) + +set_target_properties(${APPLICATION_NAME} PROPERTIES LINKER_LANGUAGE CXX) + +target_link_libraries(${APPLICATION_NAME} + PUBLIC + Eigen3::Eigen + OpenKF +) + +target_include_directories(${APPLICATION_NAME} PUBLIC + $ +) diff --git a/cpp/Examples/unscented_transform/main.cpp b/cpp/examples/unscented_transform/main.cpp similarity index 95% rename from cpp/Examples/unscented_transform/main.cpp rename to cpp/examples/unscented_transform/main.cpp index 17abc4c..8c18d64 100644 --- a/cpp/Examples/unscented_transform/main.cpp +++ b/cpp/examples/unscented_transform/main.cpp @@ -1,99 +1,99 @@ -/// -/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) -/// -/// Use of this source code is governed by an GPL-3.0 - style -/// license that can be found in the LICENSE file or at -/// https://opensource.org/licenses/GPL-3.0 -/// -/// @author Mohanad Youssef -/// @file main.cpp -/// - -#include -#include - -#include "types.h" -#include "kalman_filter/kalman_filter.h" -#include "kalman_filter/unscented_transform.h" - -static constexpr size_t DIM_1{ 1 }; -static constexpr size_t DIM_2{ 2 }; - -void runExample1(); -void runExample2(); - -kf::Vector function1(const kf::Vector & x) -{ - kf::Vector y; - y[0] = x[0] * x[0]; - return y; -} - -kf::Vector function2(const kf::Vector & x) -{ - kf::Vector y; - y[0] = x[0] * x[0]; - y[1] = x[1] * x[1]; - return y; -} - -int main(int argc, char ** argv) -{ - // example 1 - runExample1(); - - // example 2 - runExample2(); - - return 0; -} - -void runExample1() -{ - std::cout << " Start of Example 1: ===========================" << std::endl; - - kf::Vector x; - x << 0.0F; - - kf::Matrix P; - P << 0.5F; - - kf::UnscentedTransform UT; - UT.compute(x, P, 0.0F); - - kf::Vector vecY; - kf::Matrix matPyy; - - UT.transform(function1, vecY, matPyy); - - UT.showSummary(); - std::cout << "vecY: \n" << vecY << "\n"; - std::cout << "matPyy: \n" << matPyy << "\n"; - - std::cout << " End of Example 1: ===========================" << std::endl; -} - -void runExample2() -{ - std::cout << " Start of Example 2: ===========================" << std::endl; - - kf::Vector x; - x << 2.0F, 1.0F; - - kf::Matrix P; - P << 0.1F, 0.0F, 0.0F, 0.1F; - - kf::UnscentedTransform UT; - UT.compute(x, P, 0.0F); - - kf::Vector vecY; - kf::Matrix matPyy; - - UT.transform(function2, vecY, matPyy); - - UT.showSummary(); - std::cout << "vecY: \n" << vecY << "\n"; - std::cout << "matPyy: \n" << matPyy << "\n"; - - std::cout << " End of Example 2: ===========================" << std::endl; -} +/// +/// Copyright 2022 Mohanad Youssef (Al-khwarizmi) +/// +/// Use of this source code is governed by an GPL-3.0 - style +/// license that can be found in the LICENSE file or at +/// https://opensource.org/licenses/GPL-3.0 +/// +/// @author Mohanad Youssef +/// @file main.cpp +/// + +#include +#include + +#include "types.h" +#include "kalman_filter/kalman_filter.h" +#include "kalman_filter/unscented_transform.h" + +static constexpr size_t DIM_1{ 1 }; +static constexpr size_t DIM_2{ 2 }; + +void runExample1(); +void runExample2(); + +kf::Vector function1(const kf::Vector & x) +{ + kf::Vector y; + y[0] = x[0] * x[0]; + return y; +} + +kf::Vector function2(const kf::Vector & x) +{ + kf::Vector y; + y[0] = x[0] * x[0]; + y[1] = x[1] * x[1]; + return y; +} + +int main(int argc, char ** argv) +{ + // example 1 + runExample1(); + + // example 2 + runExample2(); + + return 0; +} + +void runExample1() +{ + std::cout << " Start of Example 1: ===========================" << std::endl; + + kf::Vector x; + x << 0.0F; + + kf::Matrix P; + P << 0.5F; + + kf::UnscentedTransform UT; + UT.compute(x, P, 0.0F); + + kf::Vector vecY; + kf::Matrix matPyy; + + UT.transform(function1, vecY, matPyy); + + UT.showSummary(); + std::cout << "vecY: \n" << vecY << "\n"; + std::cout << "matPyy: \n" << matPyy << "\n"; + + std::cout << " End of Example 1: ===========================" << std::endl; +} + +void runExample2() +{ + std::cout << " Start of Example 2: ===========================" << std::endl; + + kf::Vector x; + x << 2.0F, 1.0F; + + kf::Matrix P; + P << 0.1F, 0.0F, 0.0F, 0.1F; + + kf::UnscentedTransform UT; + UT.compute(x, P, 0.0F); + + kf::Vector vecY; + kf::Matrix matPyy; + + UT.transform(function2, vecY, matPyy); + + UT.showSummary(); + std::cout << "vecY: \n" << vecY << "\n"; + std::cout << "matPyy: \n" << matPyy << "\n"; + + std::cout << " End of Example 2: ===========================" << std::endl; +} From 0769da487c990bffa28b6fce5da32ea9728d24cf Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Fri, 8 Mar 2024 11:13:11 +0100 Subject: [PATCH 39/60] removing unexisting files from cmake --- cpp/examples/CMakeLists.txt | 1 - cpp/openkf/CMakeLists.txt | 3 --- 2 files changed, 4 deletions(-) diff --git a/cpp/examples/CMakeLists.txt b/cpp/examples/CMakeLists.txt index 29ec0db..42bf1ac 100644 --- a/cpp/examples/CMakeLists.txt +++ b/cpp/examples/CMakeLists.txt @@ -6,4 +6,3 @@ add_subdirectory(unscented_transform) add_subdirectory(ukf_range_sensor) add_subdirectory(test_least_squares) add_subdirectory(sr_ukf_linear_function) -add_subdirectory(gnss_application) \ No newline at end of file diff --git a/cpp/openkf/CMakeLists.txt b/cpp/openkf/CMakeLists.txt index d7637e6..7b22c8f 100644 --- a/cpp/openkf/CMakeLists.txt +++ b/cpp/openkf/CMakeLists.txt @@ -25,9 +25,6 @@ set(LIBRARY_HDR_FILES kalman_filter/unscented_transform.h kalman_filter/unscented_kalman_filter.h kalman_filter/square_root_ukf.h - helpers/helpers.h - gnss/representation.h - gnss/geodetic.h ) set(LIBRARY_NAME ${PROJECT_NAME}) From c2809dad4aa5b1718687fc644d7ab0e2edf22178 Mon Sep 17 00:00:00 2001 From: Mohanad Youssef Date: Sat, 9 Mar 2024 23:12:16 +0100 Subject: [PATCH 40/60] adding google tests --- cpp/CMakeLists.txt | 3 + cpp/examples/kf_state_estimation/main.cpp | 4 +- cpp/examples/ukf_range_sensor/main.cpp | 2 +- cpp/openkf/CMakeLists.txt | 4 +- cpp/openkf/tests/CMakeLists.txt | 25 + cpp/openkf/tests/kalman_filter_test.cpp | 114 + cpp/openkf/tests/square_root_ukf_test.cpp | 90 + cpp/openkf/tests/unit_tests.cpp | 7 + .../tests/unscented_kalman_filter_test.cpp | 144 + cpp/openkf/tests/unscented_trasform_test.cpp | 73 + cpp/openkf/tests/util_test.cpp | 0 cpp/third_party/googletest/.clang-format | 4 + .../.github/ISSUE_TEMPLATE/00-bug_report.yml | 53 + .../ISSUE_TEMPLATE/10-feature_request.yml | 33 + .../.github/ISSUE_TEMPLATE/config.yml | 5 + .../googletest/.github/workflows/gtest-ci.yml | 43 + cpp/third_party/googletest/.gitignore | 88 + cpp/third_party/googletest/BUILD.bazel | 219 + cpp/third_party/googletest/CMakeLists.txt | 27 + cpp/third_party/googletest/CONTRIBUTING.md | 141 + cpp/third_party/googletest/CONTRIBUTORS | 65 + cpp/third_party/googletest/LICENSE | 28 + cpp/third_party/googletest/README.md | 146 + cpp/third_party/googletest/WORKSPACE | 27 + .../googletest/ci/linux-presubmit.sh | 137 + .../googletest/ci/macos-presubmit.sh | 76 + .../googletest/ci/windows-presubmit.bat | 58 + cpp/third_party/googletest/docs/_config.yml | 1 + .../googletest/docs/_data/navigation.yml | 43 + .../googletest/docs/_layouts/default.html | 58 + .../googletest/docs/_sass/main.scss | 200 + cpp/third_party/googletest/docs/advanced.md | 2436 ++++++ .../googletest/docs/assets/css/style.scss | 5 + .../docs/community_created_documentation.md | 7 + cpp/third_party/googletest/docs/faq.md | 692 ++ .../googletest/docs/gmock_cheat_sheet.md | 241 + .../googletest/docs/gmock_cook_book.md | 4344 +++++++++ cpp/third_party/googletest/docs/gmock_faq.md | 390 + .../googletest/docs/gmock_for_dummies.md | 700 ++ cpp/third_party/googletest/docs/index.md | 22 + cpp/third_party/googletest/docs/pkgconfig.md | 144 + cpp/third_party/googletest/docs/platforms.md | 8 + cpp/third_party/googletest/docs/primer.md | 483 + .../googletest/docs/quickstart-bazel.md | 153 + .../googletest/docs/quickstart-cmake.md | 157 + .../googletest/docs/reference/actions.md | 115 + .../googletest/docs/reference/assertions.md | 633 ++ .../googletest/docs/reference/matchers.md | 302 + .../googletest/docs/reference/mocking.md | 589 ++ .../googletest/docs/reference/testing.md | 1432 +++ cpp/third_party/googletest/docs/samples.md | 22 + .../googletest/googlemock/CMakeLists.txt | 209 + .../googletest/googlemock/README.md | 40 + .../googletest/googlemock/cmake/gmock.pc.in | 10 + .../googlemock/cmake/gmock_main.pc.in | 10 + .../googletest/googlemock/docs/README.md | 4 + .../googlemock/include/gmock/gmock-actions.h | 2297 +++++ .../include/gmock/gmock-cardinalities.h | 159 + .../include/gmock/gmock-function-mocker.h | 518 ++ .../googlemock/include/gmock/gmock-matchers.h | 5623 ++++++++++++ .../include/gmock/gmock-more-actions.h | 658 ++ .../include/gmock/gmock-more-matchers.h | 120 + .../include/gmock/gmock-nice-strict.h | 277 + .../include/gmock/gmock-spec-builders.h | 2148 +++++ .../googlemock/include/gmock/gmock.h | 96 + .../include/gmock/internal/custom/README.md | 18 + .../internal/custom/gmock-generated-actions.h | 7 + .../gmock/internal/custom/gmock-matchers.h | 37 + .../gmock/internal/custom/gmock-port.h | 40 + .../gmock/internal/gmock-internal-utils.h | 487 ++ .../include/gmock/internal/gmock-port.h | 139 + .../include/gmock/internal/gmock-pp.h | 279 + .../googletest/googlemock/src/gmock-all.cc | 46 + .../googlemock/src/gmock-cardinalities.cc | 155 + .../googlemock/src/gmock-internal-utils.cc | 257 + .../googlemock/src/gmock-matchers.cc | 479 + .../googlemock/src/gmock-spec-builders.cc | 791 ++ .../googletest/googlemock/src/gmock.cc | 225 + .../googletest/googlemock/src/gmock_main.cc | 73 + .../googletest/googlemock/test/BUILD.bazel | 118 + .../googlemock/test/gmock-actions_test.cc | 2169 +++++ .../test/gmock-cardinalities_test.cc | 424 + .../test/gmock-function-mocker_test.cc | 998 +++ .../test/gmock-internal-utils_test.cc | 766 ++ .../test/gmock-matchers-arithmetic_test.cc | 1516 ++++ .../test/gmock-matchers-comparisons_test.cc | 2361 +++++ .../test/gmock-matchers-containers_test.cc | 3137 +++++++ .../test/gmock-matchers-misc_test.cc | 1823 ++++ .../googlemock/test/gmock-matchers_test.h | 192 + .../test/gmock-more-actions_test.cc | 1550 ++++ .../googlemock/test/gmock-nice-strict_test.cc | 541 ++ .../googlemock/test/gmock-port_test.cc | 42 + .../googlemock/test/gmock-pp-string_test.cc | 205 + .../googlemock/test/gmock-pp_test.cc | 83 + .../test/gmock-spec-builders_test.cc | 2600 ++++++ .../googlemock/test/gmock_all_test.cc | 49 + .../googlemock/test/gmock_ex_test.cc | 80 + .../googlemock/test/gmock_leak_test.py | 113 + .../googlemock/test/gmock_leak_test_.cc | 99 + .../googlemock/test/gmock_link2_test.cc | 38 + .../googlemock/test/gmock_link_test.cc | 38 + .../googlemock/test/gmock_link_test.h | 684 ++ .../googlemock/test/gmock_output_test.py | 190 + .../googlemock/test/gmock_output_test_.cc | 286 + .../test/gmock_output_test_golden.txt | 335 + .../googlemock/test/gmock_stress_test.cc | 227 + .../googletest/googlemock/test/gmock_test.cc | 179 + .../googlemock/test/gmock_test_utils.py | 91 + .../googletest/googletest/CMakeLists.txt | 330 + .../googletest/googletest/README.md | 231 + .../googletest/cmake/Config.cmake.in | 9 + .../googletest/googletest/cmake/gtest.pc.in | 9 + .../googletest/cmake/gtest_main.pc.in | 10 + .../googletest/cmake/internal_utils.cmake | 332 + .../googletest/cmake/libgtest.la.in | 21 + .../googletest/googletest/docs/README.md | 4 + .../include/gtest/gtest-assertion-result.h | 237 + .../include/gtest/gtest-death-test.h | 345 + .../googletest/include/gtest/gtest-matchers.h | 923 ++ .../googletest/include/gtest/gtest-message.h | 252 + .../include/gtest/gtest-param-test.h | 546 ++ .../googletest/include/gtest/gtest-printers.h | 1161 +++ .../googletest/include/gtest/gtest-spi.h | 250 + .../include/gtest/gtest-test-part.h | 192 + .../include/gtest/gtest-typed-test.h | 331 + .../googletest/include/gtest/gtest.h | 2321 +++++ .../include/gtest/gtest_pred_impl.h | 279 + .../googletest/include/gtest/gtest_prod.h | 60 + .../include/gtest/internal/custom/README.md | 44 + .../gtest/internal/custom/gtest-port.h | 37 + .../gtest/internal/custom/gtest-printers.h | 42 + .../include/gtest/internal/custom/gtest.h | 37 + .../internal/gtest-death-test-internal.h | 307 + .../include/gtest/internal/gtest-filepath.h | 227 + .../include/gtest/internal/gtest-internal.h | 1560 ++++ .../include/gtest/internal/gtest-param-util.h | 1026 +++ .../include/gtest/internal/gtest-port-arch.h | 122 + .../include/gtest/internal/gtest-port.h | 2481 ++++++ .../include/gtest/internal/gtest-string.h | 178 + .../include/gtest/internal/gtest-type-util.h | 220 + .../googletest/samples/prime_tables.h | 125 + .../googletest/googletest/samples/sample1.cc | 66 + .../googletest/googletest/samples/sample1.h | 41 + .../googletest/samples/sample10_unittest.cc | 138 + .../googletest/samples/sample1_unittest.cc | 148 + .../googletest/googletest/samples/sample2.cc | 54 + .../googletest/googletest/samples/sample2.h | 79 + .../googletest/samples/sample2_unittest.cc | 107 + .../googletest/samples/sample3-inl.h | 171 + .../googletest/samples/sample3_unittest.cc | 146 + .../googletest/googletest/samples/sample4.cc | 50 + .../googletest/googletest/samples/sample4.h | 53 + .../googletest/samples/sample4_unittest.cc | 53 + .../googletest/samples/sample5_unittest.cc | 189 + .../googletest/samples/sample6_unittest.cc | 214 + .../googletest/samples/sample7_unittest.cc | 113 + .../googletest/samples/sample8_unittest.cc | 154 + .../googletest/samples/sample9_unittest.cc | 148 + .../googletest/googletest/src/gtest-all.cc | 49 + .../googletest/src/gtest-assertion-result.cc | 77 + .../googletest/src/gtest-death-test.cc | 1585 ++++ .../googletest/src/gtest-filepath.cc | 414 + .../googletest/src/gtest-internal-inl.h | 1218 +++ .../googletest/src/gtest-matchers.cc | 98 + .../googletest/googletest/src/gtest-port.cc | 1392 +++ .../googletest/src/gtest-printers.cc | 555 ++ .../googletest/src/gtest-test-part.cc | 106 + .../googletest/src/gtest-typed-test.cc | 108 + .../googletest/googletest/src/gtest.cc | 6906 +++++++++++++++ .../googletest/googletest/src/gtest_main.cc | 66 + .../googletest/googletest/test/BUILD.bazel | 595 ++ .../googletest-break-on-failure-unittest.py | 195 + .../googletest-break-on-failure-unittest_.cc | 83 + .../test/googletest-catch-exceptions-test.py | 315 + .../test/googletest-catch-exceptions-test_.cc | 289 + .../googletest/test/googletest-color-test.py | 129 + .../googletest/test/googletest-color-test_.cc | 60 + .../test/googletest-death-test-test.cc | 1508 ++++ .../test/googletest-death-test_ex_test.cc | 91 + .../test/googletest-env-var-test.py | 120 + .../test/googletest-env-var-test_.cc | 130 + .../test/googletest-failfast-unittest.py | 461 + .../test/googletest-failfast-unittest_.cc | 166 + .../test/googletest-filepath-test.cc | 671 ++ .../test/googletest-filter-unittest.py | 746 ++ .../test/googletest-filter-unittest_.cc | 106 + .../googletest-global-environment-unittest.py | 141 + ...googletest-global-environment-unittest_.cc | 58 + .../test/googletest-json-outfiles-test.py | 180 + .../test/googletest-json-output-unittest.py | 820 ++ .../test/googletest-list-tests-unittest.py | 225 + .../test/googletest-list-tests-unittest_.cc | 143 + .../test/googletest-listener-test.cc | 509 ++ .../test/googletest-message-test.cc | 184 + .../test/googletest-options-test.cc | 222 + .../googletest-output-test-golden-lin.txt | 1206 +++ .../googletest/test/googletest-output-test.py | 385 + .../test/googletest-output-test_.cc | 1058 +++ ...oogletest-param-test-invalid-name1-test.py | 63 + ...ogletest-param-test-invalid-name1-test_.cc | 46 + ...oogletest-param-test-invalid-name2-test.py | 63 + ...ogletest-param-test-invalid-name2-test_.cc | 52 + .../test/googletest-param-test-test.cc | 1173 +++ .../test/googletest-param-test-test.h | 49 + .../test/googletest-param-test2-test.cc | 58 + .../googletest/test/googletest-port-test.cc | 1301 +++ .../test/googletest-printers-test.cc | 2018 +++++ .../test/googletest-setuptestsuite-test.py | 58 + .../test/googletest-setuptestsuite-test_.cc | 44 + .../test/googletest-shuffle-test.py | 378 + .../test/googletest-shuffle-test_.cc | 99 + .../test/googletest-test-part-test.cc | 220 + .../test/googletest-throw-on-failure-test.py | 166 + .../test/googletest-throw-on-failure-test_.cc | 71 + .../test/googletest-uninitialized-test.py | 70 + .../test/googletest-uninitialized-test_.cc | 39 + .../googletest/test/gtest-typed-test2_test.cc | 39 + .../googletest/test/gtest-typed-test_test.cc | 423 + .../googletest/test/gtest-typed-test_test.h | 57 + .../test/gtest-unittest-api_test.cc | 328 + .../googletest/test/gtest_all_test.cc | 46 + .../test/gtest_assert_by_exception_test.cc | 112 + .../googletest/test/gtest_dirs_test.cc | 101 + .../googletest/test/gtest_environment_test.cc | 179 + .../googletest/test/gtest_help_test.py | 201 + .../googletest/test/gtest_help_test_.cc | 44 + .../googletest/test/gtest_json_test_utils.py | 64 + .../test/gtest_list_output_unittest.py | 289 + .../test/gtest_list_output_unittest_.cc | 77 + .../googletest/test/gtest_main_unittest.cc | 42 + .../googletest/test/gtest_no_test_unittest.cc | 54 + .../test/gtest_pred_impl_unittest.cc | 2070 +++++ .../test/gtest_premature_exit_test.cc | 128 + .../googletest/test/gtest_prod_test.cc | 56 + .../googletest/test/gtest_repeat_test.cc | 222 + .../test/gtest_skip_check_output_test.py | 60 + ...test_skip_environment_check_output_test.py | 55 + .../gtest_skip_in_environment_setup_test.cc | 50 + .../googletest/test/gtest_skip_test.cc | 51 + .../googletest/test/gtest_sole_header_test.cc | 54 + .../googletest/test/gtest_stress_test.cc | 245 + .../gtest_test_macro_stack_footprint_test.cc | 89 + .../googletest/test/gtest_test_utils.py | 262 + .../googletest/test/gtest_testbridge_test.py | 63 + .../googletest/test/gtest_testbridge_test_.cc | 42 + .../test/gtest_throw_on_failure_ex_test.cc | 90 + .../googletest/test/gtest_unittest.cc | 7783 +++++++++++++++++ .../test/gtest_xml_outfile1_test_.cc | 43 + .../test/gtest_xml_outfile2_test_.cc | 77 + .../test/gtest_xml_outfiles_test.py | 147 + .../test/gtest_xml_output_unittest.py | 469 + .../test/gtest_xml_output_unittest_.cc | 197 + .../googletest/test/gtest_xml_test_utils.py | 242 + .../googletest/googletest/test/production.cc | 35 + .../googletest/googletest/test/production.h | 55 + .../googletest/googletest_deps.bzl | 22 + 256 files changed, 111099 insertions(+), 4 deletions(-) create mode 100644 cpp/openkf/tests/CMakeLists.txt create mode 100644 cpp/openkf/tests/kalman_filter_test.cpp create mode 100644 cpp/openkf/tests/square_root_ukf_test.cpp create mode 100644 cpp/openkf/tests/unit_tests.cpp create mode 100644 cpp/openkf/tests/unscented_kalman_filter_test.cpp create mode 100644 cpp/openkf/tests/unscented_trasform_test.cpp create mode 100644 cpp/openkf/tests/util_test.cpp create mode 100644 cpp/third_party/googletest/.clang-format create mode 100644 cpp/third_party/googletest/.github/ISSUE_TEMPLATE/00-bug_report.yml create mode 100644 cpp/third_party/googletest/.github/ISSUE_TEMPLATE/10-feature_request.yml create mode 100644 cpp/third_party/googletest/.github/ISSUE_TEMPLATE/config.yml create mode 100644 cpp/third_party/googletest/.github/workflows/gtest-ci.yml create mode 100644 cpp/third_party/googletest/.gitignore create mode 100644 cpp/third_party/googletest/BUILD.bazel create mode 100644 cpp/third_party/googletest/CMakeLists.txt create mode 100644 cpp/third_party/googletest/CONTRIBUTING.md create mode 100644 cpp/third_party/googletest/CONTRIBUTORS create mode 100644 cpp/third_party/googletest/LICENSE create mode 100644 cpp/third_party/googletest/README.md create mode 100644 cpp/third_party/googletest/WORKSPACE create mode 100644 cpp/third_party/googletest/ci/linux-presubmit.sh create mode 100644 cpp/third_party/googletest/ci/macos-presubmit.sh create mode 100644 cpp/third_party/googletest/ci/windows-presubmit.bat create mode 100644 cpp/third_party/googletest/docs/_config.yml create mode 100644 cpp/third_party/googletest/docs/_data/navigation.yml create mode 100644 cpp/third_party/googletest/docs/_layouts/default.html create mode 100644 cpp/third_party/googletest/docs/_sass/main.scss create mode 100644 cpp/third_party/googletest/docs/advanced.md create mode 100644 cpp/third_party/googletest/docs/assets/css/style.scss create mode 100644 cpp/third_party/googletest/docs/community_created_documentation.md create mode 100644 cpp/third_party/googletest/docs/faq.md create mode 100644 cpp/third_party/googletest/docs/gmock_cheat_sheet.md create mode 100644 cpp/third_party/googletest/docs/gmock_cook_book.md create mode 100644 cpp/third_party/googletest/docs/gmock_faq.md create mode 100644 cpp/third_party/googletest/docs/gmock_for_dummies.md create mode 100644 cpp/third_party/googletest/docs/index.md create mode 100644 cpp/third_party/googletest/docs/pkgconfig.md create mode 100644 cpp/third_party/googletest/docs/platforms.md create mode 100644 cpp/third_party/googletest/docs/primer.md create mode 100644 cpp/third_party/googletest/docs/quickstart-bazel.md create mode 100644 cpp/third_party/googletest/docs/quickstart-cmake.md create mode 100644 cpp/third_party/googletest/docs/reference/actions.md create mode 100644 cpp/third_party/googletest/docs/reference/assertions.md create mode 100644 cpp/third_party/googletest/docs/reference/matchers.md create mode 100644 cpp/third_party/googletest/docs/reference/mocking.md create mode 100644 cpp/third_party/googletest/docs/reference/testing.md create mode 100644 cpp/third_party/googletest/docs/samples.md create mode 100644 cpp/third_party/googletest/googlemock/CMakeLists.txt create mode 100644 cpp/third_party/googletest/googlemock/README.md create mode 100644 cpp/third_party/googletest/googlemock/cmake/gmock.pc.in create mode 100644 cpp/third_party/googletest/googlemock/cmake/gmock_main.pc.in create mode 100644 cpp/third_party/googletest/googlemock/docs/README.md create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-actions.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-cardinalities.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-matchers.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-more-actions.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-more-matchers.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-nice-strict.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock-spec-builders.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/gmock.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/custom/README.md create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/custom/gmock-port.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/gmock-port.h create mode 100644 cpp/third_party/googletest/googlemock/include/gmock/internal/gmock-pp.h create mode 100644 cpp/third_party/googletest/googlemock/src/gmock-all.cc create mode 100644 cpp/third_party/googletest/googlemock/src/gmock-cardinalities.cc create mode 100644 cpp/third_party/googletest/googlemock/src/gmock-internal-utils.cc create mode 100644 cpp/third_party/googletest/googlemock/src/gmock-matchers.cc create mode 100644 cpp/third_party/googletest/googlemock/src/gmock-spec-builders.cc create mode 100644 cpp/third_party/googletest/googlemock/src/gmock.cc create mode 100644 cpp/third_party/googletest/googlemock/src/gmock_main.cc create mode 100644 cpp/third_party/googletest/googlemock/test/BUILD.bazel create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-actions_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-cardinalities_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-function-mocker_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-internal-utils_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-matchers-comparisons_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-matchers-containers_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-matchers-misc_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-matchers_test.h create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-more-actions_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-nice-strict_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-port_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-pp-string_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-pp_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock-spec-builders_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_all_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_ex_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_leak_test.py create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_leak_test_.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_link2_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_link_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_link_test.h create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_output_test.py create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_output_test_.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_output_test_golden.txt create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_stress_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_test.cc create mode 100644 cpp/third_party/googletest/googlemock/test/gmock_test_utils.py create mode 100644 cpp/third_party/googletest/googletest/CMakeLists.txt create mode 100644 cpp/third_party/googletest/googletest/README.md create mode 100644 cpp/third_party/googletest/googletest/cmake/Config.cmake.in create mode 100644 cpp/third_party/googletest/googletest/cmake/gtest.pc.in create mode 100644 cpp/third_party/googletest/googletest/cmake/gtest_main.pc.in create mode 100644 cpp/third_party/googletest/googletest/cmake/internal_utils.cmake create mode 100644 cpp/third_party/googletest/googletest/cmake/libgtest.la.in create mode 100644 cpp/third_party/googletest/googletest/docs/README.md create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-assertion-result.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-death-test.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-matchers.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-message.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-param-test.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-printers.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-spi.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-test-part.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest-typed-test.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest_pred_impl.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/gtest_prod.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/custom/README.md create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/custom/gtest-port.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/custom/gtest-printers.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/custom/gtest.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-filepath.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-port-arch.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-port.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-string.h create mode 100644 cpp/third_party/googletest/googletest/include/gtest/internal/gtest-type-util.h create mode 100644 cpp/third_party/googletest/googletest/samples/prime_tables.h create mode 100644 cpp/third_party/googletest/googletest/samples/sample1.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample1.h create mode 100644 cpp/third_party/googletest/googletest/samples/sample10_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample1_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample2.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample2.h create mode 100644 cpp/third_party/googletest/googletest/samples/sample2_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample3-inl.h create mode 100644 cpp/third_party/googletest/googletest/samples/sample3_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample4.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample4.h create mode 100644 cpp/third_party/googletest/googletest/samples/sample4_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample5_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample6_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample7_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample8_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/samples/sample9_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-all.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-assertion-result.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-death-test.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-filepath.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-internal-inl.h create mode 100644 cpp/third_party/googletest/googletest/src/gtest-matchers.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-port.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-printers.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-test-part.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest-typed-test.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest.cc create mode 100644 cpp/third_party/googletest/googletest/src/gtest_main.cc create mode 100644 cpp/third_party/googletest/googletest/test/BUILD.bazel create mode 100644 cpp/third_party/googletest/googletest/test/googletest-break-on-failure-unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-break-on-failure-unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-catch-exceptions-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-catch-exceptions-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-color-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-color-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-death-test-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-death-test_ex_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-env-var-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-env-var-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-failfast-unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-failfast-unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-filepath-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-filter-unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-filter-unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-global-environment-unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-global-environment-unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-json-outfiles-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-json-output-unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-list-tests-unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-list-tests-unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-listener-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-message-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-options-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-output-test-golden-lin.txt create mode 100644 cpp/third_party/googletest/googletest/test/googletest-output-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-output-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test-invalid-name1-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test-invalid-name1-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test-invalid-name2-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test-invalid-name2-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test-test.h create mode 100644 cpp/third_party/googletest/googletest/test/googletest-param-test2-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-port-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-printers-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-setuptestsuite-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-setuptestsuite-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-shuffle-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-shuffle-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-test-part-test.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-throw-on-failure-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-throw-on-failure-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/googletest-uninitialized-test.py create mode 100644 cpp/third_party/googletest/googletest/test/googletest-uninitialized-test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest-typed-test2_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest-typed-test_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest-typed-test_test.h create mode 100644 cpp/third_party/googletest/googletest/test/gtest-unittest-api_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_all_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_assert_by_exception_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_dirs_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_environment_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_help_test.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_help_test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_json_test_utils.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_list_output_unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_list_output_unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_main_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_no_test_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_pred_impl_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_premature_exit_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_prod_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_repeat_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_skip_check_output_test.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_skip_environment_check_output_test.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_skip_in_environment_setup_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_skip_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_sole_header_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_stress_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_test_macro_stack_footprint_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_test_utils.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_testbridge_test.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_testbridge_test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_unittest.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_xml_outfile1_test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_xml_outfile2_test_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_xml_outfiles_test.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_xml_output_unittest.py create mode 100644 cpp/third_party/googletest/googletest/test/gtest_xml_output_unittest_.cc create mode 100644 cpp/third_party/googletest/googletest/test/gtest_xml_test_utils.py create mode 100644 cpp/third_party/googletest/googletest/test/production.cc create mode 100644 cpp/third_party/googletest/googletest/test/production.h create mode 100644 cpp/third_party/googletest/googletest_deps.bzl diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index 9729a31..55c6424 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -30,5 +30,8 @@ enable_language(C CXX) find_package(Eigen3 3.3 REQUIRED NO_MODULE) +include(CTest) + +add_subdirectory(third_party/googletest) add_subdirectory(openkf) add_subdirectory(examples) diff --git a/cpp/examples/kf_state_estimation/main.cpp b/cpp/examples/kf_state_estimation/main.cpp index e8661c1..a7098d1 100644 --- a/cpp/examples/kf_state_estimation/main.cpp +++ b/cpp/examples/kf_state_estimation/main.cpp @@ -42,8 +42,8 @@ void executePredictionStep() F << 1.0F, T, 0.0F, 1.0F; kf::Matrix Q; // process noise covariance - Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3) / 3.0F)); - Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2) / 2.0F); + Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3.0F) / 3.0F)); + Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2.0F) / 2.0F); Q(1, 1) = Q22 * T; kalmanfilter.predictLKF(F, Q); // execute prediction step diff --git a/cpp/examples/ukf_range_sensor/main.cpp b/cpp/examples/ukf_range_sensor/main.cpp index 3f28f00..1f19d50 100644 --- a/cpp/examples/ukf_range_sensor/main.cpp +++ b/cpp/examples/ukf_range_sensor/main.cpp @@ -75,7 +75,7 @@ void runExample1() R << 0.01F, 0.0F, 0.0F, 0.01F; kf::Vector z; - z << 2.5, 0.05; + z << 2.5F, 0.05F; kf::UnscentedKalmanFilter ukf; diff --git a/cpp/openkf/CMakeLists.txt b/cpp/openkf/CMakeLists.txt index 7b22c8f..ba32556 100644 --- a/cpp/openkf/CMakeLists.txt +++ b/cpp/openkf/CMakeLists.txt @@ -78,4 +78,6 @@ install( install( EXPORT ${TARGETS_EXPORT_NAME} DESTINATION ${CONFIG_INSTALL_DIR} -) \ No newline at end of file +) + +add_subdirectory(tests) \ No newline at end of file diff --git a/cpp/openkf/tests/CMakeLists.txt b/cpp/openkf/tests/CMakeLists.txt new file mode 100644 index 0000000..e664ccb --- /dev/null +++ b/cpp/openkf/tests/CMakeLists.txt @@ -0,0 +1,25 @@ +if (BUILD_TESTING) + cmake_minimum_required(VERSION 3.4) + project(unit_tests) + + enable_testing() + #find_package(GTest REQUIRED) + #include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) + + add_executable(${PROJECT_NAME} + unit_tests.cpp + kalman_filter_test.cpp + unscented_trasform_test.cpp + unscented_kalman_filter_test.cpp + square_root_ukf_test.cpp + ) + + target_link_libraries(${PROJECT_NAME} PUBLIC + GTest::gtest_main + OpenKF + ) + + include(GoogleTest) + gtest_discover_tests(${PROJECT_NAME}) + +endif(BUILD_TESTING) diff --git a/cpp/openkf/tests/kalman_filter_test.cpp b/cpp/openkf/tests/kalman_filter_test.cpp new file mode 100644 index 0000000..9cc5baf --- /dev/null +++ b/cpp/openkf/tests/kalman_filter_test.cpp @@ -0,0 +1,114 @@ +#include +#include "kalman_filter/kalman_filter.h" + +class KalmanFilterTest : public testing::Test +{ +public: + virtual void SetUp() override {} + virtual void TearDown() override {} + + static constexpr float FLOAT_EPSILON{ 0.00001F }; + + static constexpr int32_t DIM_X_LKF{ 2 }; + static constexpr int32_t DIM_Z_LKF{ 1 }; + static constexpr int32_t DIM_X_EKF{ 2 }; + static constexpr int32_t DIM_Z_EKF{ 2 }; + static constexpr kf::float32_t T{ 1.0F }; + static constexpr kf::float32_t Q11{ 0.1F }, Q22{ 0.1F }; + + kf::KalmanFilter m_lkf; + kf::KalmanFilter m_ekf; + + static kf::Vector covertCartesian2Polar(const kf::Vector& cartesian) + { + kf::Vector polar; + polar[0] = std::sqrt(cartesian[0] * cartesian[0] + cartesian[1] * cartesian[1]); + polar[1] = std::atan2(cartesian[1], cartesian[0]); + return polar; + } + + static kf::Matrix calculateJacobianMatrix(const kf::Vector& vecX) + { + const kf::float32_t valX2PlusY2{ (vecX[0] * vecX[0]) + (vecX[1] * vecX[1]) }; + const kf::float32_t valSqrtX2PlusY2{ std::sqrt(valX2PlusY2) }; + + kf::Matrix matHj; + matHj << + (vecX[0] / valSqrtX2PlusY2), (vecX[1] / valSqrtX2PlusY2), + (-vecX[1] / valX2PlusY2), (vecX[0] / valX2PlusY2); + + return matHj; + } +}; +TEST_F(KalmanFilterTest, test_predictLKF) +{ + m_lkf.vecX() << 0.0F, 2.0F; + m_lkf.matP() << 0.1F, 0.0F, 0.0F, 0.1F; + + kf::Matrix F; // state transition matrix + F << 1.0F, T, 0.0F, 1.0F; + + kf::Matrix Q; // process noise covariance + Q(0, 0) = (Q11 * T) + (Q22 * (std::pow(T, 3.0F) / 3.0F)); + Q(0, 1) = Q(1, 0) = Q22 * (std::pow(T, 2.0F) / 2.0F); + Q(1, 1) = Q22 * T; + + m_lkf.predictLKF(F, Q); // execute prediction step + + ASSERT_NEAR(m_lkf.vecX()(0), 2.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.vecX()(1), 2.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_lkf.matP()(0), 0.33333F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.matP()(1), 0.15F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.matP()(2), 0.15F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.matP()(3), 0.2F, FLOAT_EPSILON); +} + +TEST_F(KalmanFilterTest, test_correctLKF) +{ + m_lkf.vecX() << 2.0F, 2.0F; + m_lkf.matP() << 0.33333F, 0.15F, 0.15F, 0.2F; + + kf::Vector vecZ; + vecZ << 2.25F; + + kf::Matrix matR; + matR << 0.01F; + + kf::Matrix matH; + matH << 1.0F, 0.0F; + + m_lkf.correctLKF(vecZ, matR, matH); + + ASSERT_NEAR(m_lkf.vecX()(0), 2.24272F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.vecX()(1), 2.10922F, FLOAT_EPSILON); + + ASSERT_NEAR(m_lkf.matP()(0), 0.00970874F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.matP()(1), 0.00436893F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.matP()(2), 0.00436893F, FLOAT_EPSILON); + ASSERT_NEAR(m_lkf.matP()(3), 0.134466F, FLOAT_EPSILON); +} + +TEST_F(KalmanFilterTest, test_correctEKF) +{ + m_ekf.vecX() << 10.0F, 5.0F; + m_ekf.matP() << 0.3F, 0.0F, 0.0F, 0.3F; + + const kf::Vector measPosCart{ 10.4F, 5.2F }; + const kf::Vector vecZ{ covertCartesian2Polar(measPosCart) }; + + kf::Matrix matR; + matR << 0.1F, 0.0F, 0.0F, 0.0008F; + + kf::Matrix matHj{ calculateJacobianMatrix(m_ekf.vecX()) }; // jacobian matrix Hj + + m_ekf.correctEkf(covertCartesian2Polar, vecZ, matR, matHj); + + ASSERT_NEAR(m_ekf.vecX()(0), 10.3F, FLOAT_EPSILON); + ASSERT_NEAR(m_ekf.vecX()(1), 5.15F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ekf.matP()(0), 0.075F, FLOAT_EPSILON); + ASSERT_NEAR(m_ekf.matP()(1), -1.78814e-08F, FLOAT_EPSILON); + ASSERT_NEAR(m_ekf.matP()(2), -1.78814e-08F, FLOAT_EPSILON); + ASSERT_NEAR(m_ekf.matP()(3), 0.075F, FLOAT_EPSILON); +} diff --git a/cpp/openkf/tests/square_root_ukf_test.cpp b/cpp/openkf/tests/square_root_ukf_test.cpp new file mode 100644 index 0000000..3908901 --- /dev/null +++ b/cpp/openkf/tests/square_root_ukf_test.cpp @@ -0,0 +1,90 @@ +#include "gtest/gtest.h" +#include "kalman_filter/square_root_ukf.h" + +class SquareRootUnscentedKalmanFilterTest : public testing::Test +{ +public: + virtual void SetUp() override {} + virtual void TearDown() override {} + + static constexpr float FLOAT_EPSILON{ 0.001F }; + + static constexpr size_t DIM_X{ 2 }; + static constexpr size_t DIM_Z{ 2 }; + + kf::SquareRootUKF m_srUkf; + + static kf::Vector funcF(const kf::Vector& x) + { + return x; + } +}; + +TEST_F(SquareRootUnscentedKalmanFilterTest, test_SRUKF_Example01) +{ + // initializations + //x0 = np.array([1.0, 2.0]) + //P0 = np.array([[1.0, 0.5], [0.5, 1.0]]) + //Q = np.array([[0.5, 0.0], [0.0, 0.5]]) + + //z = np.array([1.2, 1.8]) + //R = np.array([[0.3, 0.0], [0.0, 0.3]]) + + kf::Vector x; + x << 1.0F, 2.0F; + + kf::Matrix P; + P << 1.0F, 0.5F, + 0.5F, 1.0F; + + kf::Matrix Q; + Q << 0.5F, 0.0F, + 0.0F, 0.5F; + + kf::Vector z; + z << 1.2F, 1.8F; + + kf::Matrix R; + R << 0.3F, 0.0F, + 0.0F, 0.3F; + + m_srUkf.initialize(x, P, Q, R); + + m_srUkf.predictSRUKF(funcF); + + // Expectation from the python results: + // ===================================== + //x1 = + // [1. 2.] + //P1 = + // [[1.5 0.5] + // [0.5 1.5]] + + ASSERT_NEAR(m_srUkf.vecX()[0], 1.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_srUkf.vecX()[1], 2.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_srUkf.matP()(0, 0), 1.5F, FLOAT_EPSILON); + ASSERT_NEAR(m_srUkf.matP()(0, 1), 0.5F, FLOAT_EPSILON); + + ASSERT_NEAR(m_srUkf.matP()(1, 0), 0.5F, FLOAT_EPSILON); + ASSERT_NEAR(m_srUkf.matP()(1, 1), 1.5F, FLOAT_EPSILON); + + m_srUkf.correctSRUKF(funcF, z); + + // Expectations from the python results: + // ====================================== + // x = + // [1.15385 1.84615] + // P = + // [[ 0.24582 0.01505 ] + // [ 0.01505 0.24582 ]] + + ASSERT_NEAR(m_srUkf.vecX()[0], 1.15385F, FLOAT_EPSILON); + ASSERT_NEAR(m_srUkf.vecX()[1], 1.84615F, FLOAT_EPSILON); + + ASSERT_NEAR(m_srUkf.matP()(0, 0), 0.24582F, FLOAT_EPSILON); + ASSERT_NEAR(m_srUkf.matP()(0, 1), 0.01505F, FLOAT_EPSILON); + + ASSERT_NEAR(m_srUkf.matP()(1, 0), 0.01505F, FLOAT_EPSILON); + ASSERT_NEAR(m_srUkf.matP()(1, 1), 0.24582F, FLOAT_EPSILON); +} \ No newline at end of file diff --git a/cpp/openkf/tests/unit_tests.cpp b/cpp/openkf/tests/unit_tests.cpp new file mode 100644 index 0000000..3eb216a --- /dev/null +++ b/cpp/openkf/tests/unit_tests.cpp @@ -0,0 +1,7 @@ +#include + +int main(int argc, char *argv[]) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file diff --git a/cpp/openkf/tests/unscented_kalman_filter_test.cpp b/cpp/openkf/tests/unscented_kalman_filter_test.cpp new file mode 100644 index 0000000..5bf27b3 --- /dev/null +++ b/cpp/openkf/tests/unscented_kalman_filter_test.cpp @@ -0,0 +1,144 @@ +#include "gtest/gtest.h" +#include "kalman_filter/unscented_kalman_filter.h" + +class UnscentedKalmanFilterTest : public testing::Test +{ +public: + virtual void SetUp() override {} + virtual void TearDown() override {} + + static constexpr float FLOAT_EPSILON{ 0.001F }; + + static constexpr size_t DIM_X{ 4 }; + static constexpr size_t DIM_V{ 4 }; + static constexpr size_t DIM_Z{ 2 }; + static constexpr size_t DIM_N{ 2 }; + + kf::UnscentedKalmanFilter m_ukf; + + static kf::Vector funcF(const kf::Vector& x, const kf::Vector& v) + { + kf::Vector y; + y[0] = x[0] + x[2] + v[0]; + y[1] = x[1] + x[3] + v[1]; + y[2] = x[2] + v[2]; + y[3] = x[3] + v[3]; + return y; + } + + static kf::Vector funcH(const kf::Vector& x, const kf::Vector& n) + { + kf::Vector y; + + kf::float32_t px{ x[0] + n[0] }; + kf::float32_t py{ x[1] + n[1] }; + + y[0] = std::sqrt((px * px) + (py * py)); + y[1] = std::atan(py / (px + std::numeric_limits::epsilon())); + return y; + } +}; + +TEST_F(UnscentedKalmanFilterTest, test_UKF_Example01) +{ + kf::Vector x; + x << 2.0F, 1.0F, 0.0F, 0.0F; + + kf::Matrix P; + P << 0.01F, 0.0F, 0.0F, 0.0F, + 0.0F, 0.01F, 0.0F, 0.0F, + 0.0F, 0.0F, 0.05F, 0.0F, + 0.0F, 0.0F, 0.0F, 0.05F; + + kf::Matrix Q; + Q << 0.05F, 0.0F, 0.0F, 0.0F, + 0.0F, 0.05F, 0.0F, 0.0F, + 0.0F, 0.0F, 0.1F, 0.0F, + 0.0F, 0.0F, 0.0F, 0.1F; + + kf::Matrix R; + R << 0.01F, 0.0F, 0.0F, 0.01F; + + kf::Vector z; + z << 2.5F, 0.05F; + + m_ukf.vecX() = x; + m_ukf.matP() = P; + + m_ukf.setCovarianceQ(Q); + m_ukf.setCovarianceR(R); + + m_ukf.predictUKF(funcF); + + // Expectation from the python results: + // ===================================== + // x = + // [2.0 1.0 0.0 0.0] + // P = + // [[0.11 0.00 0.05 0.00] + // [0.00 0.11 0.00 0.05] + // [0.05 0.00 0.15 0.00] + // [0.00 0.05 0.00 0.15]] + + ASSERT_NEAR(m_ukf.vecX()[0], 2.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.vecX()[1], 1.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.vecX()[2], 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.vecX()[3], 0.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(0, 0), 0.11F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(0, 1), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(0, 2), 0.05F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(0, 3), 0.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(1, 0), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(1, 1), 0.11F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(1, 2), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(1, 3), 0.05F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(2, 0), 0.05F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(2, 1), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(2, 2), 0.15F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(2, 3), 0.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(3, 0), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(3, 1), 0.05F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(3, 2), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(3, 3), 0.15F, FLOAT_EPSILON); + + m_ukf.correctUKF(funcH, z); + + // Expectations from the python results: + // ====================================== + // x = + // [ 2.554 0.356 0.252 -0.293] + // P = + // [[ 0.01 -0.001 0.005 -0. ] + // [-0.001 0.01 - 0. 0.005 ] + // [ 0.005 - 0. 0.129 - 0. ] + // [-0. 0.005 - 0. 0.129]] + + ASSERT_NEAR(m_ukf.vecX()[0], 2.554F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.vecX()[1], 0.356F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.vecX()[2], 0.252F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.vecX()[3], -0.293F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(0, 0), 0.01F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(0, 1), -0.001F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(0, 2), 0.005F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(0, 3), 0.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(1, 0), -0.001F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(1, 1), 0.01F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(1, 2), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(1, 3), 0.005F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(2, 0), 0.005F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(2, 1), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(2, 2), 0.129F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(2, 3), 0.0F, FLOAT_EPSILON); + + ASSERT_NEAR(m_ukf.matP()(3, 0), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(3, 1), 0.005F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(3, 2), 0.0F, FLOAT_EPSILON); + ASSERT_NEAR(m_ukf.matP()(3, 3), 0.129F, FLOAT_EPSILON); +} diff --git a/cpp/openkf/tests/unscented_trasform_test.cpp b/cpp/openkf/tests/unscented_trasform_test.cpp new file mode 100644 index 0000000..ce8d4c5 --- /dev/null +++ b/cpp/openkf/tests/unscented_trasform_test.cpp @@ -0,0 +1,73 @@ +#include "gtest/gtest.h" +#include "kalman_filter/unscented_transform.h" + +class UnscentedTransformTest : public testing::Test +{ +public: + virtual void SetUp() override {} + virtual void TearDown() override {} + + static constexpr float ASSERT_FLT_EPSILON{ 0.00001F }; + + static constexpr size_t DIM_1{ 1 }; + static constexpr size_t DIM_2{ 2 }; + + static kf::Vector function1(const kf::Vector& x) + { + kf::Vector y; + y[0] = x[0] * x[0]; + return y; + } + + static kf::Vector function2(const kf::Vector& x) + { + kf::Vector y; + y[0] = x[0] * x[0]; + y[1] = x[1] * x[1]; + return y; + } +}; + +TEST_F(UnscentedTransformTest, test_unscentedTransform_Example1) +{ + kf::Vector x; + x << 0.0F; + + kf::Matrix P; + P << 0.5F; + + kf::UnscentedTransform UT; + UT.compute(x, P, 0.0F); + + kf::Vector vecY; + kf::Matrix matPyy; + + UT.transform(function1, vecY, matPyy); + + ASSERT_NEAR(vecY[0], 0.5F, ASSERT_FLT_EPSILON); + ASSERT_NEAR(matPyy[0], 0.0F, ASSERT_FLT_EPSILON); +} + +TEST_F(UnscentedTransformTest, test_unscentedTransform_Example2) +{ + kf::Vector x; + x << 2.0F, 1.0F; + + kf::Matrix P; + P << 0.1F, 0.0F, 0.0F, 0.1F; + + kf::UnscentedTransform UT; + UT.compute(x, P, 0.0F); + + kf::Vector vecY; + kf::Matrix matPyy; + + UT.transform(function2, vecY, matPyy); + + ASSERT_NEAR(vecY[0], 4.1F, ASSERT_FLT_EPSILON); + ASSERT_NEAR(vecY[1], 1.1F, ASSERT_FLT_EPSILON); + ASSERT_NEAR(matPyy(0, 0), 1.61F, ASSERT_FLT_EPSILON); + ASSERT_NEAR(matPyy(0, 1), -0.01F, ASSERT_FLT_EPSILON); + ASSERT_NEAR(matPyy(1, 0), -0.01F, ASSERT_FLT_EPSILON); + ASSERT_NEAR(matPyy(1, 1), 0.41F, ASSERT_FLT_EPSILON); +} \ No newline at end of file diff --git a/cpp/openkf/tests/util_test.cpp b/cpp/openkf/tests/util_test.cpp new file mode 100644 index 0000000..e69de29 diff --git a/cpp/third_party/googletest/.clang-format b/cpp/third_party/googletest/.clang-format new file mode 100644 index 0000000..5b9bfe6 --- /dev/null +++ b/cpp/third_party/googletest/.clang-format @@ -0,0 +1,4 @@ +# Run manually to reformat a file: +# clang-format -i --style=file +Language: Cpp +BasedOnStyle: Google diff --git a/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/00-bug_report.yml b/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/00-bug_report.yml new file mode 100644 index 0000000..586779a --- /dev/null +++ b/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/00-bug_report.yml @@ -0,0 +1,53 @@ +name: Bug Report +description: Let us know that something does not work as expected. +title: "[Bug]: Please title this bug report" +body: + - type: textarea + id: what-happened + attributes: + label: Describe the issue + description: What happened, and what did you expect to happen? + validations: + required: true + - type: textarea + id: steps + attributes: + label: Steps to reproduce the problem + description: It is important that we are able to reproduce the problem that you are experiencing. Please provide all code and relevant steps to reproduce the problem, including your `BUILD`/`CMakeLists.txt` file and build commands. Links to a GitHub branch or [godbolt.org](https://godbolt.org/) that demonstrate the problem are also helpful. + validations: + required: true + - type: textarea + id: version + attributes: + label: What version of GoogleTest are you using? + description: Please include the output of `git rev-parse HEAD` or the GoogleTest release version number that you are using. + validations: + required: true + - type: textarea + id: os + attributes: + label: What operating system and version are you using? + description: If you are using a Linux distribution please include the name and version of the distribution as well. + validations: + required: true + - type: textarea + id: compiler + attributes: + label: What compiler and version are you using? + description: Please include the output of `gcc -v` or `clang -v`, or the equivalent for your compiler. + validations: + required: true + - type: textarea + id: buildsystem + attributes: + label: What build system are you using? + description: Please include the output of `bazel --version` or `cmake --version`, or the equivalent for your build system. + validations: + required: true + - type: textarea + id: additional + attributes: + label: Additional context + description: Add any other context about the problem here. + validations: + required: false diff --git a/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/10-feature_request.yml b/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/10-feature_request.yml new file mode 100644 index 0000000..f3bbc09 --- /dev/null +++ b/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/10-feature_request.yml @@ -0,0 +1,33 @@ +name: Feature request +description: Propose a new feature. +title: "[FR]: Please title this feature request" +labels: "enhancement" +body: + - type: textarea + id: version + attributes: + label: Does the feature exist in the most recent commit? + description: We recommend using the latest commit from GitHub in your projects. + validations: + required: true + - type: textarea + id: why + attributes: + label: Why do we need this feature? + description: Ideally, explain why a combination of existing features cannot be used instead. + validations: + required: true + - type: textarea + id: proposal + attributes: + label: Describe the proposal. + description: Include a detailed description of the feature, with usage examples. + validations: + required: true + - type: textarea + id: platform + attributes: + label: Is the feature specific to an operating system, compiler, or build system version? + description: If it is, please specify which versions. + validations: + required: true diff --git a/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/config.yml b/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000..65170d1 --- /dev/null +++ b/cpp/third_party/googletest/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,5 @@ +blank_issues_enabled: false +contact_links: + - name: Get Help + url: https://github.com/google/googletest/discussions + about: Please ask and answer questions here. diff --git a/cpp/third_party/googletest/.github/workflows/gtest-ci.yml b/cpp/third_party/googletest/.github/workflows/gtest-ci.yml new file mode 100644 index 0000000..03a8cc5 --- /dev/null +++ b/cpp/third_party/googletest/.github/workflows/gtest-ci.yml @@ -0,0 +1,43 @@ +name: ci + +on: + push: + pull_request: + +env: + BAZEL_CXXOPTS: -std=c++14 + +jobs: + Linux: + runs-on: ubuntu-latest + steps: + + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Tests + run: bazel test --cxxopt=-std=c++14 --features=external_include_paths --test_output=errors ... + + macOS: + runs-on: macos-latest + steps: + + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Tests + run: bazel test --cxxopt=-std=c++14 --features=external_include_paths --test_output=errors ... + + + Windows: + runs-on: windows-latest + steps: + + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Tests + run: bazel test --cxxopt=/std:c++14 --features=external_include_paths --test_output=errors ... diff --git a/cpp/third_party/googletest/.gitignore b/cpp/third_party/googletest/.gitignore new file mode 100644 index 0000000..fede02f --- /dev/null +++ b/cpp/third_party/googletest/.gitignore @@ -0,0 +1,88 @@ +# Ignore CI build directory +build/ +xcuserdata +cmake-build-debug/ +.idea/ +bazel-bin +bazel-genfiles +bazel-googletest +bazel-out +bazel-testlogs +# python +*.pyc + +# Visual Studio files +.vs +*.sdf +*.opensdf +*.VC.opendb +*.suo +*.user +_ReSharper.Caches/ +Win32-Debug/ +Win32-Release/ +x64-Debug/ +x64-Release/ + +# VSCode files +.cache/ +cmake-variants.yaml + +# Ignore autoconf / automake files +Makefile.in +aclocal.m4 +configure +build-aux/ +autom4te.cache/ +googletest/m4/libtool.m4 +googletest/m4/ltoptions.m4 +googletest/m4/ltsugar.m4 +googletest/m4/ltversion.m4 +googletest/m4/lt~obsolete.m4 +googlemock/m4 + +# Ignore generated directories. +googlemock/fused-src/ +googletest/fused-src/ + +# macOS files +.DS_Store +googletest/.DS_Store +googletest/xcode/.DS_Store + +# Ignore cmake generated directories and files. +CMakeFiles +CTestTestfile.cmake +Makefile +cmake_install.cmake +googlemock/CMakeFiles +googlemock/CTestTestfile.cmake +googlemock/Makefile +googlemock/cmake_install.cmake +googlemock/gtest +/bin +/googlemock/gmock.dir +/googlemock/gmock_main.dir +/googlemock/RUN_TESTS.vcxproj.filters +/googlemock/RUN_TESTS.vcxproj +/googlemock/INSTALL.vcxproj.filters +/googlemock/INSTALL.vcxproj +/googlemock/gmock_main.vcxproj.filters +/googlemock/gmock_main.vcxproj +/googlemock/gmock.vcxproj.filters +/googlemock/gmock.vcxproj +/googlemock/gmock.sln +/googlemock/ALL_BUILD.vcxproj.filters +/googlemock/ALL_BUILD.vcxproj +/lib +/Win32 +/ZERO_CHECK.vcxproj.filters +/ZERO_CHECK.vcxproj +/RUN_TESTS.vcxproj.filters +/RUN_TESTS.vcxproj +/INSTALL.vcxproj.filters +/INSTALL.vcxproj +/googletest-distribution.sln +/CMakeCache.txt +/ALL_BUILD.vcxproj.filters +/ALL_BUILD.vcxproj diff --git a/cpp/third_party/googletest/BUILD.bazel b/cpp/third_party/googletest/BUILD.bazel new file mode 100644 index 0000000..b1e3b7f --- /dev/null +++ b/cpp/third_party/googletest/BUILD.bazel @@ -0,0 +1,219 @@ +# Copyright 2017 Google Inc. +# All Rights Reserved. +# +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# Bazel Build for Google C++ Testing Framework(Google Test) + +package(default_visibility = ["//visibility:public"]) + +licenses(["notice"]) + +exports_files(["LICENSE"]) + +config_setting( + name = "qnx", + constraint_values = ["@platforms//os:qnx"], +) + +config_setting( + name = "windows", + constraint_values = ["@platforms//os:windows"], +) + +config_setting( + name = "freebsd", + constraint_values = ["@platforms//os:freebsd"], +) + +config_setting( + name = "openbsd", + constraint_values = ["@platforms//os:openbsd"], +) + +config_setting( + name = "msvc_compiler", + flag_values = { + "@bazel_tools//tools/cpp:compiler": "msvc-cl", + }, + visibility = [":__subpackages__"], +) + +config_setting( + name = "has_absl", + values = {"define": "absl=1"}, +) + +# Library that defines the FRIEND_TEST macro. +cc_library( + name = "gtest_prod", + hdrs = ["googletest/include/gtest/gtest_prod.h"], + includes = ["googletest/include"], +) + +# Google Test including Google Mock +cc_library( + name = "gtest", + srcs = glob( + include = [ + "googletest/src/*.cc", + "googletest/src/*.h", + "googletest/include/gtest/**/*.h", + "googlemock/src/*.cc", + "googlemock/include/gmock/**/*.h", + ], + exclude = [ + "googletest/src/gtest-all.cc", + "googletest/src/gtest_main.cc", + "googlemock/src/gmock-all.cc", + "googlemock/src/gmock_main.cc", + ], + ), + hdrs = glob([ + "googletest/include/gtest/*.h", + "googlemock/include/gmock/*.h", + ]), + copts = select({ + ":qnx": [], + ":windows": [], + "//conditions:default": ["-pthread"], + }), + defines = select({ + ":has_absl": ["GTEST_HAS_ABSL=1"], + "//conditions:default": [], + }), + features = select({ + ":windows": ["windows_export_all_symbols"], + "//conditions:default": [], + }), + includes = [ + "googlemock", + "googlemock/include", + "googletest", + "googletest/include", + ], + linkopts = select({ + ":qnx": ["-lregex"], + ":windows": [], + ":freebsd": [ + "-lm", + "-pthread", + ], + ":openbsd": [ + "-lm", + "-pthread", + ], + "//conditions:default": ["-pthread"], + }), + deps = select({ + ":has_absl": [ + "@com_google_absl//absl/container:flat_hash_set", + "@com_google_absl//absl/debugging:failure_signal_handler", + "@com_google_absl//absl/debugging:stacktrace", + "@com_google_absl//absl/debugging:symbolize", + "@com_google_absl//absl/flags:flag", + "@com_google_absl//absl/flags:parse", + "@com_google_absl//absl/flags:reflection", + "@com_google_absl//absl/flags:usage", + "@com_google_absl//absl/strings", + "@com_google_absl//absl/types:any", + "@com_google_absl//absl/types:optional", + "@com_google_absl//absl/types:variant", + "@com_googlesource_code_re2//:re2", + ], + "//conditions:default": [], + }), +) + +cc_library( + name = "gtest_main", + srcs = ["googlemock/src/gmock_main.cc"], + features = select({ + ":windows": ["windows_export_all_symbols"], + "//conditions:default": [], + }), + deps = [":gtest"], +) + +# The following rules build samples of how to use gTest. +cc_library( + name = "gtest_sample_lib", + srcs = [ + "googletest/samples/sample1.cc", + "googletest/samples/sample2.cc", + "googletest/samples/sample4.cc", + ], + hdrs = [ + "googletest/samples/prime_tables.h", + "googletest/samples/sample1.h", + "googletest/samples/sample2.h", + "googletest/samples/sample3-inl.h", + "googletest/samples/sample4.h", + ], + features = select({ + ":windows": ["windows_export_all_symbols"], + "//conditions:default": [], + }), +) + +cc_test( + name = "gtest_samples", + size = "small", + # All Samples except: + # sample9 (main) + # sample10 (main and takes a command line option and needs to be separate) + srcs = [ + "googletest/samples/sample1_unittest.cc", + "googletest/samples/sample2_unittest.cc", + "googletest/samples/sample3_unittest.cc", + "googletest/samples/sample4_unittest.cc", + "googletest/samples/sample5_unittest.cc", + "googletest/samples/sample6_unittest.cc", + "googletest/samples/sample7_unittest.cc", + "googletest/samples/sample8_unittest.cc", + ], + linkstatic = 0, + deps = [ + "gtest_sample_lib", + ":gtest_main", + ], +) + +cc_test( + name = "sample9_unittest", + size = "small", + srcs = ["googletest/samples/sample9_unittest.cc"], + deps = [":gtest"], +) + +cc_test( + name = "sample10_unittest", + size = "small", + srcs = ["googletest/samples/sample10_unittest.cc"], + deps = [":gtest"], +) diff --git a/cpp/third_party/googletest/CMakeLists.txt b/cpp/third_party/googletest/CMakeLists.txt new file mode 100644 index 0000000..089ac98 --- /dev/null +++ b/cpp/third_party/googletest/CMakeLists.txt @@ -0,0 +1,27 @@ +# Note: CMake support is community-based. The maintainers do not use CMake +# internally. + +cmake_minimum_required(VERSION 3.13) + +project(googletest-distribution) +set(GOOGLETEST_VERSION 1.14.0) + +if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX) + set(CMAKE_CXX_EXTENSIONS OFF) +endif() + +enable_testing() + +include(CMakeDependentOption) +include(GNUInstallDirs) + +#Note that googlemock target already builds googletest +option(BUILD_GMOCK "Builds the googlemock subproject" ON) +option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" ON) +option(GTEST_HAS_ABSL "Use Abseil and RE2. Requires Abseil and RE2 to be separately added to the build." OFF) + +if(BUILD_GMOCK) + add_subdirectory( googlemock ) +else() + add_subdirectory( googletest ) +endif() diff --git a/cpp/third_party/googletest/CONTRIBUTING.md b/cpp/third_party/googletest/CONTRIBUTING.md new file mode 100644 index 0000000..8bed14b --- /dev/null +++ b/cpp/third_party/googletest/CONTRIBUTING.md @@ -0,0 +1,141 @@ +# How to become a contributor and submit your own code + +## Contributor License Agreements + +We'd love to accept your patches! Before we can take them, we have to jump a +couple of legal hurdles. + +Please fill out either the individual or corporate Contributor License Agreement +(CLA). + +* If you are an individual writing original source code and you're sure you + own the intellectual property, then you'll need to sign an + [individual CLA](https://developers.google.com/open-source/cla/individual). +* If you work for a company that wants to allow you to contribute your work, + then you'll need to sign a + [corporate CLA](https://developers.google.com/open-source/cla/corporate). + +Follow either of the two links above to access the appropriate CLA and +instructions for how to sign and return it. Once we receive it, we'll be able to +accept your pull requests. + +## Are you a Googler? + +If you are a Googler, please make an attempt to submit an internal contribution +rather than a GitHub Pull Request. If you are not able to submit internally, a +PR is acceptable as an alternative. + +## Contributing A Patch + +1. Submit an issue describing your proposed change to the + [issue tracker](https://github.com/google/googletest/issues). +2. Please don't mix more than one logical change per submittal, because it + makes the history hard to follow. If you want to make a change that doesn't + have a corresponding issue in the issue tracker, please create one. +3. Also, coordinate with team members that are listed on the issue in question. + This ensures that work isn't being duplicated and communicating your plan + early also generally leads to better patches. +4. If your proposed change is accepted, and you haven't already done so, sign a + Contributor License Agreement + ([see details above](#contributor-license-agreements)). +5. Fork the desired repo, develop and test your code changes. +6. Ensure that your code adheres to the existing style in the sample to which + you are contributing. +7. Ensure that your code has an appropriate set of unit tests which all pass. +8. Submit a pull request. + +## The Google Test and Google Mock Communities + +The Google Test community exists primarily through the +[discussion group](http://groups.google.com/group/googletestframework) and the +GitHub repository. Likewise, the Google Mock community exists primarily through +their own [discussion group](http://groups.google.com/group/googlemock). You are +definitely encouraged to contribute to the discussion and you can also help us +to keep the effectiveness of the group high by following and promoting the +guidelines listed here. + +### Please Be Friendly + +Showing courtesy and respect to others is a vital part of the Google culture, +and we strongly encourage everyone participating in Google Test development to +join us in accepting nothing less. Of course, being courteous is not the same as +failing to constructively disagree with each other, but it does mean that we +should be respectful of each other when enumerating the 42 technical reasons +that a particular proposal may not be the best choice. There's never a reason to +be antagonistic or dismissive toward anyone who is sincerely trying to +contribute to a discussion. + +Sure, C++ testing is serious business and all that, but it's also a lot of fun. +Let's keep it that way. Let's strive to be one of the friendliest communities in +all of open source. + +As always, discuss Google Test in the official GoogleTest discussion group. You +don't have to actually submit code in order to sign up. Your participation +itself is a valuable contribution. + +## Style + +To keep the source consistent, readable, diffable and easy to merge, we use a +fairly rigid coding style, as defined by the +[google-styleguide](https://github.com/google/styleguide) project. All patches +will be expected to conform to the style outlined +[here](https://google.github.io/styleguide/cppguide.html). Use +[.clang-format](https://github.com/google/googletest/blob/main/.clang-format) to +check your formatting. + +## Requirements for Contributors + +If you plan to contribute a patch, you need to build Google Test, Google Mock, +and their own tests from a git checkout, which has further requirements: + +* [Python](https://www.python.org/) v3.6 or newer (for running some of the + tests and re-generating certain source files from templates) +* [CMake](https://cmake.org/) v2.8.12 or newer + +## Developing Google Test and Google Mock + +This section discusses how to make your own changes to the Google Test project. + +### Testing Google Test and Google Mock Themselves + +To make sure your changes work as intended and don't break existing +functionality, you'll want to compile and run Google Test and GoogleMock's own +tests. For that you can use CMake: + +``` +mkdir mybuild +cd mybuild +cmake -Dgtest_build_tests=ON -Dgmock_build_tests=ON ${GTEST_REPO_DIR} +``` + +To choose between building only Google Test or Google Mock, you may modify your +cmake command to be one of each + +``` +cmake -Dgtest_build_tests=ON ${GTEST_DIR} # sets up Google Test tests +cmake -Dgmock_build_tests=ON ${GMOCK_DIR} # sets up Google Mock tests +``` + +Make sure you have Python installed, as some of Google Test's tests are written +in Python. If the cmake command complains about not being able to find Python +(`Could NOT find PythonInterp (missing: PYTHON_EXECUTABLE)`), try telling it +explicitly where your Python executable can be found: + +``` +cmake -DPYTHON_EXECUTABLE=path/to/python ... +``` + +Next, you can build Google Test and / or Google Mock and all desired tests. On +\*nix, this is usually done by + +``` +make +``` + +To run the tests, do + +``` +make test +``` + +All tests should pass. diff --git a/cpp/third_party/googletest/CONTRIBUTORS b/cpp/third_party/googletest/CONTRIBUTORS new file mode 100644 index 0000000..77397a5 --- /dev/null +++ b/cpp/third_party/googletest/CONTRIBUTORS @@ -0,0 +1,65 @@ +# This file contains a list of people who've made non-trivial +# contribution to the Google C++ Testing Framework project. People +# who commit code to the project are encouraged to add their names +# here. Please keep the list sorted by first names. + +Ajay Joshi +Balázs Dán +Benoit Sigoure +Bharat Mediratta +Bogdan Piloca +Chandler Carruth +Chris Prince +Chris Taylor +Dan Egnor +Dave MacLachlan +David Anderson +Dean Sturtevant +Eric Roman +Gene Volovich +Hady Zalek +Hal Burch +Jeffrey Yasskin +Jim Keller +Joe Walnes +Jon Wray +Jói Sigurðsson +Keir Mierle +Keith Ray +Kenton Varda +Kostya Serebryany +Krystian Kuzniarek +Lev Makhlis +Manuel Klimek +Mario Tanev +Mark Paskin +Markus Heule +Martijn Vels +Matthew Simmons +Mika Raento +Mike Bland +Miklós Fazekas +Neal Norwitz +Nermin Ozkiranartli +Owen Carlsen +Paneendra Ba +Pasi Valminen +Patrick Hanna +Patrick Riley +Paul Menage +Peter Kaminski +Piotr Kaminski +Preston Jackson +Rainer Klaffenboeck +Russ Cox +Russ Rufer +Sean Mcafee +Sigurður Ásgeirsson +Sverre Sundsdal +Szymon Sobik +Takeshi Yoshino +Tracy Bialik +Vadim Berman +Vlad Losev +Wolfgang Klier +Zhanyong Wan diff --git a/cpp/third_party/googletest/LICENSE b/cpp/third_party/googletest/LICENSE new file mode 100644 index 0000000..1941a11 --- /dev/null +++ b/cpp/third_party/googletest/LICENSE @@ -0,0 +1,28 @@ +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/cpp/third_party/googletest/README.md b/cpp/third_party/googletest/README.md new file mode 100644 index 0000000..443e020 --- /dev/null +++ b/cpp/third_party/googletest/README.md @@ -0,0 +1,146 @@ +# GoogleTest + +### Announcements + +#### Live at Head + +GoogleTest now follows the +[Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support). +We recommend +[updating to the latest commit in the `main` branch as often as possible](https://github.com/abseil/abseil-cpp/blob/master/FAQ.md#what-is-live-at-head-and-how-do-i-do-it). +We do publish occasional semantic versions, tagged with +`v${major}.${minor}.${patch}` (e.g. `v1.13.0`). + +#### Documentation Updates + +Our documentation is now live on GitHub Pages at +https://google.github.io/googletest/. We recommend browsing the documentation on +GitHub Pages rather than directly in the repository. + +#### Release 1.13.0 + +[Release 1.13.0](https://github.com/google/googletest/releases/tag/v1.13.0) is +now available. + +The 1.13.x branch requires at least C++14. + +#### Continuous Integration + +We use Google's internal systems for continuous integration. \ +GitHub Actions were added for the convenience of open-source contributors. They +are exclusively maintained by the open-source community and not used by the +GoogleTest team. + +#### Coming Soon + +* We are planning to take a dependency on + [Abseil](https://github.com/abseil/abseil-cpp). +* More documentation improvements are planned. + +## Welcome to **GoogleTest**, Google's C++ test framework! + +This repository is a merger of the formerly separate GoogleTest and GoogleMock +projects. These were so closely related that it makes sense to maintain and +release them together. + +### Getting Started + +See the [GoogleTest User's Guide](https://google.github.io/googletest/) for +documentation. We recommend starting with the +[GoogleTest Primer](https://google.github.io/googletest/primer.html). + +More information about building GoogleTest can be found at +[googletest/README.md](googletest/README.md). + +## Features + +* xUnit test framework: \ + Googletest is based on the [xUnit](https://en.wikipedia.org/wiki/XUnit) + testing framework, a popular architecture for unit testing +* Test discovery: \ + Googletest automatically discovers and runs your tests, eliminating the need + to manually register your tests +* Rich set of assertions: \ + Googletest provides a variety of assertions, such as equality, inequality, + exceptions, and more, making it easy to test your code +* User-defined assertions: \ + You can define your own assertions with Googletest, making it simple to + write tests that are specific to your code +* Death tests: \ + Googletest supports death tests, which verify that your code exits in a + certain way, making it useful for testing error-handling code +* Fatal and non-fatal failures: \ + You can specify whether a test failure should be treated as fatal or + non-fatal with Googletest, allowing tests to continue running even if a + failure occurs +* Value-parameterized tests: \ + Googletest supports value-parameterized tests, which run multiple times with + different input values, making it useful for testing functions that take + different inputs +* Type-parameterized tests: \ + Googletest also supports type-parameterized tests, which run with different + data types, making it useful for testing functions that work with different + data types +* Various options for running tests: \ + Googletest provides many options for running tests including running + individual tests, running tests in a specific order and running tests in + parallel + +## Supported Platforms + +GoogleTest follows Google's +[Foundational C++ Support Policy](https://opensource.google/documentation/policies/cplusplus-support). +See +[this table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md) +for a list of currently supported versions of compilers, platforms, and build +tools. + +## Who Is Using GoogleTest? + +In addition to many internal projects at Google, GoogleTest is also used by the +following notable projects: + +* The [Chromium projects](http://www.chromium.org/) (behind the Chrome browser + and Chrome OS). +* The [LLVM](http://llvm.org/) compiler. +* [Protocol Buffers](https://github.com/google/protobuf), Google's data + interchange format. +* The [OpenCV](http://opencv.org/) computer vision library. + +## Related Open Source Projects + +[GTest Runner](https://github.com/nholthaus/gtest-runner) is a Qt5 based +automated test-runner and Graphical User Interface with powerful features for +Windows and Linux platforms. + +[GoogleTest UI](https://github.com/ospector/gtest-gbar) is a test runner that +runs your test binary, allows you to track its progress via a progress bar, and +displays a list of test failures. Clicking on one shows failure text. GoogleTest +UI is written in C#. + +[GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event +listener for GoogleTest that implements the +[TAP protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol) for test +result output. If your test runner understands TAP, you may find it useful. + +[gtest-parallel](https://github.com/google/gtest-parallel) is a test runner that +runs tests from your binary in parallel to provide significant speed-up. + +[GoogleTest Adapter](https://marketplace.visualstudio.com/items?itemName=DavidSchuldenfrei.gtest-adapter) +is a VS Code extension allowing to view GoogleTest in a tree view and run/debug +your tests. + +[C++ TestMate](https://github.com/matepek/vscode-catch2-test-adapter) is a VS +Code extension allowing to view GoogleTest in a tree view and run/debug your +tests. + +[Cornichon](https://pypi.org/project/cornichon/) is a small Gherkin DSL parser +that generates stub code for GoogleTest. + +## Contributing Changes + +Please read +[`CONTRIBUTING.md`](https://github.com/google/googletest/blob/main/CONTRIBUTING.md) +for details on how to contribute to this project. + +Happy testing! diff --git a/cpp/third_party/googletest/WORKSPACE b/cpp/third_party/googletest/WORKSPACE new file mode 100644 index 0000000..f819ffe --- /dev/null +++ b/cpp/third_party/googletest/WORKSPACE @@ -0,0 +1,27 @@ +workspace(name = "com_google_googletest") + +load("//:googletest_deps.bzl", "googletest_deps") +googletest_deps() + +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +http_archive( + name = "rules_python", # 2023-07-31T20:39:27Z + sha256 = "1250b59a33c591a1c4ba68c62e95fc88a84c334ec35a2e23f46cbc1b9a5a8b55", + strip_prefix = "rules_python-e355becc30275939d87116a4ec83dad4bb50d9e1", + urls = ["https://github.com/bazelbuild/rules_python/archive/e355becc30275939d87116a4ec83dad4bb50d9e1.zip"], +) + +http_archive( + name = "bazel_skylib", # 2023-05-31T19:24:07Z + sha256 = "08c0386f45821ce246bbbf77503c973246ed6ee5c3463e41efc197fa9bc3a7f4", + strip_prefix = "bazel-skylib-288731ef9f7f688932bd50e704a91a45ec185f9b", + urls = ["https://github.com/bazelbuild/bazel-skylib/archive/288731ef9f7f688932bd50e704a91a45ec185f9b.zip"], +) + +http_archive( + name = "platforms", # 2023-07-28T19:44:27Z + sha256 = "40eb313613ff00a5c03eed20aba58890046f4d38dec7344f00bb9a8867853526", + strip_prefix = "platforms-4ad40ef271da8176d4fc0194d2089b8a76e19d7b", + urls = ["https://github.com/bazelbuild/platforms/archive/4ad40ef271da8176d4fc0194d2089b8a76e19d7b.zip"], +) diff --git a/cpp/third_party/googletest/ci/linux-presubmit.sh b/cpp/third_party/googletest/ci/linux-presubmit.sh new file mode 100644 index 0000000..6bac887 --- /dev/null +++ b/cpp/third_party/googletest/ci/linux-presubmit.sh @@ -0,0 +1,137 @@ +#!/bin/bash +# +# Copyright 2020, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +set -euox pipefail + +readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20230217" +readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20230120" + +if [[ -z ${GTEST_ROOT:-} ]]; then + GTEST_ROOT="$(realpath $(dirname ${0})/..)" +fi + +if [[ -z ${STD:-} ]]; then + STD="c++14 c++17 c++20" +fi + +# Test the CMake build +for cc in /usr/local/bin/gcc /opt/llvm/clang/bin/clang; do + for cmake_off_on in OFF ON; do + time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --tmpfs="/build:exec" \ + --workdir="/build" \ + --rm \ + --env="CC=${cc}" \ + --env=CXXFLAGS="-Werror -Wdeprecated" \ + ${LINUX_LATEST_CONTAINER} \ + /bin/bash -c " + cmake /src \ + -DCMAKE_CXX_STANDARD=14 \ + -Dgtest_build_samples=ON \ + -Dgtest_build_tests=ON \ + -Dgmock_build_tests=ON \ + -Dcxx_no_exception=${cmake_off_on} \ + -Dcxx_no_rtti=${cmake_off_on} && \ + make -j$(nproc) && \ + ctest -j$(nproc) --output-on-failure" + done +done + +# Do one test with an older version of GCC +time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --workdir="/src" \ + --rm \ + --env="CC=/usr/local/bin/gcc" \ + --env="BAZEL_CXXOPTS=-std=c++14" \ + ${LINUX_GCC_FLOOR_CONTAINER} \ + /usr/local/bin/bazel test ... \ + --copt="-Wall" \ + --copt="-Werror" \ + --copt="-Wuninitialized" \ + --copt="-Wundef" \ + --copt="-Wno-error=pragmas" \ + --distdir="/bazel-distdir" \ + --features=external_include_paths \ + --keep_going \ + --show_timestamps \ + --test_output=errors + +# Test GCC +for std in ${STD}; do + for absl in 0 1; do + time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --workdir="/src" \ + --rm \ + --env="CC=/usr/local/bin/gcc" \ + --env="BAZEL_CXXOPTS=-std=${std}" \ + ${LINUX_LATEST_CONTAINER} \ + /usr/local/bin/bazel test ... \ + --copt="-Wall" \ + --copt="-Werror" \ + --copt="-Wuninitialized" \ + --copt="-Wundef" \ + --define="absl=${absl}" \ + --distdir="/bazel-distdir" \ + --features=external_include_paths \ + --keep_going \ + --show_timestamps \ + --test_output=errors + done +done + +# Test Clang +for std in ${STD}; do + for absl in 0 1; do + time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --workdir="/src" \ + --rm \ + --env="CC=/opt/llvm/clang/bin/clang" \ + --env="BAZEL_CXXOPTS=-std=${std}" \ + ${LINUX_LATEST_CONTAINER} \ + /usr/local/bin/bazel test ... \ + --copt="--gcc-toolchain=/usr/local" \ + --copt="-Wall" \ + --copt="-Werror" \ + --copt="-Wuninitialized" \ + --copt="-Wundef" \ + --define="absl=${absl}" \ + --distdir="/bazel-distdir" \ + --features=external_include_paths \ + --keep_going \ + --linkopt="--gcc-toolchain=/usr/local" \ + --show_timestamps \ + --test_output=errors + done +done diff --git a/cpp/third_party/googletest/ci/macos-presubmit.sh b/cpp/third_party/googletest/ci/macos-presubmit.sh new file mode 100644 index 0000000..681ebc2 --- /dev/null +++ b/cpp/third_party/googletest/ci/macos-presubmit.sh @@ -0,0 +1,76 @@ +#!/bin/bash +# +# Copyright 2020, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +set -euox pipefail + +if [[ -z ${GTEST_ROOT:-} ]]; then + GTEST_ROOT="$(realpath $(dirname ${0})/..)" +fi + +# Test the CMake build +for cmake_off_on in OFF ON; do + BUILD_DIR=$(mktemp -d build_dir.XXXXXXXX) + cd ${BUILD_DIR} + time cmake ${GTEST_ROOT} \ + -DCMAKE_CXX_STANDARD=14 \ + -Dgtest_build_samples=ON \ + -Dgtest_build_tests=ON \ + -Dgmock_build_tests=ON \ + -Dcxx_no_exception=${cmake_off_on} \ + -Dcxx_no_rtti=${cmake_off_on} + time make + time ctest -j$(nproc) --output-on-failure +done + +# Test the Bazel build + +# If we are running on Kokoro, check for a versioned Bazel binary. +KOKORO_GFILE_BAZEL_BIN="bazel-5.1.1-darwin-x86_64" +if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then + BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}" + chmod +x ${BAZEL_BIN} +else + BAZEL_BIN="bazel" +fi + +cd ${GTEST_ROOT} +for absl in 0 1; do + ${BAZEL_BIN} test ... \ + --copt="-Wall" \ + --copt="-Werror" \ + --copt="-Wundef" \ + --cxxopt="-std=c++14" \ + --define="absl=${absl}" \ + --features=external_include_paths \ + --keep_going \ + --show_timestamps \ + --test_output=errors +done diff --git a/cpp/third_party/googletest/ci/windows-presubmit.bat b/cpp/third_party/googletest/ci/windows-presubmit.bat new file mode 100644 index 0000000..48962eb --- /dev/null +++ b/cpp/third_party/googletest/ci/windows-presubmit.bat @@ -0,0 +1,58 @@ +SETLOCAL ENABLEDELAYEDEXPANSION + +SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe + +SET PATH=C:\Python34;%PATH% +SET BAZEL_PYTHON=C:\python34\python.exe +SET BAZEL_SH=C:\tools\msys64\usr\bin\bash.exe +SET CMAKE_BIN="cmake.exe" +SET CTEST_BIN="ctest.exe" +SET CTEST_OUTPUT_ON_FAILURE=1 +SET CMAKE_BUILD_PARALLEL_LEVEL=16 +SET CTEST_PARALLEL_LEVEL=16 + +IF EXIST git\googletest ( + CD git\googletest +) ELSE IF EXIST github\googletest ( + CD github\googletest +) + +IF %errorlevel% neq 0 EXIT /B 1 + +:: ---------------------------------------------------------------------------- +:: CMake +MKDIR cmake_msvc2022 +CD cmake_msvc2022 + +%CMAKE_BIN% .. ^ + -G "Visual Studio 17 2022" ^ + -DPYTHON_EXECUTABLE:FILEPATH=c:\python37\python.exe ^ + -DPYTHON_INCLUDE_DIR:PATH=c:\python37\include ^ + -DPYTHON_LIBRARY:FILEPATH=c:\python37\lib\site-packages\pip ^ + -Dgtest_build_samples=ON ^ + -Dgtest_build_tests=ON ^ + -Dgmock_build_tests=ON +IF %errorlevel% neq 0 EXIT /B 1 + +%CMAKE_BIN% --build . --target ALL_BUILD --config Debug -- -maxcpucount +IF %errorlevel% neq 0 EXIT /B 1 + +%CTEST_BIN% -C Debug --timeout 600 +IF %errorlevel% neq 0 EXIT /B 1 + +CD .. +RMDIR /S /Q cmake_msvc2022 + +:: ---------------------------------------------------------------------------- +:: Bazel + +SET BAZEL_VS=C:\Program Files\Microsoft Visual Studio\2022\Community +%BAZEL_EXE% test ... ^ + --compilation_mode=dbg ^ + --copt=/std:c++14 ^ + --copt=/WX ^ + --features=external_include_paths ^ + --keep_going ^ + --test_output=errors ^ + --test_tag_filters=-no_test_msvc2017 +IF %errorlevel% neq 0 EXIT /B 1 diff --git a/cpp/third_party/googletest/docs/_config.yml b/cpp/third_party/googletest/docs/_config.yml new file mode 100644 index 0000000..d12867e --- /dev/null +++ b/cpp/third_party/googletest/docs/_config.yml @@ -0,0 +1 @@ +title: GoogleTest diff --git a/cpp/third_party/googletest/docs/_data/navigation.yml b/cpp/third_party/googletest/docs/_data/navigation.yml new file mode 100644 index 0000000..9f33327 --- /dev/null +++ b/cpp/third_party/googletest/docs/_data/navigation.yml @@ -0,0 +1,43 @@ +nav: +- section: "Get Started" + items: + - title: "Supported Platforms" + url: "/platforms.html" + - title: "Quickstart: Bazel" + url: "/quickstart-bazel.html" + - title: "Quickstart: CMake" + url: "/quickstart-cmake.html" +- section: "Guides" + items: + - title: "GoogleTest Primer" + url: "/primer.html" + - title: "Advanced Topics" + url: "/advanced.html" + - title: "Mocking for Dummies" + url: "/gmock_for_dummies.html" + - title: "Mocking Cookbook" + url: "/gmock_cook_book.html" + - title: "Mocking Cheat Sheet" + url: "/gmock_cheat_sheet.html" +- section: "References" + items: + - title: "Testing Reference" + url: "/reference/testing.html" + - title: "Mocking Reference" + url: "/reference/mocking.html" + - title: "Assertions" + url: "/reference/assertions.html" + - title: "Matchers" + url: "/reference/matchers.html" + - title: "Actions" + url: "/reference/actions.html" + - title: "Testing FAQ" + url: "/faq.html" + - title: "Mocking FAQ" + url: "/gmock_faq.html" + - title: "Code Samples" + url: "/samples.html" + - title: "Using pkg-config" + url: "/pkgconfig.html" + - title: "Community Documentation" + url: "/community_created_documentation.html" diff --git a/cpp/third_party/googletest/docs/_layouts/default.html b/cpp/third_party/googletest/docs/_layouts/default.html new file mode 100644 index 0000000..c7f331b --- /dev/null +++ b/cpp/third_party/googletest/docs/_layouts/default.html @@ -0,0 +1,58 @@ + + + + + + + +{% seo %} + + + + + +
+
+

{{ site.title | default: "Documentation" }}

+
+ + + +
+
+
+ {{ content }} +
+
+ GoogleTest · + GitHub Repository · + License · + Privacy Policy +
+
+ + + + diff --git a/cpp/third_party/googletest/docs/_sass/main.scss b/cpp/third_party/googletest/docs/_sass/main.scss new file mode 100644 index 0000000..92edc87 --- /dev/null +++ b/cpp/third_party/googletest/docs/_sass/main.scss @@ -0,0 +1,200 @@ +// Styles for GoogleTest docs website on GitHub Pages. +// Color variables are defined in +// https://github.com/pages-themes/primer/tree/master/_sass/primer-support/lib/variables + +$sidebar-width: 260px; + +body { + display: flex; + margin: 0; +} + +.sidebar { + background: $black; + color: $text-white; + flex-shrink: 0; + height: 100vh; + overflow: auto; + position: sticky; + top: 0; + width: $sidebar-width; +} + +.sidebar h1 { + font-size: 1.5em; +} + +.sidebar h2 { + color: $gray-light; + font-size: 0.8em; + font-weight: normal; + margin-bottom: 0.8em; + padding-left: 2.5em; + text-transform: uppercase; +} + +.sidebar .header { + background: $black; + padding: 2em; + position: sticky; + top: 0; + width: 100%; +} + +.sidebar .header a { + color: $text-white; + text-decoration: none; +} + +.sidebar .nav-toggle { + display: none; +} + +.sidebar .expander { + cursor: pointer; + display: none; + height: 3em; + position: absolute; + right: 1em; + top: 1.5em; + width: 3em; +} + +.sidebar .expander .arrow { + border: solid $white; + border-width: 0 3px 3px 0; + display: block; + height: 0.7em; + margin: 1em auto; + transform: rotate(45deg); + transition: transform 0.5s; + width: 0.7em; +} + +.sidebar nav { + width: 100%; +} + +.sidebar nav ul { + list-style-type: none; + margin-bottom: 1em; + padding: 0; + + &:last-child { + margin-bottom: 2em; + } + + a { + text-decoration: none; + } + + li { + color: $text-white; + padding-left: 2em; + text-decoration: none; + } + + li.active { + background: $border-gray-darker; + font-weight: bold; + } + + li:hover { + background: $border-gray-darker; + } +} + +.main { + background-color: $bg-gray; + width: calc(100% - #{$sidebar-width}); +} + +.main .main-inner { + background-color: $white; + padding: 2em; +} + +.main .footer { + margin: 0; + padding: 2em; +} + +.main table th { + text-align: left; +} + +.main .callout { + border-left: 0.25em solid $white; + padding: 1em; + + a { + text-decoration: underline; + } + + &.important { + background-color: $bg-yellow-light; + border-color: $bg-yellow; + color: $black; + } + + &.note { + background-color: $bg-blue-light; + border-color: $text-blue; + color: $text-blue; + } + + &.tip { + background-color: $green-000; + border-color: $green-700; + color: $green-700; + } + + &.warning { + background-color: $red-000; + border-color: $text-red; + color: $text-red; + } +} + +.main .good pre { + background-color: $bg-green-light; +} + +.main .bad pre { + background-color: $red-000; +} + +@media all and (max-width: 768px) { + body { + flex-direction: column; + } + + .sidebar { + height: auto; + position: relative; + width: 100%; + } + + .sidebar .expander { + display: block; + } + + .sidebar nav { + height: 0; + overflow: hidden; + } + + .sidebar .nav-toggle:checked { + & ~ nav { + height: auto; + } + + & + .expander .arrow { + transform: rotate(-135deg); + } + } + + .main { + width: 100%; + } +} diff --git a/cpp/third_party/googletest/docs/advanced.md b/cpp/third_party/googletest/docs/advanced.md new file mode 100644 index 0000000..3871db1 --- /dev/null +++ b/cpp/third_party/googletest/docs/advanced.md @@ -0,0 +1,2436 @@ +# Advanced GoogleTest Topics + +## Introduction + +Now that you have read the [GoogleTest Primer](primer.md) and learned how to +write tests using GoogleTest, it's time to learn some new tricks. This document +will show you more assertions as well as how to construct complex failure +messages, propagate fatal failures, reuse and speed up your test fixtures, and +use various flags with your tests. + +## More Assertions + +This section covers some less frequently used, but still significant, +assertions. + +### Explicit Success and Failure + +See [Explicit Success and Failure](reference/assertions.md#success-failure) in +the Assertions Reference. + +### Exception Assertions + +See [Exception Assertions](reference/assertions.md#exceptions) in the Assertions +Reference. + +### Predicate Assertions for Better Error Messages + +Even though GoogleTest has a rich set of assertions, they can never be complete, +as it's impossible (nor a good idea) to anticipate all scenarios a user might +run into. Therefore, sometimes a user has to use `EXPECT_TRUE()` to check a +complex expression, for lack of a better macro. This has the problem of not +showing you the values of the parts of the expression, making it hard to +understand what went wrong. As a workaround, some users choose to construct the +failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this +is awkward especially when the expression has side-effects or is expensive to +evaluate. + +GoogleTest gives you three different options to solve this problem: + +#### Using an Existing Boolean Function + +If you already have a function or functor that returns `bool` (or a type that +can be implicitly converted to `bool`), you can use it in a *predicate +assertion* to get the function arguments printed for free. See +[`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) in the Assertions +Reference for details. + +#### Using a Function That Returns an AssertionResult + +While `EXPECT_PRED*()` and friends are handy for a quick job, the syntax is not +satisfactory: you have to use different macros for different arities, and it +feels more like Lisp than C++. The `::testing::AssertionResult` class solves +this problem. + +An `AssertionResult` object represents the result of an assertion (whether it's +a success or a failure, and an associated message). You can create an +`AssertionResult` using one of these factory functions: + +```c++ +namespace testing { + +// Returns an AssertionResult object to indicate that an assertion has +// succeeded. +AssertionResult AssertionSuccess(); + +// Returns an AssertionResult object to indicate that an assertion has +// failed. +AssertionResult AssertionFailure(); + +} +``` + +You can then use the `<<` operator to stream messages to the `AssertionResult` +object. + +To provide more readable messages in Boolean assertions (e.g. `EXPECT_TRUE()`), +write a predicate function that returns `AssertionResult` instead of `bool`. For +example, if you define `IsEven()` as: + +```c++ +testing::AssertionResult IsEven(int n) { + if ((n % 2) == 0) + return testing::AssertionSuccess(); + else + return testing::AssertionFailure() << n << " is odd"; +} +``` + +instead of: + +```c++ +bool IsEven(int n) { + return (n % 2) == 0; +} +``` + +the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print: + +```none +Value of: IsEven(Fib(4)) + Actual: false (3 is odd) +Expected: true +``` + +instead of a more opaque + +```none +Value of: IsEven(Fib(4)) + Actual: false +Expected: true +``` + +If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE` as well +(one third of Boolean assertions in the Google code base are negative ones), and +are fine with making the predicate slower in the success case, you can supply a +success message: + +```c++ +testing::AssertionResult IsEven(int n) { + if ((n % 2) == 0) + return testing::AssertionSuccess() << n << " is even"; + else + return testing::AssertionFailure() << n << " is odd"; +} +``` + +Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print + +```none + Value of: IsEven(Fib(6)) + Actual: true (8 is even) + Expected: false +``` + +#### Using a Predicate-Formatter + +If you find the default message generated by +[`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) and +[`EXPECT_TRUE`](reference/assertions.md#EXPECT_TRUE) unsatisfactory, or some +arguments to your predicate do not support streaming to `ostream`, you can +instead use *predicate-formatter assertions* to *fully* customize how the +message is formatted. See +[`EXPECT_PRED_FORMAT*`](reference/assertions.md#EXPECT_PRED_FORMAT) in the +Assertions Reference for details. + +### Floating-Point Comparison + +See [Floating-Point Comparison](reference/assertions.md#floating-point) in the +Assertions Reference. + +#### Floating-Point Predicate-Format Functions + +Some floating-point operations are useful, but not that often used. In order to +avoid an explosion of new macros, we provide them as predicate-format functions +that can be used in the predicate assertion macro +[`EXPECT_PRED_FORMAT2`](reference/assertions.md#EXPECT_PRED_FORMAT), for +example: + +```c++ +using ::testing::FloatLE; +using ::testing::DoubleLE; +... +EXPECT_PRED_FORMAT2(FloatLE, val1, val2); +EXPECT_PRED_FORMAT2(DoubleLE, val1, val2); +``` + +The above code verifies that `val1` is less than, or approximately equal to, +`val2`. + +### Asserting Using gMock Matchers + +See [`EXPECT_THAT`](reference/assertions.md#EXPECT_THAT) in the Assertions +Reference. + +### More String Assertions + +(Please read the [previous](#asserting-using-gmock-matchers) section first if +you haven't.) + +You can use the gMock [string matchers](reference/matchers.md#string-matchers) +with [`EXPECT_THAT`](reference/assertions.md#EXPECT_THAT) to do more string +comparison tricks (sub-string, prefix, suffix, regular expression, and etc). For +example, + +```c++ +using ::testing::HasSubstr; +using ::testing::MatchesRegex; +... + ASSERT_THAT(foo_string, HasSubstr("needle")); + EXPECT_THAT(bar_string, MatchesRegex("\\w*\\d+")); +``` + +### Windows HRESULT assertions + +See [Windows HRESULT Assertions](reference/assertions.md#HRESULT) in the +Assertions Reference. + +### Type Assertions + +You can call the function + +```c++ +::testing::StaticAssertTypeEq(); +``` + +to assert that types `T1` and `T2` are the same. The function does nothing if +the assertion is satisfied. If the types are different, the function call will +fail to compile, the compiler error message will say that `T1 and T2 are not the +same type` and most likely (depending on the compiler) show you the actual +values of `T1` and `T2`. This is mainly useful inside template code. + +**Caveat**: When used inside a member function of a class template or a function +template, `StaticAssertTypeEq()` is effective only if the function is +instantiated. For example, given: + +```c++ +template class Foo { + public: + void Bar() { testing::StaticAssertTypeEq(); } +}; +``` + +the code: + +```c++ +void Test1() { Foo foo; } +``` + +will not generate a compiler error, as `Foo::Bar()` is never actually +instantiated. Instead, you need: + +```c++ +void Test2() { Foo foo; foo.Bar(); } +``` + +to cause a compiler error. + +### Assertion Placement + +You can use assertions in any C++ function. In particular, it doesn't have to be +a method of the test fixture class. The one constraint is that assertions that +generate a fatal failure (`FAIL*` and `ASSERT_*`) can only be used in +void-returning functions. This is a consequence of Google's not using +exceptions. By placing it in a non-void function you'll get a confusing compile +error like `"error: void value not ignored as it ought to be"` or `"cannot +initialize return object of type 'bool' with an rvalue of type 'void'"` or +`"error: no viable conversion from 'void' to 'string'"`. + +If you need to use fatal assertions in a function that returns non-void, one +option is to make the function return the value in an out parameter instead. For +example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You +need to make sure that `*result` contains some sensible value even when the +function returns prematurely. As the function now returns `void`, you can use +any assertion inside of it. + +If changing the function's type is not an option, you should just use assertions +that generate non-fatal failures, such as `ADD_FAILURE*` and `EXPECT_*`. + +{: .callout .note} +NOTE: Constructors and destructors are not considered void-returning functions, +according to the C++ language specification, and so you may not use fatal +assertions in them; you'll get a compilation error if you try. Instead, either +call `abort` and crash the entire test executable, or put the fatal assertion in +a `SetUp`/`TearDown` function; see +[constructor/destructor vs. `SetUp`/`TearDown`](faq.md#CtorVsSetUp) + +{: .callout .warning} +WARNING: A fatal assertion in a helper function (private void-returning method) +called from a constructor or destructor does not terminate the current test, as +your intuition might suggest: it merely returns from the constructor or +destructor early, possibly leaving your object in a partially-constructed or +partially-destructed state! You almost certainly want to `abort` or use +`SetUp`/`TearDown` instead. + +## Skipping test execution + +Related to the assertions `SUCCEED()` and `FAIL()`, you can prevent further test +execution at runtime with the `GTEST_SKIP()` macro. This is useful when you need +to check for preconditions of the system under test during runtime and skip +tests in a meaningful way. + +`GTEST_SKIP()` can be used in individual test cases or in the `SetUp()` methods +of classes derived from either `::testing::Environment` or `::testing::Test`. +For example: + +```c++ +TEST(SkipTest, DoesSkip) { + GTEST_SKIP() << "Skipping single test"; + EXPECT_EQ(0, 1); // Won't fail; it won't be executed +} + +class SkipFixture : public ::testing::Test { + protected: + void SetUp() override { + GTEST_SKIP() << "Skipping all tests for this fixture"; + } +}; + +// Tests for SkipFixture won't be executed. +TEST_F(SkipFixture, SkipsOneTest) { + EXPECT_EQ(5, 7); // Won't fail +} +``` + +As with assertion macros, you can stream a custom message into `GTEST_SKIP()`. + +## Teaching GoogleTest How to Print Your Values + +When a test assertion such as `EXPECT_EQ` fails, GoogleTest prints the argument +values to help you debug. It does this using a user-extensible value printer. + +This printer knows how to print built-in C++ types, native arrays, STL +containers, and any type that supports the `<<` operator. For other types, it +prints the raw bytes in the value and hopes that you the user can figure it out. + +As mentioned earlier, the printer is *extensible*. That means you can teach it +to do a better job at printing your particular type than to dump the bytes. To +do that, define an `AbslStringify()` overload as a `friend` function template +for your type: + +```cpp +namespace foo { + +class Point { // We want GoogleTest to be able to print instances of this. + ... + // Provide a friend overload. + template + friend void AbslStringify(Sink& sink, const Point& point) { + absl::Format(&sink, "(%d, %d)", point.x, point.y); + } + + int x; + int y; +}; + +// If you can't declare the function in the class it's important that the +// AbslStringify overload is defined in the SAME namespace that defines Point. +// C++'s look-up rules rely on that. +enum class EnumWithStringify { kMany = 0, kChoices = 1 }; + +template +void AbslStringify(Sink& sink, EnumWithStringify e) { + absl::Format(&sink, "%s", e == EnumWithStringify::kMany ? "Many" : "Choices"); +} + +} // namespace foo +``` + +{: .callout .note} +Note: `AbslStringify()` utilizes a generic "sink" buffer to construct its +string. For more information about supported operations on `AbslStringify()`'s +sink, see go/abslstringify. + +`AbslStringify()` can also use `absl::StrFormat`'s catch-all `%v` type specifier +within its own format strings to perform type deduction. `Point` above could be +formatted as `"(%v, %v)"` for example, and deduce the `int` values as `%d`. + +Sometimes, `AbslStringify()` might not be an option: your team may wish to print +types with extra debugging information for testing purposes only. If so, you can +instead define a `PrintTo()` function like this: + +```c++ +#include + +namespace foo { + +class Point { + ... + friend void PrintTo(const Point& point, std::ostream* os) { + *os << "(" << point.x << "," << point.y << ")"; + } + + int x; + int y; +}; + +// If you can't declare the function in the class it's important that PrintTo() +// is defined in the SAME namespace that defines Point. C++'s look-up rules +// rely on that. +void PrintTo(const Point& point, std::ostream* os) { + *os << "(" << point.x << "," << point.y << ")"; +} + +} // namespace foo +``` + +If you have defined both `AbslStringify()` and `PrintTo()`, the latter will be +used by GoogleTest. This allows you to customize how the value appears in +GoogleTest's output without affecting code that relies on the behavior of +`AbslStringify()`. + +If you have an existing `<<` operator and would like to define an +`AbslStringify()`, the latter will be used for GoogleTest printing. + +If you want to print a value `x` using GoogleTest's value printer yourself, just +call `::testing::PrintToString(x)`, which returns an `std::string`: + +```c++ +vector > point_ints = GetPointIntVector(); + +EXPECT_TRUE(IsCorrectPointIntVector(point_ints)) + << "point_ints = " << testing::PrintToString(point_ints); +``` + +For more details regarding `AbslStringify()` and its integration with other +libraries, see go/abslstringify. + +## Death Tests + +In many applications, there are assertions that can cause application failure if +a condition is not met. These consistency checks, which ensure that the program +is in a known good state, are there to fail at the earliest possible time after +some program state is corrupted. If the assertion checks the wrong condition, +then the program may proceed in an erroneous state, which could lead to memory +corruption, security holes, or worse. Hence it is vitally important to test that +such assertion statements work as expected. + +Since these precondition checks cause the processes to die, we call such tests +_death tests_. More generally, any test that checks that a program terminates +(except by throwing an exception) in an expected fashion is also a death test. + +Note that if a piece of code throws an exception, we don't consider it "death" +for the purpose of death tests, as the caller of the code could catch the +exception and avoid the crash. If you want to verify exceptions thrown by your +code, see [Exception Assertions](#ExceptionAssertions). + +If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see +["Catching" Failures](#catching-failures). + +### How to Write a Death Test + +GoogleTest provides assertion macros to support death tests. See +[Death Assertions](reference/assertions.md#death) in the Assertions Reference +for details. + +To write a death test, simply use one of the macros inside your test function. +For example, + +```c++ +TEST(MyDeathTest, Foo) { + // This death test uses a compound statement. + ASSERT_DEATH({ + int n = 5; + Foo(&n); + }, "Error on line .* of Foo()"); +} + +TEST(MyDeathTest, NormalExit) { + EXPECT_EXIT(NormalExit(), testing::ExitedWithCode(0), "Success"); +} + +TEST(MyDeathTest, KillProcess) { + EXPECT_EXIT(KillProcess(), testing::KilledBySignal(SIGKILL), + "Sending myself unblockable signal"); +} +``` + +verifies that: + +* calling `Foo(5)` causes the process to die with the given error message, +* calling `NormalExit()` causes the process to print `"Success"` to stderr and + exit with exit code 0, and +* calling `KillProcess()` kills the process with signal `SIGKILL`. + +The test function body may contain other assertions and statements as well, if +necessary. + +Note that a death test only cares about three things: + +1. does `statement` abort or exit the process? +2. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status + satisfy `predicate`? Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) + is the exit status non-zero? And +3. does the stderr output match `matcher`? + +In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it +will **not** cause the death test to fail, as GoogleTest assertions don't abort +the process. + +### Death Test Naming + +{: .callout .important} +IMPORTANT: We strongly recommend you to follow the convention of naming your +**test suite** (not test) `*DeathTest` when it contains a death test, as +demonstrated in the above example. The +[Death Tests And Threads](#death-tests-and-threads) section below explains why. + +If a test fixture class is shared by normal tests and death tests, you can use +`using` or `typedef` to introduce an alias for the fixture class and avoid +duplicating its code: + +```c++ +class FooTest : public testing::Test { ... }; + +using FooDeathTest = FooTest; + +TEST_F(FooTest, DoesThis) { + // normal test +} + +TEST_F(FooDeathTest, DoesThat) { + // death test +} +``` + +### Regular Expression Syntax + +When built with Bazel and using Abseil, GoogleTest uses the +[RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX +systems (Linux, Cygwin, Mac), GoogleTest uses the +[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04) +syntax. To learn about POSIX syntax, you may want to read this +[Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_extended). + +On Windows, GoogleTest uses its own simple regular expression implementation. It +lacks many features. For example, we don't support union (`"x|y"`), grouping +(`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among +others. Below is what we do support (`A` denotes a literal character, period +(`.`), or a single `\\ ` escape sequence; `x` and `y` denote regular +expressions.): + +Expression | Meaning +---------- | -------------------------------------------------------------- +`c` | matches any literal character `c` +`\\d` | matches any decimal digit +`\\D` | matches any character that's not a decimal digit +`\\f` | matches `\f` +`\\n` | matches `\n` +`\\r` | matches `\r` +`\\s` | matches any ASCII whitespace, including `\n` +`\\S` | matches any character that's not a whitespace +`\\t` | matches `\t` +`\\v` | matches `\v` +`\\w` | matches any letter, `_`, or decimal digit +`\\W` | matches any character that `\\w` doesn't match +`\\c` | matches any literal character `c`, which must be a punctuation +`.` | matches any single character except `\n` +`A?` | matches 0 or 1 occurrences of `A` +`A*` | matches 0 or many occurrences of `A` +`A+` | matches 1 or many occurrences of `A` +`^` | matches the beginning of a string (not that of each line) +`$` | matches the end of a string (not that of each line) +`xy` | matches `x` followed by `y` + +To help you determine which capability is available on your system, GoogleTest +defines macros to govern which regular expression it is using. The macros are: +`GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death +tests to work in all cases, you can either `#if` on these macros or use the more +limited syntax only. + +### How It Works + +See [Death Assertions](reference/assertions.md#death) in the Assertions +Reference. + +### Death Tests And Threads + +The reason for the two death test styles has to do with thread safety. Due to +well-known problems with forking in the presence of threads, death tests should +be run in a single-threaded context. Sometimes, however, it isn't feasible to +arrange that kind of environment. For example, statically-initialized modules +may start threads before main is ever reached. Once threads have been created, +it may be difficult or impossible to clean them up. + +GoogleTest has three features intended to raise awareness of threading issues. + +1. A warning is emitted if multiple threads are running when a death test is + encountered. +2. Test suites with a name ending in "DeathTest" are run before all other + tests. +3. It uses `clone()` instead of `fork()` to spawn the child process on Linux + (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely + to cause the child to hang when the parent process has multiple threads. + +It's perfectly fine to create threads inside a death test statement; they are +executed in a separate process and cannot affect the parent. + +### Death Test Styles + +The "threadsafe" death test style was introduced in order to help mitigate the +risks of testing in a possibly multithreaded environment. It trades increased +test execution time (potentially dramatically so) for improved thread safety. + +The automated testing framework does not set the style flag. You can choose a +particular style of death tests by setting the flag programmatically: + +```c++ +GTEST_FLAG_SET(death_test_style, "threadsafe"); +``` + +You can do this in `main()` to set the style for all death tests in the binary, +or in individual tests. Recall that flags are saved before running each test and +restored afterwards, so you need not do that yourself. For example: + +```c++ +int main(int argc, char** argv) { + testing::InitGoogleTest(&argc, argv); + GTEST_FLAG_SET(death_test_style, "fast"); + return RUN_ALL_TESTS(); +} + +TEST(MyDeathTest, TestOne) { + GTEST_FLAG_SET(death_test_style, "threadsafe"); + // This test is run in the "threadsafe" style: + ASSERT_DEATH(ThisShouldDie(), ""); +} + +TEST(MyDeathTest, TestTwo) { + // This test is run in the "fast" style: + ASSERT_DEATH(ThisShouldDie(), ""); +} +``` + +### Caveats + +The `statement` argument of `ASSERT_EXIT()` can be any valid C++ statement. If +it leaves the current function via a `return` statement or by throwing an +exception, the death test is considered to have failed. Some GoogleTest macros +may return from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid +them in `statement`. + +Since `statement` runs in the child process, any in-memory side effect (e.g. +modifying a variable, releasing memory, etc) it causes will *not* be observable +in the parent process. In particular, if you release memory in a death test, +your program will fail the heap check as the parent process will never see the +memory reclaimed. To solve this problem, you can + +1. try not to free memory in a death test; +2. free the memory again in the parent process; or +3. do not use the heap checker in your program. + +Due to an implementation detail, you cannot place multiple death test assertions +on the same line; otherwise, compilation will fail with an unobvious error +message. + +Despite the improved thread safety afforded by the "threadsafe" style of death +test, thread problems such as deadlock are still possible in the presence of +handlers registered with `pthread_atfork(3)`. + +## Using Assertions in Sub-routines + +{: .callout .note} +Note: If you want to put a series of test assertions in a subroutine to check +for a complex condition, consider using +[a custom GMock matcher](gmock_cook_book.md#NewMatchers) instead. This lets you +provide a more readable error message in case of failure and avoid all of the +issues described below. + +### Adding Traces to Assertions + +If a test sub-routine is called from several places, when an assertion inside it +fails, it can be hard to tell which invocation of the sub-routine the failure is +from. You can alleviate this problem using extra logging or custom failure +messages, but that usually clutters up your tests. A better solution is to use +the `SCOPED_TRACE` macro or the `ScopedTrace` utility: + +```c++ +SCOPED_TRACE(message); +``` + +```c++ +ScopedTrace trace("file_path", line_number, message); +``` + +where `message` can be anything streamable to `std::ostream`. `SCOPED_TRACE` +macro will cause the current file name, line number, and the given message to be +added in every failure message. `ScopedTrace` accepts explicit file name and +line number in arguments, which is useful for writing test helpers. The effect +will be undone when the control leaves the current lexical scope. + +For example, + +```c++ +10: void Sub1(int n) { +11: EXPECT_EQ(Bar(n), 1); +12: EXPECT_EQ(Bar(n + 1), 2); +13: } +14: +15: TEST(FooTest, Bar) { +16: { +17: SCOPED_TRACE("A"); // This trace point will be included in +18: // every failure in this scope. +19: Sub1(1); +20: } +21: // Now it won't. +22: Sub1(9); +23: } +``` + +could result in messages like these: + +```none +path/to/foo_test.cc:11: Failure +Value of: Bar(n) +Expected: 1 + Actual: 2 +Google Test trace: +path/to/foo_test.cc:17: A + +path/to/foo_test.cc:12: Failure +Value of: Bar(n + 1) +Expected: 2 + Actual: 3 +``` + +Without the trace, it would've been difficult to know which invocation of +`Sub1()` the two failures come from respectively. (You could add an extra +message to each assertion in `Sub1()` to indicate the value of `n`, but that's +tedious.) + +Some tips on using `SCOPED_TRACE`: + +1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the + beginning of a sub-routine, instead of at each call site. +2. When calling sub-routines inside a loop, make the loop iterator part of the + message in `SCOPED_TRACE` such that you can know which iteration the failure + is from. +3. Sometimes the line number of the trace point is enough for identifying the + particular invocation of a sub-routine. In this case, you don't have to + choose a unique message for `SCOPED_TRACE`. You can simply use `""`. +4. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer + scope. In this case, all active trace points will be included in the failure + messages, in reverse order they are encountered. +5. The trace dump is clickable in Emacs - hit `return` on a line number and + you'll be taken to that line in the source file! + +### Propagating Fatal Failures + +A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that +when they fail they only abort the _current function_, not the entire test. For +example, the following test will segfault: + +```c++ +void Subroutine() { + // Generates a fatal failure and aborts the current function. + ASSERT_EQ(1, 2); + + // The following won't be executed. + ... +} + +TEST(FooTest, Bar) { + Subroutine(); // The intended behavior is for the fatal failure + // in Subroutine() to abort the entire test. + + // The actual behavior: the function goes on after Subroutine() returns. + int* p = nullptr; + *p = 3; // Segfault! +} +``` + +To alleviate this, GoogleTest provides three different solutions. You could use +either exceptions, the `(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the +`HasFatalFailure()` function. They are described in the following two +subsections. + +#### Asserting on Subroutines with an exception + +The following code can turn ASSERT-failure into an exception: + +```c++ +class ThrowListener : public testing::EmptyTestEventListener { + void OnTestPartResult(const testing::TestPartResult& result) override { + if (result.type() == testing::TestPartResult::kFatalFailure) { + throw testing::AssertionException(result); + } + } +}; +int main(int argc, char** argv) { + ... + testing::UnitTest::GetInstance()->listeners().Append(new ThrowListener); + return RUN_ALL_TESTS(); +} +``` + +This listener should be added after other listeners if you have any, otherwise +they won't see failed `OnTestPartResult`. + +#### Asserting on Subroutines + +As shown above, if your test calls a subroutine that has an `ASSERT_*` failure +in it, the test will continue after the subroutine returns. This may not be what +you want. + +Often people want fatal failures to propagate like exceptions. For that +GoogleTest offers the following macros: + +Fatal assertion | Nonfatal assertion | Verifies +------------------------------------- | ------------------------------------- | -------- +`ASSERT_NO_FATAL_FAILURE(statement);` | `EXPECT_NO_FATAL_FAILURE(statement);` | `statement` doesn't generate any new fatal failures in the current thread. + +Only failures in the thread that executes the assertion are checked to determine +the result of this type of assertions. If `statement` creates new threads, +failures in these threads are ignored. + +Examples: + +```c++ +ASSERT_NO_FATAL_FAILURE(Foo()); + +int i; +EXPECT_NO_FATAL_FAILURE({ + i = Bar(); +}); +``` + +Assertions from multiple threads are currently not supported on Windows. + +#### Checking for Failures in the Current Test + +`HasFatalFailure()` in the `::testing::Test` class returns `true` if an +assertion in the current test has suffered a fatal failure. This allows +functions to catch fatal failures in a sub-routine and return early. + +```c++ +class Test { + public: + ... + static bool HasFatalFailure(); +}; +``` + +The typical usage, which basically simulates the behavior of a thrown exception, +is: + +```c++ +TEST(FooTest, Bar) { + Subroutine(); + // Aborts if Subroutine() had a fatal failure. + if (HasFatalFailure()) return; + + // The following won't be executed. + ... +} +``` + +If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test +fixture, you must add the `::testing::Test::` prefix, as in: + +```c++ +if (testing::Test::HasFatalFailure()) return; +``` + +Similarly, `HasNonfatalFailure()` returns `true` if the current test has at +least one non-fatal failure, and `HasFailure()` returns `true` if the current +test has at least one failure of either kind. + +## Logging Additional Information + +In your test code, you can call `RecordProperty("key", value)` to log additional +information, where `value` can be either a string or an `int`. The *last* value +recorded for a key will be emitted to the +[XML output](#generating-an-xml-report) if you specify one. For example, the +test + +```c++ +TEST_F(WidgetUsageTest, MinAndMaxWidgets) { + RecordProperty("MaximumWidgets", ComputeMaxUsage()); + RecordProperty("MinimumWidgets", ComputeMinUsage()); +} +``` + +will output XML like this: + +```xml + ... + + ... +``` + +{: .callout .note} +> NOTE: +> +> * `RecordProperty()` is a static member of the `Test` class. Therefore it +> needs to be prefixed with `::testing::Test::` if used outside of the +> `TEST` body and the test fixture class. +> * *`key`* must be a valid XML attribute name, and cannot conflict with the +> ones already used by GoogleTest (`name`, `status`, `time`, `classname`, +> `type_param`, and `value_param`). +> * Calling `RecordProperty()` outside of the lifespan of a test is allowed. +> If it's called outside of a test but between a test suite's +> `SetUpTestSuite()` and `TearDownTestSuite()` methods, it will be +> attributed to the XML element for the test suite. If it's called outside +> of all test suites (e.g. in a test environment), it will be attributed to +> the top-level XML element. + +## Sharing Resources Between Tests in the Same Test Suite + +GoogleTest creates a new test fixture object for each test in order to make +tests independent and easier to debug. However, sometimes tests use resources +that are expensive to set up, making the one-copy-per-test model prohibitively +expensive. + +If the tests don't change the resource, there's no harm in their sharing a +single resource copy. So, in addition to per-test set-up/tear-down, GoogleTest +also supports per-test-suite set-up/tear-down. To use it: + +1. In your test fixture class (say `FooTest` ), declare as `static` some member + variables to hold the shared resources. +2. Outside your test fixture class (typically just below it), define those + member variables, optionally giving them initial values. +3. In the same test fixture class, define a `static void SetUpTestSuite()` + function (remember not to spell it as **`SetupTestSuite`** with a small + `u`!) to set up the shared resources and a `static void TearDownTestSuite()` + function to tear them down. + +That's it! GoogleTest automatically calls `SetUpTestSuite()` before running the +*first test* in the `FooTest` test suite (i.e. before creating the first +`FooTest` object), and calls `TearDownTestSuite()` after running the *last test* +in it (i.e. after deleting the last `FooTest` object). In between, the tests can +use the shared resources. + +Remember that the test order is undefined, so your code can't depend on a test +preceding or following another. Also, the tests must either not modify the state +of any shared resource, or, if they do modify the state, they must restore the +state to its original value before passing control to the next test. + +Note that `SetUpTestSuite()` may be called multiple times for a test fixture +class that has derived classes, so you should not expect code in the function +body to be run only once. Also, derived classes still have access to shared +resources defined as static members, so careful consideration is needed when +managing shared resources to avoid memory leaks if shared resources are not +properly cleaned up in `TearDownTestSuite()`. + +Here's an example of per-test-suite set-up and tear-down: + +```c++ +class FooTest : public testing::Test { + protected: + // Per-test-suite set-up. + // Called before the first test in this test suite. + // Can be omitted if not needed. + static void SetUpTestSuite() { + shared_resource_ = new ...; + + // If `shared_resource_` is **not deleted** in `TearDownTestSuite()`, + // reallocation should be prevented because `SetUpTestSuite()` may be called + // in subclasses of FooTest and lead to memory leak. + // + // if (shared_resource_ == nullptr) { + // shared_resource_ = new ...; + // } + } + + // Per-test-suite tear-down. + // Called after the last test in this test suite. + // Can be omitted if not needed. + static void TearDownTestSuite() { + delete shared_resource_; + shared_resource_ = nullptr; + } + + // You can define per-test set-up logic as usual. + void SetUp() override { ... } + + // You can define per-test tear-down logic as usual. + void TearDown() override { ... } + + // Some expensive resource shared by all tests. + static T* shared_resource_; +}; + +T* FooTest::shared_resource_ = nullptr; + +TEST_F(FooTest, Test1) { + ... you can refer to shared_resource_ here ... +} + +TEST_F(FooTest, Test2) { + ... you can refer to shared_resource_ here ... +} +``` + +{: .callout .note} +NOTE: Though the above code declares `SetUpTestSuite()` protected, it may +sometimes be necessary to declare it public, such as when using it with +`TEST_P`. + +## Global Set-Up and Tear-Down + +Just as you can do set-up and tear-down at the test level and the test suite +level, you can also do it at the test program level. Here's how. + +First, you subclass the `::testing::Environment` class to define a test +environment, which knows how to set-up and tear-down: + +```c++ +class Environment : public ::testing::Environment { + public: + ~Environment() override {} + + // Override this to define how to set up the environment. + void SetUp() override {} + + // Override this to define how to tear down the environment. + void TearDown() override {} +}; +``` + +Then, you register an instance of your environment class with GoogleTest by +calling the `::testing::AddGlobalTestEnvironment()` function: + +```c++ +Environment* AddGlobalTestEnvironment(Environment* env); +``` + +Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of +each environment object, then runs the tests if none of the environments +reported fatal failures and `GTEST_SKIP()` was not called. `RUN_ALL_TESTS()` +always calls `TearDown()` with each environment object, regardless of whether or +not the tests were run. + +It's OK to register multiple environment objects. In this suite, their `SetUp()` +will be called in the order they are registered, and their `TearDown()` will be +called in the reverse order. + +Note that GoogleTest takes ownership of the registered environment objects. +Therefore **do not delete them** by yourself. + +You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is called, +probably in `main()`. If you use `gtest_main`, you need to call this before +`main()` starts for it to take effect. One way to do this is to define a global +variable like this: + +```c++ +testing::Environment* const foo_env = + testing::AddGlobalTestEnvironment(new FooEnvironment); +``` + +However, we strongly recommend you to write your own `main()` and call +`AddGlobalTestEnvironment()` there, as relying on initialization of global +variables makes the code harder to read and may cause problems when you register +multiple environments from different translation units and the environments have +dependencies among them (remember that the compiler doesn't guarantee the order +in which global variables from different translation units are initialized). + +## Value-Parameterized Tests + +*Value-parameterized tests* allow you to test your code with different +parameters without writing multiple copies of the same test. This is useful in a +number of situations, for example: + +* You have a piece of code whose behavior is affected by one or more + command-line flags. You want to make sure your code performs correctly for + various values of those flags. +* You want to test different implementations of an OO interface. +* You want to test your code over various inputs (a.k.a. data-driven testing). + This feature is easy to abuse, so please exercise your good sense when doing + it! + +### How to Write Value-Parameterized Tests + +To write value-parameterized tests, first you should define a fixture class. It +must be derived from both `testing::Test` and `testing::WithParamInterface` +(the latter is a pure interface), where `T` is the type of your parameter +values. For convenience, you can just derive the fixture class from +`testing::TestWithParam`, which itself is derived from both `testing::Test` +and `testing::WithParamInterface`. `T` can be any copyable type. If it's a +raw pointer, you are responsible for managing the lifespan of the pointed +values. + +{: .callout .note} +NOTE: If your test fixture defines `SetUpTestSuite()` or `TearDownTestSuite()` +they must be declared **public** rather than **protected** in order to use +`TEST_P`. + +```c++ +class FooTest : + public testing::TestWithParam { + // You can implement all the usual fixture class members here. + // To access the test parameter, call GetParam() from class + // TestWithParam. +}; + +// Or, when you want to add parameters to a pre-existing fixture class: +class BaseTest : public testing::Test { + ... +}; +class BarTest : public BaseTest, + public testing::WithParamInterface { + ... +}; +``` + +Then, use the `TEST_P` macro to define as many test patterns using this fixture +as you want. The `_P` suffix is for "parameterized" or "pattern", whichever you +prefer to think. + +```c++ +TEST_P(FooTest, DoesBlah) { + // Inside a test, access the test parameter with the GetParam() method + // of the TestWithParam class: + EXPECT_TRUE(foo.Blah(GetParam())); + ... +} + +TEST_P(FooTest, HasBlahBlah) { + ... +} +``` + +Finally, you can use the `INSTANTIATE_TEST_SUITE_P` macro to instantiate the +test suite with any set of parameters you want. GoogleTest defines a number of +functions for generating test parameters—see details at +[`INSTANTIATE_TEST_SUITE_P`](reference/testing.md#INSTANTIATE_TEST_SUITE_P) in +the Testing Reference. + +For example, the following statement will instantiate tests from the `FooTest` +test suite each with parameter values `"meeny"`, `"miny"`, and `"moe"` using the +[`Values`](reference/testing.md#param-generators) parameter generator: + +```c++ +INSTANTIATE_TEST_SUITE_P(MeenyMinyMoe, + FooTest, + testing::Values("meeny", "miny", "moe")); +``` + +{: .callout .note} +NOTE: The code above must be placed at global or namespace scope, not at +function scope. + +The first argument to `INSTANTIATE_TEST_SUITE_P` is a unique name for the +instantiation of the test suite. The next argument is the name of the test +pattern, and the last is the +[parameter generator](reference/testing.md#param-generators). + +The parameter generator expression is not evaluated until GoogleTest is +initialized (via `InitGoogleTest()`). Any prior initialization done in the +`main` function will be accessible from the parameter generator, for example, +the results of flag parsing. + +You can instantiate a test pattern more than once, so to distinguish different +instances of the pattern, the instantiation name is added as a prefix to the +actual test suite name. Remember to pick unique prefixes for different +instantiations. The tests from the instantiation above will have these names: + +* `MeenyMinyMoe/FooTest.DoesBlah/0` for `"meeny"` +* `MeenyMinyMoe/FooTest.DoesBlah/1` for `"miny"` +* `MeenyMinyMoe/FooTest.DoesBlah/2` for `"moe"` +* `MeenyMinyMoe/FooTest.HasBlahBlah/0` for `"meeny"` +* `MeenyMinyMoe/FooTest.HasBlahBlah/1` for `"miny"` +* `MeenyMinyMoe/FooTest.HasBlahBlah/2` for `"moe"` + +You can use these names in [`--gtest_filter`](#running-a-subset-of-the-tests). + +The following statement will instantiate all tests from `FooTest` again, each +with parameter values `"cat"` and `"dog"` using the +[`ValuesIn`](reference/testing.md#param-generators) parameter generator: + +```c++ +constexpr absl::string_view kPets[] = {"cat", "dog"}; +INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(kPets)); +``` + +The tests from the instantiation above will have these names: + +* `Pets/FooTest.DoesBlah/0` for `"cat"` +* `Pets/FooTest.DoesBlah/1` for `"dog"` +* `Pets/FooTest.HasBlahBlah/0` for `"cat"` +* `Pets/FooTest.HasBlahBlah/1` for `"dog"` + +Please note that `INSTANTIATE_TEST_SUITE_P` will instantiate *all* tests in the +given test suite, whether their definitions come before or *after* the +`INSTANTIATE_TEST_SUITE_P` statement. + +Additionally, by default, every `TEST_P` without a corresponding +`INSTANTIATE_TEST_SUITE_P` causes a failing test in test suite +`GoogleTestVerification`. If you have a test suite where that omission is not an +error, for example it is in a library that may be linked in for other reasons or +where the list of test cases is dynamic and may be empty, then this check can be +suppressed by tagging the test suite: + +```c++ +GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FooTest); +``` + +You can see [sample7_unittest.cc] and [sample8_unittest.cc] for more examples. + +[sample7_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample7_unittest.cc "Parameterized Test example" +[sample8_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample8_unittest.cc "Parameterized Test example with multiple parameters" + +### Creating Value-Parameterized Abstract Tests + +In the above, we define and instantiate `FooTest` in the *same* source file. +Sometimes you may want to define value-parameterized tests in a library and let +other people instantiate them later. This pattern is known as *abstract tests*. +As an example of its application, when you are designing an interface you can +write a standard suite of abstract tests (perhaps using a factory function as +the test parameter) that all implementations of the interface are expected to +pass. When someone implements the interface, they can instantiate your suite to +get all the interface-conformance tests for free. + +To define abstract tests, you should organize your code like this: + +1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) + in a header file, say `foo_param_test.h`. Think of this as *declaring* your + abstract tests. +2. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes + `foo_param_test.h`. Think of this as *implementing* your abstract tests. + +Once they are defined, you can instantiate them by including `foo_param_test.h`, +invoking `INSTANTIATE_TEST_SUITE_P()`, and depending on the library target that +contains `foo_param_test.cc`. You can instantiate the same abstract test suite +multiple times, possibly in different source files. + +### Specifying Names for Value-Parameterized Test Parameters + +The optional last argument to `INSTANTIATE_TEST_SUITE_P()` allows the user to +specify a function or functor that generates custom test name suffixes based on +the test parameters. The function should accept one argument of type +`testing::TestParamInfo`, and return `std::string`. + +`testing::PrintToStringParamName` is a builtin test suffix generator that +returns the value of `testing::PrintToString(GetParam())`. It does not work for +`std::string` or C strings. + +{: .callout .note} +NOTE: test names must be non-empty, unique, and may only contain ASCII +alphanumeric characters. In particular, they +[should not contain underscores](faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore) + +```c++ +class MyTestSuite : public testing::TestWithParam {}; + +TEST_P(MyTestSuite, MyTest) +{ + std::cout << "Example Test Param: " << GetParam() << std::endl; +} + +INSTANTIATE_TEST_SUITE_P(MyGroup, MyTestSuite, testing::Range(0, 10), + testing::PrintToStringParamName()); +``` + +Providing a custom functor allows for more control over test parameter name +generation, especially for types where the automatic conversion does not +generate helpful parameter names (e.g. strings as demonstrated above). The +following example illustrates this for multiple parameters, an enumeration type +and a string, and also demonstrates how to combine generators. It uses a lambda +for conciseness: + +```c++ +enum class MyType { MY_FOO = 0, MY_BAR = 1 }; + +class MyTestSuite : public testing::TestWithParam> { +}; + +INSTANTIATE_TEST_SUITE_P( + MyGroup, MyTestSuite, + testing::Combine( + testing::Values(MyType::MY_FOO, MyType::MY_BAR), + testing::Values("A", "B")), + [](const testing::TestParamInfo& info) { + std::string name = absl::StrCat( + std::get<0>(info.param) == MyType::MY_FOO ? "Foo" : "Bar", + std::get<1>(info.param)); + absl::c_replace_if(name, [](char c) { return !std::isalnum(c); }, '_'); + return name; + }); +``` + +## Typed Tests + +Suppose you have multiple implementations of the same interface and want to make +sure that all of them satisfy some common requirements. Or, you may have defined +several types that are supposed to conform to the same "concept" and you want to +verify it. In both cases, you want the same test logic repeated for different +types. + +While you can write one `TEST` or `TEST_F` for each type you want to test (and +you may even factor the test logic into a function template that you invoke from +the `TEST`), it's tedious and doesn't scale: if you want `m` tests over `n` +types, you'll end up writing `m*n` `TEST`s. + +*Typed tests* allow you to repeat the same test logic over a list of types. You +only need to write the test logic once, although you must know the type list +when writing typed tests. Here's how you do it: + +First, define a fixture class template. It should be parameterized by a type. +Remember to derive it from `::testing::Test`: + +```c++ +template +class FooTest : public testing::Test { + public: + ... + using List = std::list; + static T shared_; + T value_; +}; +``` + +Next, associate a list of types with the test suite, which will be repeated for +each type in the list: + +```c++ +using MyTypes = ::testing::Types; +TYPED_TEST_SUITE(FooTest, MyTypes); +``` + +The type alias (`using` or `typedef`) is necessary for the `TYPED_TEST_SUITE` +macro to parse correctly. Otherwise the compiler will think that each comma in +the type list introduces a new macro argument. + +Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test for this +test suite. You can repeat this as many times as you want: + +```c++ +TYPED_TEST(FooTest, DoesBlah) { + // Inside a test, refer to the special name TypeParam to get the type + // parameter. Since we are inside a derived class template, C++ requires + // us to visit the members of FooTest via 'this'. + TypeParam n = this->value_; + + // To visit static members of the fixture, add the 'TestFixture::' + // prefix. + n += TestFixture::shared_; + + // To refer to typedefs in the fixture, add the 'typename TestFixture::' + // prefix. The 'typename' is required to satisfy the compiler. + typename TestFixture::List values; + + values.push_back(n); + ... +} + +TYPED_TEST(FooTest, HasPropertyA) { ... } +``` + +You can see [sample6_unittest.cc] for a complete example. + +[sample6_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample6_unittest.cc "Typed Test example" + +## Type-Parameterized Tests + +*Type-parameterized tests* are like typed tests, except that they don't require +you to know the list of types ahead of time. Instead, you can define the test +logic first and instantiate it with different type lists later. You can even +instantiate it more than once in the same program. + +If you are designing an interface or concept, you can define a suite of +type-parameterized tests to verify properties that any valid implementation of +the interface/concept should have. Then, the author of each implementation can +just instantiate the test suite with their type to verify that it conforms to +the requirements, without having to write similar tests repeatedly. Here's an +example: + +First, define a fixture class template, as we did with typed tests: + +```c++ +template +class FooTest : public testing::Test { + void DoSomethingInteresting(); + ... +}; +``` + +Next, declare that you will define a type-parameterized test suite: + +```c++ +TYPED_TEST_SUITE_P(FooTest); +``` + +Then, use `TYPED_TEST_P()` to define a type-parameterized test. You can repeat +this as many times as you want: + +```c++ +TYPED_TEST_P(FooTest, DoesBlah) { + // Inside a test, refer to TypeParam to get the type parameter. + TypeParam n = 0; + + // You will need to use `this` explicitly to refer to fixture members. + this->DoSomethingInteresting() + ... +} + +TYPED_TEST_P(FooTest, HasPropertyA) { ... } +``` + +Now the tricky part: you need to register all test patterns using the +`REGISTER_TYPED_TEST_SUITE_P` macro before you can instantiate them. The first +argument of the macro is the test suite name; the rest are the names of the +tests in this test suite: + +```c++ +REGISTER_TYPED_TEST_SUITE_P(FooTest, + DoesBlah, HasPropertyA); +``` + +Finally, you are free to instantiate the pattern with the types you want. If you +put the above code in a header file, you can `#include` it in multiple C++ +source files and instantiate it multiple times. + +```c++ +using MyTypes = ::testing::Types; +INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes); +``` + +To distinguish different instances of the pattern, the first argument to the +`INSTANTIATE_TYPED_TEST_SUITE_P` macro is a prefix that will be added to the +actual test suite name. Remember to pick unique prefixes for different +instances. + +In the special case where the type list contains only one type, you can write +that type directly without `::testing::Types<...>`, like this: + +```c++ +INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int); +``` + +You can see [sample6_unittest.cc] for a complete example. + +## Testing Private Code + +If you change your software's internal implementation, your tests should not +break as long as the change is not observable by users. Therefore, **per the +black-box testing principle, most of the time you should test your code through +its public interfaces.** + +**If you still find yourself needing to test internal implementation code, +consider if there's a better design.** The desire to test internal +implementation is often a sign that the class is doing too much. Consider +extracting an implementation class, and testing it. Then use that implementation +class in the original class. + +If you absolutely have to test non-public interface code though, you can. There +are two cases to consider: + +* Static functions ( *not* the same as static member functions!) or unnamed + namespaces, and +* Private or protected class members + +To test them, we use the following special techniques: + +* Both static functions and definitions/declarations in an unnamed namespace + are only visible within the same translation unit. To test them, you can + `#include` the entire `.cc` file being tested in your `*_test.cc` file. + (#including `.cc` files is not a good way to reuse code - you should not do + this in production code!) + + However, a better approach is to move the private code into the + `foo::internal` namespace, where `foo` is the namespace your project + normally uses, and put the private declarations in a `*-internal.h` file. + Your production `.cc` files and your tests are allowed to include this + internal header, but your clients are not. This way, you can fully test your + internal implementation without leaking it to your clients. + +* Private class members are only accessible from within the class or by + friends. To access a class' private members, you can declare your test + fixture as a friend to the class and define accessors in your fixture. Tests + using the fixture can then access the private members of your production + class via the accessors in the fixture. Note that even though your fixture + is a friend to your production class, your tests are not automatically + friends to it, as they are technically defined in sub-classes of the + fixture. + + Another way to test private members is to refactor them into an + implementation class, which is then declared in a `*-internal.h` file. Your + clients aren't allowed to include this header but your tests can. Such is + called the + [Pimpl](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/the-c-pimpl-r1794/) + (Private Implementation) idiom. + + Or, you can declare an individual test as a friend of your class by adding + this line in the class body: + + ```c++ + FRIEND_TEST(TestSuiteName, TestName); + ``` + + For example, + + ```c++ + // foo.h + class Foo { + ... + private: + FRIEND_TEST(FooTest, BarReturnsZeroOnNull); + + int Bar(void* x); + }; + + // foo_test.cc + ... + TEST(FooTest, BarReturnsZeroOnNull) { + Foo foo; + EXPECT_EQ(foo.Bar(NULL), 0); // Uses Foo's private member Bar(). + } + ``` + + Pay special attention when your class is defined in a namespace. If you want + your test fixtures and tests to be friends of your class, then they must be + defined in the exact same namespace (no anonymous or inline namespaces). + + For example, if the code to be tested looks like: + + ```c++ + namespace my_namespace { + + class Foo { + friend class FooTest; + FRIEND_TEST(FooTest, Bar); + FRIEND_TEST(FooTest, Baz); + ... definition of the class Foo ... + }; + + } // namespace my_namespace + ``` + + Your test code should be something like: + + ```c++ + namespace my_namespace { + + class FooTest : public testing::Test { + protected: + ... + }; + + TEST_F(FooTest, Bar) { ... } + TEST_F(FooTest, Baz) { ... } + + } // namespace my_namespace + ``` + +## "Catching" Failures + +If you are building a testing utility on top of GoogleTest, you'll want to test +your utility. What framework would you use to test it? GoogleTest, of course. + +The challenge is to verify that your testing utility reports failures correctly. +In frameworks that report a failure by throwing an exception, you could catch +the exception and assert on it. But GoogleTest doesn't use exceptions, so how do +we test that a piece of code generates an expected failure? + +`"gtest/gtest-spi.h"` contains some constructs to do this. +After #including this header, you can use + +```c++ + EXPECT_FATAL_FAILURE(statement, substring); +``` + +to assert that `statement` generates a fatal (e.g. `ASSERT_*`) failure in the +current thread whose message contains the given `substring`, or use + +```c++ + EXPECT_NONFATAL_FAILURE(statement, substring); +``` + +if you are expecting a non-fatal (e.g. `EXPECT_*`) failure. + +Only failures in the current thread are checked to determine the result of this +type of expectations. If `statement` creates new threads, failures in these +threads are also ignored. If you want to catch failures in other threads as +well, use one of the following macros instead: + +```c++ + EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substring); + EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substring); +``` + +{: .callout .note} +NOTE: Assertions from multiple threads are currently not supported on Windows. + +For technical reasons, there are some caveats: + +1. You cannot stream a failure message to either macro. + +2. `statement` in `EXPECT_FATAL_FAILURE{_ON_ALL_THREADS}()` cannot reference + local non-static variables or non-static members of `this` object. + +3. `statement` in `EXPECT_FATAL_FAILURE{_ON_ALL_THREADS}()` cannot return a + value. + +## Registering tests programmatically + +The `TEST` macros handle the vast majority of all use cases, but there are few +where runtime registration logic is required. For those cases, the framework +provides the `::testing::RegisterTest` that allows callers to register arbitrary +tests dynamically. + +This is an advanced API only to be used when the `TEST` macros are insufficient. +The macros should be preferred when possible, as they avoid most of the +complexity of calling this function. + +It provides the following signature: + +```c++ +template +TestInfo* RegisterTest(const char* test_suite_name, const char* test_name, + const char* type_param, const char* value_param, + const char* file, int line, Factory factory); +``` + +The `factory` argument is a factory callable (move-constructible) object or +function pointer that creates a new instance of the Test object. It handles +ownership to the caller. The signature of the callable is `Fixture*()`, where +`Fixture` is the test fixture class for the test. All tests registered with the +same `test_suite_name` must return the same fixture type. This is checked at +runtime. + +The framework will infer the fixture class from the factory and will call the +`SetUpTestSuite` and `TearDownTestSuite` for it. + +Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is +undefined. + +Use case example: + +```c++ +class MyFixture : public testing::Test { + public: + // All of these optional, just like in regular macro usage. + static void SetUpTestSuite() { ... } + static void TearDownTestSuite() { ... } + void SetUp() override { ... } + void TearDown() override { ... } +}; + +class MyTest : public MyFixture { + public: + explicit MyTest(int data) : data_(data) {} + void TestBody() override { ... } + + private: + int data_; +}; + +void RegisterMyTests(const std::vector& values) { + for (int v : values) { + testing::RegisterTest( + "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr, + std::to_string(v).c_str(), + __FILE__, __LINE__, + // Important to use the fixture type as the return type here. + [=]() -> MyFixture* { return new MyTest(v); }); + } +} +... +int main(int argc, char** argv) { + testing::InitGoogleTest(&argc, argv); + std::vector values_to_test = LoadValuesFromConfig(); + RegisterMyTests(values_to_test); + ... + return RUN_ALL_TESTS(); +} +``` + +## Getting the Current Test's Name + +Sometimes a function may need to know the name of the currently running test. +For example, you may be using the `SetUp()` method of your test fixture to set +the golden file name based on which test is running. The +[`TestInfo`](reference/testing.md#TestInfo) class has this information. + +To obtain a `TestInfo` object for the currently running test, call +`current_test_info()` on the [`UnitTest`](reference/testing.md#UnitTest) +singleton object: + +```c++ + // Gets information about the currently running test. + // Do NOT delete the returned object - it's managed by the UnitTest class. + const testing::TestInfo* const test_info = + testing::UnitTest::GetInstance()->current_test_info(); + + printf("We are in test %s of test suite %s.\n", + test_info->name(), + test_info->test_suite_name()); +``` + +`current_test_info()` returns a null pointer if no test is running. In +particular, you cannot find the test suite name in `SetUpTestSuite()`, +`TearDownTestSuite()` (where you know the test suite name implicitly), or +functions called from them. + +## Extending GoogleTest by Handling Test Events + +GoogleTest provides an **event listener API** to let you receive notifications +about the progress of a test program and test failures. The events you can +listen to include the start and end of the test program, a test suite, or a test +method, among others. You may use this API to augment or replace the standard +console output, replace the XML output, or provide a completely different form +of output, such as a GUI or a database. You can also use test events as +checkpoints to implement a resource leak checker, for example. + +### Defining Event Listeners + +To define a event listener, you subclass either +[`testing::TestEventListener`](reference/testing.md#TestEventListener) or +[`testing::EmptyTestEventListener`](reference/testing.md#EmptyTestEventListener) +The former is an (abstract) interface, where *each pure virtual method can be +overridden to handle a test event* (For example, when a test starts, the +`OnTestStart()` method will be called.). The latter provides an empty +implementation of all methods in the interface, such that a subclass only needs +to override the methods it cares about. + +When an event is fired, its context is passed to the handler function as an +argument. The following argument types are used: + +* UnitTest reflects the state of the entire test program, +* TestSuite has information about a test suite, which can contain one or more + tests, +* TestInfo contains the state of a test, and +* TestPartResult represents the result of a test assertion. + +An event handler function can examine the argument it receives to find out +interesting information about the event and the test program's state. + +Here's an example: + +```c++ + class MinimalistPrinter : public testing::EmptyTestEventListener { + // Called before a test starts. + void OnTestStart(const testing::TestInfo& test_info) override { + printf("*** Test %s.%s starting.\n", + test_info.test_suite_name(), test_info.name()); + } + + // Called after a failed assertion or a SUCCESS(). + void OnTestPartResult(const testing::TestPartResult& test_part_result) override { + printf("%s in %s:%d\n%s\n", + test_part_result.failed() ? "*** Failure" : "Success", + test_part_result.file_name(), + test_part_result.line_number(), + test_part_result.summary()); + } + + // Called after a test ends. + void OnTestEnd(const testing::TestInfo& test_info) override { + printf("*** Test %s.%s ending.\n", + test_info.test_suite_name(), test_info.name()); + } + }; +``` + +### Using Event Listeners + +To use the event listener you have defined, add an instance of it to the +GoogleTest event listener list (represented by class +[`TestEventListeners`](reference/testing.md#TestEventListeners) - note the "s" +at the end of the name) in your `main()` function, before calling +`RUN_ALL_TESTS()`: + +```c++ +int main(int argc, char** argv) { + testing::InitGoogleTest(&argc, argv); + // Gets hold of the event listener list. + testing::TestEventListeners& listeners = + testing::UnitTest::GetInstance()->listeners(); + // Adds a listener to the end. GoogleTest takes the ownership. + listeners.Append(new MinimalistPrinter); + return RUN_ALL_TESTS(); +} +``` + +There's only one problem: the default test result printer is still in effect, so +its output will mingle with the output from your minimalist printer. To suppress +the default printer, just release it from the event listener list and delete it. +You can do so by adding one line: + +```c++ + ... + delete listeners.Release(listeners.default_result_printer()); + listeners.Append(new MinimalistPrinter); + return RUN_ALL_TESTS(); +``` + +Now, sit back and enjoy a completely different output from your tests. For more +details, see [sample9_unittest.cc]. + +[sample9_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample9_unittest.cc "Event listener example" + +You may append more than one listener to the list. When an `On*Start()` or +`OnTestPartResult()` event is fired, the listeners will receive it in the order +they appear in the list (since new listeners are added to the end of the list, +the default text printer and the default XML generator will receive the event +first). An `On*End()` event will be received by the listeners in the *reverse* +order. This allows output by listeners added later to be framed by output from +listeners added earlier. + +### Generating Failures in Listeners + +You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`, `FAIL()`, etc) +when processing an event. There are some restrictions: + +1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will + cause `OnTestPartResult()` to be called recursively). +2. A listener that handles `OnTestPartResult()` is not allowed to generate any + failure. + +When you add listeners to the listener list, you should put listeners that +handle `OnTestPartResult()` *before* listeners that can generate failures. This +ensures that failures generated by the latter are attributed to the right test +by the former. + +See [sample10_unittest.cc] for an example of a failure-raising listener. + +[sample10_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample10_unittest.cc "Failure-raising listener example" + +## Running Test Programs: Advanced Options + +GoogleTest test programs are ordinary executables. Once built, you can run them +directly and affect their behavior via the following environment variables +and/or command line flags. For the flags to work, your programs must call +`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`. + +To see a list of supported flags and their usage, please run your test program +with the `--help` flag. You can also use `-h`, `-?`, or `/?` for short. + +If an option is specified both by an environment variable and by a flag, the +latter takes precedence. + +### Selecting Tests + +#### Listing Test Names + +Sometimes it is necessary to list the available tests in a program before +running them so that a filter may be applied if needed. Including the flag +`--gtest_list_tests` overrides all other flags and lists tests in the following +format: + +```none +TestSuite1. + TestName1 + TestName2 +TestSuite2. + TestName +``` + +None of the tests listed are actually run if the flag is provided. There is no +corresponding environment variable for this flag. + +#### Running a Subset of the Tests + +By default, a GoogleTest program runs all tests the user has defined. Sometimes, +you want to run only a subset of the tests (e.g. for debugging or quickly +verifying a change). If you set the `GTEST_FILTER` environment variable or the +`--gtest_filter` flag to a filter string, GoogleTest will only run the tests +whose full names (in the form of `TestSuiteName.TestName`) match the filter. + +The format of a filter is a '`:`'-separated list of wildcard patterns (called +the *positive patterns*) optionally followed by a '`-`' and another +'`:`'-separated pattern list (called the *negative patterns*). A test matches +the filter if and only if it matches any of the positive patterns but does not +match any of the negative patterns. + +A pattern may contain `'*'` (matches any string) or `'?'` (matches any single +character). For convenience, the filter `'*-NegativePatterns'` can be also +written as `'-NegativePatterns'`. + +For example: + +* `./foo_test` Has no flag, and thus runs all its tests. +* `./foo_test --gtest_filter=*` Also runs everything, due to the single + match-everything `*` value. +* `./foo_test --gtest_filter=FooTest.*` Runs everything in test suite + `FooTest` . +* `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full + name contains either `"Null"` or `"Constructor"` . +* `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests. +* `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test + suite `FooTest` except `FooTest.Bar`. +* `./foo_test --gtest_filter=FooTest.*:BarTest.*-FooTest.Bar:BarTest.Foo` Runs + everything in test suite `FooTest` except `FooTest.Bar` and everything in + test suite `BarTest` except `BarTest.Foo`. + +#### Stop test execution upon first failure + +By default, a GoogleTest program runs all tests the user has defined. In some +cases (e.g. iterative test development & execution) it may be desirable stop +test execution upon first failure (trading improved latency for completeness). +If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set, +the test runner will stop execution as soon as the first test failure is found. + +#### Temporarily Disabling Tests + +If you have a broken test that you cannot fix right away, you can add the +`DISABLED_` prefix to its name. This will exclude it from execution. This is +better than commenting out the code or using `#if 0`, as disabled tests are +still compiled (and thus won't rot). + +If you need to disable all tests in a test suite, you can either add `DISABLED_` +to the front of the name of each test, or alternatively add it to the front of +the test suite name. + +For example, the following tests won't be run by GoogleTest, even though they +will still be compiled: + +```c++ +// Tests that Foo does Abc. +TEST(FooTest, DISABLED_DoesAbc) { ... } + +class DISABLED_BarTest : public testing::Test { ... }; + +// Tests that Bar does Xyz. +TEST_F(DISABLED_BarTest, DoesXyz) { ... } +``` + +{: .callout .note} +NOTE: This feature should only be used for temporary pain-relief. You still have +to fix the disabled tests at a later date. As a reminder, GoogleTest will print +a banner warning you if a test program contains any disabled tests. + +{: .callout .tip} +TIP: You can easily count the number of disabled tests you have using +`grep`. This number can be used as a metric for +improving your test quality. + +#### Temporarily Enabling Disabled Tests + +To include disabled tests in test execution, just invoke the test program with +the `--gtest_also_run_disabled_tests` flag or set the +`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other than `0`. +You can combine this with the `--gtest_filter` flag to further select which +disabled tests to run. + +### Repeating the Tests + +Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it +will fail only 1% of the time, making it rather hard to reproduce the bug under +a debugger. This can be a major source of frustration. + +The `--gtest_repeat` flag allows you to repeat all (or selected) test methods in +a program many times. Hopefully, a flaky test will eventually fail and give you +a chance to debug. Here's how to use it: + +```none +$ foo_test --gtest_repeat=1000 +Repeat foo_test 1000 times and don't stop at failures. + +$ foo_test --gtest_repeat=-1 +A negative count means repeating forever. + +$ foo_test --gtest_repeat=1000 --gtest_break_on_failure +Repeat foo_test 1000 times, stopping at the first failure. This +is especially useful when running under a debugger: when the test +fails, it will drop into the debugger and you can then inspect +variables and stacks. + +$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar.* +Repeat the tests whose name matches the filter 1000 times. +``` + +If your test program contains +[global set-up/tear-down](#global-set-up-and-tear-down) code, it will be +repeated in each iteration as well, as the flakiness may be in it. To avoid +repeating global set-up/tear-down, specify +`--gtest_recreate_environments_when_repeating=false`{.nowrap}. + +You can also specify the repeat count by setting the `GTEST_REPEAT` environment +variable. + +### Shuffling the Tests + +You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE` +environment variable to `1`) to run the tests in a program in a random order. +This helps to reveal bad dependencies between tests. + +By default, GoogleTest uses a random seed calculated from the current time. +Therefore you'll get a different order every time. The console output includes +the random seed value, such that you can reproduce an order-related test failure +later. To specify the random seed explicitly, use the `--gtest_random_seed=SEED` +flag (or set the `GTEST_RANDOM_SEED` environment variable), where `SEED` is an +integer in the range [0, 99999]. The seed value 0 is special: it tells +GoogleTest to do the default behavior of calculating the seed from the current +time. + +If you combine this with `--gtest_repeat=N`, GoogleTest will pick a different +random seed and re-shuffle the tests in each iteration. + +### Distributing Test Functions to Multiple Machines + +If you have more than one machine you can use to run a test program, you might +want to run the test functions in parallel and get the result faster. We call +this technique *sharding*, where each machine is called a *shard*. + +GoogleTest is compatible with test sharding. To take advantage of this feature, +your test runner (not part of GoogleTest) needs to do the following: + +1. Allocate a number of machines (shards) to run the tests. +1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total + number of shards. It must be the same for all shards. +1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index + of the shard. Different shards must be assigned different indices, which + must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`. +1. Run the same test program on all shards. When GoogleTest sees the above two + environment variables, it will select a subset of the test functions to run. + Across all shards, each test function in the program will be run exactly + once. +1. Wait for all shards to finish, then collect and report the results. + +Your project may have tests that were written without GoogleTest and thus don't +understand this protocol. In order for your test runner to figure out which test +supports sharding, it can set the environment variable `GTEST_SHARD_STATUS_FILE` +to a non-existent file path. If a test program supports sharding, it will create +this file to acknowledge that fact; otherwise it will not create it. The actual +contents of the file are not important at this time, although we may put some +useful information in it in the future. + +Here's an example to make it clear. Suppose you have a test program `foo_test` +that contains the following 5 test functions: + +``` +TEST(A, V) +TEST(A, W) +TEST(B, X) +TEST(B, Y) +TEST(B, Z) +``` + +Suppose you have 3 machines at your disposal. To run the test functions in +parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and set +`GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively. Then you would +run the same `foo_test` on each machine. + +GoogleTest reserves the right to change how the work is distributed across the +shards, but here's one possible scenario: + +* Machine #0 runs `A.V` and `B.X`. +* Machine #1 runs `A.W` and `B.Y`. +* Machine #2 runs `B.Z`. + +### Controlling Test Output + +#### Colored Terminal Output + +GoogleTest can use colors in its terminal output to make it easier to spot the +important information: + +
...
+[----------] 1 test from FooTest
+[ RUN      ] FooTest.DoesAbc
+[       OK ] FooTest.DoesAbc
+[----------] 2 tests from BarTest
+[ RUN      ] BarTest.HasXyzProperty
+[       OK ] BarTest.HasXyzProperty
+[ RUN      ] BarTest.ReturnsTrueOnSuccess
+... some error messages ...
+[   FAILED ] BarTest.ReturnsTrueOnSuccess
+...
+[==========] 30 tests from 14 test suites ran.
+[   PASSED ] 28 tests.
+[   FAILED ] 2 tests, listed below:
+[   FAILED ] BarTest.ReturnsTrueOnSuccess
+[   FAILED ] AnotherTest.DoesXyz
+
+ 2 FAILED TESTS
+
+ +You can set the `GTEST_COLOR` environment variable or the `--gtest_color` +command line flag to `yes`, `no`, or `auto` (the default) to enable colors, +disable colors, or let GoogleTest decide. When the value is `auto`, GoogleTest +will use colors if and only if the output goes to a terminal and (on non-Windows +platforms) the `TERM` environment variable is set to `xterm` or `xterm-color`. + +#### Suppressing test passes + +By default, GoogleTest prints 1 line of output for each test, indicating if it +passed or failed. To show only test failures, run the test program with +`--gtest_brief=1`, or set the GTEST_BRIEF environment variable to `1`. + +#### Suppressing the Elapsed Time + +By default, GoogleTest prints the time it takes to run each test. To disable +that, run the test program with the `--gtest_print_time=0` command line flag, or +set the GTEST_PRINT_TIME environment variable to `0`. + +#### Suppressing UTF-8 Text Output + +In case of assertion failures, GoogleTest prints expected and actual values of +type `string` both as hex-encoded strings as well as in readable UTF-8 text if +they contain valid non-ASCII UTF-8 characters. If you want to suppress the UTF-8 +text because, for example, you don't have an UTF-8 compatible output medium, run +the test program with `--gtest_print_utf8=0` or set the `GTEST_PRINT_UTF8` +environment variable to `0`. + +#### Generating an XML Report + +GoogleTest can emit a detailed XML report to a file in addition to its normal +textual output. The report contains the duration of each test, and thus can help +you identify slow tests. + +To generate the XML report, set the `GTEST_OUTPUT` environment variable or the +`--gtest_output` flag to the string `"xml:path_to_output_file"`, which will +create the file at the given location. You can also just use the string `"xml"`, +in which case the output can be found in the `test_detail.xml` file in the +current directory. + +If you specify a directory (for example, `"xml:output/directory/"` on Linux or +`"xml:output\directory\"` on Windows), GoogleTest will create the XML file in +that directory, named after the test executable (e.g. `foo_test.xml` for test +program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left +over from a previous run), GoogleTest will pick a different name (e.g. +`foo_test_1.xml`) to avoid overwriting it. + +The report is based on the `junitreport` Ant task. Since that format was +originally intended for Java, a little interpretation is required to make it +apply to GoogleTest tests, as shown here: + +```xml + + + + + + + + + +``` + +* The root `` element corresponds to the entire test program. +* `` elements correspond to GoogleTest test suites. +* `` elements correspond to GoogleTest test functions. + +For instance, the following program + +```c++ +TEST(MathTest, Addition) { ... } +TEST(MathTest, Subtraction) { ... } +TEST(LogicTest, NonContradiction) { ... } +``` + +could generate this report: + +```xml + + + + + ... + ... + + + + + + + + + +``` + +Things to note: + +* The `tests` attribute of a `` or `` element tells how + many test functions the GoogleTest program or test suite contains, while the + `failures` attribute tells how many of them failed. + +* The `time` attribute expresses the duration of the test, test suite, or + entire test program in seconds. + +* The `timestamp` attribute records the local date and time of the test + execution. + +* The `file` and `line` attributes record the source file location, where the + test was defined. + +* Each `` element corresponds to a single failed GoogleTest + assertion. + +#### Generating a JSON Report + +GoogleTest can also emit a JSON report as an alternative format to XML. To +generate the JSON report, set the `GTEST_OUTPUT` environment variable or the +`--gtest_output` flag to the string `"json:path_to_output_file"`, which will +create the file at the given location. You can also just use the string +`"json"`, in which case the output can be found in the `test_detail.json` file +in the current directory. + +The report format conforms to the following JSON Schema: + +```json +{ + "$schema": "http://json-schema.org/schema#", + "type": "object", + "definitions": { + "TestCase": { + "type": "object", + "properties": { + "name": { "type": "string" }, + "tests": { "type": "integer" }, + "failures": { "type": "integer" }, + "disabled": { "type": "integer" }, + "time": { "type": "string" }, + "testsuite": { + "type": "array", + "items": { + "$ref": "#/definitions/TestInfo" + } + } + } + }, + "TestInfo": { + "type": "object", + "properties": { + "name": { "type": "string" }, + "file": { "type": "string" }, + "line": { "type": "integer" }, + "status": { + "type": "string", + "enum": ["RUN", "NOTRUN"] + }, + "time": { "type": "string" }, + "classname": { "type": "string" }, + "failures": { + "type": "array", + "items": { + "$ref": "#/definitions/Failure" + } + } + } + }, + "Failure": { + "type": "object", + "properties": { + "failures": { "type": "string" }, + "type": { "type": "string" } + } + } + }, + "properties": { + "tests": { "type": "integer" }, + "failures": { "type": "integer" }, + "disabled": { "type": "integer" }, + "errors": { "type": "integer" }, + "timestamp": { + "type": "string", + "format": "date-time" + }, + "time": { "type": "string" }, + "name": { "type": "string" }, + "testsuites": { + "type": "array", + "items": { + "$ref": "#/definitions/TestCase" + } + } + } +} +``` + +The report uses the format that conforms to the following Proto3 using the +[JSON encoding](https://developers.google.com/protocol-buffers/docs/proto3#json): + +```proto +syntax = "proto3"; + +package googletest; + +import "google/protobuf/timestamp.proto"; +import "google/protobuf/duration.proto"; + +message UnitTest { + int32 tests = 1; + int32 failures = 2; + int32 disabled = 3; + int32 errors = 4; + google.protobuf.Timestamp timestamp = 5; + google.protobuf.Duration time = 6; + string name = 7; + repeated TestCase testsuites = 8; +} + +message TestCase { + string name = 1; + int32 tests = 2; + int32 failures = 3; + int32 disabled = 4; + int32 errors = 5; + google.protobuf.Duration time = 6; + repeated TestInfo testsuite = 7; +} + +message TestInfo { + string name = 1; + string file = 6; + int32 line = 7; + enum Status { + RUN = 0; + NOTRUN = 1; + } + Status status = 2; + google.protobuf.Duration time = 3; + string classname = 4; + message Failure { + string failures = 1; + string type = 2; + } + repeated Failure failures = 5; +} +``` + +For instance, the following program + +```c++ +TEST(MathTest, Addition) { ... } +TEST(MathTest, Subtraction) { ... } +TEST(LogicTest, NonContradiction) { ... } +``` + +could generate this report: + +```json +{ + "tests": 3, + "failures": 1, + "errors": 0, + "time": "0.035s", + "timestamp": "2011-10-31T18:52:42Z", + "name": "AllTests", + "testsuites": [ + { + "name": "MathTest", + "tests": 2, + "failures": 1, + "errors": 0, + "time": "0.015s", + "testsuite": [ + { + "name": "Addition", + "file": "test.cpp", + "line": 1, + "status": "RUN", + "time": "0.007s", + "classname": "", + "failures": [ + { + "message": "Value of: add(1, 1)\n Actual: 3\nExpected: 2", + "type": "" + }, + { + "message": "Value of: add(1, -1)\n Actual: 1\nExpected: 0", + "type": "" + } + ] + }, + { + "name": "Subtraction", + "file": "test.cpp", + "line": 2, + "status": "RUN", + "time": "0.005s", + "classname": "" + } + ] + }, + { + "name": "LogicTest", + "tests": 1, + "failures": 0, + "errors": 0, + "time": "0.005s", + "testsuite": [ + { + "name": "NonContradiction", + "file": "test.cpp", + "line": 3, + "status": "RUN", + "time": "0.005s", + "classname": "" + } + ] + } + ] +} +``` + +{: .callout .important} +IMPORTANT: The exact format of the JSON document is subject to change. + +### Controlling How Failures Are Reported + +#### Detecting Test Premature Exit + +Google Test implements the _premature-exit-file_ protocol for test runners to +catch any kind of unexpected exits of test programs. Upon start, Google Test +creates the file which will be automatically deleted after all work has been +finished. Then, the test runner can check if this file exists. In case the file +remains undeleted, the inspected test has exited prematurely. + +This feature is enabled only if the `TEST_PREMATURE_EXIT_FILE` environment +variable has been set. + +#### Turning Assertion Failures into Break-Points + +When running test programs under a debugger, it's very convenient if the +debugger can catch an assertion failure and automatically drop into interactive +mode. GoogleTest's *break-on-failure* mode supports this behavior. + +To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value +other than `0`. Alternatively, you can use the `--gtest_break_on_failure` +command line flag. + +#### Disabling Catching Test-Thrown Exceptions + +GoogleTest can be used either with or without exceptions enabled. If a test +throws a C++ exception or (on Windows) a structured exception (SEH), by default +GoogleTest catches it, reports it as a test failure, and continues with the next +test method. This maximizes the coverage of a test run. Also, on Windows an +uncaught exception will cause a pop-up window, so catching the exceptions allows +you to run the tests automatically. + +When debugging the test failures, however, you may instead want the exceptions +to be handled by the debugger, such that you can examine the call stack when an +exception is thrown. To achieve that, set the `GTEST_CATCH_EXCEPTIONS` +environment variable to `0`, or use the `--gtest_catch_exceptions=0` flag when +running the tests. + +### Sanitizer Integration + +The +[Undefined Behavior Sanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html), +[Address Sanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer), +and +[Thread Sanitizer](https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual) +all provide weak functions that you can override to trigger explicit failures +when they detect sanitizer errors, such as creating a reference from `nullptr`. +To override these functions, place definitions for them in a source file that +you compile as part of your main binary: + +``` +extern "C" { +void __ubsan_on_report() { + FAIL() << "Encountered an undefined behavior sanitizer error"; +} +void __asan_on_error() { + FAIL() << "Encountered an address sanitizer error"; +} +void __tsan_on_report() { + FAIL() << "Encountered a thread sanitizer error"; +} +} // extern "C" +``` + +After compiling your project with one of the sanitizers enabled, if a particular +test triggers a sanitizer error, GoogleTest will report that it failed. diff --git a/cpp/third_party/googletest/docs/assets/css/style.scss b/cpp/third_party/googletest/docs/assets/css/style.scss new file mode 100644 index 0000000..bb30f41 --- /dev/null +++ b/cpp/third_party/googletest/docs/assets/css/style.scss @@ -0,0 +1,5 @@ +--- +--- + +@import "jekyll-theme-primer"; +@import "main"; diff --git a/cpp/third_party/googletest/docs/community_created_documentation.md b/cpp/third_party/googletest/docs/community_created_documentation.md new file mode 100644 index 0000000..4569075 --- /dev/null +++ b/cpp/third_party/googletest/docs/community_created_documentation.md @@ -0,0 +1,7 @@ +# Community-Created Documentation + +The following is a list, in no particular order, of links to documentation +created by the Googletest community. + +* [Googlemock Insights](https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/googletest/insights.md), + by [ElectricRCAircraftGuy](https://github.com/ElectricRCAircraftGuy) diff --git a/cpp/third_party/googletest/docs/faq.md b/cpp/third_party/googletest/docs/faq.md new file mode 100644 index 0000000..1928097 --- /dev/null +++ b/cpp/third_party/googletest/docs/faq.md @@ -0,0 +1,692 @@ +# GoogleTest FAQ + +## Why should test suite names and test names not contain underscore? + +{: .callout .note} +Note: GoogleTest reserves underscore (`_`) for special purpose keywords, such as +[the `DISABLED_` prefix](advanced.md#temporarily-disabling-tests), in addition +to the following rationale. + +Underscore (`_`) is special, as C++ reserves the following to be used by the +compiler and the standard library: + +1. any identifier that starts with an `_` followed by an upper-case letter, and +2. any identifier that contains two consecutive underscores (i.e. `__`) + *anywhere* in its name. + +User code is *prohibited* from using such identifiers. + +Now let's look at what this means for `TEST` and `TEST_F`. + +Currently `TEST(TestSuiteName, TestName)` generates a class named +`TestSuiteName_TestName_Test`. What happens if `TestSuiteName` or `TestName` +contains `_`? + +1. If `TestSuiteName` starts with an `_` followed by an upper-case letter (say, + `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus + invalid. +2. If `TestSuiteName` ends with an `_` (say, `Foo_`), we get + `Foo__TestName_Test`, which is invalid. +3. If `TestName` starts with an `_` (say, `_Bar`), we get + `TestSuiteName__Bar_Test`, which is invalid. +4. If `TestName` ends with an `_` (say, `Bar_`), we get + `TestSuiteName_Bar__Test`, which is invalid. + +So clearly `TestSuiteName` and `TestName` cannot start or end with `_` +(Actually, `TestSuiteName` can start with `_` -- as long as the `_` isn't +followed by an upper-case letter. But that's getting complicated. So for +simplicity we just say that it cannot start with `_`.). + +It may seem fine for `TestSuiteName` and `TestName` to contain `_` in the +middle. However, consider this: + +```c++ +TEST(Time, Flies_Like_An_Arrow) { ... } +TEST(Time_Flies, Like_An_Arrow) { ... } +``` + +Now, the two `TEST`s will both generate the same class +(`Time_Flies_Like_An_Arrow_Test`). That's not good. + +So for simplicity, we just ask the users to avoid `_` in `TestSuiteName` and +`TestName`. The rule is more constraining than necessary, but it's simple and +easy to remember. It also gives GoogleTest some wiggle room in case its +implementation needs to change in the future. + +If you violate the rule, there may not be immediate consequences, but your test +may (just may) break with a new compiler (or a new version of the compiler you +are using) or with a new version of GoogleTest. Therefore it's best to follow +the rule. + +## Why does GoogleTest support `EXPECT_EQ(NULL, ptr)` and `ASSERT_EQ(NULL, ptr)` but not `EXPECT_NE(NULL, ptr)` and `ASSERT_NE(NULL, ptr)`? + +First of all, you can use `nullptr` with each of these macros, e.g. +`EXPECT_EQ(ptr, nullptr)`, `EXPECT_NE(ptr, nullptr)`, `ASSERT_EQ(ptr, nullptr)`, +`ASSERT_NE(ptr, nullptr)`. This is the preferred syntax in the style guide +because `nullptr` does not have the type problems that `NULL` does. + +Due to some peculiarity of C++, it requires some non-trivial template meta +programming tricks to support using `NULL` as an argument of the `EXPECT_XX()` +and `ASSERT_XX()` macros. Therefore we only do it where it's most needed +(otherwise we make the implementation of GoogleTest harder to maintain and more +error-prone than necessary). + +Historically, the `EXPECT_EQ()` macro took the *expected* value as its first +argument and the *actual* value as the second, though this argument order is now +discouraged. It was reasonable that someone wanted +to write `EXPECT_EQ(NULL, some_expression)`, and this indeed was requested +several times. Therefore we implemented it. + +The need for `EXPECT_NE(NULL, ptr)` wasn't nearly as strong. When the assertion +fails, you already know that `ptr` must be `NULL`, so it doesn't add any +information to print `ptr` in this case. That means `EXPECT_TRUE(ptr != NULL)` +works just as well. + +If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'd have to +support `EXPECT_NE(ptr, NULL)` as well. This means using the template meta +programming tricks twice in the implementation, making it even harder to +understand and maintain. We believe the benefit doesn't justify the cost. + +Finally, with the growth of the gMock matcher library, we are encouraging people +to use the unified `EXPECT_THAT(value, matcher)` syntax more often in tests. One +significant advantage of the matcher approach is that matchers can be easily +combined to form new matchers, while the `EXPECT_NE`, etc, macros cannot be +easily combined. Therefore we want to invest more in the matchers than in the +`EXPECT_XX()` macros. + +## I need to test that different implementations of an interface satisfy some common requirements. Should I use typed tests or value-parameterized tests? + +For testing various implementations of the same interface, either typed tests or +value-parameterized tests can get it done. It's really up to you the user to +decide which is more convenient for you, depending on your particular case. Some +rough guidelines: + +* Typed tests can be easier to write if instances of the different + implementations can be created the same way, modulo the type. For example, + if all these implementations have a public default constructor (such that + you can write `new TypeParam`), or if their factory functions have the same + form (e.g. `CreateInstance()`). +* Value-parameterized tests can be easier to write if you need different code + patterns to create different implementations' instances, e.g. `new Foo` vs + `new Bar(5)`. To accommodate for the differences, you can write factory + function wrappers and pass these function pointers to the tests as their + parameters. +* When a typed test fails, the default output includes the name of the type, + which can help you quickly identify which implementation is wrong. + Value-parameterized tests only show the number of the failed iteration by + default. You will need to define a function that returns the iteration name + and pass it as the third parameter to INSTANTIATE_TEST_SUITE_P to have more + useful output. +* When using typed tests, you need to make sure you are testing against the + interface type, not the concrete types (in other words, you want to make + sure `implicit_cast(my_concrete_impl)` works, not just that + `my_concrete_impl` works). It's less likely to make mistakes in this area + when using value-parameterized tests. + +I hope I didn't confuse you more. :-) If you don't mind, I'd suggest you to give +both approaches a try. Practice is a much better way to grasp the subtle +differences between the two tools. Once you have some concrete experience, you +can much more easily decide which one to use the next time. + +## I got some run-time errors about invalid proto descriptors when using `ProtocolMessageEquals`. Help! + +{: .callout .note} +**Note:** `ProtocolMessageEquals` and `ProtocolMessageEquiv` are *deprecated* +now. Please use `EqualsProto`, etc instead. + +`ProtocolMessageEquals` and `ProtocolMessageEquiv` were redefined recently and +are now less tolerant of invalid protocol buffer definitions. In particular, if +you have a `foo.proto` that doesn't fully qualify the type of a protocol message +it references (e.g. `message` where it should be `message`), you +will now get run-time errors like: + +``` +... descriptor.cc:...] Invalid proto descriptor for file "path/to/foo.proto": +... descriptor.cc:...] blah.MyMessage.my_field: ".Bar" is not defined. +``` + +If you see this, your `.proto` file is broken and needs to be fixed by making +the types fully qualified. The new definition of `ProtocolMessageEquals` and +`ProtocolMessageEquiv` just happen to reveal your bug. + +## My death test modifies some state, but the change seems lost after the death test finishes. Why? + +Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the +expected crash won't kill the test program (i.e. the parent process). As a +result, any in-memory side effects they incur are observable in their respective +sub-processes, but not in the parent process. You can think of them as running +in a parallel universe, more or less. + +In particular, if you use mocking and the death test statement invokes some mock +methods, the parent process will think the calls have never occurred. Therefore, +you may want to move your `EXPECT_CALL` statements inside the `EXPECT_DEATH` +macro. + +## EXPECT_EQ(htonl(blah), blah_blah) generates weird compiler errors in opt mode. Is this a GoogleTest bug? + +Actually, the bug is in `htonl()`. + +According to `'man htonl'`, `htonl()` is a *function*, which means it's valid to +use `htonl` as a function pointer. However, in opt mode `htonl()` is defined as +a *macro*, which breaks this usage. + +Worse, the macro definition of `htonl()` uses a `gcc` extension and is *not* +standard C++. That hacky implementation has some ad hoc limitations. In +particular, it prevents you from writing `Foo()`, where `Foo` +is a template that has an integral argument. + +The implementation of `EXPECT_EQ(a, b)` uses `sizeof(... a ...)` inside a +template argument, and thus doesn't compile in opt mode when `a` contains a call +to `htonl()`. It is difficult to make `EXPECT_EQ` bypass the `htonl()` bug, as +the solution must work with different compilers on various platforms. + +## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? + +If your class has a static data member: + +```c++ +// foo.h +class Foo { + ... + static const int kBar = 100; +}; +``` + +You also need to define it *outside* of the class body in `foo.cc`: + +```c++ +const int Foo::kBar; // No initializer here. +``` + +Otherwise your code is **invalid C++**, and may break in unexpected ways. In +particular, using it in GoogleTest comparison assertions (`EXPECT_EQ`, etc) will +generate an "undefined reference" linker error. The fact that "it used to work" +doesn't mean it's valid. It just means that you were lucky. :-) + +If the declaration of the static data member is `constexpr` then it is +implicitly an `inline` definition, and a separate definition in `foo.cc` is not +needed: + +```c++ +// foo.h +class Foo { + ... + static constexpr int kBar = 100; // Defines kBar, no need to do it in foo.cc. +}; +``` + +## Can I derive a test fixture from another? + +Yes. + +Each test fixture has a corresponding and same named test suite. This means only +one test suite can use a particular fixture. Sometimes, however, multiple test +cases may want to use the same or slightly different fixtures. For example, you +may want to make sure that all of a GUI library's test suites don't leak +important system resources like fonts and brushes. + +In GoogleTest, you share a fixture among test suites by putting the shared logic +in a base test fixture, then deriving from that base a separate fixture for each +test suite that wants to use this common logic. You then use `TEST_F()` to write +tests using each derived fixture. + +Typically, your code looks like this: + +```c++ +// Defines a base test fixture. +class BaseTest : public ::testing::Test { + protected: + ... +}; + +// Derives a fixture FooTest from BaseTest. +class FooTest : public BaseTest { + protected: + void SetUp() override { + BaseTest::SetUp(); // Sets up the base fixture first. + ... additional set-up work ... + } + + void TearDown() override { + ... clean-up work for FooTest ... + BaseTest::TearDown(); // Remember to tear down the base fixture + // after cleaning up FooTest! + } + + ... functions and variables for FooTest ... +}; + +// Tests that use the fixture FooTest. +TEST_F(FooTest, Bar) { ... } +TEST_F(FooTest, Baz) { ... } + +... additional fixtures derived from BaseTest ... +``` + +If necessary, you can continue to derive test fixtures from a derived fixture. +GoogleTest has no limit on how deep the hierarchy can be. + +For a complete example using derived test fixtures, see +[sample5_unittest.cc](https://github.com/google/googletest/blob/main/googletest/samples/sample5_unittest.cc). + +## My compiler complains "void value not ignored as it ought to be." What does this mean? + +You're probably using an `ASSERT_*()` in a function that doesn't return `void`. +`ASSERT_*()` can only be used in `void` functions, due to exceptions being +disabled by our build system. Please see more details +[here](advanced.md#assertion-placement). + +## My death test hangs (or seg-faults). How do I fix it? + +In GoogleTest, death tests are run in a child process and the way they work is +delicate. To write death tests you really need to understand how they work—see +the details at [Death Assertions](reference/assertions.md#death) in the +Assertions Reference. + +In particular, death tests don't like having multiple threads in the parent +process. So the first thing you can try is to eliminate creating threads outside +of `EXPECT_DEATH()`. For example, you may want to use mocks or fake objects +instead of real ones in your tests. + +Sometimes this is impossible as some library you must use may be creating +threads before `main()` is even reached. In this case, you can try to minimize +the chance of conflicts by either moving as many activities as possible inside +`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or +leaving as few things as possible in it. Also, you can try to set the death test +style to `"threadsafe"`, which is safer but slower, and see if it helps. + +If you go with thread-safe death tests, remember that they rerun the test +program from the beginning in the child process. Therefore make sure your +program can run side-by-side with itself and is deterministic. + +In the end, this boils down to good concurrent programming. You have to make +sure that there are no race conditions or deadlocks in your program. No silver +bullet - sorry! + +## Should I use the constructor/destructor of the test fixture or SetUp()/TearDown()? {#CtorVsSetUp} + +The first thing to remember is that GoogleTest does **not** reuse the same test +fixture object across multiple tests. For each `TEST_F`, GoogleTest will create +a **fresh** test fixture object, immediately call `SetUp()`, run the test body, +call `TearDown()`, and then delete the test fixture object. + +When you need to write per-test set-up and tear-down logic, you have the choice +between using the test fixture constructor/destructor or `SetUp()/TearDown()`. +The former is usually preferred, as it has the following benefits: + +* By initializing a member variable in the constructor, we have the option to + make it `const`, which helps prevent accidental changes to its value and + makes the tests more obviously correct. +* In case we need to subclass the test fixture class, the subclass' + constructor is guaranteed to call the base class' constructor *first*, and + the subclass' destructor is guaranteed to call the base class' destructor + *afterward*. With `SetUp()/TearDown()`, a subclass may make the mistake of + forgetting to call the base class' `SetUp()/TearDown()` or call them at the + wrong time. + +You may still want to use `SetUp()/TearDown()` in the following cases: + +* C++ does not allow virtual function calls in constructors and destructors. + You can call a method declared as virtual, but it will not use dynamic + dispatch. It will use the definition from the class the constructor of which + is currently executing. This is because calling a virtual method before the + derived class constructor has a chance to run is very dangerous - the + virtual method might operate on uninitialized data. Therefore, if you need + to call a method that will be overridden in a derived class, you have to use + `SetUp()/TearDown()`. +* In the body of a constructor (or destructor), it's not possible to use the + `ASSERT_xx` macros. Therefore, if the set-up operation could cause a fatal + test failure that should prevent the test from running, it's necessary to + use `abort` and abort the whole test + executable, or to use `SetUp()` instead of a constructor. +* If the tear-down operation could throw an exception, you must use + `TearDown()` as opposed to the destructor, as throwing in a destructor leads + to undefined behavior and usually will kill your program right away. Note + that many standard libraries (like STL) may throw when exceptions are + enabled in the compiler. Therefore you should prefer `TearDown()` if you + want to write portable tests that work with or without exceptions. +* The GoogleTest team is considering making the assertion macros throw on + platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux + client-side), which will eliminate the need for the user to propagate + failures from a subroutine to its caller. Therefore, you shouldn't use + GoogleTest assertions in a destructor if your code could run on such a + platform. + +## The compiler complains "no matching function to call" when I use ASSERT_PRED*. How do I fix it? + +See details for [`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) in the +Assertions Reference. + +## My compiler complains about "ignoring return value" when I call RUN_ALL_TESTS(). Why? + +Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is, +instead of + +```c++ + return RUN_ALL_TESTS(); +``` + +they write + +```c++ + RUN_ALL_TESTS(); +``` + +This is **wrong and dangerous**. The testing services needs to see the return +value of `RUN_ALL_TESTS()` in order to determine if a test has passed. If your +`main()` function ignores it, your test will be considered successful even if it +has a GoogleTest assertion failure. Very bad. + +We have decided to fix this (thanks to Michael Chastain for the idea). Now, your +code will no longer be able to ignore `RUN_ALL_TESTS()` when compiled with +`gcc`. If you do so, you'll get a compiler error. + +If you see the compiler complaining about you ignoring the return value of +`RUN_ALL_TESTS()`, the fix is simple: just make sure its value is used as the +return value of `main()`. + +But how could we introduce a change that breaks existing tests? Well, in this +case, the code was already broken in the first place, so we didn't break it. :-) + +## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? + +Due to a peculiarity of C++, in order to support the syntax for streaming +messages to an `ASSERT_*`, e.g. + +```c++ + ASSERT_EQ(1, Foo()) << "blah blah" << foo; +``` + +we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and +`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the +content of your constructor/destructor to a private void member function, or +switch to `EXPECT_*()` if that works. This +[section](advanced.md#assertion-placement) in the user's guide explains it. + +## My SetUp() function is not called. Why? + +C++ is case-sensitive. Did you spell it as `Setup()`? + +Similarly, sometimes people spell `SetUpTestSuite()` as `SetupTestSuite()` and +wonder why it's never called. + +## I have several test suites which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. + +You don't have to. Instead of + +```c++ +class FooTest : public BaseTest {}; + +TEST_F(FooTest, Abc) { ... } +TEST_F(FooTest, Def) { ... } + +class BarTest : public BaseTest {}; + +TEST_F(BarTest, Abc) { ... } +TEST_F(BarTest, Def) { ... } +``` + +you can simply `typedef` the test fixtures: + +```c++ +typedef BaseTest FooTest; + +TEST_F(FooTest, Abc) { ... } +TEST_F(FooTest, Def) { ... } + +typedef BaseTest BarTest; + +TEST_F(BarTest, Abc) { ... } +TEST_F(BarTest, Def) { ... } +``` + +## GoogleTest output is buried in a whole bunch of LOG messages. What do I do? + +The GoogleTest output is meant to be a concise and human-friendly report. If +your test generates textual output itself, it will mix with the GoogleTest +output, making it hard to read. However, there is an easy solution to this +problem. + +Since `LOG` messages go to stderr, we decided to let GoogleTest output go to +stdout. This way, you can easily separate the two using redirection. For +example: + +```shell +$ ./my_test > gtest_output.txt +``` + +## Why should I prefer test fixtures over global variables? + +There are several good reasons: + +1. It's likely your test needs to change the states of its global variables. + This makes it difficult to keep side effects from escaping one test and + contaminating others, making debugging difficult. By using fixtures, each + test has a fresh set of variables that's different (but with the same + names). Thus, tests are kept independent of each other. +2. Global variables pollute the global namespace. +3. Test fixtures can be reused via subclassing, which cannot be done easily + with global variables. This is useful if many test suites have something in + common. + +## What can the statement argument in ASSERT_DEATH() be? + +`ASSERT_DEATH(statement, matcher)` (or any death assertion macro) can be used +wherever *`statement`* is valid. So basically *`statement`* can be any C++ +statement that makes sense in the current context. In particular, it can +reference global and/or local variables, and can be: + +* a simple function call (often the case), +* a complex expression, or +* a compound statement. + +Some examples are shown here: + +```c++ +// A death test can be a simple function call. +TEST(MyDeathTest, FunctionCall) { + ASSERT_DEATH(Xyz(5), "Xyz failed"); +} + +// Or a complex expression that references variables and functions. +TEST(MyDeathTest, ComplexExpression) { + const bool c = Condition(); + ASSERT_DEATH((c ? Func1(0) : object2.Method("test")), + "(Func1|Method) failed"); +} + +// Death assertions can be used anywhere in a function. In +// particular, they can be inside a loop. +TEST(MyDeathTest, InsideLoop) { + // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die. + for (int i = 0; i < 5; i++) { + EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors", + ::testing::Message() << "where i is " << i); + } +} + +// A death assertion can contain a compound statement. +TEST(MyDeathTest, CompoundStatement) { + // Verifies that at lease one of Bar(0), Bar(1), ..., and + // Bar(4) dies. + ASSERT_DEATH({ + for (int i = 0; i < 5; i++) { + Bar(i); + } + }, + "Bar has \\d+ errors"); +} +``` + +## I have a fixture class `FooTest`, but `TEST_F(FooTest, Bar)` gives me error ``"no matching function for call to `FooTest::FooTest()'"``. Why? + +GoogleTest needs to be able to create objects of your test fixture class, so it +must have a default constructor. Normally the compiler will define one for you. +However, there are cases where you have to define your own: + +* If you explicitly declare a non-default constructor for class `FooTest` + (`DISALLOW_EVIL_CONSTRUCTORS()` does this), then you need to define a + default constructor, even if it would be empty. +* If `FooTest` has a const non-static data member, then you have to define the + default constructor *and* initialize the const member in the initializer + list of the constructor. (Early versions of `gcc` doesn't force you to + initialize the const member. It's a bug that has been fixed in `gcc 4`.) + +## Why does ASSERT_DEATH complain about previous threads that were already joined? + +With the Linux pthread library, there is no turning back once you cross the line +from a single thread to multiple threads. The first time you create a thread, a +manager thread is created in addition, so you get 3, not 2, threads. Later when +the thread you create joins the main thread, the thread count decrements by 1, +but the manager thread will never be killed, so you still have 2 threads, which +means you cannot safely run a death test. + +The new NPTL thread library doesn't suffer from this problem, as it doesn't +create a manager thread. However, if you don't control which machine your test +runs on, you shouldn't depend on this. + +## Why does GoogleTest require the entire test suite, instead of individual tests, to be named *DeathTest when it uses ASSERT_DEATH? + +GoogleTest does not interleave tests from different test suites. That is, it +runs all tests in one test suite first, and then runs all tests in the next test +suite, and so on. GoogleTest does this because it needs to set up a test suite +before the first test in it is run, and tear it down afterwards. Splitting up +the test case would require multiple set-up and tear-down processes, which is +inefficient and makes the semantics unclean. + +If we were to determine the order of tests based on test name instead of test +case name, then we would have a problem with the following situation: + +```c++ +TEST_F(FooTest, AbcDeathTest) { ... } +TEST_F(FooTest, Uvw) { ... } + +TEST_F(BarTest, DefDeathTest) { ... } +TEST_F(BarTest, Xyz) { ... } +``` + +Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't +interleave tests from different test suites, we need to run all tests in the +`FooTest` case before running any test in the `BarTest` case. This contradicts +with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`. + +## But I don't like calling my entire test suite \*DeathTest when it contains both death tests and non-death tests. What do I do? + +You don't have to, but if you like, you may split up the test suite into +`FooTest` and `FooDeathTest`, where the names make it clear that they are +related: + +```c++ +class FooTest : public ::testing::Test { ... }; + +TEST_F(FooTest, Abc) { ... } +TEST_F(FooTest, Def) { ... } + +using FooDeathTest = FooTest; + +TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... } +TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... } +``` + +## GoogleTest prints the LOG messages in a death test's child process only when the test fails. How can I see the LOG messages when the death test succeeds? + +Printing the LOG messages generated by the statement inside `EXPECT_DEATH()` +makes it harder to search for real problems in the parent's log. Therefore, +GoogleTest only prints them when the death test has failed. + +If you really need to see such LOG messages, a workaround is to temporarily +break the death test (e.g. by changing the regex pattern it is expected to +match). Admittedly, this is a hack. We'll consider a more permanent solution +after the fork-and-exec-style death tests are implemented. + +## The compiler complains about `no match for 'operator<<'` when I use an assertion. What gives? + +If you use a user-defined type `FooType` in an assertion, you must make sure +there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function +defined such that we can print a value of `FooType`. + +In addition, if `FooType` is declared in a name space, the `<<` operator also +needs to be defined in the *same* name space. See +[Tip of the Week #49](http://abseil.io/tips/49) for details. + +## How do I suppress the memory leak messages on Windows? + +Since the statically initialized GoogleTest singleton requires allocations on +the heap, the Visual C++ memory leak detector will report memory leaks at the +end of the program run. The easiest way to avoid this is to use the +`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any +statically initialized heap objects. See MSDN for more details and additional +heap check/debug routines. + +## How can my code detect if it is running in a test? + +If you write code that sniffs whether it's running in a test and does different +things accordingly, you are leaking test-only logic into production code and +there is no easy way to ensure that the test-only code paths aren't run by +mistake in production. Such cleverness also leads to +[Heisenbugs](https://en.wikipedia.org/wiki/Heisenbug). Therefore we strongly +advise against the practice, and GoogleTest doesn't provide a way to do it. + +In general, the recommended way to cause the code to behave differently under +test is [Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection). You can inject +different functionality from the test and from the production code. Since your +production code doesn't link in the for-test logic at all (the +[`testonly`](http://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly) attribute for BUILD targets helps to ensure +that), there is no danger in accidentally running it. + +However, if you *really*, *really*, *really* have no choice, and if you follow +the rule of ending your test program names with `_test`, you can use the +*horrible* hack of sniffing your executable name (`argv[0]` in `main()`) to know +whether the code is under test. + +## How do I temporarily disable a test? + +If you have a broken test that you cannot fix right away, you can add the +`DISABLED_` prefix to its name. This will exclude it from execution. This is +better than commenting out the code or using `#if 0`, as disabled tests are +still compiled (and thus won't rot). + +To include disabled tests in test execution, just invoke the test program with +the `--gtest_also_run_disabled_tests` flag. + +## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces? + +Yes. + +The rule is **all test methods in the same test suite must use the same fixture +class.** This means that the following is **allowed** because both tests use the +same fixture class (`::testing::Test`). + +```c++ +namespace foo { +TEST(CoolTest, DoSomething) { + SUCCEED(); +} +} // namespace foo + +namespace bar { +TEST(CoolTest, DoSomething) { + SUCCEED(); +} +} // namespace bar +``` + +However, the following code is **not allowed** and will produce a runtime error +from GoogleTest because the test methods are using different test fixture +classes with the same test suite name. + +```c++ +namespace foo { +class CoolTest : public ::testing::Test {}; // Fixture foo::CoolTest +TEST_F(CoolTest, DoSomething) { + SUCCEED(); +} +} // namespace foo + +namespace bar { +class CoolTest : public ::testing::Test {}; // Fixture: bar::CoolTest +TEST_F(CoolTest, DoSomething) { + SUCCEED(); +} +} // namespace bar +``` diff --git a/cpp/third_party/googletest/docs/gmock_cheat_sheet.md b/cpp/third_party/googletest/docs/gmock_cheat_sheet.md new file mode 100644 index 0000000..ddafaaa --- /dev/null +++ b/cpp/third_party/googletest/docs/gmock_cheat_sheet.md @@ -0,0 +1,241 @@ +# gMock Cheat Sheet + +## Defining a Mock Class + +### Mocking a Normal Class {#MockClass} + +Given + +```cpp +class Foo { + public: + virtual ~Foo(); + virtual int GetSize() const = 0; + virtual string Describe(const char* name) = 0; + virtual string Describe(int type) = 0; + virtual bool Process(Bar elem, int count) = 0; +}; +``` + +(note that `~Foo()` **must** be virtual) we can define its mock as + +```cpp +#include + +class MockFoo : public Foo { + public: + MOCK_METHOD(int, GetSize, (), (const, override)); + MOCK_METHOD(string, Describe, (const char* name), (override)); + MOCK_METHOD(string, Describe, (int type), (override)); + MOCK_METHOD(bool, Process, (Bar elem, int count), (override)); +}; +``` + +To create a "nice" mock, which ignores all uninteresting calls, a "naggy" mock, +which warns on all uninteresting calls, or a "strict" mock, which treats them as +failures: + +```cpp +using ::testing::NiceMock; +using ::testing::NaggyMock; +using ::testing::StrictMock; + +NiceMock nice_foo; // The type is a subclass of MockFoo. +NaggyMock naggy_foo; // The type is a subclass of MockFoo. +StrictMock strict_foo; // The type is a subclass of MockFoo. +``` + +{: .callout .note} +**Note:** A mock object is currently naggy by default. We may make it nice by +default in the future. + +### Mocking a Class Template {#MockTemplate} + +Class templates can be mocked just like any class. + +To mock + +```cpp +template +class StackInterface { + public: + virtual ~StackInterface(); + virtual int GetSize() const = 0; + virtual void Push(const Elem& x) = 0; +}; +``` + +(note that all member functions that are mocked, including `~StackInterface()` +**must** be virtual). + +```cpp +template +class MockStack : public StackInterface { + public: + MOCK_METHOD(int, GetSize, (), (const, override)); + MOCK_METHOD(void, Push, (const Elem& x), (override)); +}; +``` + +### Specifying Calling Conventions for Mock Functions + +If your mock function doesn't use the default calling convention, you can +specify it by adding `Calltype(convention)` to `MOCK_METHOD`'s 4th parameter. +For example, + +```cpp + MOCK_METHOD(bool, Foo, (int n), (Calltype(STDMETHODCALLTYPE))); + MOCK_METHOD(int, Bar, (double x, double y), + (const, Calltype(STDMETHODCALLTYPE))); +``` + +where `STDMETHODCALLTYPE` is defined by `` on Windows. + +## Using Mocks in Tests {#UsingMocks} + +The typical work flow is: + +1. Import the gMock names you need to use. All gMock symbols are in the + `testing` namespace unless they are macros or otherwise noted. +2. Create the mock objects. +3. Optionally, set the default actions of the mock objects. +4. Set your expectations on the mock objects (How will they be called? What + will they do?). +5. Exercise code that uses the mock objects; if necessary, check the result + using googletest assertions. +6. When a mock object is destructed, gMock automatically verifies that all + expectations on it have been satisfied. + +Here's an example: + +```cpp +using ::testing::Return; // #1 + +TEST(BarTest, DoesThis) { + MockFoo foo; // #2 + + ON_CALL(foo, GetSize()) // #3 + .WillByDefault(Return(1)); + // ... other default actions ... + + EXPECT_CALL(foo, Describe(5)) // #4 + .Times(3) + .WillRepeatedly(Return("Category 5")); + // ... other expectations ... + + EXPECT_EQ(MyProductionFunction(&foo), "good"); // #5 +} // #6 +``` + +## Setting Default Actions {#OnCall} + +gMock has a **built-in default action** for any function that returns `void`, +`bool`, a numeric value, or a pointer. In C++11, it will additionally returns +the default-constructed value, if one exists for the given type. + +To customize the default action for functions with return type `T`, use +[`DefaultValue`](reference/mocking.md#DefaultValue). For example: + +```cpp + // Sets the default action for return type std::unique_ptr to + // creating a new Buzz every time. + DefaultValue>::SetFactory( + [] { return std::make_unique(AccessLevel::kInternal); }); + + // When this fires, the default action of MakeBuzz() will run, which + // will return a new Buzz object. + EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")).Times(AnyNumber()); + + auto buzz1 = mock_buzzer_.MakeBuzz("hello"); + auto buzz2 = mock_buzzer_.MakeBuzz("hello"); + EXPECT_NE(buzz1, nullptr); + EXPECT_NE(buzz2, nullptr); + EXPECT_NE(buzz1, buzz2); + + // Resets the default action for return type std::unique_ptr, + // to avoid interfere with other tests. + DefaultValue>::Clear(); +``` + +To customize the default action for a particular method of a specific mock +object, use [`ON_CALL`](reference/mocking.md#ON_CALL). `ON_CALL` has a similar +syntax to `EXPECT_CALL`, but it is used for setting default behaviors when you +do not require that the mock method is called. See +[Knowing When to Expect](gmock_cook_book.md#UseOnCall) for a more detailed +discussion. + +## Setting Expectations {#ExpectCall} + +See [`EXPECT_CALL`](reference/mocking.md#EXPECT_CALL) in the Mocking Reference. + +## Matchers {#MatcherList} + +See the [Matchers Reference](reference/matchers.md). + +## Actions {#ActionList} + +See the [Actions Reference](reference/actions.md). + +## Cardinalities {#CardinalityList} + +See the [`Times` clause](reference/mocking.md#EXPECT_CALL.Times) of +`EXPECT_CALL` in the Mocking Reference. + +## Expectation Order + +By default, expectations can be matched in *any* order. If some or all +expectations must be matched in a given order, you can use the +[`After` clause](reference/mocking.md#EXPECT_CALL.After) or +[`InSequence` clause](reference/mocking.md#EXPECT_CALL.InSequence) of +`EXPECT_CALL`, or use an [`InSequence` object](reference/mocking.md#InSequence). + +## Verifying and Resetting a Mock + +gMock will verify the expectations on a mock object when it is destructed, or +you can do it earlier: + +```cpp +using ::testing::Mock; +... +// Verifies and removes the expectations on mock_obj; +// returns true if and only if successful. +Mock::VerifyAndClearExpectations(&mock_obj); +... +// Verifies and removes the expectations on mock_obj; +// also removes the default actions set by ON_CALL(); +// returns true if and only if successful. +Mock::VerifyAndClear(&mock_obj); +``` + +Do not set new expectations after verifying and clearing a mock after its use. +Setting expectations after code that exercises the mock has undefined behavior. +See [Using Mocks in Tests](gmock_for_dummies.md#using-mocks-in-tests) for more +information. + +You can also tell gMock that a mock object can be leaked and doesn't need to be +verified: + +```cpp +Mock::AllowLeak(&mock_obj); +``` + +## Mock Classes + +gMock defines a convenient mock class template + +```cpp +class MockFunction { + public: + MOCK_METHOD(R, Call, (A1, ..., An)); +}; +``` + +See this [recipe](gmock_cook_book.md#UsingCheckPoints) for one application of +it. + +## Flags + +| Flag | Description | +| :----------------------------- | :---------------------------------------- | +| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. | +| `--gmock_verbose=LEVEL` | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. | diff --git a/cpp/third_party/googletest/docs/gmock_cook_book.md b/cpp/third_party/googletest/docs/gmock_cook_book.md new file mode 100644 index 0000000..da10918 --- /dev/null +++ b/cpp/third_party/googletest/docs/gmock_cook_book.md @@ -0,0 +1,4344 @@ +# gMock Cookbook + +You can find recipes for using gMock here. If you haven't yet, please read +[the dummy guide](gmock_for_dummies.md) first to make sure you understand the +basics. + +{: .callout .note} +**Note:** gMock lives in the `testing` name space. For readability, it is +recommended to write `using ::testing::Foo;` once in your file before using the +name `Foo` defined by gMock. We omit such `using` statements in this section for +brevity, but you should do it in your own code. + +## Creating Mock Classes + +Mock classes are defined as normal classes, using the `MOCK_METHOD` macro to +generate mocked methods. The macro gets 3 or 4 parameters: + +```cpp +class MyMock { + public: + MOCK_METHOD(ReturnType, MethodName, (Args...)); + MOCK_METHOD(ReturnType, MethodName, (Args...), (Specs...)); +}; +``` + +The first 3 parameters are simply the method declaration, split into 3 parts. +The 4th parameter accepts a closed list of qualifiers, which affect the +generated method: + +* **`const`** - Makes the mocked method a `const` method. Required if + overriding a `const` method. +* **`override`** - Marks the method with `override`. Recommended if overriding + a `virtual` method. +* **`noexcept`** - Marks the method with `noexcept`. Required if overriding a + `noexcept` method. +* **`Calltype(...)`** - Sets the call type for the method (e.g. to + `STDMETHODCALLTYPE`), useful in Windows. +* **`ref(...)`** - Marks the method with the reference qualification + specified. Required if overriding a method that has reference + qualifications. Eg `ref(&)` or `ref(&&)`. + +### Dealing with unprotected commas + +Unprotected commas, i.e. commas which are not surrounded by parentheses, prevent +`MOCK_METHOD` from parsing its arguments correctly: + +{: .bad} +```cpp +class MockFoo { + public: + MOCK_METHOD(std::pair, GetPair, ()); // Won't compile! + MOCK_METHOD(bool, CheckMap, (std::map, bool)); // Won't compile! +}; +``` + +Solution 1 - wrap with parentheses: + +{: .good} +```cpp +class MockFoo { + public: + MOCK_METHOD((std::pair), GetPair, ()); + MOCK_METHOD(bool, CheckMap, ((std::map), bool)); +}; +``` + +Note that wrapping a return or argument type with parentheses is, in general, +invalid C++. `MOCK_METHOD` removes the parentheses. + +Solution 2 - define an alias: + +{: .good} +```cpp +class MockFoo { + public: + using BoolAndInt = std::pair; + MOCK_METHOD(BoolAndInt, GetPair, ()); + using MapIntDouble = std::map; + MOCK_METHOD(bool, CheckMap, (MapIntDouble, bool)); +}; +``` + +### Mocking Private or Protected Methods + +You must always put a mock method definition (`MOCK_METHOD`) in a `public:` +section of the mock class, regardless of the method being mocked being `public`, +`protected`, or `private` in the base class. This allows `ON_CALL` and +`EXPECT_CALL` to reference the mock function from outside of the mock class. +(Yes, C++ allows a subclass to change the access level of a virtual function in +the base class.) Example: + +```cpp +class Foo { + public: + ... + virtual bool Transform(Gadget* g) = 0; + + protected: + virtual void Resume(); + + private: + virtual int GetTimeOut(); +}; + +class MockFoo : public Foo { + public: + ... + MOCK_METHOD(bool, Transform, (Gadget* g), (override)); + + // The following must be in the public section, even though the + // methods are protected or private in the base class. + MOCK_METHOD(void, Resume, (), (override)); + MOCK_METHOD(int, GetTimeOut, (), (override)); +}; +``` + +### Mocking Overloaded Methods + +You can mock overloaded functions as usual. No special attention is required: + +```cpp +class Foo { + ... + + // Must be virtual as we'll inherit from Foo. + virtual ~Foo(); + + // Overloaded on the types and/or numbers of arguments. + virtual int Add(Element x); + virtual int Add(int times, Element x); + + // Overloaded on the const-ness of this object. + virtual Bar& GetBar(); + virtual const Bar& GetBar() const; +}; + +class MockFoo : public Foo { + ... + MOCK_METHOD(int, Add, (Element x), (override)); + MOCK_METHOD(int, Add, (int times, Element x), (override)); + + MOCK_METHOD(Bar&, GetBar, (), (override)); + MOCK_METHOD(const Bar&, GetBar, (), (const, override)); +}; +``` + +{: .callout .note} +**Note:** if you don't mock all versions of the overloaded method, the compiler +will give you a warning about some methods in the base class being hidden. To +fix that, use `using` to bring them in scope: + +```cpp +class MockFoo : public Foo { + ... + using Foo::Add; + MOCK_METHOD(int, Add, (Element x), (override)); + // We don't want to mock int Add(int times, Element x); + ... +}; +``` + +### Mocking Class Templates + +You can mock class templates just like any class. + +```cpp +template +class StackInterface { + ... + // Must be virtual as we'll inherit from StackInterface. + virtual ~StackInterface(); + + virtual int GetSize() const = 0; + virtual void Push(const Elem& x) = 0; +}; + +template +class MockStack : public StackInterface { + ... + MOCK_METHOD(int, GetSize, (), (override)); + MOCK_METHOD(void, Push, (const Elem& x), (override)); +}; +``` + +### Mocking Non-virtual Methods {#MockingNonVirtualMethods} + +gMock can mock non-virtual functions to be used in Hi-perf dependency injection. + +In this case, instead of sharing a common base class with the real class, your +mock class will be *unrelated* to the real class, but contain methods with the +same signatures. The syntax for mocking non-virtual methods is the *same* as +mocking virtual methods (just don't add `override`): + +```cpp +// A simple packet stream class. None of its members is virtual. +class ConcretePacketStream { + public: + void AppendPacket(Packet* new_packet); + const Packet* GetPacket(size_t packet_number) const; + size_t NumberOfPackets() const; + ... +}; + +// A mock packet stream class. It inherits from no other, but defines +// GetPacket() and NumberOfPackets(). +class MockPacketStream { + public: + MOCK_METHOD(const Packet*, GetPacket, (size_t packet_number), (const)); + MOCK_METHOD(size_t, NumberOfPackets, (), (const)); + ... +}; +``` + +Note that the mock class doesn't define `AppendPacket()`, unlike the real class. +That's fine as long as the test doesn't need to call it. + +Next, you need a way to say that you want to use `ConcretePacketStream` in +production code, and use `MockPacketStream` in tests. Since the functions are +not virtual and the two classes are unrelated, you must specify your choice at +*compile time* (as opposed to run time). + +One way to do it is to templatize your code that needs to use a packet stream. +More specifically, you will give your code a template type argument for the type +of the packet stream. In production, you will instantiate your template with +`ConcretePacketStream` as the type argument. In tests, you will instantiate the +same template with `MockPacketStream`. For example, you may write: + +```cpp +template +void CreateConnection(PacketStream* stream) { ... } + +template +class PacketReader { + public: + void ReadPackets(PacketStream* stream, size_t packet_num); +}; +``` + +Then you can use `CreateConnection()` and +`PacketReader` in production code, and use +`CreateConnection()` and `PacketReader` in +tests. + +```cpp + MockPacketStream mock_stream; + EXPECT_CALL(mock_stream, ...)...; + .. set more expectations on mock_stream ... + PacketReader reader(&mock_stream); + ... exercise reader ... +``` + +### Mocking Free Functions + +It is not possible to directly mock a free function (i.e. a C-style function or +a static method). If you need to, you can rewrite your code to use an interface +(abstract class). + +Instead of calling a free function (say, `OpenFile`) directly, introduce an +interface for it and have a concrete subclass that calls the free function: + +```cpp +class FileInterface { + public: + ... + virtual bool Open(const char* path, const char* mode) = 0; +}; + +class File : public FileInterface { + public: + ... + bool Open(const char* path, const char* mode) override { + return OpenFile(path, mode); + } +}; +``` + +Your code should talk to `FileInterface` to open a file. Now it's easy to mock +out the function. + +This may seem like a lot of hassle, but in practice you often have multiple +related functions that you can put in the same interface, so the per-function +syntactic overhead will be much lower. + +If you are concerned about the performance overhead incurred by virtual +functions, and profiling confirms your concern, you can combine this with the +recipe for [mocking non-virtual methods](#MockingNonVirtualMethods). + +Alternatively, instead of introducing a new interface, you can rewrite your code +to accept a std::function instead of the free function, and then use +[MockFunction](#MockFunction) to mock the std::function. + +### Old-Style `MOCK_METHODn` Macros + +Before the generic `MOCK_METHOD` macro +[was introduced in 2018](https://github.com/google/googletest/commit/c5f08bf91944ce1b19bcf414fa1760e69d20afc2), +mocks where created using a family of macros collectively called `MOCK_METHODn`. +These macros are still supported, though migration to the new `MOCK_METHOD` is +recommended. + +The macros in the `MOCK_METHODn` family differ from `MOCK_METHOD`: + +* The general structure is `MOCK_METHODn(MethodName, ReturnType(Args))`, + instead of `MOCK_METHOD(ReturnType, MethodName, (Args))`. +* The number `n` must equal the number of arguments. +* When mocking a const method, one must use `MOCK_CONST_METHODn`. +* When mocking a class template, the macro name must be suffixed with `_T`. +* In order to specify the call type, the macro name must be suffixed with + `_WITH_CALLTYPE`, and the call type is the first macro argument. + +Old macros and their new equivalents: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Simple
OldMOCK_METHOD1(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int))
Const Method
OldMOCK_CONST_METHOD1(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const))
Method in a Class Template
OldMOCK_METHOD1_T(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int))
Const Method in a Class Template
OldMOCK_CONST_METHOD1_T(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const))
Method with Call Type
OldMOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (Calltype(STDMETHODCALLTYPE)))
Const Method with Call Type
OldMOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const, Calltype(STDMETHODCALLTYPE)))
Method with Call Type in a Class Template
OldMOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (Calltype(STDMETHODCALLTYPE)))
Const Method with Call Type in a Class Template
OldMOCK_CONST_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const, Calltype(STDMETHODCALLTYPE)))
+ +### The Nice, the Strict, and the Naggy {#NiceStrictNaggy} + +If a mock method has no `EXPECT_CALL` spec but is called, we say that it's an +"uninteresting call", and the default action (which can be specified using +`ON_CALL()`) of the method will be taken. Currently, an uninteresting call will +also by default cause gMock to print a warning. + +However, sometimes you may want to ignore these uninteresting calls, and +sometimes you may want to treat them as errors. gMock lets you make the decision +on a per-mock-object basis. + +Suppose your test uses a mock class `MockFoo`: + +```cpp +TEST(...) { + MockFoo mock_foo; + EXPECT_CALL(mock_foo, DoThis()); + ... code that uses mock_foo ... +} +``` + +If a method of `mock_foo` other than `DoThis()` is called, you will get a +warning. However, if you rewrite your test to use `NiceMock` instead, +you can suppress the warning: + +```cpp +using ::testing::NiceMock; + +TEST(...) { + NiceMock mock_foo; + EXPECT_CALL(mock_foo, DoThis()); + ... code that uses mock_foo ... +} +``` + +`NiceMock` is a subclass of `MockFoo`, so it can be used wherever +`MockFoo` is accepted. + +It also works if `MockFoo`'s constructor takes some arguments, as +`NiceMock` "inherits" `MockFoo`'s constructors: + +```cpp +using ::testing::NiceMock; + +TEST(...) { + NiceMock mock_foo(5, "hi"); // Calls MockFoo(5, "hi"). + EXPECT_CALL(mock_foo, DoThis()); + ... code that uses mock_foo ... +} +``` + +The usage of `StrictMock` is similar, except that it makes all uninteresting +calls failures: + +```cpp +using ::testing::StrictMock; + +TEST(...) { + StrictMock mock_foo; + EXPECT_CALL(mock_foo, DoThis()); + ... code that uses mock_foo ... + + // The test will fail if a method of mock_foo other than DoThis() + // is called. +} +``` + +{: .callout .note} +NOTE: `NiceMock` and `StrictMock` only affects *uninteresting* calls (calls of +*methods* with no expectations); they do not affect *unexpected* calls (calls of +methods with expectations, but they don't match). See +[Understanding Uninteresting vs Unexpected Calls](#uninteresting-vs-unexpected). + +There are some caveats though (sadly they are side effects of C++'s +limitations): + +1. `NiceMock` and `StrictMock` only work for mock methods + defined using the `MOCK_METHOD` macro **directly** in the `MockFoo` class. + If a mock method is defined in a **base class** of `MockFoo`, the "nice" or + "strict" modifier may not affect it, depending on the compiler. In + particular, nesting `NiceMock` and `StrictMock` (e.g. + `NiceMock >`) is **not** supported. +2. `NiceMock` and `StrictMock` may not work correctly if the + destructor of `MockFoo` is not virtual. We would like to fix this, but it + requires cleaning up existing tests. + +Finally, you should be **very cautious** about when to use naggy or strict +mocks, as they tend to make tests more brittle and harder to maintain. When you +refactor your code without changing its externally visible behavior, ideally you +shouldn't need to update any tests. If your code interacts with a naggy mock, +however, you may start to get spammed with warnings as the result of your +change. Worse, if your code interacts with a strict mock, your tests may start +to fail and you'll be forced to fix them. Our general recommendation is to use +nice mocks (not yet the default) most of the time, use naggy mocks (the current +default) when developing or debugging tests, and use strict mocks only as the +last resort. + +### Simplifying the Interface without Breaking Existing Code {#SimplerInterfaces} + +Sometimes a method has a long list of arguments that is mostly uninteresting. +For example: + +```cpp +class LogSink { + public: + ... + virtual void send(LogSeverity severity, const char* full_filename, + const char* base_filename, int line, + const struct tm* tm_time, + const char* message, size_t message_len) = 0; +}; +``` + +This method's argument list is lengthy and hard to work with (the `message` +argument is not even 0-terminated). If we mock it as is, using the mock will be +awkward. If, however, we try to simplify this interface, we'll need to fix all +clients depending on it, which is often infeasible. + +The trick is to redispatch the method in the mock class: + +```cpp +class ScopedMockLog : public LogSink { + public: + ... + void send(LogSeverity severity, const char* full_filename, + const char* base_filename, int line, const tm* tm_time, + const char* message, size_t message_len) override { + // We are only interested in the log severity, full file name, and + // log message. + Log(severity, full_filename, std::string(message, message_len)); + } + + // Implements the mock method: + // + // void Log(LogSeverity severity, + // const string& file_path, + // const string& message); + MOCK_METHOD(void, Log, + (LogSeverity severity, const string& file_path, + const string& message)); +}; +``` + +By defining a new mock method with a trimmed argument list, we make the mock +class more user-friendly. + +This technique may also be applied to make overloaded methods more amenable to +mocking. For example, when overloads have been used to implement default +arguments: + +```cpp +class MockTurtleFactory : public TurtleFactory { + public: + Turtle* MakeTurtle(int length, int weight) override { ... } + Turtle* MakeTurtle(int length, int weight, int speed) override { ... } + + // the above methods delegate to this one: + MOCK_METHOD(Turtle*, DoMakeTurtle, ()); +}; +``` + +This allows tests that don't care which overload was invoked to avoid specifying +argument matchers: + +```cpp +ON_CALL(factory, DoMakeTurtle) + .WillByDefault(Return(MakeMockTurtle())); +``` + +### Alternative to Mocking Concrete Classes + +Often you may find yourself using classes that don't implement interfaces. In +order to test your code that uses such a class (let's call it `Concrete`), you +may be tempted to make the methods of `Concrete` virtual and then mock it. + +Try not to do that. + +Making a non-virtual function virtual is a big decision. It creates an extension +point where subclasses can tweak your class' behavior. This weakens your control +on the class because now it's harder to maintain the class invariants. You +should make a function virtual only when there is a valid reason for a subclass +to override it. + +Mocking concrete classes directly is problematic as it creates a tight coupling +between the class and the tests - any small change in the class may invalidate +your tests and make test maintenance a pain. + +To avoid such problems, many programmers have been practicing "coding to +interfaces": instead of talking to the `Concrete` class, your code would define +an interface and talk to it. Then you implement that interface as an adaptor on +top of `Concrete`. In tests, you can easily mock that interface to observe how +your code is doing. + +This technique incurs some overhead: + +* You pay the cost of virtual function calls (usually not a problem). +* There is more abstraction for the programmers to learn. + +However, it can also bring significant benefits in addition to better +testability: + +* `Concrete`'s API may not fit your problem domain very well, as you may not + be the only client it tries to serve. By designing your own interface, you + have a chance to tailor it to your need - you may add higher-level + functionalities, rename stuff, etc instead of just trimming the class. This + allows you to write your code (user of the interface) in a more natural way, + which means it will be more readable, more maintainable, and you'll be more + productive. +* If `Concrete`'s implementation ever has to change, you don't have to rewrite + everywhere it is used. Instead, you can absorb the change in your + implementation of the interface, and your other code and tests will be + insulated from this change. + +Some people worry that if everyone is practicing this technique, they will end +up writing lots of redundant code. This concern is totally understandable. +However, there are two reasons why it may not be the case: + +* Different projects may need to use `Concrete` in different ways, so the best + interfaces for them will be different. Therefore, each of them will have its + own domain-specific interface on top of `Concrete`, and they will not be the + same code. +* If enough projects want to use the same interface, they can always share it, + just like they have been sharing `Concrete`. You can check in the interface + and the adaptor somewhere near `Concrete` (perhaps in a `contrib` + sub-directory) and let many projects use it. + +You need to weigh the pros and cons carefully for your particular problem, but +I'd like to assure you that the Java community has been practicing this for a +long time and it's a proven effective technique applicable in a wide variety of +situations. :-) + +### Delegating Calls to a Fake {#DelegatingToFake} + +Some times you have a non-trivial fake implementation of an interface. For +example: + +```cpp +class Foo { + public: + virtual ~Foo() {} + virtual char DoThis(int n) = 0; + virtual void DoThat(const char* s, int* p) = 0; +}; + +class FakeFoo : public Foo { + public: + char DoThis(int n) override { + return (n > 0) ? '+' : + (n < 0) ? '-' : '0'; + } + + void DoThat(const char* s, int* p) override { + *p = strlen(s); + } +}; +``` + +Now you want to mock this interface such that you can set expectations on it. +However, you also want to use `FakeFoo` for the default behavior, as duplicating +it in the mock object is, well, a lot of work. + +When you define the mock class using gMock, you can have it delegate its default +action to a fake class you already have, using this pattern: + +```cpp +class MockFoo : public Foo { + public: + // Normal mock method definitions using gMock. + MOCK_METHOD(char, DoThis, (int n), (override)); + MOCK_METHOD(void, DoThat, (const char* s, int* p), (override)); + + // Delegates the default actions of the methods to a FakeFoo object. + // This must be called *before* the custom ON_CALL() statements. + void DelegateToFake() { + ON_CALL(*this, DoThis).WillByDefault([this](int n) { + return fake_.DoThis(n); + }); + ON_CALL(*this, DoThat).WillByDefault([this](const char* s, int* p) { + fake_.DoThat(s, p); + }); + } + + private: + FakeFoo fake_; // Keeps an instance of the fake in the mock. +}; +``` + +With that, you can use `MockFoo` in your tests as usual. Just remember that if +you don't explicitly set an action in an `ON_CALL()` or `EXPECT_CALL()`, the +fake will be called upon to do it.: + +```cpp +using ::testing::_; + +TEST(AbcTest, Xyz) { + MockFoo foo; + + foo.DelegateToFake(); // Enables the fake for delegation. + + // Put your ON_CALL(foo, ...)s here, if any. + + // No action specified, meaning to use the default action. + EXPECT_CALL(foo, DoThis(5)); + EXPECT_CALL(foo, DoThat(_, _)); + + int n = 0; + EXPECT_EQ(foo.DoThis(5), '+'); // FakeFoo::DoThis() is invoked. + foo.DoThat("Hi", &n); // FakeFoo::DoThat() is invoked. + EXPECT_EQ(n, 2); +} +``` + +**Some tips:** + +* If you want, you can still override the default action by providing your own + `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`. +* In `DelegateToFake()`, you only need to delegate the methods whose fake + implementation you intend to use. + +* The general technique discussed here works for overloaded methods, but + you'll need to tell the compiler which version you mean. To disambiguate a + mock function (the one you specify inside the parentheses of `ON_CALL()`), + use [this technique](#SelectOverload); to disambiguate a fake function (the + one you place inside `Invoke()`), use a `static_cast` to specify the + function's type. For instance, if class `Foo` has methods `char DoThis(int + n)` and `bool DoThis(double x) const`, and you want to invoke the latter, + you need to write `Invoke(&fake_, static_cast(&FakeFoo::DoThis))` instead of `Invoke(&fake_, &FakeFoo::DoThis)` + (The strange-looking thing inside the angled brackets of `static_cast` is + the type of a function pointer to the second `DoThis()` method.). + +* Having to mix a mock and a fake is often a sign of something gone wrong. + Perhaps you haven't got used to the interaction-based way of testing yet. Or + perhaps your interface is taking on too many roles and should be split up. + Therefore, **don't abuse this**. We would only recommend to do it as an + intermediate step when you are refactoring your code. + +Regarding the tip on mixing a mock and a fake, here's an example on why it may +be a bad sign: Suppose you have a class `System` for low-level system +operations. In particular, it does file and I/O operations. And suppose you want +to test how your code uses `System` to do I/O, and you just want the file +operations to work normally. If you mock out the entire `System` class, you'll +have to provide a fake implementation for the file operation part, which +suggests that `System` is taking on too many roles. + +Instead, you can define a `FileOps` interface and an `IOOps` interface and split +`System`'s functionalities into the two. Then you can mock `IOOps` without +mocking `FileOps`. + +### Delegating Calls to a Real Object + +When using testing doubles (mocks, fakes, stubs, and etc), sometimes their +behaviors will differ from those of the real objects. This difference could be +either intentional (as in simulating an error such that you can test the error +handling code) or unintentional. If your mocks have different behaviors than the +real objects by mistake, you could end up with code that passes the tests but +fails in production. + +You can use the *delegating-to-real* technique to ensure that your mock has the +same behavior as the real object while retaining the ability to validate calls. +This technique is very similar to the [delegating-to-fake](#DelegatingToFake) +technique, the difference being that we use a real object instead of a fake. +Here's an example: + +```cpp +using ::testing::AtLeast; + +class MockFoo : public Foo { + public: + MockFoo() { + // By default, all calls are delegated to the real object. + ON_CALL(*this, DoThis).WillByDefault([this](int n) { + return real_.DoThis(n); + }); + ON_CALL(*this, DoThat).WillByDefault([this](const char* s, int* p) { + real_.DoThat(s, p); + }); + ... + } + MOCK_METHOD(char, DoThis, ...); + MOCK_METHOD(void, DoThat, ...); + ... + private: + Foo real_; +}; + +... + MockFoo mock; + EXPECT_CALL(mock, DoThis()) + .Times(3); + EXPECT_CALL(mock, DoThat("Hi")) + .Times(AtLeast(1)); + ... use mock in test ... +``` + +With this, gMock will verify that your code made the right calls (with the right +arguments, in the right order, called the right number of times, etc), and a +real object will answer the calls (so the behavior will be the same as in +production). This gives you the best of both worlds. + +### Delegating Calls to a Parent Class + +Ideally, you should code to interfaces, whose methods are all pure virtual. In +reality, sometimes you do need to mock a virtual method that is not pure (i.e, +it already has an implementation). For example: + +```cpp +class Foo { + public: + virtual ~Foo(); + + virtual void Pure(int n) = 0; + virtual int Concrete(const char* str) { ... } +}; + +class MockFoo : public Foo { + public: + // Mocking a pure method. + MOCK_METHOD(void, Pure, (int n), (override)); + // Mocking a concrete method. Foo::Concrete() is shadowed. + MOCK_METHOD(int, Concrete, (const char* str), (override)); +}; +``` + +Sometimes you may want to call `Foo::Concrete()` instead of +`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub action, or +perhaps your test doesn't need to mock `Concrete()` at all (but it would be +oh-so painful to have to define a new mock class whenever you don't need to mock +one of its methods). + +You can call `Foo::Concrete()` inside an action by: + +```cpp +... + EXPECT_CALL(foo, Concrete).WillOnce([&foo](const char* str) { + return foo.Foo::Concrete(str); + }); +``` + +or tell the mock object that you don't want to mock `Concrete()`: + +```cpp +... + ON_CALL(foo, Concrete).WillByDefault([&foo](const char* str) { + return foo.Foo::Concrete(str); + }); +``` + +(Why don't we just write `{ return foo.Concrete(str); }`? If you do that, +`MockFoo::Concrete()` will be called (and cause an infinite recursion) since +`Foo::Concrete()` is virtual. That's just how C++ works.) + +## Using Matchers + +### Matching Argument Values Exactly + +You can specify exactly which arguments a mock method is expecting: + +```cpp +using ::testing::Return; +... + EXPECT_CALL(foo, DoThis(5)) + .WillOnce(Return('a')); + EXPECT_CALL(foo, DoThat("Hello", bar)); +``` + +### Using Simple Matchers + +You can use matchers to match arguments that have a certain property: + +```cpp +using ::testing::NotNull; +using ::testing::Return; +... + EXPECT_CALL(foo, DoThis(Ge(5))) // The argument must be >= 5. + .WillOnce(Return('a')); + EXPECT_CALL(foo, DoThat("Hello", NotNull())); + // The second argument must not be NULL. +``` + +A frequently used matcher is `_`, which matches anything: + +```cpp + EXPECT_CALL(foo, DoThat(_, NotNull())); +``` + +### Combining Matchers {#CombiningMatchers} + +You can build complex matchers from existing ones using `AllOf()`, +`AllOfArray()`, `AnyOf()`, `AnyOfArray()` and `Not()`: + +```cpp +using ::testing::AllOf; +using ::testing::Gt; +using ::testing::HasSubstr; +using ::testing::Ne; +using ::testing::Not; +... + // The argument must be > 5 and != 10. + EXPECT_CALL(foo, DoThis(AllOf(Gt(5), + Ne(10)))); + + // The first argument must not contain sub-string "blah". + EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")), + NULL)); +``` + +Matchers are function objects, and parametrized matchers can be composed just +like any other function. However because their types can be long and rarely +provide meaningful information, it can be easier to express them with C++14 +generic lambdas to avoid specifying types. For example, + +```cpp +using ::testing::Contains; +using ::testing::Property; + +inline constexpr auto HasFoo = [](const auto& f) { + return Property("foo", &MyClass::foo, Contains(f)); +}; +... + EXPECT_THAT(x, HasFoo("blah")); +``` + +### Casting Matchers {#SafeMatcherCast} + +gMock matchers are statically typed, meaning that the compiler can catch your +mistake if you use a matcher of the wrong type (for example, if you use `Eq(5)` +to match a `string` argument). Good for you! + +Sometimes, however, you know what you're doing and want the compiler to give you +some slack. One example is that you have a matcher for `long` and the argument +you want to match is `int`. While the two types aren't exactly the same, there +is nothing really wrong with using a `Matcher` to match an `int` - after +all, we can first convert the `int` argument to a `long` losslessly before +giving it to the matcher. + +To support this need, gMock gives you the `SafeMatcherCast(m)` function. It +casts a matcher `m` to type `Matcher`. To ensure safety, gMock checks that +(let `U` be the type `m` accepts : + +1. Type `T` can be *implicitly* cast to type `U`; +2. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and + floating-point numbers), the conversion from `T` to `U` is not lossy (in + other words, any value representable by `T` can also be represented by `U`); + and +3. When `U` is a reference, `T` must also be a reference (as the underlying + matcher may be interested in the address of the `U` value). + +The code won't compile if any of these conditions isn't met. + +Here's one example: + +```cpp +using ::testing::SafeMatcherCast; + +// A base class and a child class. +class Base { ... }; +class Derived : public Base { ... }; + +class MockFoo : public Foo { + public: + MOCK_METHOD(void, DoThis, (Derived* derived), (override)); +}; + +... + MockFoo foo; + // m is a Matcher we got from somewhere. + EXPECT_CALL(foo, DoThis(SafeMatcherCast(m))); +``` + +If you find `SafeMatcherCast(m)` too limiting, you can use a similar function +`MatcherCast(m)`. The difference is that `MatcherCast` works as long as you +can `static_cast` type `T` to type `U`. + +`MatcherCast` essentially lets you bypass C++'s type system (`static_cast` isn't +always safe as it could throw away information, for example), so be careful not +to misuse/abuse it. + +### Selecting Between Overloaded Functions {#SelectOverload} + +If you expect an overloaded function to be called, the compiler may need some +help on which overloaded version it is. + +To disambiguate functions overloaded on the const-ness of this object, use the +`Const()` argument wrapper. + +```cpp +using ::testing::ReturnRef; + +class MockFoo : public Foo { + ... + MOCK_METHOD(Bar&, GetBar, (), (override)); + MOCK_METHOD(const Bar&, GetBar, (), (const, override)); +}; + +... + MockFoo foo; + Bar bar1, bar2; + EXPECT_CALL(foo, GetBar()) // The non-const GetBar(). + .WillOnce(ReturnRef(bar1)); + EXPECT_CALL(Const(foo), GetBar()) // The const GetBar(). + .WillOnce(ReturnRef(bar2)); +``` + +(`Const()` is defined by gMock and returns a `const` reference to its argument.) + +To disambiguate overloaded functions with the same number of arguments but +different argument types, you may need to specify the exact type of a matcher, +either by wrapping your matcher in `Matcher()`, or using a matcher whose +type is fixed (`TypedEq`, `An()`, etc): + +```cpp +using ::testing::An; +using ::testing::Matcher; +using ::testing::TypedEq; + +class MockPrinter : public Printer { + public: + MOCK_METHOD(void, Print, (int n), (override)); + MOCK_METHOD(void, Print, (char c), (override)); +}; + +TEST(PrinterTest, Print) { + MockPrinter printer; + + EXPECT_CALL(printer, Print(An())); // void Print(int); + EXPECT_CALL(printer, Print(Matcher(Lt(5)))); // void Print(int); + EXPECT_CALL(printer, Print(TypedEq('a'))); // void Print(char); + + printer.Print(3); + printer.Print(6); + printer.Print('a'); +} +``` + +### Performing Different Actions Based on the Arguments + +When a mock method is called, the *last* matching expectation that's still +active will be selected (think "newer overrides older"). So, you can make a +method do different things depending on its argument values like this: + +```cpp +using ::testing::_; +using ::testing::Lt; +using ::testing::Return; +... + // The default case. + EXPECT_CALL(foo, DoThis(_)) + .WillRepeatedly(Return('b')); + // The more specific case. + EXPECT_CALL(foo, DoThis(Lt(5))) + .WillRepeatedly(Return('a')); +``` + +Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will be +returned; otherwise `'b'` will be returned. + +### Matching Multiple Arguments as a Whole + +Sometimes it's not enough to match the arguments individually. For example, we +may want to say that the first argument must be less than the second argument. +The `With()` clause allows us to match all arguments of a mock function as a +whole. For example, + +```cpp +using ::testing::_; +using ::testing::Ne; +using ::testing::Lt; +... + EXPECT_CALL(foo, InRange(Ne(0), _)) + .With(Lt()); +``` + +says that the first argument of `InRange()` must not be 0, and must be less than +the second argument. + +The expression inside `With()` must be a matcher of type `Matcher>`, where `A1`, ..., `An` are the types of the function arguments. + +You can also write `AllArgs(m)` instead of `m` inside `.With()`. The two forms +are equivalent, but `.With(AllArgs(Lt()))` is more readable than `.With(Lt())`. + +You can use `Args(m)` to match the `n` selected arguments (as a +tuple) against `m`. For example, + +```cpp +using ::testing::_; +using ::testing::AllOf; +using ::testing::Args; +using ::testing::Lt; +... + EXPECT_CALL(foo, Blah) + .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt()))); +``` + +says that `Blah` will be called with arguments `x`, `y`, and `z` where `x < y < +z`. Note that in this example, it wasn't necessary to specify the positional +matchers. + +As a convenience and example, gMock provides some matchers for 2-tuples, +including the `Lt()` matcher above. See +[Multi-argument Matchers](reference/matchers.md#MultiArgMatchers) for the +complete list. + +Note that if you want to pass the arguments to a predicate of your own (e.g. +`.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be written to +take a `std::tuple` as its argument; gMock will pass the `n` selected arguments +as *one* single tuple to the predicate. + +### Using Matchers as Predicates + +Have you noticed that a matcher is just a fancy predicate that also knows how to +describe itself? Many existing algorithms take predicates as arguments (e.g. +those defined in STL's `` header), and it would be a shame if gMock +matchers were not allowed to participate. + +Luckily, you can use a matcher where a unary predicate functor is expected by +wrapping it inside the `Matches()` function. For example, + +```cpp +#include +#include + +using ::testing::Matches; +using ::testing::Ge; + +vector v; +... +// How many elements in v are >= 10? +const int count = count_if(v.begin(), v.end(), Matches(Ge(10))); +``` + +Since you can build complex matchers from simpler ones easily using gMock, this +gives you a way to conveniently construct composite predicates (doing the same +using STL's `` header is just painful). For example, here's a +predicate that's satisfied by any number that is >= 0, <= 100, and != 50: + +```cpp +using ::testing::AllOf; +using ::testing::Ge; +using ::testing::Le; +using ::testing::Matches; +using ::testing::Ne; +... +Matches(AllOf(Ge(0), Le(100), Ne(50))) +``` + +### Using Matchers in googletest Assertions + +See [`EXPECT_THAT`](reference/assertions.md#EXPECT_THAT) in the Assertions +Reference. + +### Using Predicates as Matchers + +gMock provides a set of built-in matchers for matching arguments with expected +values—see the [Matchers Reference](reference/matchers.md) for more information. +In case you find the built-in set lacking, you can use an arbitrary unary +predicate function or functor as a matcher - as long as the predicate accepts a +value of the type you want. You do this by wrapping the predicate inside the +`Truly()` function, for example: + +```cpp +using ::testing::Truly; + +int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; } +... + // Bar() must be called with an even number. + EXPECT_CALL(foo, Bar(Truly(IsEven))); +``` + +Note that the predicate function / functor doesn't have to return `bool`. It +works as long as the return value can be used as the condition in the statement +`if (condition) ...`. + +### Matching Arguments that Are Not Copyable + +When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, gMock saves away a copy of +`bar`. When `Foo()` is called later, gMock compares the argument to `Foo()` with +the saved copy of `bar`. This way, you don't need to worry about `bar` being +modified or destroyed after the `EXPECT_CALL()` is executed. The same is true +when you use matchers like `Eq(bar)`, `Le(bar)`, and so on. + +But what if `bar` cannot be copied (i.e. has no copy constructor)? You could +define your own matcher function or callback and use it with `Truly()`, as the +previous couple of recipes have shown. Or, you may be able to get away from it +if you can guarantee that `bar` won't be changed after the `EXPECT_CALL()` is +executed. Just tell gMock that it should save a reference to `bar`, instead of a +copy of it. Here's how: + +```cpp +using ::testing::Eq; +using ::testing::Lt; +... + // Expects that Foo()'s argument == bar. + EXPECT_CALL(mock_obj, Foo(Eq(std::ref(bar)))); + + // Expects that Foo()'s argument < bar. + EXPECT_CALL(mock_obj, Foo(Lt(std::ref(bar)))); +``` + +Remember: if you do this, don't change `bar` after the `EXPECT_CALL()`, or the +result is undefined. + +### Validating a Member of an Object + +Often a mock function takes a reference to object as an argument. When matching +the argument, you may not want to compare the entire object against a fixed +object, as that may be over-specification. Instead, you may need to validate a +certain member variable or the result of a certain getter method of the object. +You can do this with `Field()` and `Property()`. More specifically, + +```cpp +Field(&Foo::bar, m) +``` + +is a matcher that matches a `Foo` object whose `bar` member variable satisfies +matcher `m`. + +```cpp +Property(&Foo::baz, m) +``` + +is a matcher that matches a `Foo` object whose `baz()` method returns a value +that satisfies matcher `m`. + +For example: + +| Expression | Description | +| :--------------------------- | :--------------------------------------- | +| `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. | +| `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. | + +Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no argument +and be declared as `const`. Don't use `Property()` against member functions that +you do not own, because taking addresses of functions is fragile and generally +not part of the contract of the function. + +`Field()` and `Property()` can also match plain pointers to objects. For +instance, + +```cpp +using ::testing::Field; +using ::testing::Ge; +... +Field(&Foo::number, Ge(3)) +``` + +matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`, the match +will always fail regardless of the inner matcher. + +What if you want to validate more than one members at the same time? Remember +that there are [`AllOf()` and `AllOfArray()`](#CombiningMatchers). + +Finally `Field()` and `Property()` provide overloads that take the field or +property names as the first argument to include it in the error message. This +can be useful when creating combined matchers. + +```cpp +using ::testing::AllOf; +using ::testing::Field; +using ::testing::Matcher; +using ::testing::SafeMatcherCast; + +Matcher IsFoo(const Foo& foo) { + return AllOf(Field("some_field", &Foo::some_field, foo.some_field), + Field("other_field", &Foo::other_field, foo.other_field), + Field("last_field", &Foo::last_field, foo.last_field)); +} +``` + +### Validating the Value Pointed to by a Pointer Argument + +C++ functions often take pointers as arguments. You can use matchers like +`IsNull()`, `NotNull()`, and other comparison matchers to match a pointer, but +what if you want to make sure the value *pointed to* by the pointer, instead of +the pointer itself, has a certain property? Well, you can use the `Pointee(m)` +matcher. + +`Pointee(m)` matches a pointer if and only if `m` matches the value the pointer +points to. For example: + +```cpp +using ::testing::Ge; +using ::testing::Pointee; +... + EXPECT_CALL(foo, Bar(Pointee(Ge(3)))); +``` + +expects `foo.Bar()` to be called with a pointer that points to a value greater +than or equal to 3. + +One nice thing about `Pointee()` is that it treats a `NULL` pointer as a match +failure, so you can write `Pointee(m)` instead of + +```cpp +using ::testing::AllOf; +using ::testing::NotNull; +using ::testing::Pointee; +... + AllOf(NotNull(), Pointee(m)) +``` + +without worrying that a `NULL` pointer will crash your test. + +Also, did we tell you that `Pointee()` works with both raw pointers **and** +smart pointers (`std::unique_ptr`, `std::shared_ptr`, etc)? + +What if you have a pointer to pointer? You guessed it - you can use nested +`Pointee()` to probe deeper inside the value. For example, +`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer that points +to a number less than 3 (what a mouthful...). + +### Defining a Custom Matcher Class {#CustomMatcherClass} + +Most matchers can be simply defined using [the MATCHER* macros](#NewMatchers), +which are terse and flexible, and produce good error messages. However, these +macros are not very explicit about the interfaces they create and are not always +suitable, especially for matchers that will be widely reused. + +For more advanced cases, you may need to define your own matcher class. A custom +matcher allows you to test a specific invariant property of that object. Let's +take a look at how to do so. + +Imagine you have a mock function that takes an object of type `Foo`, which has +an `int bar()` method and an `int baz()` method. You want to constrain that the +argument's `bar()` value plus its `baz()` value is a given number. (This is an +invariant.) Here's how we can write and use a matcher class to do so: + +```cpp +class BarPlusBazEqMatcher { + public: + using is_gtest_matcher = void; + + explicit BarPlusBazEqMatcher(int expected_sum) + : expected_sum_(expected_sum) {} + + bool MatchAndExplain(const Foo& foo, + std::ostream* /* listener */) const { + return (foo.bar() + foo.baz()) == expected_sum_; + } + + void DescribeTo(std::ostream* os) const { + *os << "bar() + baz() equals " << expected_sum_; + } + + void DescribeNegationTo(std::ostream* os) const { + *os << "bar() + baz() does not equal " << expected_sum_; + } + private: + const int expected_sum_; +}; + +::testing::Matcher BarPlusBazEq(int expected_sum) { + return BarPlusBazEqMatcher(expected_sum); +} + +... + Foo foo; + EXPECT_THAT(foo, BarPlusBazEq(5))...; +``` + +### Matching Containers + +Sometimes an STL container (e.g. list, vector, map, ...) is passed to a mock +function and you may want to validate it. Since most STL containers support the +`==` operator, you can write `Eq(expected_container)` or simply +`expected_container` to match a container exactly. + +Sometimes, though, you may want to be more flexible (for example, the first +element must be an exact match, but the second element can be any positive +number, and so on). Also, containers used in tests often have a small number of +elements, and having to define the expected container out-of-line is a bit of a +hassle. + +You can use the `ElementsAre()` or `UnorderedElementsAre()` matcher in such +cases: + +```cpp +using ::testing::_; +using ::testing::ElementsAre; +using ::testing::Gt; +... + MOCK_METHOD(void, Foo, (const vector& numbers), (override)); +... + EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5))); +``` + +The above matcher says that the container must have 4 elements, which must be 1, +greater than 0, anything, and 5 respectively. + +If you instead write: + +```cpp +using ::testing::_; +using ::testing::Gt; +using ::testing::UnorderedElementsAre; +... + MOCK_METHOD(void, Foo, (const vector& numbers), (override)); +... + EXPECT_CALL(mock, Foo(UnorderedElementsAre(1, Gt(0), _, 5))); +``` + +It means that the container must have 4 elements, which (under some permutation) +must be 1, greater than 0, anything, and 5 respectively. + +As an alternative you can place the arguments in a C-style array and use +`ElementsAreArray()` or `UnorderedElementsAreArray()` instead: + +```cpp +using ::testing::ElementsAreArray; +... + // ElementsAreArray accepts an array of element values. + const int expected_vector1[] = {1, 5, 2, 4, ...}; + EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1))); + + // Or, an array of element matchers. + Matcher expected_vector2[] = {1, Gt(2), _, 3, ...}; + EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2))); +``` + +In case the array needs to be dynamically created (and therefore the array size +cannot be inferred by the compiler), you can give `ElementsAreArray()` an +additional argument to specify the array size: + +```cpp +using ::testing::ElementsAreArray; +... + int* const expected_vector3 = new int[count]; + ... fill expected_vector3 with values ... + EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count))); +``` + +Use `Pair` when comparing maps or other associative containers. + +{% raw %} + +```cpp +using ::testing::UnorderedElementsAre; +using ::testing::Pair; +... + absl::flat_hash_map m = {{"a", 1}, {"b", 2}, {"c", 3}}; + EXPECT_THAT(m, UnorderedElementsAre( + Pair("a", 1), Pair("b", 2), Pair("c", 3))); +``` + +{% endraw %} + +**Tips:** + +* `ElementsAre*()` can be used to match *any* container that implements the + STL iterator pattern (i.e. it has a `const_iterator` type and supports + `begin()/end()`), not just the ones defined in STL. It will even work with + container types yet to be written - as long as they follows the above + pattern. +* You can use nested `ElementsAre*()` to match nested (multi-dimensional) + containers. +* If the container is passed by pointer instead of by reference, just write + `Pointee(ElementsAre*(...))`. +* The order of elements *matters* for `ElementsAre*()`. If you are using it + with containers whose element order are undefined (such as a + `std::unordered_map`) you should use `UnorderedElementsAre`. + +### Sharing Matchers + +Under the hood, a gMock matcher object consists of a pointer to a ref-counted +implementation object. Copying matchers is allowed and very efficient, as only +the pointer is copied. When the last matcher that references the implementation +object dies, the implementation object will be deleted. + +Therefore, if you have some complex matcher that you want to use again and +again, there is no need to build it every time. Just assign it to a matcher +variable and use that variable repeatedly! For example, + +```cpp +using ::testing::AllOf; +using ::testing::Gt; +using ::testing::Le; +using ::testing::Matcher; +... + Matcher in_range = AllOf(Gt(5), Le(10)); + ... use in_range as a matcher in multiple EXPECT_CALLs ... +``` + +### Matchers must have no side-effects {#PureMatchers} + +{: .callout .warning} +WARNING: gMock does not guarantee when or how many times a matcher will be +invoked. Therefore, all matchers must be *purely functional*: they cannot have +any side effects, and the match result must not depend on anything other than +the matcher's parameters and the value being matched. + +This requirement must be satisfied no matter how a matcher is defined (e.g., if +it is one of the standard matchers, or a custom matcher). In particular, a +matcher can never call a mock function, as that will affect the state of the +mock object and gMock. + +## Setting Expectations + +### Knowing When to Expect {#UseOnCall} + +**`ON_CALL`** is likely the *single most under-utilized construct* in gMock. + +There are basically two constructs for defining the behavior of a mock object: +`ON_CALL` and `EXPECT_CALL`. The difference? `ON_CALL` defines what happens when +a mock method is called, but doesn't imply any expectation on the method +being called. `EXPECT_CALL` not only defines the behavior, but also sets an +expectation that the method will be called with the given arguments, for the +given number of times (and *in the given order* when you specify the order +too). + +Since `EXPECT_CALL` does more, isn't it better than `ON_CALL`? Not really. Every +`EXPECT_CALL` adds a constraint on the behavior of the code under test. Having +more constraints than necessary is *baaad* - even worse than not having enough +constraints. + +This may be counter-intuitive. How could tests that verify more be worse than +tests that verify less? Isn't verification the whole point of tests? + +The answer lies in *what* a test should verify. **A good test verifies the +contract of the code.** If a test over-specifies, it doesn't leave enough +freedom to the implementation. As a result, changing the implementation without +breaking the contract (e.g. refactoring and optimization), which should be +perfectly fine to do, can break such tests. Then you have to spend time fixing +them, only to see them broken again the next time the implementation is changed. + +Keep in mind that one doesn't have to verify more than one property in one test. +In fact, **it's a good style to verify only one thing in one test.** If you do +that, a bug will likely break only one or two tests instead of dozens (which +case would you rather debug?). If you are also in the habit of giving tests +descriptive names that tell what they verify, you can often easily guess what's +wrong just from the test log itself. + +So use `ON_CALL` by default, and only use `EXPECT_CALL` when you actually intend +to verify that the call is made. For example, you may have a bunch of `ON_CALL`s +in your test fixture to set the common mock behavior shared by all tests in the +same group, and write (scarcely) different `EXPECT_CALL`s in different `TEST_F`s +to verify different aspects of the code's behavior. Compared with the style +where each `TEST` has many `EXPECT_CALL`s, this leads to tests that are more +resilient to implementational changes (and thus less likely to require +maintenance) and makes the intent of the tests more obvious (so they are easier +to maintain when you do need to maintain them). + +If you are bothered by the "Uninteresting mock function call" message printed +when a mock method without an `EXPECT_CALL` is called, you may use a `NiceMock` +instead to suppress all such messages for the mock object, or suppress the +message for specific methods by adding `EXPECT_CALL(...).Times(AnyNumber())`. DO +NOT suppress it by blindly adding an `EXPECT_CALL(...)`, or you'll have a test +that's a pain to maintain. + +### Ignoring Uninteresting Calls + +If you are not interested in how a mock method is called, just don't say +anything about it. In this case, if the method is ever called, gMock will +perform its default action to allow the test program to continue. If you are not +happy with the default action taken by gMock, you can override it using +`DefaultValue::Set()` (described [here](#DefaultValue)) or `ON_CALL()`. + +Please note that once you expressed interest in a particular mock method (via +`EXPECT_CALL()`), all invocations to it must match some expectation. If this +function is called but the arguments don't match any `EXPECT_CALL()` statement, +it will be an error. + +### Disallowing Unexpected Calls + +If a mock method shouldn't be called at all, explicitly say so: + +```cpp +using ::testing::_; +... + EXPECT_CALL(foo, Bar(_)) + .Times(0); +``` + +If some calls to the method are allowed, but the rest are not, just list all the +expected calls: + +```cpp +using ::testing::AnyNumber; +using ::testing::Gt; +... + EXPECT_CALL(foo, Bar(5)); + EXPECT_CALL(foo, Bar(Gt(10))) + .Times(AnyNumber()); +``` + +A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()` statements +will be an error. + +### Understanding Uninteresting vs Unexpected Calls {#uninteresting-vs-unexpected} + +*Uninteresting* calls and *unexpected* calls are different concepts in gMock. +*Very* different. + +A call `x.Y(...)` is **uninteresting** if there's *not even a single* +`EXPECT_CALL(x, Y(...))` set. In other words, the test isn't interested in the +`x.Y()` method at all, as evident in that the test doesn't care to say anything +about it. + +A call `x.Y(...)` is **unexpected** if there are *some* `EXPECT_CALL(x, +Y(...))`s set, but none of them matches the call. Put another way, the test is +interested in the `x.Y()` method (therefore it explicitly sets some +`EXPECT_CALL` to verify how it's called); however, the verification fails as the +test doesn't expect this particular call to happen. + +**An unexpected call is always an error,** as the code under test doesn't behave +the way the test expects it to behave. + +**By default, an uninteresting call is not an error,** as it violates no +constraint specified by the test. (gMock's philosophy is that saying nothing +means there is no constraint.) However, it leads to a warning, as it *might* +indicate a problem (e.g. the test author might have forgotten to specify a +constraint). + +In gMock, `NiceMock` and `StrictMock` can be used to make a mock class "nice" or +"strict". How does this affect uninteresting calls and unexpected calls? + +A **nice mock** suppresses uninteresting call *warnings*. It is less chatty than +the default mock, but otherwise is the same. If a test fails with a default +mock, it will also fail using a nice mock instead. And vice versa. Don't expect +making a mock nice to change the test's result. + +A **strict mock** turns uninteresting call warnings into errors. So making a +mock strict may change the test's result. + +Let's look at an example: + +```cpp +TEST(...) { + NiceMock mock_registry; + EXPECT_CALL(mock_registry, GetDomainOwner("google.com")) + .WillRepeatedly(Return("Larry Page")); + + // Use mock_registry in code under test. + ... &mock_registry ... +} +``` + +The sole `EXPECT_CALL` here says that all calls to `GetDomainOwner()` must have +`"google.com"` as the argument. If `GetDomainOwner("yahoo.com")` is called, it +will be an unexpected call, and thus an error. *Having a nice mock doesn't +change the severity of an unexpected call.* + +So how do we tell gMock that `GetDomainOwner()` can be called with some other +arguments as well? The standard technique is to add a "catch all" `EXPECT_CALL`: + +```cpp + EXPECT_CALL(mock_registry, GetDomainOwner(_)) + .Times(AnyNumber()); // catches all other calls to this method. + EXPECT_CALL(mock_registry, GetDomainOwner("google.com")) + .WillRepeatedly(Return("Larry Page")); +``` + +Remember that `_` is the wildcard matcher that matches anything. With this, if +`GetDomainOwner("google.com")` is called, it will do what the second +`EXPECT_CALL` says; if it is called with a different argument, it will do what +the first `EXPECT_CALL` says. + +Note that the order of the two `EXPECT_CALL`s is important, as a newer +`EXPECT_CALL` takes precedence over an older one. + +For more on uninteresting calls, nice mocks, and strict mocks, read +["The Nice, the Strict, and the Naggy"](#NiceStrictNaggy). + +### Ignoring Uninteresting Arguments {#ParameterlessExpectations} + +If your test doesn't care about the parameters (it only cares about the number +or order of calls), you can often simply omit the parameter list: + +```cpp + // Expect foo.Bar( ... ) twice with any arguments. + EXPECT_CALL(foo, Bar).Times(2); + + // Delegate to the given method whenever the factory is invoked. + ON_CALL(foo_factory, MakeFoo) + .WillByDefault(&BuildFooForTest); +``` + +This functionality is only available when a method is not overloaded; to prevent +unexpected behavior it is a compilation error to try to set an expectation on a +method where the specific overload is ambiguous. You can work around this by +supplying a [simpler mock interface](#SimplerInterfaces) than the mocked class +provides. + +This pattern is also useful when the arguments are interesting, but match logic +is substantially complex. You can leave the argument list unspecified and use +SaveArg actions to [save the values for later verification](#SaveArgVerify). If +you do that, you can easily differentiate calling the method the wrong number of +times from calling it with the wrong arguments. + +### Expecting Ordered Calls {#OrderedCalls} + +Although an `EXPECT_CALL()` statement defined later takes precedence when gMock +tries to match a function call with an expectation, by default calls don't have +to happen in the order `EXPECT_CALL()` statements are written. For example, if +the arguments match the matchers in the second `EXPECT_CALL()`, but not those in +the first and third, then the second expectation will be used. + +If you would rather have all calls occur in the order of the expectations, put +the `EXPECT_CALL()` statements in a block where you define a variable of type +`InSequence`: + +```cpp +using ::testing::_; +using ::testing::InSequence; + + { + InSequence s; + + EXPECT_CALL(foo, DoThis(5)); + EXPECT_CALL(bar, DoThat(_)) + .Times(2); + EXPECT_CALL(foo, DoThis(6)); + } +``` + +In this example, we expect a call to `foo.DoThis(5)`, followed by two calls to +`bar.DoThat()` where the argument can be anything, which are in turn followed by +a call to `foo.DoThis(6)`. If a call occurred out-of-order, gMock will report an +error. + +### Expecting Partially Ordered Calls {#PartialOrder} + +Sometimes requiring everything to occur in a predetermined order can lead to +brittle tests. For example, we may care about `A` occurring before both `B` and +`C`, but aren't interested in the relative order of `B` and `C`. In this case, +the test should reflect our real intent, instead of being overly constraining. + +gMock allows you to impose an arbitrary DAG (directed acyclic graph) on the +calls. One way to express the DAG is to use the +[`After` clause](reference/mocking.md#EXPECT_CALL.After) of `EXPECT_CALL`. + +Another way is via the `InSequence()` clause (not the same as the `InSequence` +class), which we borrowed from jMock 2. It's less flexible than `After()`, but +more convenient when you have long chains of sequential calls, as it doesn't +require you to come up with different names for the expectations in the chains. +Here's how it works: + +If we view `EXPECT_CALL()` statements as nodes in a graph, and add an edge from +node A to node B wherever A must occur before B, we can get a DAG. We use the +term "sequence" to mean a directed path in this DAG. Now, if we decompose the +DAG into sequences, we just need to know which sequences each `EXPECT_CALL()` +belongs to in order to be able to reconstruct the original DAG. + +So, to specify the partial order on the expectations we need to do two things: +first to define some `Sequence` objects, and then for each `EXPECT_CALL()` say +which `Sequence` objects it is part of. + +Expectations in the same sequence must occur in the order they are written. For +example, + +```cpp +using ::testing::Sequence; +... + Sequence s1, s2; + + EXPECT_CALL(foo, A()) + .InSequence(s1, s2); + EXPECT_CALL(bar, B()) + .InSequence(s1); + EXPECT_CALL(bar, C()) + .InSequence(s2); + EXPECT_CALL(foo, D()) + .InSequence(s2); +``` + +specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A -> C -> D`): + +```text + +---> B + | + A ---| + | + +---> C ---> D +``` + +This means that A must occur before B and C, and C must occur before D. There's +no restriction about the order other than these. + +### Controlling When an Expectation Retires + +When a mock method is called, gMock only considers expectations that are still +active. An expectation is active when created, and becomes inactive (aka +*retires*) when a call that has to occur later has occurred. For example, in + +```cpp +using ::testing::_; +using ::testing::Sequence; +... + Sequence s1, s2; + + EXPECT_CALL(log, Log(WARNING, _, "File too large.")) // #1 + .Times(AnyNumber()) + .InSequence(s1, s2); + EXPECT_CALL(log, Log(WARNING, _, "Data set is empty.")) // #2 + .InSequence(s1); + EXPECT_CALL(log, Log(WARNING, _, "User not found.")) // #3 + .InSequence(s2); +``` + +as soon as either #2 or #3 is matched, #1 will retire. If a warning `"File too +large."` is logged after this, it will be an error. + +Note that an expectation doesn't retire automatically when it's saturated. For +example, + +```cpp +using ::testing::_; +... + EXPECT_CALL(log, Log(WARNING, _, _)); // #1 + EXPECT_CALL(log, Log(WARNING, _, "File too large.")); // #2 +``` + +says that there will be exactly one warning with the message `"File too +large."`. If the second warning contains this message too, #2 will match again +and result in an upper-bound-violated error. + +If this is not what you want, you can ask an expectation to retire as soon as it +becomes saturated: + +```cpp +using ::testing::_; +... + EXPECT_CALL(log, Log(WARNING, _, _)); // #1 + EXPECT_CALL(log, Log(WARNING, _, "File too large.")) // #2 + .RetiresOnSaturation(); +``` + +Here #2 can be used only once, so if you have two warnings with the message +`"File too large."`, the first will match #2 and the second will match #1 - +there will be no error. + +## Using Actions + +### Returning References from Mock Methods + +If a mock function's return type is a reference, you need to use `ReturnRef()` +instead of `Return()` to return a result: + +```cpp +using ::testing::ReturnRef; + +class MockFoo : public Foo { + public: + MOCK_METHOD(Bar&, GetBar, (), (override)); +}; +... + MockFoo foo; + Bar bar; + EXPECT_CALL(foo, GetBar()) + .WillOnce(ReturnRef(bar)); +... +``` + +### Returning Live Values from Mock Methods + +The `Return(x)` action saves a copy of `x` when the action is created, and +always returns the same value whenever it's executed. Sometimes you may want to +instead return the *live* value of `x` (i.e. its value at the time when the +action is *executed*.). Use either `ReturnRef()` or `ReturnPointee()` for this +purpose. + +If the mock function's return type is a reference, you can do it using +`ReturnRef(x)`, as shown in the previous recipe ("Returning References from Mock +Methods"). However, gMock doesn't let you use `ReturnRef()` in a mock function +whose return type is not a reference, as doing that usually indicates a user +error. So, what shall you do? + +Though you may be tempted, DO NOT use `std::ref()`: + +```cpp +using ::testing::Return; + +class MockFoo : public Foo { + public: + MOCK_METHOD(int, GetValue, (), (override)); +}; +... + int x = 0; + MockFoo foo; + EXPECT_CALL(foo, GetValue()) + .WillRepeatedly(Return(std::ref(x))); // Wrong! + x = 42; + EXPECT_EQ(foo.GetValue(), 42); +``` + +Unfortunately, it doesn't work here. The above code will fail with error: + +```text +Value of: foo.GetValue() + Actual: 0 +Expected: 42 +``` + +The reason is that `Return(*value*)` converts `value` to the actual return type +of the mock function at the time when the action is *created*, not when it is +*executed*. (This behavior was chosen for the action to be safe when `value` is +a proxy object that references some temporary objects.) As a result, +`std::ref(x)` is converted to an `int` value (instead of a `const int&`) when +the expectation is set, and `Return(std::ref(x))` will always return 0. + +`ReturnPointee(pointer)` was provided to solve this problem specifically. It +returns the value pointed to by `pointer` at the time the action is *executed*: + +```cpp +using ::testing::ReturnPointee; +... + int x = 0; + MockFoo foo; + EXPECT_CALL(foo, GetValue()) + .WillRepeatedly(ReturnPointee(&x)); // Note the & here. + x = 42; + EXPECT_EQ(foo.GetValue(), 42); // This will succeed now. +``` + +### Combining Actions + +Want to do more than one thing when a function is called? That's fine. `DoAll()` +allows you to do a sequence of actions every time. Only the return value of the +last action in the sequence will be used. + +```cpp +using ::testing::_; +using ::testing::DoAll; + +class MockFoo : public Foo { + public: + MOCK_METHOD(bool, Bar, (int n), (override)); +}; +... + EXPECT_CALL(foo, Bar(_)) + .WillOnce(DoAll(action_1, + action_2, + ... + action_n)); +``` + +### Verifying Complex Arguments {#SaveArgVerify} + +If you want to verify that a method is called with a particular argument but the +match criteria is complex, it can be difficult to distinguish between +cardinality failures (calling the method the wrong number of times) and argument +match failures. Similarly, if you are matching multiple parameters, it may not +be easy to distinguishing which argument failed to match. For example: + +```cpp + // Not ideal: this could fail because of a problem with arg1 or arg2, or maybe + // just the method wasn't called. + EXPECT_CALL(foo, SendValues(_, ElementsAre(1, 4, 4, 7), EqualsProto( ... ))); +``` + +You can instead save the arguments and test them individually: + +```cpp + EXPECT_CALL(foo, SendValues) + .WillOnce(DoAll(SaveArg<1>(&actual_array), SaveArg<2>(&actual_proto))); + ... run the test + EXPECT_THAT(actual_array, ElementsAre(1, 4, 4, 7)); + EXPECT_THAT(actual_proto, EqualsProto( ... )); +``` + +### Mocking Side Effects {#MockingSideEffects} + +Sometimes a method exhibits its effect not via returning a value but via side +effects. For example, it may change some global state or modify an output +argument. To mock side effects, in general you can define your own action by +implementing `::testing::ActionInterface`. + +If all you need to do is to change an output argument, the built-in +`SetArgPointee()` action is convenient: + +```cpp +using ::testing::_; +using ::testing::SetArgPointee; + +class MockMutator : public Mutator { + public: + MOCK_METHOD(void, Mutate, (bool mutate, int* value), (override)); + ... +} +... + MockMutator mutator; + EXPECT_CALL(mutator, Mutate(true, _)) + .WillOnce(SetArgPointee<1>(5)); +``` + +In this example, when `mutator.Mutate()` is called, we will assign 5 to the +`int` variable pointed to by argument #1 (0-based). + +`SetArgPointee()` conveniently makes an internal copy of the value you pass to +it, removing the need to keep the value in scope and alive. The implication +however is that the value must have a copy constructor and assignment operator. + +If the mock method also needs to return a value as well, you can chain +`SetArgPointee()` with `Return()` using `DoAll()`, remembering to put the +`Return()` statement last: + +```cpp +using ::testing::_; +using ::testing::DoAll; +using ::testing::Return; +using ::testing::SetArgPointee; + +class MockMutator : public Mutator { + public: + ... + MOCK_METHOD(bool, MutateInt, (int* value), (override)); +} +... + MockMutator mutator; + EXPECT_CALL(mutator, MutateInt(_)) + .WillOnce(DoAll(SetArgPointee<0>(5), + Return(true))); +``` + +Note, however, that if you use the `ReturnOKWith()` method, it will override the +values provided by `SetArgPointee()` in the response parameters of your function +call. + +If the output argument is an array, use the `SetArrayArgument(first, last)` +action instead. It copies the elements in source range `[first, last)` to the +array pointed to by the `N`-th (0-based) argument: + +```cpp +using ::testing::NotNull; +using ::testing::SetArrayArgument; + +class MockArrayMutator : public ArrayMutator { + public: + MOCK_METHOD(void, Mutate, (int* values, int num_values), (override)); + ... +} +... + MockArrayMutator mutator; + int values[5] = {1, 2, 3, 4, 5}; + EXPECT_CALL(mutator, Mutate(NotNull(), 5)) + .WillOnce(SetArrayArgument<0>(values, values + 5)); +``` + +This also works when the argument is an output iterator: + +```cpp +using ::testing::_; +using ::testing::SetArrayArgument; + +class MockRolodex : public Rolodex { + public: + MOCK_METHOD(void, GetNames, (std::back_insert_iterator>), + (override)); + ... +} +... + MockRolodex rolodex; + vector names = {"George", "John", "Thomas"}; + EXPECT_CALL(rolodex, GetNames(_)) + .WillOnce(SetArrayArgument<0>(names.begin(), names.end())); +``` + +### Changing a Mock Object's Behavior Based on the State + +If you expect a call to change the behavior of a mock object, you can use +`::testing::InSequence` to specify different behaviors before and after the +call: + +```cpp +using ::testing::InSequence; +using ::testing::Return; + +... + { + InSequence seq; + EXPECT_CALL(my_mock, IsDirty()) + .WillRepeatedly(Return(true)); + EXPECT_CALL(my_mock, Flush()); + EXPECT_CALL(my_mock, IsDirty()) + .WillRepeatedly(Return(false)); + } + my_mock.FlushIfDirty(); +``` + +This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called +and return `false` afterwards. + +If the behavior change is more complex, you can store the effects in a variable +and make a mock method get its return value from that variable: + +```cpp +using ::testing::_; +using ::testing::SaveArg; +using ::testing::Return; + +ACTION_P(ReturnPointee, p) { return *p; } +... + int previous_value = 0; + EXPECT_CALL(my_mock, GetPrevValue) + .WillRepeatedly(ReturnPointee(&previous_value)); + EXPECT_CALL(my_mock, UpdateValue) + .WillRepeatedly(SaveArg<0>(&previous_value)); + my_mock.DoSomethingToUpdateValue(); +``` + +Here `my_mock.GetPrevValue()` will always return the argument of the last +`UpdateValue()` call. + +### Setting the Default Value for a Return Type {#DefaultValue} + +If a mock method's return type is a built-in C++ type or pointer, by default it +will return 0 when invoked. Also, in C++ 11 and above, a mock method whose +return type has a default constructor will return a default-constructed value by +default. You only need to specify an action if this default value doesn't work +for you. + +Sometimes, you may want to change this default value, or you may want to specify +a default value for types gMock doesn't know about. You can do this using the +`::testing::DefaultValue` class template: + +```cpp +using ::testing::DefaultValue; + +class MockFoo : public Foo { + public: + MOCK_METHOD(Bar, CalculateBar, (), (override)); +}; + + +... + Bar default_bar; + // Sets the default return value for type Bar. + DefaultValue::Set(default_bar); + + MockFoo foo; + + // We don't need to specify an action here, as the default + // return value works for us. + EXPECT_CALL(foo, CalculateBar()); + + foo.CalculateBar(); // This should return default_bar. + + // Unsets the default return value. + DefaultValue::Clear(); +``` + +Please note that changing the default value for a type can make your tests hard +to understand. We recommend you to use this feature judiciously. For example, +you may want to make sure the `Set()` and `Clear()` calls are right next to the +code that uses your mock. + +### Setting the Default Actions for a Mock Method + +You've learned how to change the default value of a given type. However, this +may be too coarse for your purpose: perhaps you have two mock methods with the +same return type and you want them to have different behaviors. The `ON_CALL()` +macro allows you to customize your mock's behavior at the method level: + +```cpp +using ::testing::_; +using ::testing::AnyNumber; +using ::testing::Gt; +using ::testing::Return; +... + ON_CALL(foo, Sign(_)) + .WillByDefault(Return(-1)); + ON_CALL(foo, Sign(0)) + .WillByDefault(Return(0)); + ON_CALL(foo, Sign(Gt(0))) + .WillByDefault(Return(1)); + + EXPECT_CALL(foo, Sign(_)) + .Times(AnyNumber()); + + foo.Sign(5); // This should return 1. + foo.Sign(-9); // This should return -1. + foo.Sign(0); // This should return 0. +``` + +As you may have guessed, when there are more than one `ON_CALL()` statements, +the newer ones in the order take precedence over the older ones. In other words, +the **last** one that matches the function arguments will be used. This matching +order allows you to set up the common behavior in a mock object's constructor or +the test fixture's set-up phase and specialize the mock's behavior later. + +Note that both `ON_CALL` and `EXPECT_CALL` have the same "later statements take +precedence" rule, but they don't interact. That is, `EXPECT_CALL`s have their +own precedence order distinct from the `ON_CALL` precedence order. + +### Using Functions/Methods/Functors/Lambdas as Actions {#FunctionsAsActions} + +If the built-in actions don't suit you, you can use an existing callable +(function, `std::function`, method, functor, lambda) as an action. + +```cpp +using ::testing::_; using ::testing::Invoke; + +class MockFoo : public Foo { + public: + MOCK_METHOD(int, Sum, (int x, int y), (override)); + MOCK_METHOD(bool, ComplexJob, (int x), (override)); +}; + +int CalculateSum(int x, int y) { return x + y; } +int Sum3(int x, int y, int z) { return x + y + z; } + +class Helper { + public: + bool ComplexJob(int x); +}; + +... + MockFoo foo; + Helper helper; + EXPECT_CALL(foo, Sum(_, _)) + .WillOnce(&CalculateSum) + .WillRepeatedly(Invoke(NewPermanentCallback(Sum3, 1))); + EXPECT_CALL(foo, ComplexJob(_)) + .WillOnce(Invoke(&helper, &Helper::ComplexJob)) + .WillOnce([] { return true; }) + .WillRepeatedly([](int x) { return x > 0; }); + + foo.Sum(5, 6); // Invokes CalculateSum(5, 6). + foo.Sum(2, 3); // Invokes Sum3(1, 2, 3). + foo.ComplexJob(10); // Invokes helper.ComplexJob(10). + foo.ComplexJob(-1); // Invokes the inline lambda. +``` + +The only requirement is that the type of the function, etc must be *compatible* +with the signature of the mock function, meaning that the latter's arguments (if +it takes any) can be implicitly converted to the corresponding arguments of the +former, and the former's return type can be implicitly converted to that of the +latter. So, you can invoke something whose type is *not* exactly the same as the +mock function, as long as it's safe to do so - nice, huh? + +Note that: + +* The action takes ownership of the callback and will delete it when the + action itself is destructed. +* If the type of a callback is derived from a base callback type `C`, you need + to implicitly cast it to `C` to resolve the overloading, e.g. + + ```cpp + using ::testing::Invoke; + ... + ResultCallback* is_ok = ...; + ... Invoke(is_ok) ...; // This works. + + BlockingClosure* done = new BlockingClosure; + ... Invoke(implicit_cast(done)) ...; // The cast is necessary. + ``` + +### Using Functions with Extra Info as Actions + +The function or functor you call using `Invoke()` must have the same number of +arguments as the mock function you use it for. Sometimes you may have a function +that takes more arguments, and you are willing to pass in the extra arguments +yourself to fill the gap. You can do this in gMock using callbacks with +pre-bound arguments. Here's an example: + +```cpp +using ::testing::Invoke; + +class MockFoo : public Foo { + public: + MOCK_METHOD(char, DoThis, (int n), (override)); +}; + +char SignOfSum(int x, int y) { + const int sum = x + y; + return (sum > 0) ? '+' : (sum < 0) ? '-' : '0'; +} + +TEST_F(FooTest, Test) { + MockFoo foo; + + EXPECT_CALL(foo, DoThis(2)) + .WillOnce(Invoke(NewPermanentCallback(SignOfSum, 5))); + EXPECT_EQ(foo.DoThis(2), '+'); // Invokes SignOfSum(5, 2). +} +``` + +### Invoking a Function/Method/Functor/Lambda/Callback Without Arguments + +`Invoke()` passes the mock function's arguments to the function, etc being +invoked such that the callee has the full context of the call to work with. If +the invoked function is not interested in some or all of the arguments, it can +simply ignore them. + +Yet, a common pattern is that a test author wants to invoke a function without +the arguments of the mock function. She could do that using a wrapper function +that throws away the arguments before invoking an underlining nullary function. +Needless to say, this can be tedious and obscures the intent of the test. + +There are two solutions to this problem. First, you can pass any callable of +zero args as an action. Alternatively, use `InvokeWithoutArgs()`, which is like +`Invoke()` except that it doesn't pass the mock function's arguments to the +callee. Here's an example of each: + +```cpp +using ::testing::_; +using ::testing::InvokeWithoutArgs; + +class MockFoo : public Foo { + public: + MOCK_METHOD(bool, ComplexJob, (int n), (override)); +}; + +bool Job1() { ... } +bool Job2(int n, char c) { ... } + +... + MockFoo foo; + EXPECT_CALL(foo, ComplexJob(_)) + .WillOnce([] { Job1(); }); + .WillOnce(InvokeWithoutArgs(NewPermanentCallback(Job2, 5, 'a'))); + + foo.ComplexJob(10); // Invokes Job1(). + foo.ComplexJob(20); // Invokes Job2(5, 'a'). +``` + +Note that: + +* The action takes ownership of the callback and will delete it when the + action itself is destructed. +* If the type of a callback is derived from a base callback type `C`, you need + to implicitly cast it to `C` to resolve the overloading, e.g. + + ```cpp + using ::testing::InvokeWithoutArgs; + ... + ResultCallback* is_ok = ...; + ... InvokeWithoutArgs(is_ok) ...; // This works. + + BlockingClosure* done = ...; + ... InvokeWithoutArgs(implicit_cast(done)) ...; + // The cast is necessary. + ``` + +### Invoking an Argument of the Mock Function + +Sometimes a mock function will receive a function pointer, a functor (in other +words, a "callable") as an argument, e.g. + +```cpp +class MockFoo : public Foo { + public: + MOCK_METHOD(bool, DoThis, (int n, (ResultCallback1* callback)), + (override)); +}; +``` + +and you may want to invoke this callable argument: + +```cpp +using ::testing::_; +... + MockFoo foo; + EXPECT_CALL(foo, DoThis(_, _)) + .WillOnce(...); + // Will execute callback->Run(5), where callback is the + // second argument DoThis() receives. +``` + +{: .callout .note} +NOTE: The section below is legacy documentation from before C++ had lambdas: + +Arghh, you need to refer to a mock function argument but C++ has no lambda +(yet), so you have to define your own action. :-( Or do you really? + +Well, gMock has an action to solve *exactly* this problem: + +```cpp +InvokeArgument(arg_1, arg_2, ..., arg_m) +``` + +will invoke the `N`-th (0-based) argument the mock function receives, with +`arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is a function +pointer, a functor, or a callback. gMock handles them all. + +With that, you could write: + +```cpp +using ::testing::_; +using ::testing::InvokeArgument; +... + EXPECT_CALL(foo, DoThis(_, _)) + .WillOnce(InvokeArgument<1>(5)); + // Will execute callback->Run(5), where callback is the + // second argument DoThis() receives. +``` + +What if the callable takes an argument by reference? No problem - just wrap it +inside `std::ref()`: + +```cpp + ... + MOCK_METHOD(bool, Bar, + ((ResultCallback2* callback)), + (override)); + ... + using ::testing::_; + using ::testing::InvokeArgument; + ... + MockFoo foo; + Helper helper; + ... + EXPECT_CALL(foo, Bar(_)) + .WillOnce(InvokeArgument<0>(5, std::ref(helper))); + // std::ref(helper) guarantees that a reference to helper, not a copy of + // it, will be passed to the callback. +``` + +What if the callable takes an argument by reference and we do **not** wrap the +argument in `std::ref()`? Then `InvokeArgument()` will *make a copy* of the +argument, and pass a *reference to the copy*, instead of a reference to the +original value, to the callable. This is especially handy when the argument is a +temporary value: + +```cpp + ... + MOCK_METHOD(bool, DoThat, (bool (*f)(const double& x, const string& s)), + (override)); + ... + using ::testing::_; + using ::testing::InvokeArgument; + ... + MockFoo foo; + ... + EXPECT_CALL(foo, DoThat(_)) + .WillOnce(InvokeArgument<0>(5.0, string("Hi"))); + // Will execute (*f)(5.0, string("Hi")), where f is the function pointer + // DoThat() receives. Note that the values 5.0 and string("Hi") are + // temporary and dead once the EXPECT_CALL() statement finishes. Yet + // it's fine to perform this action later, since a copy of the values + // are kept inside the InvokeArgument action. +``` + +### Ignoring an Action's Result + +Sometimes you have an action that returns *something*, but you need an action +that returns `void` (perhaps you want to use it in a mock function that returns +`void`, or perhaps it needs to be used in `DoAll()` and it's not the last in the +list). `IgnoreResult()` lets you do that. For example: + +```cpp +using ::testing::_; +using ::testing::DoAll; +using ::testing::IgnoreResult; +using ::testing::Return; + +int Process(const MyData& data); +string DoSomething(); + +class MockFoo : public Foo { + public: + MOCK_METHOD(void, Abc, (const MyData& data), (override)); + MOCK_METHOD(bool, Xyz, (), (override)); +}; + + ... + MockFoo foo; + EXPECT_CALL(foo, Abc(_)) + // .WillOnce(Invoke(Process)); + // The above line won't compile as Process() returns int but Abc() needs + // to return void. + .WillOnce(IgnoreResult(Process)); + EXPECT_CALL(foo, Xyz()) + .WillOnce(DoAll(IgnoreResult(DoSomething), + // Ignores the string DoSomething() returns. + Return(true))); +``` + +Note that you **cannot** use `IgnoreResult()` on an action that already returns +`void`. Doing so will lead to ugly compiler errors. + +### Selecting an Action's Arguments {#SelectingArgs} + +Say you have a mock function `Foo()` that takes seven arguments, and you have a +custom action that you want to invoke when `Foo()` is called. Trouble is, the +custom action only wants three arguments: + +```cpp +using ::testing::_; +using ::testing::Invoke; +... + MOCK_METHOD(bool, Foo, + (bool visible, const string& name, int x, int y, + (const map>), double& weight, double min_weight, + double max_wight)); +... +bool IsVisibleInQuadrant1(bool visible, int x, int y) { + return visible && x >= 0 && y >= 0; +} +... + EXPECT_CALL(mock, Foo) + .WillOnce(Invoke(IsVisibleInQuadrant1)); // Uh, won't compile. :-( +``` + +To please the compiler God, you need to define an "adaptor" that has the same +signature as `Foo()` and calls the custom action with the right arguments: + +```cpp +using ::testing::_; +using ::testing::Invoke; +... +bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y, + const map, double>& weight, + double min_weight, double max_wight) { + return IsVisibleInQuadrant1(visible, x, y); +} +... + EXPECT_CALL(mock, Foo) + .WillOnce(Invoke(MyIsVisibleInQuadrant1)); // Now it works. +``` + +But isn't this awkward? + +gMock provides a generic *action adaptor*, so you can spend your time minding +more important business than writing your own adaptors. Here's the syntax: + +```cpp +WithArgs(action) +``` + +creates an action that passes the arguments of the mock function at the given +indices (0-based) to the inner `action` and performs it. Using `WithArgs`, our +original example can be written as: + +```cpp +using ::testing::_; +using ::testing::Invoke; +using ::testing::WithArgs; +... + EXPECT_CALL(mock, Foo) + .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1))); // No need to define your own adaptor. +``` + +For better readability, gMock also gives you: + +* `WithoutArgs(action)` when the inner `action` takes *no* argument, and +* `WithArg(action)` (no `s` after `Arg`) when the inner `action` takes + *one* argument. + +As you may have realized, `InvokeWithoutArgs(...)` is just syntactic sugar for +`WithoutArgs(Invoke(...))`. + +Here are more tips: + +* The inner action used in `WithArgs` and friends does not have to be + `Invoke()` -- it can be anything. +* You can repeat an argument in the argument list if necessary, e.g. + `WithArgs<2, 3, 3, 5>(...)`. +* You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`. +* The types of the selected arguments do *not* have to match the signature of + the inner action exactly. It works as long as they can be implicitly + converted to the corresponding arguments of the inner action. For example, + if the 4-th argument of the mock function is an `int` and `my_action` takes + a `double`, `WithArg<4>(my_action)` will work. + +### Ignoring Arguments in Action Functions + +The [selecting-an-action's-arguments](#SelectingArgs) recipe showed us one way +to make a mock function and an action with incompatible argument lists fit +together. The downside is that wrapping the action in `WithArgs<...>()` can get +tedious for people writing the tests. + +If you are defining a function (or method, functor, lambda, callback) to be used +with `Invoke*()`, and you are not interested in some of its arguments, an +alternative to `WithArgs` is to declare the uninteresting arguments as `Unused`. +This makes the definition less cluttered and less fragile in case the types of +the uninteresting arguments change. It could also increase the chance the action +function can be reused. For example, given + +```cpp + public: + MOCK_METHOD(double, Foo, double(const string& label, double x, double y), + (override)); + MOCK_METHOD(double, Bar, (int index, double x, double y), (override)); +``` + +instead of + +```cpp +using ::testing::_; +using ::testing::Invoke; + +double DistanceToOriginWithLabel(const string& label, double x, double y) { + return sqrt(x*x + y*y); +} +double DistanceToOriginWithIndex(int index, double x, double y) { + return sqrt(x*x + y*y); +} +... + EXPECT_CALL(mock, Foo("abc", _, _)) + .WillOnce(Invoke(DistanceToOriginWithLabel)); + EXPECT_CALL(mock, Bar(5, _, _)) + .WillOnce(Invoke(DistanceToOriginWithIndex)); +``` + +you could write + +```cpp +using ::testing::_; +using ::testing::Invoke; +using ::testing::Unused; + +double DistanceToOrigin(Unused, double x, double y) { + return sqrt(x*x + y*y); +} +... + EXPECT_CALL(mock, Foo("abc", _, _)) + .WillOnce(Invoke(DistanceToOrigin)); + EXPECT_CALL(mock, Bar(5, _, _)) + .WillOnce(Invoke(DistanceToOrigin)); +``` + +### Sharing Actions + +Just like matchers, a gMock action object consists of a pointer to a ref-counted +implementation object. Therefore copying actions is also allowed and very +efficient. When the last action that references the implementation object dies, +the implementation object will be deleted. + +If you have some complex action that you want to use again and again, you may +not have to build it from scratch every time. If the action doesn't have an +internal state (i.e. if it always does the same thing no matter how many times +it has been called), you can assign it to an action variable and use that +variable repeatedly. For example: + +```cpp +using ::testing::Action; +using ::testing::DoAll; +using ::testing::Return; +using ::testing::SetArgPointee; +... + Action set_flag = DoAll(SetArgPointee<0>(5), + Return(true)); + ... use set_flag in .WillOnce() and .WillRepeatedly() ... +``` + +However, if the action has its own state, you may be surprised if you share the +action object. Suppose you have an action factory `IncrementCounter(init)` which +creates an action that increments and returns a counter whose initial value is +`init`, using two actions created from the same expression and using a shared +action will exhibit different behaviors. Example: + +```cpp + EXPECT_CALL(foo, DoThis()) + .WillRepeatedly(IncrementCounter(0)); + EXPECT_CALL(foo, DoThat()) + .WillRepeatedly(IncrementCounter(0)); + foo.DoThis(); // Returns 1. + foo.DoThis(); // Returns 2. + foo.DoThat(); // Returns 1 - DoThat() uses a different + // counter than DoThis()'s. +``` + +versus + +```cpp +using ::testing::Action; +... + Action increment = IncrementCounter(0); + EXPECT_CALL(foo, DoThis()) + .WillRepeatedly(increment); + EXPECT_CALL(foo, DoThat()) + .WillRepeatedly(increment); + foo.DoThis(); // Returns 1. + foo.DoThis(); // Returns 2. + foo.DoThat(); // Returns 3 - the counter is shared. +``` + +### Testing Asynchronous Behavior + +One oft-encountered problem with gMock is that it can be hard to test +asynchronous behavior. Suppose you had a `EventQueue` class that you wanted to +test, and you created a separate `EventDispatcher` interface so that you could +easily mock it out. However, the implementation of the class fired all the +events on a background thread, which made test timings difficult. You could just +insert `sleep()` statements and hope for the best, but that makes your test +behavior nondeterministic. A better way is to use gMock actions and +`Notification` objects to force your asynchronous test to behave synchronously. + +```cpp +class MockEventDispatcher : public EventDispatcher { + MOCK_METHOD(bool, DispatchEvent, (int32), (override)); +}; + +TEST(EventQueueTest, EnqueueEventTest) { + MockEventDispatcher mock_event_dispatcher; + EventQueue event_queue(&mock_event_dispatcher); + + const int32 kEventId = 321; + absl::Notification done; + EXPECT_CALL(mock_event_dispatcher, DispatchEvent(kEventId)) + .WillOnce([&done] { done.Notify(); }); + + event_queue.EnqueueEvent(kEventId); + done.WaitForNotification(); +} +``` + +In the example above, we set our normal gMock expectations, but then add an +additional action to notify the `Notification` object. Now we can just call +`Notification::WaitForNotification()` in the main thread to wait for the +asynchronous call to finish. After that, our test suite is complete and we can +safely exit. + +{: .callout .note} +Note: this example has a downside: namely, if the expectation is not satisfied, +our test will run forever. It will eventually time-out and fail, but it will +take longer and be slightly harder to debug. To alleviate this problem, you can +use `WaitForNotificationWithTimeout(ms)` instead of `WaitForNotification()`. + +## Misc Recipes on Using gMock + +### Mocking Methods That Use Move-Only Types + +C++11 introduced *move-only types*. A move-only-typed value can be moved from +one object to another, but cannot be copied. `std::unique_ptr` is probably +the most commonly used move-only type. + +Mocking a method that takes and/or returns move-only types presents some +challenges, but nothing insurmountable. This recipe shows you how you can do it. +Note that the support for move-only method arguments was only introduced to +gMock in April 2017; in older code, you may find more complex +[workarounds](#LegacyMoveOnly) for lack of this feature. + +Let’s say we are working on a fictional project that lets one post and share +snippets called “buzzes”. Your code uses these types: + +```cpp +enum class AccessLevel { kInternal, kPublic }; + +class Buzz { + public: + explicit Buzz(AccessLevel access) { ... } + ... +}; + +class Buzzer { + public: + virtual ~Buzzer() {} + virtual std::unique_ptr MakeBuzz(StringPiece text) = 0; + virtual bool ShareBuzz(std::unique_ptr buzz, int64_t timestamp) = 0; + ... +}; +``` + +A `Buzz` object represents a snippet being posted. A class that implements the +`Buzzer` interface is capable of creating and sharing `Buzz`es. Methods in +`Buzzer` may return a `unique_ptr` or take a `unique_ptr`. Now we +need to mock `Buzzer` in our tests. + +To mock a method that accepts or returns move-only types, you just use the +familiar `MOCK_METHOD` syntax as usual: + +```cpp +class MockBuzzer : public Buzzer { + public: + MOCK_METHOD(std::unique_ptr, MakeBuzz, (StringPiece text), (override)); + MOCK_METHOD(bool, ShareBuzz, (std::unique_ptr buzz, int64_t timestamp), + (override)); +}; +``` + +Now that we have the mock class defined, we can use it in tests. In the +following code examples, we assume that we have defined a `MockBuzzer` object +named `mock_buzzer_`: + +```cpp + MockBuzzer mock_buzzer_; +``` + +First let’s see how we can set expectations on the `MakeBuzz()` method, which +returns a `unique_ptr`. + +As usual, if you set an expectation without an action (i.e. the `.WillOnce()` or +`.WillRepeatedly()` clause), when that expectation fires, the default action for +that method will be taken. Since `unique_ptr<>` has a default constructor that +returns a null `unique_ptr`, that’s what you’ll get if you don’t specify an +action: + +```cpp +using ::testing::IsNull; +... + // Use the default action. + EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")); + + // Triggers the previous EXPECT_CALL. + EXPECT_THAT(mock_buzzer_.MakeBuzz("hello"), IsNull()); +``` + +If you are not happy with the default action, you can tweak it as usual; see +[Setting Default Actions](#OnCall). + +If you just need to return a move-only value, you can use it in combination with +`WillOnce`. For example: + +```cpp + EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")) + .WillOnce(Return(std::make_unique(AccessLevel::kInternal))); + EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("hello")); +``` + +Quiz time! What do you think will happen if a `Return` action is performed more +than once (e.g. you write `... .WillRepeatedly(Return(std::move(...)));`)? Come +think of it, after the first time the action runs, the source value will be +consumed (since it’s a move-only value), so the next time around, there’s no +value to move from -- you’ll get a run-time error that `Return(std::move(...))` +can only be run once. + +If you need your mock method to do more than just moving a pre-defined value, +remember that you can always use a lambda or a callable object, which can do +pretty much anything you want: + +```cpp + EXPECT_CALL(mock_buzzer_, MakeBuzz("x")) + .WillRepeatedly([](StringPiece text) { + return std::make_unique(AccessLevel::kInternal); + }); + + EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x")); + EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x")); +``` + +Every time this `EXPECT_CALL` fires, a new `unique_ptr` will be created +and returned. You cannot do this with `Return(std::make_unique<...>(...))`. + +That covers returning move-only values; but how do we work with methods +accepting move-only arguments? The answer is that they work normally, although +some actions will not compile when any of method's arguments are move-only. You +can always use `Return`, or a [lambda or functor](#FunctionsAsActions): + +```cpp + using ::testing::Unused; + + EXPECT_CALL(mock_buzzer_, ShareBuzz(NotNull(), _)).WillOnce(Return(true)); + EXPECT_TRUE(mock_buzzer_.ShareBuzz(std::make_unique(AccessLevel::kInternal)), + 0); + + EXPECT_CALL(mock_buzzer_, ShareBuzz(_, _)).WillOnce( + [](std::unique_ptr buzz, Unused) { return buzz != nullptr; }); + EXPECT_FALSE(mock_buzzer_.ShareBuzz(nullptr, 0)); +``` + +Many built-in actions (`WithArgs`, `WithoutArgs`,`DeleteArg`, `SaveArg`, ...) +could in principle support move-only arguments, but the support for this is not +implemented yet. If this is blocking you, please file a bug. + +A few actions (e.g. `DoAll`) copy their arguments internally, so they can never +work with non-copyable objects; you'll have to use functors instead. + +#### Legacy workarounds for move-only types {#LegacyMoveOnly} + +Support for move-only function arguments was only introduced to gMock in April +of 2017. In older code, you may encounter the following workaround for the lack +of this feature (it is no longer necessary - we're including it just for +reference): + +```cpp +class MockBuzzer : public Buzzer { + public: + MOCK_METHOD(bool, DoShareBuzz, (Buzz* buzz, Time timestamp)); + bool ShareBuzz(std::unique_ptr buzz, Time timestamp) override { + return DoShareBuzz(buzz.get(), timestamp); + } +}; +``` + +The trick is to delegate the `ShareBuzz()` method to a mock method (let’s call +it `DoShareBuzz()`) that does not take move-only parameters. Then, instead of +setting expectations on `ShareBuzz()`, you set them on the `DoShareBuzz()` mock +method: + +```cpp + MockBuzzer mock_buzzer_; + EXPECT_CALL(mock_buzzer_, DoShareBuzz(NotNull(), _)); + + // When one calls ShareBuzz() on the MockBuzzer like this, the call is + // forwarded to DoShareBuzz(), which is mocked. Therefore this statement + // will trigger the above EXPECT_CALL. + mock_buzzer_.ShareBuzz(std::make_unique(AccessLevel::kInternal), 0); +``` + +### Making the Compilation Faster + +Believe it or not, the *vast majority* of the time spent on compiling a mock +class is in generating its constructor and destructor, as they perform +non-trivial tasks (e.g. verification of the expectations). What's more, mock +methods with different signatures have different types and thus their +constructors/destructors need to be generated by the compiler separately. As a +result, if you mock many different types of methods, compiling your mock class +can get really slow. + +If you are experiencing slow compilation, you can move the definition of your +mock class' constructor and destructor out of the class body and into a `.cc` +file. This way, even if you `#include` your mock class in N files, the compiler +only needs to generate its constructor and destructor once, resulting in a much +faster compilation. + +Let's illustrate the idea using an example. Here's the definition of a mock +class before applying this recipe: + +```cpp +// File mock_foo.h. +... +class MockFoo : public Foo { + public: + // Since we don't declare the constructor or the destructor, + // the compiler will generate them in every translation unit + // where this mock class is used. + + MOCK_METHOD(int, DoThis, (), (override)); + MOCK_METHOD(bool, DoThat, (const char* str), (override)); + ... more mock methods ... +}; +``` + +After the change, it would look like: + +```cpp +// File mock_foo.h. +... +class MockFoo : public Foo { + public: + // The constructor and destructor are declared, but not defined, here. + MockFoo(); + virtual ~MockFoo(); + + MOCK_METHOD(int, DoThis, (), (override)); + MOCK_METHOD(bool, DoThat, (const char* str), (override)); + ... more mock methods ... +}; +``` + +and + +```cpp +// File mock_foo.cc. +#include "path/to/mock_foo.h" + +// The definitions may appear trivial, but the functions actually do a +// lot of things through the constructors/destructors of the member +// variables used to implement the mock methods. +MockFoo::MockFoo() {} +MockFoo::~MockFoo() {} +``` + +### Forcing a Verification + +When it's being destroyed, your friendly mock object will automatically verify +that all expectations on it have been satisfied, and will generate googletest +failures if not. This is convenient as it leaves you with one less thing to +worry about. That is, unless you are not sure if your mock object will be +destroyed. + +How could it be that your mock object won't eventually be destroyed? Well, it +might be created on the heap and owned by the code you are testing. Suppose +there's a bug in that code and it doesn't delete the mock object properly - you +could end up with a passing test when there's actually a bug. + +Using a heap checker is a good idea and can alleviate the concern, but its +implementation is not 100% reliable. So, sometimes you do want to *force* gMock +to verify a mock object before it is (hopefully) destructed. You can do this +with `Mock::VerifyAndClearExpectations(&mock_object)`: + +```cpp +TEST(MyServerTest, ProcessesRequest) { + using ::testing::Mock; + + MockFoo* const foo = new MockFoo; + EXPECT_CALL(*foo, ...)...; + // ... other expectations ... + + // server now owns foo. + MyServer server(foo); + server.ProcessRequest(...); + + // In case that server's destructor will forget to delete foo, + // this will verify the expectations anyway. + Mock::VerifyAndClearExpectations(foo); +} // server is destroyed when it goes out of scope here. +``` + +{: .callout .tip} +**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a `bool` to +indicate whether the verification was successful (`true` for yes), so you can +wrap that function call inside a `ASSERT_TRUE()` if there is no point going +further when the verification has failed. + +Do not set new expectations after verifying and clearing a mock after its use. +Setting expectations after code that exercises the mock has undefined behavior. +See [Using Mocks in Tests](gmock_for_dummies.md#using-mocks-in-tests) for more +information. + +### Using Checkpoints {#UsingCheckPoints} + +Sometimes you might want to test a mock object's behavior in phases whose sizes +are each manageable, or you might want to set more detailed expectations about +which API calls invoke which mock functions. + +A technique you can use is to put the expectations in a sequence and insert +calls to a dummy "checkpoint" function at specific places. Then you can verify +that the mock function calls do happen at the right time. For example, if you +are exercising the code: + +```cpp + Foo(1); + Foo(2); + Foo(3); +``` + +and want to verify that `Foo(1)` and `Foo(3)` both invoke `mock.Bar("a")`, but +`Foo(2)` doesn't invoke anything, you can write: + +```cpp +using ::testing::MockFunction; + +TEST(FooTest, InvokesBarCorrectly) { + MyMock mock; + // Class MockFunction has exactly one mock method. It is named + // Call() and has type F. + MockFunction check; + { + InSequence s; + + EXPECT_CALL(mock, Bar("a")); + EXPECT_CALL(check, Call("1")); + EXPECT_CALL(check, Call("2")); + EXPECT_CALL(mock, Bar("a")); + } + Foo(1); + check.Call("1"); + Foo(2); + check.Call("2"); + Foo(3); +} +``` + +The expectation spec says that the first `Bar("a")` call must happen before +checkpoint "1", the second `Bar("a")` call must happen after checkpoint "2", and +nothing should happen between the two checkpoints. The explicit checkpoints make +it clear which `Bar("a")` is called by which call to `Foo()`. + +### Mocking Destructors + +Sometimes you want to make sure a mock object is destructed at the right time, +e.g. after `bar->A()` is called but before `bar->B()` is called. We already know +that you can specify constraints on the [order](#OrderedCalls) of mock function +calls, so all we need to do is to mock the destructor of the mock function. + +This sounds simple, except for one problem: a destructor is a special function +with special syntax and special semantics, and the `MOCK_METHOD` macro doesn't +work for it: + +```cpp +MOCK_METHOD(void, ~MockFoo, ()); // Won't compile! +``` + +The good news is that you can use a simple pattern to achieve the same effect. +First, add a mock function `Die()` to your mock class and call it in the +destructor, like this: + +```cpp +class MockFoo : public Foo { + ... + // Add the following two lines to the mock class. + MOCK_METHOD(void, Die, ()); + ~MockFoo() override { Die(); } +}; +``` + +(If the name `Die()` clashes with an existing symbol, choose another name.) Now, +we have translated the problem of testing when a `MockFoo` object dies to +testing when its `Die()` method is called: + +```cpp + MockFoo* foo = new MockFoo; + MockBar* bar = new MockBar; + ... + { + InSequence s; + + // Expects *foo to die after bar->A() and before bar->B(). + EXPECT_CALL(*bar, A()); + EXPECT_CALL(*foo, Die()); + EXPECT_CALL(*bar, B()); + } +``` + +And that's that. + +### Using gMock and Threads {#UsingThreads} + +In a **unit** test, it's best if you could isolate and test a piece of code in a +single-threaded context. That avoids race conditions and dead locks, and makes +debugging your test much easier. + +Yet most programs are multi-threaded, and sometimes to test something we need to +pound on it from more than one thread. gMock works for this purpose too. + +Remember the steps for using a mock: + +1. Create a mock object `foo`. +2. Set its default actions and expectations using `ON_CALL()` and + `EXPECT_CALL()`. +3. The code under test calls methods of `foo`. +4. Optionally, verify and reset the mock. +5. Destroy the mock yourself, or let the code under test destroy it. The + destructor will automatically verify it. + +If you follow the following simple rules, your mocks and threads can live +happily together: + +* Execute your *test code* (as opposed to the code being tested) in *one* + thread. This makes your test easy to follow. +* Obviously, you can do step #1 without locking. +* When doing step #2 and #5, make sure no other thread is accessing `foo`. + Obvious too, huh? +* #3 and #4 can be done either in one thread or in multiple threads - anyway + you want. gMock takes care of the locking, so you don't have to do any - + unless required by your test logic. + +If you violate the rules (for example, if you set expectations on a mock while +another thread is calling its methods), you get undefined behavior. That's not +fun, so don't do it. + +gMock guarantees that the action for a mock function is done in the same thread +that called the mock function. For example, in + +```cpp + EXPECT_CALL(mock, Foo(1)) + .WillOnce(action1); + EXPECT_CALL(mock, Foo(2)) + .WillOnce(action2); +``` + +if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2, gMock will +execute `action1` in thread 1 and `action2` in thread 2. + +gMock does *not* impose a sequence on actions performed in different threads +(doing so may create deadlocks as the actions may need to cooperate). This means +that the execution of `action1` and `action2` in the above example *may* +interleave. If this is a problem, you should add proper synchronization logic to +`action1` and `action2` to make the test thread-safe. + +Also, remember that `DefaultValue` is a global resource that potentially +affects *all* living mock objects in your program. Naturally, you won't want to +mess with it from multiple threads or when there still are mocks in action. + +### Controlling How Much Information gMock Prints + +When gMock sees something that has the potential of being an error (e.g. a mock +function with no expectation is called, a.k.a. an uninteresting call, which is +allowed but perhaps you forgot to explicitly ban the call), it prints some +warning messages, including the arguments of the function, the return value, and +the stack trace. Hopefully this will remind you to take a look and see if there +is indeed a problem. + +Sometimes you are confident that your tests are correct and may not appreciate +such friendly messages. Some other times, you are debugging your tests or +learning about the behavior of the code you are testing, and wish you could +observe every mock call that happens (including argument values, the return +value, and the stack trace). Clearly, one size doesn't fit all. + +You can control how much gMock tells you using the `--gmock_verbose=LEVEL` +command-line flag, where `LEVEL` is a string with three possible values: + +* `info`: gMock will print all informational messages, warnings, and errors + (most verbose). At this setting, gMock will also log any calls to the + `ON_CALL/EXPECT_CALL` macros. It will include a stack trace in + "uninteresting call" warnings. +* `warning`: gMock will print both warnings and errors (less verbose); it will + omit the stack traces in "uninteresting call" warnings. This is the default. +* `error`: gMock will print errors only (least verbose). + +Alternatively, you can adjust the value of that flag from within your tests like +so: + +```cpp + ::testing::FLAGS_gmock_verbose = "error"; +``` + +If you find gMock printing too many stack frames with its informational or +warning messages, remember that you can control their amount with the +`--gtest_stack_trace_depth=max_depth` flag. + +Now, judiciously use the right flag to enable gMock serve you better! + +### Gaining Super Vision into Mock Calls + +You have a test using gMock. It fails: gMock tells you some expectations aren't +satisfied. However, you aren't sure why: Is there a typo somewhere in the +matchers? Did you mess up the order of the `EXPECT_CALL`s? Or is the code under +test doing something wrong? How can you find out the cause? + +Won't it be nice if you have X-ray vision and can actually see the trace of all +`EXPECT_CALL`s and mock method calls as they are made? For each call, would you +like to see its actual argument values and which `EXPECT_CALL` gMock thinks it +matches? If you still need some help to figure out who made these calls, how +about being able to see the complete stack trace at each mock call? + +You can unlock this power by running your test with the `--gmock_verbose=info` +flag. For example, given the test program: + +```cpp +#include + +using ::testing::_; +using ::testing::HasSubstr; +using ::testing::Return; + +class MockFoo { + public: + MOCK_METHOD(void, F, (const string& x, const string& y)); +}; + +TEST(Foo, Bar) { + MockFoo mock; + EXPECT_CALL(mock, F(_, _)).WillRepeatedly(Return()); + EXPECT_CALL(mock, F("a", "b")); + EXPECT_CALL(mock, F("c", HasSubstr("d"))); + + mock.F("a", "good"); + mock.F("a", "b"); +} +``` + +if you run it with `--gmock_verbose=info`, you will see this output: + +```shell +[ RUN ] Foo.Bar + +foo_test.cc:14: EXPECT_CALL(mock, F(_, _)) invoked +Stack trace: ... + +foo_test.cc:15: EXPECT_CALL(mock, F("a", "b")) invoked +Stack trace: ... + +foo_test.cc:16: EXPECT_CALL(mock, F("c", HasSubstr("d"))) invoked +Stack trace: ... + +foo_test.cc:14: Mock function call matches EXPECT_CALL(mock, F(_, _))... + Function call: F(@0x7fff7c8dad40"a",@0x7fff7c8dad10"good") +Stack trace: ... + +foo_test.cc:15: Mock function call matches EXPECT_CALL(mock, F("a", "b"))... + Function call: F(@0x7fff7c8dada0"a",@0x7fff7c8dad70"b") +Stack trace: ... + +foo_test.cc:16: Failure +Actual function call count doesn't match EXPECT_CALL(mock, F("c", HasSubstr("d")))... + Expected: to be called once + Actual: never called - unsatisfied and active +[ FAILED ] Foo.Bar +``` + +Suppose the bug is that the `"c"` in the third `EXPECT_CALL` is a typo and +should actually be `"a"`. With the above message, you should see that the actual +`F("a", "good")` call is matched by the first `EXPECT_CALL`, not the third as +you thought. From that it should be obvious that the third `EXPECT_CALL` is +written wrong. Case solved. + +If you are interested in the mock call trace but not the stack traces, you can +combine `--gmock_verbose=info` with `--gtest_stack_trace_depth=0` on the test +command line. + +### Running Tests in Emacs + +If you build and run your tests in Emacs using the `M-x google-compile` command +(as many googletest users do), the source file locations of gMock and googletest +errors will be highlighted. Just press `` on one of them and you'll be +taken to the offending line. Or, you can just type `C-x`` to jump to the next +error. + +To make it even easier, you can add the following lines to your `~/.emacs` file: + +```text +(global-set-key "\M-m" 'google-compile) ; m is for make +(global-set-key [M-down] 'next-error) +(global-set-key [M-up] '(lambda () (interactive) (next-error -1))) +``` + +Then you can type `M-m` to start a build (if you want to run the test as well, +just make sure `foo_test.run` or `runtests` is in the build command you supply +after typing `M-m`), or `M-up`/`M-down` to move back and forth between errors. + +## Extending gMock + +### Writing New Matchers Quickly {#NewMatchers} + +{: .callout .warning} +WARNING: gMock does not guarantee when or how many times a matcher will be +invoked. Therefore, all matchers must be functionally pure. See +[this section](#PureMatchers) for more details. + +The `MATCHER*` family of macros can be used to define custom matchers easily. +The syntax: + +```cpp +MATCHER(name, description_string_expression) { statements; } +``` + +will define a matcher with the given name that executes the statements, which +must return a `bool` to indicate if the match succeeds. Inside the statements, +you can refer to the value being matched by `arg`, and refer to its type by +`arg_type`. + +The *description string* is a `string`-typed expression that documents what the +matcher does, and is used to generate the failure message when the match fails. +It can (and should) reference the special `bool` variable `negation`, and should +evaluate to the description of the matcher when `negation` is `false`, or that +of the matcher's negation when `negation` is `true`. + +For convenience, we allow the description string to be empty (`""`), in which +case gMock will use the sequence of words in the matcher name as the +description. + +For example: + +```cpp +MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; } +``` + +allows you to write + +```cpp + // Expects mock_foo.Bar(n) to be called where n is divisible by 7. + EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7())); +``` + +or, + +```cpp + using ::testing::Not; + ... + // Verifies that a value is divisible by 7 and the other is not. + EXPECT_THAT(some_expression, IsDivisibleBy7()); + EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7())); +``` + +If the above assertions fail, they will print something like: + +```shell + Value of: some_expression + Expected: is divisible by 7 + Actual: 27 + ... + Value of: some_other_expression + Expected: not (is divisible by 7) + Actual: 21 +``` + +where the descriptions `"is divisible by 7"` and `"not (is divisible by 7)"` are +automatically calculated from the matcher name `IsDivisibleBy7`. + +As you may have noticed, the auto-generated descriptions (especially those for +the negation) may not be so great. You can always override them with a `string` +expression of your own: + +```cpp +MATCHER(IsDivisibleBy7, + absl::StrCat(negation ? "isn't" : "is", " divisible by 7")) { + return (arg % 7) == 0; +} +``` + +Optionally, you can stream additional information to a hidden argument named +`result_listener` to explain the match result. For example, a better definition +of `IsDivisibleBy7` is: + +```cpp +MATCHER(IsDivisibleBy7, "") { + if ((arg % 7) == 0) + return true; + + *result_listener << "the remainder is " << (arg % 7); + return false; +} +``` + +With this definition, the above assertion will give a better message: + +```shell + Value of: some_expression + Expected: is divisible by 7 + Actual: 27 (the remainder is 6) +``` + +You should let `MatchAndExplain()` print *any additional information* that can +help a user understand the match result. Note that it should explain why the +match succeeds in case of a success (unless it's obvious) - this is useful when +the matcher is used inside `Not()`. There is no need to print the argument value +itself, as gMock already prints it for you. + +{: .callout .note} +NOTE: The type of the value being matched (`arg_type`) is determined by the +context in which you use the matcher and is supplied to you by the compiler, so +you don't need to worry about declaring it (nor can you). This allows the +matcher to be polymorphic. For example, `IsDivisibleBy7()` can be used to match +any type where the value of `(arg % 7) == 0` can be implicitly converted to a +`bool`. In the `Bar(IsDivisibleBy7())` example above, if method `Bar()` takes an +`int`, `arg_type` will be `int`; if it takes an `unsigned long`, `arg_type` will +be `unsigned long`; and so on. + +### Writing New Parameterized Matchers Quickly + +Sometimes you'll want to define a matcher that has parameters. For that you can +use the macro: + +```cpp +MATCHER_P(name, param_name, description_string) { statements; } +``` + +where the description string can be either `""` or a `string` expression that +references `negation` and `param_name`. + +For example: + +```cpp +MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } +``` + +will allow you to write: + +```cpp + EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); +``` + +which may lead to this message (assuming `n` is 10): + +```shell + Value of: Blah("a") + Expected: has absolute value 10 + Actual: -9 +``` + +Note that both the matcher description and its parameter are printed, making the +message human-friendly. + +In the matcher definition body, you can write `foo_type` to reference the type +of a parameter named `foo`. For example, in the body of +`MATCHER_P(HasAbsoluteValue, value)` above, you can write `value_type` to refer +to the type of `value`. + +gMock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to `MATCHER_P10` to +support multi-parameter matchers: + +```cpp +MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; } +``` + +Please note that the custom description string is for a particular *instance* of +the matcher, where the parameters have been bound to actual values. Therefore +usually you'll want the parameter values to be part of the description. gMock +lets you do that by referencing the matcher parameters in the description string +expression. + +For example, + +```cpp +using ::testing::PrintToString; +MATCHER_P2(InClosedRange, low, hi, + absl::StrFormat("%s in range [%s, %s]", negation ? "isn't" : "is", + PrintToString(low), PrintToString(hi))) { + return low <= arg && arg <= hi; +} +... +EXPECT_THAT(3, InClosedRange(4, 6)); +``` + +would generate a failure that contains the message: + +```shell + Expected: is in range [4, 6] +``` + +If you specify `""` as the description, the failure message will contain the +sequence of words in the matcher name followed by the parameter values printed +as a tuple. For example, + +```cpp + MATCHER_P2(InClosedRange, low, hi, "") { ... } + ... + EXPECT_THAT(3, InClosedRange(4, 6)); +``` + +would generate a failure that contains the text: + +```shell + Expected: in closed range (4, 6) +``` + +For the purpose of typing, you can view + +```cpp +MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } +``` + +as shorthand for + +```cpp +template +FooMatcherPk +Foo(p1_type p1, ..., pk_type pk) { ... } +``` + +When you write `Foo(v1, ..., vk)`, the compiler infers the types of the +parameters `v1`, ..., and `vk` for you. If you are not happy with the result of +the type inference, you can specify the types by explicitly instantiating the +template, as in `Foo(5, false)`. As said earlier, you don't get to +(or need to) specify `arg_type` as that's determined by the context in which the +matcher is used. + +You can assign the result of expression `Foo(p1, ..., pk)` to a variable of type +`FooMatcherPk`. This can be useful when composing +matchers. Matchers that don't have a parameter or have only one parameter have +special types: you can assign `Foo()` to a `FooMatcher`-typed variable, and +assign `Foo(p)` to a `FooMatcherP`-typed variable. + +While you can instantiate a matcher template with reference types, passing the +parameters by pointer usually makes your code more readable. If, however, you +still want to pass a parameter by reference, be aware that in the failure +message generated by the matcher you will see the value of the referenced object +but not its address. + +You can overload matchers with different numbers of parameters: + +```cpp +MATCHER_P(Blah, a, description_string_1) { ... } +MATCHER_P2(Blah, a, b, description_string_2) { ... } +``` + +While it's tempting to always use the `MATCHER*` macros when defining a new +matcher, you should also consider implementing the matcher interface directly +instead (see the recipes that follow), especially if you need to use the matcher +a lot. While these approaches require more work, they give you more control on +the types of the value being matched and the matcher parameters, which in +general leads to better compiler error messages that pay off in the long run. +They also allow overloading matchers based on parameter types (as opposed to +just based on the number of parameters). + +### Writing New Monomorphic Matchers + +A matcher of argument type `T` implements the matcher interface for `T` and does +two things: it tests whether a value of type `T` matches the matcher, and can +describe what kind of values it matches. The latter ability is used for +generating readable error messages when expectations are violated. + +A matcher of `T` must declare a typedef like: + +```cpp +using is_gtest_matcher = void; +``` + +and supports the following operations: + +```cpp +// Match a value and optionally explain into an ostream. +bool matched = matcher.MatchAndExplain(value, maybe_os); +// where `value` is of type `T` and +// `maybe_os` is of type `std::ostream*`, where it can be null if the caller +// is not interested in there textual explanation. + +matcher.DescribeTo(os); +matcher.DescribeNegationTo(os); +// where `os` is of type `std::ostream*`. +``` + +If you need a custom matcher but `Truly()` is not a good option (for example, +you may not be happy with the way `Truly(predicate)` describes itself, or you +may want your matcher to be polymorphic as `Eq(value)` is), you can define a +matcher to do whatever you want in two steps: first implement the matcher +interface, and then define a factory function to create a matcher instance. The +second step is not strictly needed but it makes the syntax of using the matcher +nicer. + +For example, you can define a matcher to test whether an `int` is divisible by 7 +and then use it like this: + +```cpp +using ::testing::Matcher; + +class DivisibleBy7Matcher { + public: + using is_gtest_matcher = void; + + bool MatchAndExplain(int n, std::ostream*) const { + return (n % 7) == 0; + } + + void DescribeTo(std::ostream* os) const { + *os << "is divisible by 7"; + } + + void DescribeNegationTo(std::ostream* os) const { + *os << "is not divisible by 7"; + } +}; + +Matcher DivisibleBy7() { + return DivisibleBy7Matcher(); +} + +... + EXPECT_CALL(foo, Bar(DivisibleBy7())); +``` + +You may improve the matcher message by streaming additional information to the +`os` argument in `MatchAndExplain()`: + +```cpp +class DivisibleBy7Matcher { + public: + bool MatchAndExplain(int n, std::ostream* os) const { + const int remainder = n % 7; + if (remainder != 0 && os != nullptr) { + *os << "the remainder is " << remainder; + } + return remainder == 0; + } + ... +}; +``` + +Then, `EXPECT_THAT(x, DivisibleBy7());` may generate a message like this: + +```shell +Value of: x +Expected: is divisible by 7 + Actual: 23 (the remainder is 2) +``` + +{: .callout .tip} +Tip: for convenience, `MatchAndExplain()` can take a `MatchResultListener*` +instead of `std::ostream*`. + +### Writing New Polymorphic Matchers + +Expanding what we learned above to *polymorphic* matchers is now just as simple +as adding templates in the right place. + +```cpp + +class NotNullMatcher { + public: + using is_gtest_matcher = void; + + // To implement a polymorphic matcher, we just need to make MatchAndExplain a + // template on its first argument. + + // In this example, we want to use NotNull() with any pointer, so + // MatchAndExplain() accepts a pointer of any type as its first argument. + // In general, you can define MatchAndExplain() as an ordinary method or + // a method template, or even overload it. + template + bool MatchAndExplain(T* p, std::ostream*) const { + return p != nullptr; + } + + // Describes the property of a value matching this matcher. + void DescribeTo(std::ostream* os) const { *os << "is not NULL"; } + + // Describes the property of a value NOT matching this matcher. + void DescribeNegationTo(std::ostream* os) const { *os << "is NULL"; } +}; + +NotNullMatcher NotNull() { + return NotNullMatcher(); +} + +... + + EXPECT_CALL(foo, Bar(NotNull())); // The argument must be a non-NULL pointer. +``` + +### Legacy Matcher Implementation + +Defining matchers used to be somewhat more complicated, in which it required +several supporting classes and virtual functions. To implement a matcher for +type `T` using the legacy API you have to derive from `MatcherInterface` and +call `MakeMatcher` to construct the object. + +The interface looks like this: + +```cpp +class MatchResultListener { + public: + ... + // Streams x to the underlying ostream; does nothing if the ostream + // is NULL. + template + MatchResultListener& operator<<(const T& x); + + // Returns the underlying ostream. + std::ostream* stream(); +}; + +template +class MatcherInterface { + public: + virtual ~MatcherInterface(); + + // Returns true if and only if the matcher matches x; also explains the match + // result to 'listener'. + virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; + + // Describes this matcher to an ostream. + virtual void DescribeTo(std::ostream* os) const = 0; + + // Describes the negation of this matcher to an ostream. + virtual void DescribeNegationTo(std::ostream* os) const; +}; +``` + +Fortunately, most of the time you can define a polymorphic matcher easily with +the help of `MakePolymorphicMatcher()`. Here's how you can define `NotNull()` as +an example: + +```cpp +using ::testing::MakePolymorphicMatcher; +using ::testing::MatchResultListener; +using ::testing::PolymorphicMatcher; + +class NotNullMatcher { + public: + // To implement a polymorphic matcher, first define a COPYABLE class + // that has three members MatchAndExplain(), DescribeTo(), and + // DescribeNegationTo(), like the following. + + // In this example, we want to use NotNull() with any pointer, so + // MatchAndExplain() accepts a pointer of any type as its first argument. + // In general, you can define MatchAndExplain() as an ordinary method or + // a method template, or even overload it. + template + bool MatchAndExplain(T* p, + MatchResultListener* /* listener */) const { + return p != NULL; + } + + // Describes the property of a value matching this matcher. + void DescribeTo(std::ostream* os) const { *os << "is not NULL"; } + + // Describes the property of a value NOT matching this matcher. + void DescribeNegationTo(std::ostream* os) const { *os << "is NULL"; } +}; + +// To construct a polymorphic matcher, pass an instance of the class +// to MakePolymorphicMatcher(). Note the return type. +PolymorphicMatcher NotNull() { + return MakePolymorphicMatcher(NotNullMatcher()); +} + +... + + EXPECT_CALL(foo, Bar(NotNull())); // The argument must be a non-NULL pointer. +``` + +{: .callout .note} +**Note:** Your polymorphic matcher class does **not** need to inherit from +`MatcherInterface` or any other class, and its methods do **not** need to be +virtual. + +Like in a monomorphic matcher, you may explain the match result by streaming +additional information to the `listener` argument in `MatchAndExplain()`. + +### Writing New Cardinalities + +A cardinality is used in `Times()` to tell gMock how many times you expect a +call to occur. It doesn't have to be exact. For example, you can say +`AtLeast(5)` or `Between(2, 4)`. + +If the [built-in set](gmock_cheat_sheet.md#CardinalityList) of cardinalities +doesn't suit you, you are free to define your own by implementing the following +interface (in namespace `testing`): + +```cpp +class CardinalityInterface { + public: + virtual ~CardinalityInterface(); + + // Returns true if and only if call_count calls will satisfy this cardinality. + virtual bool IsSatisfiedByCallCount(int call_count) const = 0; + + // Returns true if and only if call_count calls will saturate this + // cardinality. + virtual bool IsSaturatedByCallCount(int call_count) const = 0; + + // Describes self to an ostream. + virtual void DescribeTo(std::ostream* os) const = 0; +}; +``` + +For example, to specify that a call must occur even number of times, you can +write + +```cpp +using ::testing::Cardinality; +using ::testing::CardinalityInterface; +using ::testing::MakeCardinality; + +class EvenNumberCardinality : public CardinalityInterface { + public: + bool IsSatisfiedByCallCount(int call_count) const override { + return (call_count % 2) == 0; + } + + bool IsSaturatedByCallCount(int call_count) const override { + return false; + } + + void DescribeTo(std::ostream* os) const { + *os << "called even number of times"; + } +}; + +Cardinality EvenNumber() { + return MakeCardinality(new EvenNumberCardinality); +} + +... + EXPECT_CALL(foo, Bar(3)) + .Times(EvenNumber()); +``` + +### Writing New Actions {#QuickNewActions} + +If the built-in actions don't work for you, you can easily define your own one. +All you need is a call operator with a signature compatible with the mocked +function. So you can use a lambda: + +```cpp +MockFunction mock; +EXPECT_CALL(mock, Call).WillOnce([](const int input) { return input * 7; }); +EXPECT_EQ(mock.AsStdFunction()(2), 14); +``` + +Or a struct with a call operator (even a templated one): + +```cpp +struct MultiplyBy { + template + T operator()(T arg) { return arg * multiplier; } + + int multiplier; +}; + +// Then use: +// EXPECT_CALL(...).WillOnce(MultiplyBy{7}); +``` + +It's also fine for the callable to take no arguments, ignoring the arguments +supplied to the mock function: + +```cpp +MockFunction mock; +EXPECT_CALL(mock, Call).WillOnce([] { return 17; }); +EXPECT_EQ(mock.AsStdFunction()(0), 17); +``` + +When used with `WillOnce`, the callable can assume it will be called at most +once and is allowed to be a move-only type: + +```cpp +// An action that contains move-only types and has an &&-qualified operator, +// demanding in the type system that it be called at most once. This can be +// used with WillOnce, but the compiler will reject it if handed to +// WillRepeatedly. +struct MoveOnlyAction { + std::unique_ptr move_only_state; + std::unique_ptr operator()() && { return std::move(move_only_state); } +}; + +MockFunction()> mock; +EXPECT_CALL(mock, Call).WillOnce(MoveOnlyAction{std::make_unique(17)}); +EXPECT_THAT(mock.AsStdFunction()(), Pointee(Eq(17))); +``` + +More generally, to use with a mock function whose signature is `R(Args...)` the +object can be anything convertible to `OnceAction` or +`Action. The difference between the two is that `OnceAction` has +weaker requirements (`Action` requires a copy-constructible input that can be +called repeatedly whereas `OnceAction` requires only move-constructible and +supports `&&`-qualified call operators), but can be used only with `WillOnce`. +`OnceAction` is typically relevant only when supporting move-only types or +actions that want a type-system guarantee that they will be called at most once. + +Typically the `OnceAction` and `Action` templates need not be referenced +directly in your actions: a struct or class with a call operator is sufficient, +as in the examples above. But fancier polymorphic actions that need to know the +specific return type of the mock function can define templated conversion +operators to make that possible. See `gmock-actions.h` for examples. + +#### Legacy macro-based Actions + +Before C++11, the functor-based actions were not supported; the old way of +writing actions was through a set of `ACTION*` macros. We suggest to avoid them +in new code; they hide a lot of logic behind the macro, potentially leading to +harder-to-understand compiler errors. Nevertheless, we cover them here for +completeness. + +By writing + +```cpp +ACTION(name) { statements; } +``` + +in a namespace scope (i.e. not inside a class or function), you will define an +action with the given name that executes the statements. The value returned by +`statements` will be used as the return value of the action. Inside the +statements, you can refer to the K-th (0-based) argument of the mock function as +`argK`. For example: + +```cpp +ACTION(IncrementArg1) { return ++(*arg1); } +``` + +allows you to write + +```cpp +... WillOnce(IncrementArg1()); +``` + +Note that you don't need to specify the types of the mock function arguments. +Rest assured that your code is type-safe though: you'll get a compiler error if +`*arg1` doesn't support the `++` operator, or if the type of `++(*arg1)` isn't +compatible with the mock function's return type. + +Another example: + +```cpp +ACTION(Foo) { + (*arg2)(5); + Blah(); + *arg1 = 0; + return arg0; +} +``` + +defines an action `Foo()` that invokes argument #2 (a function pointer) with 5, +calls function `Blah()`, sets the value pointed to by argument #1 to 0, and +returns argument #0. + +For more convenience and flexibility, you can also use the following pre-defined +symbols in the body of `ACTION`: + +`argK_type` | The type of the K-th (0-based) argument of the mock function +:-------------- | :----------------------------------------------------------- +`args` | All arguments of the mock function as a tuple +`args_type` | The type of all arguments of the mock function as a tuple +`return_type` | The return type of the mock function +`function_type` | The type of the mock function + +For example, when using an `ACTION` as a stub action for mock function: + +```cpp +int DoSomething(bool flag, int* ptr); +``` + +we have: + +Pre-defined Symbol | Is Bound To +------------------ | --------------------------------- +`arg0` | the value of `flag` +`arg0_type` | the type `bool` +`arg1` | the value of `ptr` +`arg1_type` | the type `int*` +`args` | the tuple `(flag, ptr)` +`args_type` | the type `std::tuple` +`return_type` | the type `int` +`function_type` | the type `int(bool, int*)` + +#### Legacy macro-based parameterized Actions + +Sometimes you'll want to parameterize an action you define. For that we have +another macro + +```cpp +ACTION_P(name, param) { statements; } +``` + +For example, + +```cpp +ACTION_P(Add, n) { return arg0 + n; } +``` + +will allow you to write + +```cpp +// Returns argument #0 + 5. +... WillOnce(Add(5)); +``` + +For convenience, we use the term *arguments* for the values used to invoke the +mock function, and the term *parameters* for the values used to instantiate an +action. + +Note that you don't need to provide the type of the parameter either. Suppose +the parameter is named `param`, you can also use the gMock-defined symbol +`param_type` to refer to the type of the parameter as inferred by the compiler. +For example, in the body of `ACTION_P(Add, n)` above, you can write `n_type` for +the type of `n`. + +gMock also provides `ACTION_P2`, `ACTION_P3`, and etc to support multi-parameter +actions. For example, + +```cpp +ACTION_P2(ReturnDistanceTo, x, y) { + double dx = arg0 - x; + double dy = arg1 - y; + return sqrt(dx*dx + dy*dy); +} +``` + +lets you write + +```cpp +... WillOnce(ReturnDistanceTo(5.0, 26.5)); +``` + +You can view `ACTION` as a degenerated parameterized action where the number of +parameters is 0. + +You can also easily define actions overloaded on the number of parameters: + +```cpp +ACTION_P(Plus, a) { ... } +ACTION_P2(Plus, a, b) { ... } +``` + +### Restricting the Type of an Argument or Parameter in an ACTION + +For maximum brevity and reusability, the `ACTION*` macros don't ask you to +provide the types of the mock function arguments and the action parameters. +Instead, we let the compiler infer the types for us. + +Sometimes, however, we may want to be more explicit about the types. There are +several tricks to do that. For example: + +```cpp +ACTION(Foo) { + // Makes sure arg0 can be converted to int. + int n = arg0; + ... use n instead of arg0 here ... +} + +ACTION_P(Bar, param) { + // Makes sure the type of arg1 is const char*. + ::testing::StaticAssertTypeEq(); + + // Makes sure param can be converted to bool. + bool flag = param; +} +``` + +where `StaticAssertTypeEq` is a compile-time assertion in googletest that +verifies two types are the same. + +### Writing New Action Templates Quickly + +Sometimes you want to give an action explicit template parameters that cannot be +inferred from its value parameters. `ACTION_TEMPLATE()` supports that and can be +viewed as an extension to `ACTION()` and `ACTION_P*()`. + +The syntax: + +```cpp +ACTION_TEMPLATE(ActionName, + HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), + AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } +``` + +defines an action template that takes *m* explicit template parameters and *n* +value parameters, where *m* is in [1, 10] and *n* is in [0, 10]. `name_i` is the +name of the *i*-th template parameter, and `kind_i` specifies whether it's a +`typename`, an integral constant, or a template. `p_i` is the name of the *i*-th +value parameter. + +Example: + +```cpp +// DuplicateArg(output) converts the k-th argument of the mock +// function to type T and copies it to *output. +ACTION_TEMPLATE(DuplicateArg, + // Note the comma between int and k: + HAS_2_TEMPLATE_PARAMS(int, k, typename, T), + AND_1_VALUE_PARAMS(output)) { + *output = T(std::get(args)); +} +``` + +To create an instance of an action template, write: + +```cpp +ActionName(v1, ..., v_n) +``` + +where the `t`s are the template arguments and the `v`s are the value arguments. +The value argument types are inferred by the compiler. For example: + +```cpp +using ::testing::_; +... + int n; + EXPECT_CALL(mock, Foo).WillOnce(DuplicateArg<1, unsigned char>(&n)); +``` + +If you want to explicitly specify the value argument types, you can provide +additional template arguments: + +```cpp +ActionName(v1, ..., v_n) +``` + +where `u_i` is the desired type of `v_i`. + +`ACTION_TEMPLATE` and `ACTION`/`ACTION_P*` can be overloaded on the number of +value parameters, but not on the number of template parameters. Without the +restriction, the meaning of the following is unclear: + +```cpp + OverloadedAction(x); +``` + +Are we using a single-template-parameter action where `bool` refers to the type +of `x`, or a two-template-parameter action where the compiler is asked to infer +the type of `x`? + +### Using the ACTION Object's Type + +If you are writing a function that returns an `ACTION` object, you'll need to +know its type. The type depends on the macro used to define the action and the +parameter types. The rule is relatively simple: + + +| Given Definition | Expression | Has Type | +| ----------------------------- | ------------------- | --------------------- | +| `ACTION(Foo)` | `Foo()` | `FooAction` | +| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` | `Foo()` | `FooAction` | +| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP` | +| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar(int_value)` | `BarActionP` | +| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2` | +| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz(bool_value, int_value)` | `BazActionP2` | +| ... | ... | ... | + + +Note that we have to pick different suffixes (`Action`, `ActionP`, `ActionP2`, +and etc) for actions with different numbers of value parameters, or the action +definitions cannot be overloaded on the number of them. + +### Writing New Monomorphic Actions {#NewMonoActions} + +While the `ACTION*` macros are very convenient, sometimes they are +inappropriate. For example, despite the tricks shown in the previous recipes, +they don't let you directly specify the types of the mock function arguments and +the action parameters, which in general leads to unoptimized compiler error +messages that can baffle unfamiliar users. They also don't allow overloading +actions based on parameter types without jumping through some hoops. + +An alternative to the `ACTION*` macros is to implement +`::testing::ActionInterface`, where `F` is the type of the mock function in +which the action will be used. For example: + +```cpp +template +class ActionInterface { + public: + virtual ~ActionInterface(); + + // Performs the action. Result is the return type of function type + // F, and ArgumentTuple is the tuple of arguments of F. + // + + // For example, if F is int(bool, const string&), then Result would + // be int, and ArgumentTuple would be std::tuple. + virtual Result Perform(const ArgumentTuple& args) = 0; +}; +``` + +```cpp +using ::testing::_; +using ::testing::Action; +using ::testing::ActionInterface; +using ::testing::MakeAction; + +typedef int IncrementMethod(int*); + +class IncrementArgumentAction : public ActionInterface { + public: + int Perform(const std::tuple& args) override { + int* p = std::get<0>(args); // Grabs the first argument. + return *p++; + } +}; + +Action IncrementArgument() { + return MakeAction(new IncrementArgumentAction); +} + +... + EXPECT_CALL(foo, Baz(_)) + .WillOnce(IncrementArgument()); + + int n = 5; + foo.Baz(&n); // Should return 5 and change n to 6. +``` + +### Writing New Polymorphic Actions {#NewPolyActions} + +The previous recipe showed you how to define your own action. This is all good, +except that you need to know the type of the function in which the action will +be used. Sometimes that can be a problem. For example, if you want to use the +action in functions with *different* types (e.g. like `Return()` and +`SetArgPointee()`). + +If an action can be used in several types of mock functions, we say it's +*polymorphic*. The `MakePolymorphicAction()` function template makes it easy to +define such an action: + +```cpp +namespace testing { +template +PolymorphicAction MakePolymorphicAction(const Impl& impl); +} // namespace testing +``` + +As an example, let's define an action that returns the second argument in the +mock function's argument list. The first step is to define an implementation +class: + +```cpp +class ReturnSecondArgumentAction { + public: + template + Result Perform(const ArgumentTuple& args) const { + // To get the i-th (0-based) argument, use std::get(args). + return std::get<1>(args); + } +}; +``` + +This implementation class does *not* need to inherit from any particular class. +What matters is that it must have a `Perform()` method template. This method +template takes the mock function's arguments as a tuple in a **single** +argument, and returns the result of the action. It can be either `const` or not, +but must be invocable with exactly one template argument, which is the result +type. In other words, you must be able to call `Perform(args)` where `R` is +the mock function's return type and `args` is its arguments in a tuple. + +Next, we use `MakePolymorphicAction()` to turn an instance of the implementation +class into the polymorphic action we need. It will be convenient to have a +wrapper for this: + +```cpp +using ::testing::MakePolymorphicAction; +using ::testing::PolymorphicAction; + +PolymorphicAction ReturnSecondArgument() { + return MakePolymorphicAction(ReturnSecondArgumentAction()); +} +``` + +Now, you can use this polymorphic action the same way you use the built-in ones: + +```cpp +using ::testing::_; + +class MockFoo : public Foo { + public: + MOCK_METHOD(int, DoThis, (bool flag, int n), (override)); + MOCK_METHOD(string, DoThat, (int x, const char* str1, const char* str2), + (override)); +}; + + ... + MockFoo foo; + EXPECT_CALL(foo, DoThis).WillOnce(ReturnSecondArgument()); + EXPECT_CALL(foo, DoThat).WillOnce(ReturnSecondArgument()); + ... + foo.DoThis(true, 5); // Will return 5. + foo.DoThat(1, "Hi", "Bye"); // Will return "Hi". +``` + +### Teaching gMock How to Print Your Values + +When an uninteresting or unexpected call occurs, gMock prints the argument +values and the stack trace to help you debug. Assertion macros like +`EXPECT_THAT` and `EXPECT_EQ` also print the values in question when the +assertion fails. gMock and googletest do this using googletest's user-extensible +value printer. + +This printer knows how to print built-in C++ types, native arrays, STL +containers, and any type that supports the `<<` operator. For other types, it +prints the raw bytes in the value and hopes that you the user can figure it out. +[The GoogleTest advanced guide](advanced.md#teaching-googletest-how-to-print-your-values) +explains how to extend the printer to do a better job at printing your +particular type than to dump the bytes. + +## Useful Mocks Created Using gMock + + + + +### Mock std::function {#MockFunction} + +`std::function` is a general function type introduced in C++11. It is a +preferred way of passing callbacks to new interfaces. Functions are copyable, +and are not usually passed around by pointer, which makes them tricky to mock. +But fear not - `MockFunction` can help you with that. + +`MockFunction` has a mock method `Call()` with the signature: + +```cpp + R Call(T1, ..., Tn); +``` + +It also has a `AsStdFunction()` method, which creates a `std::function` proxy +forwarding to Call: + +```cpp + std::function AsStdFunction(); +``` + +To use `MockFunction`, first create `MockFunction` object and set up +expectations on its `Call` method. Then pass proxy obtained from +`AsStdFunction()` to the code you are testing. For example: + +```cpp +TEST(FooTest, RunsCallbackWithBarArgument) { + // 1. Create a mock object. + MockFunction mock_function; + + // 2. Set expectations on Call() method. + EXPECT_CALL(mock_function, Call("bar")).WillOnce(Return(1)); + + // 3. Exercise code that uses std::function. + Foo(mock_function.AsStdFunction()); + // Foo's signature can be either of: + // void Foo(const std::function& fun); + // void Foo(std::function fun); + + // 4. All expectations will be verified when mock_function + // goes out of scope and is destroyed. +} +``` + +Remember that function objects created with `AsStdFunction()` are just +forwarders. If you create multiple of them, they will share the same set of +expectations. + +Although `std::function` supports unlimited number of arguments, `MockFunction` +implementation is limited to ten. If you ever hit that limit... well, your +callback has bigger problems than being mockable. :-) diff --git a/cpp/third_party/googletest/docs/gmock_faq.md b/cpp/third_party/googletest/docs/gmock_faq.md new file mode 100644 index 0000000..8f220bf --- /dev/null +++ b/cpp/third_party/googletest/docs/gmock_faq.md @@ -0,0 +1,390 @@ +# Legacy gMock FAQ + +### When I call a method on my mock object, the method for the real object is invoked instead. What's the problem? + +In order for a method to be mocked, it must be *virtual*, unless you use the +[high-perf dependency injection technique](gmock_cook_book.md#MockingNonVirtualMethods). + +### Can I mock a variadic function? + +You cannot mock a variadic function (i.e. a function taking ellipsis (`...`) +arguments) directly in gMock. + +The problem is that in general, there is *no way* for a mock object to know how +many arguments are passed to the variadic method, and what the arguments' types +are. Only the *author of the base class* knows the protocol, and we cannot look +into his or her head. + +Therefore, to mock such a function, the *user* must teach the mock object how to +figure out the number of arguments and their types. One way to do it is to +provide overloaded versions of the function. + +Ellipsis arguments are inherited from C and not really a C++ feature. They are +unsafe to use and don't work with arguments that have constructors or +destructors. Therefore we recommend to avoid them in C++ as much as possible. + +### MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter. Why? + +If you compile this using Microsoft Visual C++ 2005 SP1: + +```cpp +class Foo { + ... + virtual void Bar(const int i) = 0; +}; + +class MockFoo : public Foo { + ... + MOCK_METHOD(void, Bar, (const int i), (override)); +}; +``` + +You may get the following warning: + +```shell +warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier +``` + +This is a MSVC bug. The same code compiles fine with gcc, for example. If you +use Visual C++ 2008 SP1, you would get the warning: + +```shell +warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers +``` + +In C++, if you *declare* a function with a `const` parameter, the `const` +modifier is ignored. Therefore, the `Foo` base class above is equivalent to: + +```cpp +class Foo { + ... + virtual void Bar(int i) = 0; // int or const int? Makes no difference. +}; +``` + +In fact, you can *declare* `Bar()` with an `int` parameter, and define it with a +`const int` parameter. The compiler will still match them up. + +Since making a parameter `const` is meaningless in the method declaration, we +recommend to remove it in both `Foo` and `MockFoo`. That should workaround the +VC bug. + +Note that we are talking about the *top-level* `const` modifier here. If the +function parameter is passed by pointer or reference, declaring the pointee or +referee as `const` is still meaningful. For example, the following two +declarations are *not* equivalent: + +```cpp +void Bar(int* p); // Neither p nor *p is const. +void Bar(const int* p); // p is not const, but *p is. +``` + +### I can't figure out why gMock thinks my expectations are not satisfied. What should I do? + +You might want to run your test with `--gmock_verbose=info`. This flag lets +gMock print a trace of every mock function call it receives. By studying the +trace, you'll gain insights on why the expectations you set are not met. + +If you see the message "The mock function has no default action set, and its +return type has no default value set.", then try +[adding a default action](gmock_cheat_sheet.md#OnCall). Due to a known issue, +unexpected calls on mocks without default actions don't print out a detailed +comparison between the actual arguments and the expected arguments. + +### My program crashed and `ScopedMockLog` spit out tons of messages. Is it a gMock bug? + +gMock and `ScopedMockLog` are likely doing the right thing here. + +When a test crashes, the failure signal handler will try to log a lot of +information (the stack trace, and the address map, for example). The messages +are compounded if you have many threads with depth stacks. When `ScopedMockLog` +intercepts these messages and finds that they don't match any expectations, it +prints an error for each of them. + +You can learn to ignore the errors, or you can rewrite your expectations to make +your test more robust, for example, by adding something like: + +```cpp +using ::testing::AnyNumber; +using ::testing::Not; +... + // Ignores any log not done by us. + EXPECT_CALL(log, Log(_, Not(EndsWith("/my_file.cc")), _)) + .Times(AnyNumber()); +``` + +### How can I assert that a function is NEVER called? + +```cpp +using ::testing::_; +... + EXPECT_CALL(foo, Bar(_)) + .Times(0); +``` + +### I have a failed test where gMock tells me TWICE that a particular expectation is not satisfied. Isn't this redundant? + +When gMock detects a failure, it prints relevant information (the mock function +arguments, the state of relevant expectations, and etc) to help the user debug. +If another failure is detected, gMock will do the same, including printing the +state of relevant expectations. + +Sometimes an expectation's state didn't change between two failures, and you'll +see the same description of the state twice. They are however *not* redundant, +as they refer to *different points in time*. The fact they are the same *is* +interesting information. + +### I get a heapcheck failure when using a mock object, but using a real object is fine. What can be wrong? + +Does the class (hopefully a pure interface) you are mocking have a virtual +destructor? + +Whenever you derive from a base class, make sure its destructor is virtual. +Otherwise Bad Things will happen. Consider the following code: + +```cpp +class Base { + public: + // Not virtual, but should be. + ~Base() { ... } + ... +}; + +class Derived : public Base { + public: + ... + private: + std::string value_; +}; + +... + Base* p = new Derived; + ... + delete p; // Surprise! ~Base() will be called, but ~Derived() will not + // - value_ is leaked. +``` + +By changing `~Base()` to virtual, `~Derived()` will be correctly called when +`delete p` is executed, and the heap checker will be happy. + +### The "newer expectations override older ones" rule makes writing expectations awkward. Why does gMock do that? + +When people complain about this, often they are referring to code like: + +```cpp +using ::testing::Return; +... + // foo.Bar() should be called twice, return 1 the first time, and return + // 2 the second time. However, I have to write the expectations in the + // reverse order. This sucks big time!!! + EXPECT_CALL(foo, Bar()) + .WillOnce(Return(2)) + .RetiresOnSaturation(); + EXPECT_CALL(foo, Bar()) + .WillOnce(Return(1)) + .RetiresOnSaturation(); +``` + +The problem, is that they didn't pick the **best** way to express the test's +intent. + +By default, expectations don't have to be matched in *any* particular order. If +you want them to match in a certain order, you need to be explicit. This is +gMock's (and jMock's) fundamental philosophy: it's easy to accidentally +over-specify your tests, and we want to make it harder to do so. + +There are two better ways to write the test spec. You could either put the +expectations in sequence: + +```cpp +using ::testing::Return; +... + // foo.Bar() should be called twice, return 1 the first time, and return + // 2 the second time. Using a sequence, we can write the expectations + // in their natural order. + { + InSequence s; + EXPECT_CALL(foo, Bar()) + .WillOnce(Return(1)) + .RetiresOnSaturation(); + EXPECT_CALL(foo, Bar()) + .WillOnce(Return(2)) + .RetiresOnSaturation(); + } +``` + +or you can put the sequence of actions in the same expectation: + +```cpp +using ::testing::Return; +... + // foo.Bar() should be called twice, return 1 the first time, and return + // 2 the second time. + EXPECT_CALL(foo, Bar()) + .WillOnce(Return(1)) + .WillOnce(Return(2)) + .RetiresOnSaturation(); +``` + +Back to the original questions: why does gMock search the expectations (and +`ON_CALL`s) from back to front? Because this allows a user to set up a mock's +behavior for the common case early (e.g. in the mock's constructor or the test +fixture's set-up phase) and customize it with more specific rules later. If +gMock searches from front to back, this very useful pattern won't be possible. + +### gMock prints a warning when a function without EXPECT_CALL is called, even if I have set its behavior using ON_CALL. Would it be reasonable not to show the warning in this case? + +When choosing between being neat and being safe, we lean toward the latter. So +the answer is that we think it's better to show the warning. + +Often people write `ON_CALL`s in the mock object's constructor or `SetUp()`, as +the default behavior rarely changes from test to test. Then in the test body +they set the expectations, which are often different for each test. Having an +`ON_CALL` in the set-up part of a test doesn't mean that the calls are expected. +If there's no `EXPECT_CALL` and the method is called, it's possibly an error. If +we quietly let the call go through without notifying the user, bugs may creep in +unnoticed. + +If, however, you are sure that the calls are OK, you can write + +```cpp +using ::testing::_; +... + EXPECT_CALL(foo, Bar(_)) + .WillRepeatedly(...); +``` + +instead of + +```cpp +using ::testing::_; +... + ON_CALL(foo, Bar(_)) + .WillByDefault(...); +``` + +This tells gMock that you do expect the calls and no warning should be printed. + +Also, you can control the verbosity by specifying `--gmock_verbose=error`. Other +values are `info` and `warning`. If you find the output too noisy when +debugging, just choose a less verbose level. + +### How can I delete the mock function's argument in an action? + +If your mock function takes a pointer argument and you want to delete that +argument, you can use testing::DeleteArg() to delete the N'th (zero-indexed) +argument: + +```cpp +using ::testing::_; + ... + MOCK_METHOD(void, Bar, (X* x, const Y& y)); + ... + EXPECT_CALL(mock_foo_, Bar(_, _)) + .WillOnce(testing::DeleteArg<0>())); +``` + +### How can I perform an arbitrary action on a mock function's argument? + +If you find yourself needing to perform some action that's not supported by +gMock directly, remember that you can define your own actions using +[`MakeAction()`](#NewMonoActions) or +[`MakePolymorphicAction()`](#NewPolyActions), or you can write a stub function +and invoke it using [`Invoke()`](#FunctionsAsActions). + +```cpp +using ::testing::_; +using ::testing::Invoke; + ... + MOCK_METHOD(void, Bar, (X* p)); + ... + EXPECT_CALL(mock_foo_, Bar(_)) + .WillOnce(Invoke(MyAction(...))); +``` + +### My code calls a static/global function. Can I mock it? + +You can, but you need to make some changes. + +In general, if you find yourself needing to mock a static function, it's a sign +that your modules are too tightly coupled (and less flexible, less reusable, +less testable, etc). You are probably better off defining a small interface and +call the function through that interface, which then can be easily mocked. It's +a bit of work initially, but usually pays for itself quickly. + +This Google Testing Blog +[post](https://testing.googleblog.com/2008/06/defeat-static-cling.html) says it +excellently. Check it out. + +### My mock object needs to do complex stuff. It's a lot of pain to specify the actions. gMock sucks! + +I know it's not a question, but you get an answer for free any way. :-) + +With gMock, you can create mocks in C++ easily. And people might be tempted to +use them everywhere. Sometimes they work great, and sometimes you may find them, +well, a pain to use. So, what's wrong in the latter case? + +When you write a test without using mocks, you exercise the code and assert that +it returns the correct value or that the system is in an expected state. This is +sometimes called "state-based testing". + +Mocks are great for what some call "interaction-based" testing: instead of +checking the system state at the very end, mock objects verify that they are +invoked the right way and report an error as soon as it arises, giving you a +handle on the precise context in which the error was triggered. This is often +more effective and economical to do than state-based testing. + +If you are doing state-based testing and using a test double just to simulate +the real object, you are probably better off using a fake. Using a mock in this +case causes pain, as it's not a strong point for mocks to perform complex +actions. If you experience this and think that mocks suck, you are just not +using the right tool for your problem. Or, you might be trying to solve the +wrong problem. :-) + +### I got a warning "Uninteresting function call encountered - default action taken.." Should I panic? + +By all means, NO! It's just an FYI. :-) + +What it means is that you have a mock function, you haven't set any expectations +on it (by gMock's rule this means that you are not interested in calls to this +function and therefore it can be called any number of times), and it is called. +That's OK - you didn't say it's not OK to call the function! + +What if you actually meant to disallow this function to be called, but forgot to +write `EXPECT_CALL(foo, Bar()).Times(0)`? While one can argue that it's the +user's fault, gMock tries to be nice and prints you a note. + +So, when you see the message and believe that there shouldn't be any +uninteresting calls, you should investigate what's going on. To make your life +easier, gMock dumps the stack trace when an uninteresting call is encountered. +From that you can figure out which mock function it is, and how it is called. + +### I want to define a custom action. Should I use Invoke() or implement the ActionInterface interface? + +Either way is fine - you want to choose the one that's more convenient for your +circumstance. + +Usually, if your action is for a particular function type, defining it using +`Invoke()` should be easier; if your action can be used in functions of +different types (e.g. if you are defining `Return(*value*)`), +`MakePolymorphicAction()` is easiest. Sometimes you want precise control on what +types of functions the action can be used in, and implementing `ActionInterface` +is the way to go here. See the implementation of `Return()` in `gmock-actions.h` +for an example. + +### I use SetArgPointee() in WillOnce(), but gcc complains about "conflicting return type specified". What does it mean? + +You got this error as gMock has no idea what value it should return when the +mock method is called. `SetArgPointee()` says what the side effect is, but +doesn't say what the return value should be. You need `DoAll()` to chain a +`SetArgPointee()` with a `Return()` that provides a value appropriate to the API +being mocked. + +See this [recipe](gmock_cook_book.md#mocking-side-effects) for more details and +an example. + +### I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it. What can I do? + +We've noticed that when the `/clr` compiler flag is used, Visual C++ uses 5~6 +times as much memory when compiling a mock class. We suggest to avoid `/clr` +when compiling native C++ mocks. diff --git a/cpp/third_party/googletest/docs/gmock_for_dummies.md b/cpp/third_party/googletest/docs/gmock_for_dummies.md new file mode 100644 index 0000000..43f907a --- /dev/null +++ b/cpp/third_party/googletest/docs/gmock_for_dummies.md @@ -0,0 +1,700 @@ +# gMock for Dummies + +## What Is gMock? + +When you write a prototype or test, often it's not feasible or wise to rely on +real objects entirely. A **mock object** implements the same interface as a real +object (so it can be used as one), but lets you specify at run time how it will +be used and what it should do (which methods will be called? in which order? how +many times? with what arguments? what will they return? etc). + +It is easy to confuse the term *fake objects* with mock objects. Fakes and mocks +actually mean very different things in the Test-Driven Development (TDD) +community: + +* **Fake** objects have working implementations, but usually take some + shortcut (perhaps to make the operations less expensive), which makes them + not suitable for production. An in-memory file system would be an example of + a fake. +* **Mocks** are objects pre-programmed with *expectations*, which form a + specification of the calls they are expected to receive. + +If all this seems too abstract for you, don't worry - the most important thing +to remember is that a mock allows you to check the *interaction* between itself +and code that uses it. The difference between fakes and mocks shall become much +clearer once you start to use mocks. + +**gMock** is a library (sometimes we also call it a "framework" to make it sound +cool) for creating mock classes and using them. It does to C++ what +jMock/EasyMock does to Java (well, more or less). + +When using gMock, + +1. first, you use some simple macros to describe the interface you want to + mock, and they will expand to the implementation of your mock class; +2. next, you create some mock objects and specify its expectations and behavior + using an intuitive syntax; +3. then you exercise code that uses the mock objects. gMock will catch any + violation to the expectations as soon as it arises. + +## Why gMock? + +While mock objects help you remove unnecessary dependencies in tests and make +them fast and reliable, using mocks manually in C++ is *hard*: + +* Someone has to implement the mocks. The job is usually tedious and + error-prone. No wonder people go great distance to avoid it. +* The quality of those manually written mocks is a bit, uh, unpredictable. You + may see some really polished ones, but you may also see some that were + hacked up in a hurry and have all sorts of ad hoc restrictions. +* The knowledge you gained from using one mock doesn't transfer to the next + one. + +In contrast, Java and Python programmers have some fine mock frameworks (jMock, +EasyMock, etc), which automate the creation of mocks. As a result, mocking is a +proven effective technique and widely adopted practice in those communities. +Having the right tool absolutely makes the difference. + +gMock was built to help C++ programmers. It was inspired by jMock and EasyMock, +but designed with C++'s specifics in mind. It is your friend if any of the +following problems is bothering you: + +* You are stuck with a sub-optimal design and wish you had done more + prototyping before it was too late, but prototyping in C++ is by no means + "rapid". +* Your tests are slow as they depend on too many libraries or use expensive + resources (e.g. a database). +* Your tests are brittle as some resources they use are unreliable (e.g. the + network). +* You want to test how your code handles a failure (e.g. a file checksum + error), but it's not easy to cause one. +* You need to make sure that your module interacts with other modules in the + right way, but it's hard to observe the interaction; therefore you resort to + observing the side effects at the end of the action, but it's awkward at + best. +* You want to "mock out" your dependencies, except that they don't have mock + implementations yet; and, frankly, you aren't thrilled by some of those + hand-written mocks. + +We encourage you to use gMock as + +* a *design* tool, for it lets you experiment with your interface design early + and often. More iterations lead to better designs! +* a *testing* tool to cut your tests' outbound dependencies and probe the + interaction between your module and its collaborators. + +## Getting Started + +gMock is bundled with googletest. + +## A Case for Mock Turtles + +Let's look at an example. Suppose you are developing a graphics program that +relies on a [LOGO](http://en.wikipedia.org/wiki/Logo_programming_language)-like +API for drawing. How would you test that it does the right thing? Well, you can +run it and compare the screen with a golden screen snapshot, but let's admit it: +tests like this are expensive to run and fragile (What if you just upgraded to a +shiny new graphics card that has better anti-aliasing? Suddenly you have to +update all your golden images.). It would be too painful if all your tests are +like this. Fortunately, you learned about +[Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection) and know the right thing +to do: instead of having your application talk to the system API directly, wrap +the API in an interface (say, `Turtle`) and code to that interface: + +```cpp +class Turtle { + ... + virtual ~Turtle() {} + virtual void PenUp() = 0; + virtual void PenDown() = 0; + virtual void Forward(int distance) = 0; + virtual void Turn(int degrees) = 0; + virtual void GoTo(int x, int y) = 0; + virtual int GetX() const = 0; + virtual int GetY() const = 0; +}; +``` + +(Note that the destructor of `Turtle` **must** be virtual, as is the case for +**all** classes you intend to inherit from - otherwise the destructor of the +derived class will not be called when you delete an object through a base +pointer, and you'll get corrupted program states like memory leaks.) + +You can control whether the turtle's movement will leave a trace using `PenUp()` +and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and +`GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the +turtle. + +Your program will normally use a real implementation of this interface. In +tests, you can use a mock implementation instead. This allows you to easily +check what drawing primitives your program is calling, with what arguments, and +in which order. Tests written this way are much more robust (they won't break +because your new machine does anti-aliasing differently), easier to read and +maintain (the intent of a test is expressed in the code, not in some binary +images), and run *much, much faster*. + +## Writing the Mock Class + +If you are lucky, the mocks you need to use have already been implemented by +some nice people. If, however, you find yourself in the position to write a mock +class, relax - gMock turns this task into a fun game! (Well, almost.) + +### How to Define It + +Using the `Turtle` interface as example, here are the simple steps you need to +follow: + +* Derive a class `MockTurtle` from `Turtle`. +* Take a *virtual* function of `Turtle` (while it's possible to + [mock non-virtual methods using templates](gmock_cook_book.md#MockingNonVirtualMethods), + it's much more involved). +* In the `public:` section of the child class, write `MOCK_METHOD();` +* Now comes the fun part: you take the function signature, cut-and-paste it + into the macro, and add two commas - one between the return type and the + name, another between the name and the argument list. +* If you're mocking a const method, add a 4th parameter containing `(const)` + (the parentheses are required). +* Since you're overriding a virtual method, we suggest adding the `override` + keyword. For const methods the 4th parameter becomes `(const, override)`, + for non-const methods just `(override)`. This isn't mandatory. +* Repeat until all virtual functions you want to mock are done. (It goes + without saying that *all* pure virtual methods in your abstract class must + be either mocked or overridden.) + +After the process, you should have something like: + +```cpp +#include // Brings in gMock. + +class MockTurtle : public Turtle { + public: + ... + MOCK_METHOD(void, PenUp, (), (override)); + MOCK_METHOD(void, PenDown, (), (override)); + MOCK_METHOD(void, Forward, (int distance), (override)); + MOCK_METHOD(void, Turn, (int degrees), (override)); + MOCK_METHOD(void, GoTo, (int x, int y), (override)); + MOCK_METHOD(int, GetX, (), (const, override)); + MOCK_METHOD(int, GetY, (), (const, override)); +}; +``` + +You don't need to define these mock methods somewhere else - the `MOCK_METHOD` +macro will generate the definitions for you. It's that simple! + +### Where to Put It + +When you define a mock class, you need to decide where to put its definition. +Some people put it in a `_test.cc`. This is fine when the interface being mocked +(say, `Foo`) is owned by the same person or team. Otherwise, when the owner of +`Foo` changes it, your test could break. (You can't really expect `Foo`'s +maintainer to fix every test that uses `Foo`, can you?) + +Generally, you should not mock classes you don't own. If you must mock such a +class owned by others, define the mock class in `Foo`'s Bazel package (usually +the same directory or a `testing` sub-directory), and put it in a `.h` and a +`cc_library` with `testonly=True`. Then everyone can reference them from their +tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and +only tests that depend on the changed methods need to be fixed. + +Another way to do it: you can introduce a thin layer `FooAdaptor` on top of +`Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb +changes in `Foo` much more easily. While this is more work initially, carefully +choosing the adaptor interface can make your code easier to write and more +readable (a net win in the long run), as you can choose `FooAdaptor` to fit your +specific domain much better than `Foo` does. + +## Using Mocks in Tests + +Once you have a mock class, using it is easy. The typical work flow is: + +1. Import the gMock names from the `testing` namespace such that you can use + them unqualified (You only have to do it once per file). Remember that + namespaces are a good idea. +2. Create some mock objects. +3. Specify your expectations on them (How many times will a method be called? + With what arguments? What should it do? etc.). +4. Exercise some code that uses the mocks; optionally, check the result using + googletest assertions. If a mock method is called more than expected or with + wrong arguments, you'll get an error immediately. +5. When a mock is destructed, gMock will automatically check whether all + expectations on it have been satisfied. + +Here's an example: + +```cpp +#include "path/to/mock-turtle.h" +#include +#include + +using ::testing::AtLeast; // #1 + +TEST(PainterTest, CanDrawSomething) { + MockTurtle turtle; // #2 + EXPECT_CALL(turtle, PenDown()) // #3 + .Times(AtLeast(1)); + + Painter painter(&turtle); // #4 + + EXPECT_TRUE(painter.DrawCircle(0, 0, 10)); // #5 +} +``` + +As you might have guessed, this test checks that `PenDown()` is called at least +once. If the `painter` object didn't call this method, your test will fail with +a message like this: + +```text +path/to/my_test.cc:119: Failure +Actual function call count doesn't match this expectation: +Actually: never called; +Expected: called at least once. +Stack trace: +... +``` + +**Tip 1:** If you run the test from an Emacs buffer, you can hit `` on +the line number to jump right to the failed expectation. + +**Tip 2:** If your mock objects are never deleted, the final verification won't +happen. Therefore it's a good idea to turn on the heap checker in your tests +when you allocate mocks on the heap. You get that automatically if you use the +`gtest_main` library already. + +**Important note:** gMock requires expectations to be set **before** the mock +functions are called, otherwise the behavior is **undefined**. Do not alternate +between calls to `EXPECT_CALL()` and calls to the mock functions, and do not set +any expectations on a mock after passing the mock to an API. + +This means `EXPECT_CALL()` should be read as expecting that a call will occur +*in the future*, not that a call has occurred. Why does gMock work like that? +Well, specifying the expectation beforehand allows gMock to report a violation +as soon as it rises, when the context (stack trace, etc) is still available. +This makes debugging much easier. + +Admittedly, this test is contrived and doesn't do much. You can easily achieve +the same effect without using gMock. However, as we shall reveal soon, gMock +allows you to do *so much more* with the mocks. + +## Setting Expectations + +The key to using a mock object successfully is to set the *right expectations* +on it. If you set the expectations too strict, your test will fail as the result +of unrelated changes. If you set them too loose, bugs can slip through. You want +to do it just right such that your test can catch exactly the kind of bugs you +intend it to catch. gMock provides the necessary means for you to do it "just +right." + +### General Syntax + +In gMock we use the `EXPECT_CALL()` macro to set an expectation on a mock +method. The general syntax is: + +```cpp +EXPECT_CALL(mock_object, method(matchers)) + .Times(cardinality) + .WillOnce(action) + .WillRepeatedly(action); +``` + +The macro has two arguments: first the mock object, and then the method and its +arguments. Note that the two are separated by a comma (`,`), not a period (`.`). +(Why using a comma? The answer is that it was necessary for technical reasons.) +If the method is not overloaded, the macro can also be called without matchers: + +```cpp +EXPECT_CALL(mock_object, non-overloaded-method) + .Times(cardinality) + .WillOnce(action) + .WillRepeatedly(action); +``` + +This syntax allows the test writer to specify "called with any arguments" +without explicitly specifying the number or types of arguments. To avoid +unintended ambiguity, this syntax may only be used for methods that are not +overloaded. + +Either form of the macro can be followed by some optional *clauses* that provide +more information about the expectation. We'll discuss how each clause works in +the coming sections. + +This syntax is designed to make an expectation read like English. For example, +you can probably guess that + +```cpp +using ::testing::Return; +... +EXPECT_CALL(turtle, GetX()) + .Times(5) + .WillOnce(Return(100)) + .WillOnce(Return(150)) + .WillRepeatedly(Return(200)); +``` + +says that the `turtle` object's `GetX()` method will be called five times, it +will return 100 the first time, 150 the second time, and then 200 every time. +Some people like to call this style of syntax a Domain-Specific Language (DSL). + +{: .callout .note} +**Note:** Why do we use a macro to do this? Well it serves two purposes: first +it makes expectations easily identifiable (either by `grep` or by a human +reader), and second it allows gMock to include the source file location of a +failed expectation in messages, making debugging easier. + +### Matchers: What Arguments Do We Expect? + +When a mock function takes arguments, we may specify what arguments we are +expecting, for example: + +```cpp +// Expects the turtle to move forward by 100 units. +EXPECT_CALL(turtle, Forward(100)); +``` + +Oftentimes you do not want to be too specific. Remember that talk about tests +being too rigid? Over specification leads to brittle tests and obscures the +intent of tests. Therefore we encourage you to specify only what's necessary—no +more, no less. If you aren't interested in the value of an argument, write `_` +as the argument, which means "anything goes": + +```cpp +using ::testing::_; +... +// Expects that the turtle jumps to somewhere on the x=50 line. +EXPECT_CALL(turtle, GoTo(50, _)); +``` + +`_` is an instance of what we call **matchers**. A matcher is like a predicate +and can test whether an argument is what we'd expect. You can use a matcher +inside `EXPECT_CALL()` wherever a function argument is expected. `_` is a +convenient way of saying "any value". + +In the above examples, `100` and `50` are also matchers; implicitly, they are +the same as `Eq(100)` and `Eq(50)`, which specify that the argument must be +equal (using `operator==`) to the matcher argument. There are many +[built-in matchers](reference/matchers.md) for common types (as well as +[custom matchers](gmock_cook_book.md#NewMatchers)); for example: + +```cpp +using ::testing::Ge; +... +// Expects the turtle moves forward by at least 100. +EXPECT_CALL(turtle, Forward(Ge(100))); +``` + +If you don't care about *any* arguments, rather than specify `_` for each of +them you may instead omit the parameter list: + +```cpp +// Expects the turtle to move forward. +EXPECT_CALL(turtle, Forward); +// Expects the turtle to jump somewhere. +EXPECT_CALL(turtle, GoTo); +``` + +This works for all non-overloaded methods; if a method is overloaded, you need +to help gMock resolve which overload is expected by specifying the number of +arguments and possibly also the +[types of the arguments](gmock_cook_book.md#SelectOverload). + +### Cardinalities: How Many Times Will It Be Called? + +The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We +call its argument a **cardinality** as it tells *how many times* the call should +occur. It allows us to repeat an expectation many times without actually writing +it as many times. More importantly, a cardinality can be "fuzzy", just like a +matcher can be. This allows a user to express the intent of a test exactly. + +An interesting special case is when we say `Times(0)`. You may have guessed - it +means that the function shouldn't be called with the given arguments at all, and +gMock will report a googletest failure whenever the function is (wrongfully) +called. + +We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the +list of built-in cardinalities you can use, see +[here](gmock_cheat_sheet.md#CardinalityList). + +The `Times()` clause can be omitted. **If you omit `Times()`, gMock will infer +the cardinality for you.** The rules are easy to remember: + +* If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the + `EXPECT_CALL()`, the inferred cardinality is `Times(1)`. +* If there are *n* `WillOnce()`'s but **no** `WillRepeatedly()`, where *n* >= + 1, the cardinality is `Times(n)`. +* If there are *n* `WillOnce()`'s and **one** `WillRepeatedly()`, where *n* >= + 0, the cardinality is `Times(AtLeast(n))`. + +**Quick quiz:** what do you think will happen if a function is expected to be +called twice but actually called four times? + +### Actions: What Should It Do? + +Remember that a mock object doesn't really have a working implementation? We as +users have to tell it what to do when a method is invoked. This is easy in +gMock. + +First, if the return type of a mock function is a built-in type or a pointer, +the function has a **default action** (a `void` function will just return, a +`bool` function will return `false`, and other functions will return 0). In +addition, in C++ 11 and above, a mock function whose return type is +default-constructible (i.e. has a default constructor) has a default action of +returning a default-constructed value. If you don't say anything, this behavior +will be used. + +Second, if a mock function doesn't have a default action, or the default action +doesn't suit you, you can specify the action to be taken each time the +expectation matches using a series of `WillOnce()` clauses followed by an +optional `WillRepeatedly()`. For example, + +```cpp +using ::testing::Return; +... +EXPECT_CALL(turtle, GetX()) + .WillOnce(Return(100)) + .WillOnce(Return(200)) + .WillOnce(Return(300)); +``` + +says that `turtle.GetX()` will be called *exactly three times* (gMock inferred +this from how many `WillOnce()` clauses we've written, since we didn't +explicitly write `Times()`), and will return 100, 200, and 300 respectively. + +```cpp +using ::testing::Return; +... +EXPECT_CALL(turtle, GetY()) + .WillOnce(Return(100)) + .WillOnce(Return(200)) + .WillRepeatedly(Return(300)); +``` + +says that `turtle.GetY()` will be called *at least twice* (gMock knows this as +we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no +explicit `Times()`), will return 100 and 200 respectively the first two times, +and 300 from the third time on. + +Of course, if you explicitly write a `Times()`, gMock will not try to infer the +cardinality itself. What if the number you specified is larger than there are +`WillOnce()` clauses? Well, after all `WillOnce()`s are used up, gMock will do +the *default* action for the function every time (unless, of course, you have a +`WillRepeatedly()`.). + +What can we do inside `WillOnce()` besides `Return()`? You can return a +reference using `ReturnRef(`*`variable`*`)`, or invoke a pre-defined function, +among [others](gmock_cook_book.md#using-actions). + +**Important note:** The `EXPECT_CALL()` statement evaluates the action clause +only once, even though the action may be performed many times. Therefore you +must be careful about side effects. The following may not do what you want: + +```cpp +using ::testing::Return; +... +int n = 100; +EXPECT_CALL(turtle, GetX()) + .Times(4) + .WillRepeatedly(Return(n++)); +``` + +Instead of returning 100, 101, 102, ..., consecutively, this mock function will +always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` +will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will +return the same pointer every time. If you want the side effect to happen every +time, you need to define a custom action, which we'll teach in the +[cook book](gmock_cook_book.md). + +Time for another quiz! What do you think the following means? + +```cpp +using ::testing::Return; +... +EXPECT_CALL(turtle, GetY()) + .Times(4) + .WillOnce(Return(100)); +``` + +Obviously `turtle.GetY()` is expected to be called four times. But if you think +it will return 100 every time, think twice! Remember that one `WillOnce()` +clause will be consumed each time the function is invoked and the default action +will be taken afterwards. So the right answer is that `turtle.GetY()` will +return 100 the first time, but **return 0 from the second time on**, as +returning 0 is the default action for `int` functions. + +### Using Multiple Expectations {#MultiExpectations} + +So far we've only shown examples where you have a single expectation. More +realistically, you'll specify expectations on multiple mock methods which may be +from multiple mock objects. + +By default, when a mock method is invoked, gMock will search the expectations in +the **reverse order** they are defined, and stop when an active expectation that +matches the arguments is found (you can think of it as "newer rules override +older ones."). If the matching expectation cannot take any more calls, you will +get an upper-bound-violated failure. Here's an example: + +```cpp +using ::testing::_; +... +EXPECT_CALL(turtle, Forward(_)); // #1 +EXPECT_CALL(turtle, Forward(10)) // #2 + .Times(2); +``` + +If `Forward(10)` is called three times in a row, the third time it will be an +error, as the last matching expectation (#2) has been saturated. If, however, +the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, +as now #1 will be the matching expectation. + +{: .callout .note} +**Note:** Why does gMock search for a match in the *reverse* order of the +expectations? The reason is that this allows a user to set up the default +expectations in a mock object's constructor or the test fixture's set-up phase +and then customize the mock by writing more specific expectations in the test +body. So, if you have two expectations on the same method, you want to put the +one with more specific matchers **after** the other, or the more specific rule +would be shadowed by the more general one that comes after it. + +{: .callout .tip} +**Tip:** It is very common to start with a catch-all expectation for a method +and `Times(AnyNumber())` (omitting arguments, or with `_` for all arguments, if +overloaded). This makes any calls to the method expected. This is not necessary +for methods that are not mentioned at all (these are "uninteresting"), but is +useful for methods that have some expectations, but for which other calls are +ok. See +[Understanding Uninteresting vs Unexpected Calls](gmock_cook_book.md#uninteresting-vs-unexpected). + +### Ordered vs Unordered Calls {#OrderedCalls} + +By default, an expectation can match a call even though an earlier expectation +hasn't been satisfied. In other words, the calls don't have to occur in the +order the expectations are specified. + +Sometimes, you may want all the expected calls to occur in a strict order. To +say this in gMock is easy: + +```cpp +using ::testing::InSequence; +... +TEST(FooTest, DrawsLineSegment) { + ... + { + InSequence seq; + + EXPECT_CALL(turtle, PenDown()); + EXPECT_CALL(turtle, Forward(100)); + EXPECT_CALL(turtle, PenUp()); + } + Foo(); +} +``` + +By creating an object of type `InSequence`, all expectations in its scope are +put into a *sequence* and have to occur *sequentially*. Since we are just +relying on the constructor and destructor of this object to do the actual work, +its name is really irrelevant. + +In this example, we test that `Foo()` calls the three expected functions in the +order as written. If a call is made out-of-order, it will be an error. + +(What if you care about the relative order of some of the calls, but not all of +them? Can you specify an arbitrary partial order? The answer is ... yes! The +details can be found [here](gmock_cook_book.md#OrderedCalls).) + +### All Expectations Are Sticky (Unless Said Otherwise) {#StickyExpectations} + +Now let's do a quick quiz to see how well you can use this mock stuff already. +How would you test that the turtle is asked to go to the origin *exactly twice* +(you want to ignore any other instructions it receives)? + +After you've come up with your answer, take a look at ours and compare notes +(solve it yourself first - don't cheat!): + +```cpp +using ::testing::_; +using ::testing::AnyNumber; +... +EXPECT_CALL(turtle, GoTo(_, _)) // #1 + .Times(AnyNumber()); +EXPECT_CALL(turtle, GoTo(0, 0)) // #2 + .Times(2); +``` + +Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, gMock will +see that the arguments match expectation #2 (remember that we always pick the +last matching expectation). Now, since we said that there should be only two +such calls, gMock will report an error immediately. This is basically what we've +told you in the [Using Multiple Expectations](#MultiExpectations) section above. + +This example shows that **expectations in gMock are "sticky" by default**, in +the sense that they remain active even after we have reached their invocation +upper bounds. This is an important rule to remember, as it affects the meaning +of the spec, and is **different** to how it's done in many other mocking +frameworks (Why'd we do that? Because we think our rule makes the common cases +easier to express and understand.). + +Simple? Let's see if you've really understood it: what does the following code +say? + +```cpp +using ::testing::Return; +... +for (int i = n; i > 0; i--) { + EXPECT_CALL(turtle, GetX()) + .WillOnce(Return(10*i)); +} +``` + +If you think it says that `turtle.GetX()` will be called `n` times and will +return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we +said, expectations are sticky. So, the second time `turtle.GetX()` is called, +the last (latest) `EXPECT_CALL()` statement will match, and will immediately +lead to an "upper bound violated" error - this piece of code is not very useful! + +One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is +to explicitly say that the expectations are *not* sticky. In other words, they +should *retire* as soon as they are saturated: + +```cpp +using ::testing::Return; +... +for (int i = n; i > 0; i--) { + EXPECT_CALL(turtle, GetX()) + .WillOnce(Return(10*i)) + .RetiresOnSaturation(); +} +``` + +And, there's a better way to do it: in this case, we expect the calls to occur +in a specific order, and we line up the actions to match the order. Since the +order is important here, we should make it explicit using a sequence: + +```cpp +using ::testing::InSequence; +using ::testing::Return; +... +{ + InSequence s; + + for (int i = 1; i <= n; i++) { + EXPECT_CALL(turtle, GetX()) + .WillOnce(Return(10*i)) + .RetiresOnSaturation(); + } +} +``` + +By the way, the other situation where an expectation may *not* be sticky is when +it's in a sequence - as soon as another expectation that comes after it in the +sequence has been used, it automatically retires (and will never be used to +match any call). + +### Uninteresting Calls + +A mock object may have many methods, and not all of them are that interesting. +For example, in some tests we may not care about how many times `GetX()` and +`GetY()` get called. + +In gMock, if you are not interested in a method, just don't say anything about +it. If a call to this method occurs, you'll see a warning in the test output, +but it won't be a failure. This is called "naggy" behavior; to change, see +[The Nice, the Strict, and the Naggy](gmock_cook_book.md#NiceStrictNaggy). diff --git a/cpp/third_party/googletest/docs/index.md b/cpp/third_party/googletest/docs/index.md new file mode 100644 index 0000000..b162c74 --- /dev/null +++ b/cpp/third_party/googletest/docs/index.md @@ -0,0 +1,22 @@ +# GoogleTest User's Guide + +## Welcome to GoogleTest! + +GoogleTest is Google's C++ testing and mocking framework. This user's guide has +the following contents: + +* [GoogleTest Primer](primer.md) - Teaches you how to write simple tests using + GoogleTest. Read this first if you are new to GoogleTest. +* [GoogleTest Advanced](advanced.md) - Read this when you've finished the + Primer and want to utilize GoogleTest to its full potential. +* [GoogleTest Samples](samples.md) - Describes some GoogleTest samples. +* [GoogleTest FAQ](faq.md) - Have a question? Want some tips? Check here + first. +* [Mocking for Dummies](gmock_for_dummies.md) - Teaches you how to create mock + objects and use them in tests. +* [Mocking Cookbook](gmock_cook_book.md) - Includes tips and approaches to + common mocking use cases. +* [Mocking Cheat Sheet](gmock_cheat_sheet.md) - A handy reference for + matchers, actions, invariants, and more. +* [Mocking FAQ](gmock_faq.md) - Contains answers to some mocking-specific + questions. diff --git a/cpp/third_party/googletest/docs/pkgconfig.md b/cpp/third_party/googletest/docs/pkgconfig.md new file mode 100644 index 0000000..bf05d59 --- /dev/null +++ b/cpp/third_party/googletest/docs/pkgconfig.md @@ -0,0 +1,144 @@ +## Using GoogleTest from various build systems + +GoogleTest comes with pkg-config files that can be used to determine all +necessary flags for compiling and linking to GoogleTest (and GoogleMock). +Pkg-config is a standardised plain-text format containing + +* the includedir (-I) path +* necessary macro (-D) definitions +* further required flags (-pthread) +* the library (-L) path +* the library (-l) to link to + +All current build systems support pkg-config in one way or another. For all +examples here we assume you want to compile the sample +`samples/sample3_unittest.cc`. + +### CMake + +Using `pkg-config` in CMake is fairly easy: + +```cmake +find_package(PkgConfig) +pkg_search_module(GTEST REQUIRED gtest_main) + +add_executable(testapp) +target_sources(testapp PRIVATE samples/sample3_unittest.cc) +target_link_libraries(testapp PRIVATE ${GTEST_LDFLAGS}) +target_compile_options(testapp PRIVATE ${GTEST_CFLAGS}) + +enable_testing() +add_test(first_and_only_test testapp) +``` + +It is generally recommended that you use `target_compile_options` + `_CFLAGS` +over `target_include_directories` + `_INCLUDE_DIRS` as the former includes not +just -I flags (GoogleTest might require a macro indicating to internal headers +that all libraries have been compiled with threading enabled. In addition, +GoogleTest might also require `-pthread` in the compiling step, and as such +splitting the pkg-config `Cflags` variable into include dirs and macros for +`target_compile_definitions()` might still miss this). The same recommendation +goes for using `_LDFLAGS` over the more commonplace `_LIBRARIES`, which happens +to discard `-L` flags and `-pthread`. + +### Help! pkg-config can't find GoogleTest! + +Let's say you have a `CMakeLists.txt` along the lines of the one in this +tutorial and you try to run `cmake`. It is very possible that you get a failure +along the lines of: + +``` +-- Checking for one of the modules 'gtest_main' +CMake Error at /usr/share/cmake/Modules/FindPkgConfig.cmake:640 (message): + None of the required 'gtest_main' found +``` + +These failures are common if you installed GoogleTest yourself and have not +sourced it from a distro or other package manager. If so, you need to tell +pkg-config where it can find the `.pc` files containing the information. Say you +installed GoogleTest to `/usr/local`, then it might be that the `.pc` files are +installed under `/usr/local/lib64/pkgconfig`. If you set + +``` +export PKG_CONFIG_PATH=/usr/local/lib64/pkgconfig +``` + +pkg-config will also try to look in `PKG_CONFIG_PATH` to find `gtest_main.pc`. + +### Using pkg-config in a cross-compilation setting + +Pkg-config can be used in a cross-compilation setting too. To do this, let's +assume the final prefix of the cross-compiled installation will be `/usr`, and +your sysroot is `/home/MYUSER/sysroot`. Configure and install GTest using + +``` +mkdir build && cmake -DCMAKE_INSTALL_PREFIX=/usr .. +``` + +Install into the sysroot using `DESTDIR`: + +``` +make -j install DESTDIR=/home/MYUSER/sysroot +``` + +Before we continue, it is recommended to **always** define the following two +variables for pkg-config in a cross-compilation setting: + +``` +export PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=yes +export PKG_CONFIG_ALLOW_SYSTEM_LIBS=yes +``` + +otherwise `pkg-config` will filter `-I` and `-L` flags against standard prefixes +such as `/usr` (see https://bugs.freedesktop.org/show_bug.cgi?id=28264#c3 for +reasons why this stripping needs to occur usually). + +If you look at the generated pkg-config file, it will look something like + +``` +libdir=/usr/lib64 +includedir=/usr/include + +Name: gtest +Description: GoogleTest (without main() function) +Version: 1.11.0 +URL: https://github.com/google/googletest +Libs: -L${libdir} -lgtest -lpthread +Cflags: -I${includedir} -DGTEST_HAS_PTHREAD=1 -lpthread +``` + +Notice that the sysroot is not included in `libdir` and `includedir`! If you try +to run `pkg-config` with the correct +`PKG_CONFIG_LIBDIR=/home/MYUSER/sysroot/usr/lib64/pkgconfig` against this `.pc` +file, you will get + +``` +$ pkg-config --cflags gtest +-DGTEST_HAS_PTHREAD=1 -lpthread -I/usr/include +$ pkg-config --libs gtest +-L/usr/lib64 -lgtest -lpthread +``` + +which is obviously wrong and points to the `CBUILD` and not `CHOST` root. In +order to use this in a cross-compilation setting, we need to tell pkg-config to +inject the actual sysroot into `-I` and `-L` variables. Let us now tell +pkg-config about the actual sysroot + +``` +export PKG_CONFIG_DIR= +export PKG_CONFIG_SYSROOT_DIR=/home/MYUSER/sysroot +export PKG_CONFIG_LIBDIR=${PKG_CONFIG_SYSROOT_DIR}/usr/lib64/pkgconfig +``` + +and running `pkg-config` again we get + +``` +$ pkg-config --cflags gtest +-DGTEST_HAS_PTHREAD=1 -lpthread -I/home/MYUSER/sysroot/usr/include +$ pkg-config --libs gtest +-L/home/MYUSER/sysroot/usr/lib64 -lgtest -lpthread +``` + +which contains the correct sysroot now. For a more comprehensive guide to also +including `${CHOST}` in build system calls, see the excellent tutorial by Diego +Elio Pettenò: diff --git a/cpp/third_party/googletest/docs/platforms.md b/cpp/third_party/googletest/docs/platforms.md new file mode 100644 index 0000000..d35a7be --- /dev/null +++ b/cpp/third_party/googletest/docs/platforms.md @@ -0,0 +1,8 @@ +# Supported Platforms + +GoogleTest follows Google's +[Foundational C++ Support Policy](https://opensource.google/documentation/policies/cplusplus-support). +See +[this table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md) +for a list of currently supported versions compilers, platforms, and build +tools. diff --git a/cpp/third_party/googletest/docs/primer.md b/cpp/third_party/googletest/docs/primer.md new file mode 100644 index 0000000..f2a97a7 --- /dev/null +++ b/cpp/third_party/googletest/docs/primer.md @@ -0,0 +1,483 @@ +# GoogleTest Primer + +## Introduction: Why GoogleTest? + +*GoogleTest* helps you write better C++ tests. + +GoogleTest is a testing framework developed by the Testing Technology team with +Google's specific requirements and constraints in mind. Whether you work on +Linux, Windows, or a Mac, if you write C++ code, GoogleTest can help you. And it +supports *any* kind of tests, not just unit tests. + +So what makes a good test, and how does GoogleTest fit in? We believe: + +1. Tests should be *independent* and *repeatable*. It's a pain to debug a test + that succeeds or fails as a result of other tests. GoogleTest isolates the + tests by running each of them on a different object. When a test fails, + GoogleTest allows you to run it in isolation for quick debugging. +2. Tests should be well *organized* and reflect the structure of the tested + code. GoogleTest groups related tests into test suites that can share data + and subroutines. This common pattern is easy to recognize and makes tests + easy to maintain. Such consistency is especially helpful when people switch + projects and start to work on a new code base. +3. Tests should be *portable* and *reusable*. Google has a lot of code that is + platform-neutral; its tests should also be platform-neutral. GoogleTest + works on different OSes, with different compilers, with or without + exceptions, so GoogleTest tests can work with a variety of configurations. +4. When tests fail, they should provide as much *information* about the problem + as possible. GoogleTest doesn't stop at the first test failure. Instead, it + only stops the current test and continues with the next. You can also set up + tests that report non-fatal failures after which the current test continues. + Thus, you can detect and fix multiple bugs in a single run-edit-compile + cycle. +5. The testing framework should liberate test writers from housekeeping chores + and let them focus on the test *content*. GoogleTest automatically keeps + track of all tests defined, and doesn't require the user to enumerate them + in order to run them. +6. Tests should be *fast*. With GoogleTest, you can reuse shared resources + across tests and pay for the set-up/tear-down only once, without making + tests depend on each other. + +Since GoogleTest is based on the popular xUnit architecture, you'll feel right +at home if you've used JUnit or PyUnit before. If not, it will take you about 10 +minutes to learn the basics and get started. So let's go! + +## Beware of the Nomenclature + +{: .callout .note} +*Note:* There might be some confusion arising from different definitions of the +terms *Test*, *Test Case* and *Test Suite*, so beware of misunderstanding these. + +Historically, GoogleTest started to use the term *Test Case* for grouping +related tests, whereas current publications, including International Software +Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) materials and +various textbooks on software quality, use the term +*[Test Suite][istqb test suite]* for this. + +The related term *Test*, as it is used in GoogleTest, corresponds to the term +*[Test Case][istqb test case]* of ISTQB and others. + +The term *Test* is commonly of broad enough sense, including ISTQB's definition +of *Test Case*, so it's not much of a problem here. But the term *Test Case* as +was used in Google Test is of contradictory sense and thus confusing. + +GoogleTest recently started replacing the term *Test Case* with *Test Suite*. +The preferred API is *TestSuite*. The older TestCase API is being slowly +deprecated and refactored away. + +So please be aware of the different definitions of the terms: + + +Meaning | GoogleTest Term | [ISTQB](http://www.istqb.org/) Term +:----------------------------------------------------------------------------------- | :---------------------- | :---------------------------------- +Exercise a particular program path with specific input values and verify the results | [TEST()](#simple-tests) | [Test Case][istqb test case] + + +[istqb test case]: http://glossary.istqb.org/en/search/test%20case +[istqb test suite]: http://glossary.istqb.org/en/search/test%20suite + +## Basic Concepts + +When using GoogleTest, you start by writing *assertions*, which are statements +that check whether a condition is true. An assertion's result can be *success*, +*nonfatal failure*, or *fatal failure*. If a fatal failure occurs, it aborts the +current function; otherwise the program continues normally. + +*Tests* use assertions to verify the tested code's behavior. If a test crashes +or has a failed assertion, then it *fails*; otherwise it *succeeds*. + +A *test suite* contains one or many tests. You should group your tests into test +suites that reflect the structure of the tested code. When multiple tests in a +test suite need to share common objects and subroutines, you can put them into a +*test fixture* class. + +A *test program* can contain multiple test suites. + +We'll now explain how to write a test program, starting at the individual +assertion level and building up to tests and test suites. + +## Assertions + +GoogleTest assertions are macros that resemble function calls. You test a class +or function by making assertions about its behavior. When an assertion fails, +GoogleTest prints the assertion's source file and line number location, along +with a failure message. You may also supply a custom failure message which will +be appended to GoogleTest's message. + +The assertions come in pairs that test the same thing but have different effects +on the current function. `ASSERT_*` versions generate fatal failures when they +fail, and **abort the current function**. `EXPECT_*` versions generate nonfatal +failures, which don't abort the current function. Usually `EXPECT_*` are +preferred, as they allow more than one failure to be reported in a test. +However, you should use `ASSERT_*` if it doesn't make sense to continue when the +assertion in question fails. + +Since a failed `ASSERT_*` returns from the current function immediately, +possibly skipping clean-up code that comes after it, it may cause a space leak. +Depending on the nature of the leak, it may or may not be worth fixing - so keep +this in mind if you get a heap checker error in addition to assertion errors. + +To provide a custom failure message, simply stream it into the macro using the +`<<` operator or a sequence of such operators. See the following example, using +the [`ASSERT_EQ` and `EXPECT_EQ`](reference/assertions.md#EXPECT_EQ) macros to +verify value equality: + +```c++ +ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length"; + +for (int i = 0; i < x.size(); ++i) { + EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i; +} +``` + +Anything that can be streamed to an `ostream` can be streamed to an assertion +macro--in particular, C strings and `string` objects. If a wide string +(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is +streamed to an assertion, it will be translated to UTF-8 when printed. + +GoogleTest provides a collection of assertions for verifying the behavior of +your code in various ways. You can check Boolean conditions, compare values +based on relational operators, verify string values, floating-point values, and +much more. There are even assertions that enable you to verify more complex +states by providing custom predicates. For the complete list of assertions +provided by GoogleTest, see the [Assertions Reference](reference/assertions.md). + +## Simple Tests + +To create a test: + +1. Use the `TEST()` macro to define and name a test function. These are + ordinary C++ functions that don't return a value. +2. In this function, along with any valid C++ statements you want to include, + use the various GoogleTest assertions to check values. +3. The test's result is determined by the assertions; if any assertion in the + test fails (either fatally or non-fatally), or if the test crashes, the + entire test fails. Otherwise, it succeeds. + +```c++ +TEST(TestSuiteName, TestName) { + ... test body ... +} +``` + +`TEST()` arguments go from general to specific. The *first* argument is the name +of the test suite, and the *second* argument is the test's name within the test +suite. Both names must be valid C++ identifiers, and they should not contain any +underscores (`_`). A test's *full name* consists of its containing test suite +and its individual name. Tests from different test suites can have the same +individual name. + +For example, let's take a simple integer function: + +```c++ +int Factorial(int n); // Returns the factorial of n +``` + +A test suite for this function might look like: + +```c++ +// Tests factorial of 0. +TEST(FactorialTest, HandlesZeroInput) { + EXPECT_EQ(Factorial(0), 1); +} + +// Tests factorial of positive numbers. +TEST(FactorialTest, HandlesPositiveInput) { + EXPECT_EQ(Factorial(1), 1); + EXPECT_EQ(Factorial(2), 2); + EXPECT_EQ(Factorial(3), 6); + EXPECT_EQ(Factorial(8), 40320); +} +``` + +GoogleTest groups the test results by test suites, so logically related tests +should be in the same test suite; in other words, the first argument to their +`TEST()` should be the same. In the above example, we have two tests, +`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test +suite `FactorialTest`. + +When naming your test suites and tests, you should follow the same convention as +for +[naming functions and classes](https://google.github.io/styleguide/cppguide.html#Function_Names). + +**Availability**: Linux, Windows, Mac. + +## Test Fixtures: Using the Same Data Configuration for Multiple Tests {#same-data-multiple-tests} + +If you find yourself writing two or more tests that operate on similar data, you +can use a *test fixture*. This allows you to reuse the same configuration of +objects for several different tests. + +To create a fixture: + +1. Derive a class from `::testing::Test` . Start its body with `protected:`, as + we'll want to access fixture members from sub-classes. +2. Inside the class, declare any objects you plan to use. +3. If necessary, write a default constructor or `SetUp()` function to prepare + the objects for each test. A common mistake is to spell `SetUp()` as + **`Setup()`** with a small `u` - Use `override` in C++11 to make sure you + spelled it correctly. +4. If necessary, write a destructor or `TearDown()` function to release any + resources you allocated in `SetUp()` . To learn when you should use the + constructor/destructor and when you should use `SetUp()/TearDown()`, read + the [FAQ](faq.md#CtorVsSetUp). +5. If needed, define subroutines for your tests to share. + +When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to +access objects and subroutines in the test fixture: + +```c++ +TEST_F(TestFixtureClassName, TestName) { + ... test body ... +} +``` + +Unlike `TEST()`, in `TEST_F()` the first argument must be the name of the test +fixture class. (`_F` stands for "Fixture"). No test suite name is specified for +this macro. + +Unfortunately, the C++ macro system does not allow us to create a single macro +that can handle both types of tests. Using the wrong macro causes a compiler +error. + +Also, you must first define a test fixture class before using it in a +`TEST_F()`, or you'll get the compiler error "`virtual outside class +declaration`". + +For each test defined with `TEST_F()`, GoogleTest will create a *fresh* test +fixture at runtime, immediately initialize it via `SetUp()`, run the test, clean +up by calling `TearDown()`, and then delete the test fixture. Note that +different tests in the same test suite have different test fixture objects, and +GoogleTest always deletes a test fixture before it creates the next one. +GoogleTest does **not** reuse the same test fixture for multiple tests. Any +changes one test makes to the fixture do not affect other tests. + +As an example, let's write tests for a FIFO queue class named `Queue`, which has +the following interface: + +```c++ +template // E is the element type. +class Queue { + public: + Queue(); + void Enqueue(const E& element); + E* Dequeue(); // Returns NULL if the queue is empty. + size_t size() const; + ... +}; +``` + +First, define a fixture class. By convention, you should give it the name +`FooTest` where `Foo` is the class being tested. + +```c++ +class QueueTest : public ::testing::Test { + protected: + void SetUp() override { + // q0_ remains empty + q1_.Enqueue(1); + q2_.Enqueue(2); + q2_.Enqueue(3); + } + + // void TearDown() override {} + + Queue q0_; + Queue q1_; + Queue q2_; +}; +``` + +In this case, `TearDown()` is not needed since we don't have to clean up after +each test, other than what's already done by the destructor. + +Now we'll write tests using `TEST_F()` and this fixture. + +```c++ +TEST_F(QueueTest, IsEmptyInitially) { + EXPECT_EQ(q0_.size(), 0); +} + +TEST_F(QueueTest, DequeueWorks) { + int* n = q0_.Dequeue(); + EXPECT_EQ(n, nullptr); + + n = q1_.Dequeue(); + ASSERT_NE(n, nullptr); + EXPECT_EQ(*n, 1); + EXPECT_EQ(q1_.size(), 0); + delete n; + + n = q2_.Dequeue(); + ASSERT_NE(n, nullptr); + EXPECT_EQ(*n, 2); + EXPECT_EQ(q2_.size(), 1); + delete n; +} +``` + +The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is +to use `EXPECT_*` when you want the test to continue to reveal more errors after +the assertion failure, and use `ASSERT_*` when continuing after failure doesn't +make sense. For example, the second assertion in the `Dequeue` test is +`ASSERT_NE(n, nullptr)`, as we need to dereference the pointer `n` later, which +would lead to a segfault when `n` is `NULL`. + +When these tests run, the following happens: + +1. GoogleTest constructs a `QueueTest` object (let's call it `t1`). +2. `t1.SetUp()` initializes `t1`. +3. The first test (`IsEmptyInitially`) runs on `t1`. +4. `t1.TearDown()` cleans up after the test finishes. +5. `t1` is destructed. +6. The above steps are repeated on another `QueueTest` object, this time + running the `DequeueWorks` test. + +**Availability**: Linux, Windows, Mac. + +## Invoking the Tests + +`TEST()` and `TEST_F()` implicitly register their tests with GoogleTest. So, +unlike with many other C++ testing frameworks, you don't have to re-list all +your defined tests in order to run them. + +After defining your tests, you can run them with `RUN_ALL_TESTS()`, which +returns `0` if all the tests are successful, or `1` otherwise. Note that +`RUN_ALL_TESTS()` runs *all tests* in your link unit--they can be from different +test suites, or even different source files. + +When invoked, the `RUN_ALL_TESTS()` macro: + +* Saves the state of all GoogleTest flags. + +* Creates a test fixture object for the first test. + +* Initializes it via `SetUp()`. + +* Runs the test on the fixture object. + +* Cleans up the fixture via `TearDown()`. + +* Deletes the fixture. + +* Restores the state of all GoogleTest flags. + +* Repeats the above steps for the next test, until all tests have run. + +If a fatal failure happens the subsequent steps will be skipped. + +{: .callout .important} +> IMPORTANT: You must **not** ignore the return value of `RUN_ALL_TESTS()`, or +> you will get a compiler error. The rationale for this design is that the +> automated testing service determines whether a test has passed based on its +> exit code, not on its stdout/stderr output; thus your `main()` function must +> return the value of `RUN_ALL_TESTS()`. +> +> Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than +> once conflicts with some advanced GoogleTest features (e.g., thread-safe +> [death tests](advanced.md#death-tests)) and thus is not supported. + +**Availability**: Linux, Windows, Mac. + +## Writing the main() Function + +Most users should *not* need to write their own `main` function and instead link +with `gtest_main` (as opposed to with `gtest`), which defines a suitable entry +point. See the end of this section for details. The remainder of this section +should only apply when you need to do something custom before the tests run that +cannot be expressed within the framework of fixtures and test suites. + +If you write your own `main` function, it should return the value of +`RUN_ALL_TESTS()`. + +You can start from this boilerplate: + +```c++ +#include "this/package/foo.h" + +#include + +namespace my { +namespace project { +namespace { + +// The fixture for testing class Foo. +class FooTest : public ::testing::Test { + protected: + // You can remove any or all of the following functions if their bodies would + // be empty. + + FooTest() { + // You can do set-up work for each test here. + } + + ~FooTest() override { + // You can do clean-up work that doesn't throw exceptions here. + } + + // If the constructor and destructor are not enough for setting up + // and cleaning up each test, you can define the following methods: + + void SetUp() override { + // Code here will be called immediately after the constructor (right + // before each test). + } + + void TearDown() override { + // Code here will be called immediately after each test (right + // before the destructor). + } + + // Class members declared here can be used by all tests in the test suite + // for Foo. +}; + +// Tests that the Foo::Bar() method does Abc. +TEST_F(FooTest, MethodBarDoesAbc) { + const std::string input_filepath = "this/package/testdata/myinputfile.dat"; + const std::string output_filepath = "this/package/testdata/myoutputfile.dat"; + Foo f; + EXPECT_EQ(f.Bar(input_filepath, output_filepath), 0); +} + +// Tests that Foo does Xyz. +TEST_F(FooTest, DoesXyz) { + // Exercises the Xyz feature of Foo. +} + +} // namespace +} // namespace project +} // namespace my + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} +``` + +The `::testing::InitGoogleTest()` function parses the command line for +GoogleTest flags, and removes all recognized flags. This allows the user to +control a test program's behavior via various flags, which we'll cover in the +[AdvancedGuide](advanced.md). You **must** call this function before calling +`RUN_ALL_TESTS()`, or the flags won't be properly initialized. + +On Windows, `InitGoogleTest()` also works with wide strings, so it can be used +in programs compiled in `UNICODE` mode as well. + +But maybe you think that writing all those `main` functions is too much work? We +agree with you completely, and that's why Google Test provides a basic +implementation of main(). If it fits your needs, then just link your test with +the `gtest_main` library and you are good to go. + +{: .callout .note} +NOTE: `ParseGUnitFlags()` is deprecated in favor of `InitGoogleTest()`. + +## Known Limitations + +* Google Test is designed to be thread-safe. The implementation is thread-safe + on systems where the `pthreads` library is available. It is currently + *unsafe* to use Google Test assertions from two threads concurrently on + other systems (e.g. Windows). In most tests this is not an issue as usually + the assertions are done in the main thread. If you want to help, you can + volunteer to implement the necessary synchronization primitives in + `gtest-port.h` for your platform. diff --git a/cpp/third_party/googletest/docs/quickstart-bazel.md b/cpp/third_party/googletest/docs/quickstart-bazel.md new file mode 100644 index 0000000..4f693db --- /dev/null +++ b/cpp/third_party/googletest/docs/quickstart-bazel.md @@ -0,0 +1,153 @@ +# Quickstart: Building with Bazel + +This tutorial aims to get you up and running with GoogleTest using the Bazel +build system. If you're using GoogleTest for the first time or need a refresher, +we recommend this tutorial as a starting point. + +## Prerequisites + +To complete this tutorial, you'll need: + +* A compatible operating system (e.g. Linux, macOS, Windows). +* A compatible C++ compiler that supports at least C++14. +* [Bazel](https://bazel.build/), the preferred build system used by the + GoogleTest team. + +See [Supported Platforms](platforms.md) for more information about platforms +compatible with GoogleTest. + +If you don't already have Bazel installed, see the +[Bazel installation guide](https://bazel.build/install). + +{: .callout .note} Note: The terminal commands in this tutorial show a Unix +shell prompt, but the commands work on the Windows command line as well. + +## Set up a Bazel workspace + +A +[Bazel workspace](https://docs.bazel.build/versions/main/build-ref.html#workspace) +is a directory on your filesystem that you use to manage source files for the +software you want to build. Each workspace directory has a text file named +`WORKSPACE` which may be empty, or may contain references to external +dependencies required to build the outputs. + +First, create a directory for your workspace: + +``` +$ mkdir my_workspace && cd my_workspace +``` + +Next, you’ll create the `WORKSPACE` file to specify dependencies. A common and +recommended way to depend on GoogleTest is to use a +[Bazel external dependency](https://docs.bazel.build/versions/main/external.html) +via the +[`http_archive` rule](https://docs.bazel.build/versions/main/repo/http.html#http_archive). +To do this, in the root directory of your workspace (`my_workspace/`), create a +file named `WORKSPACE` with the following contents: + +``` +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +http_archive( + name = "com_google_googletest", + urls = ["https://github.com/google/googletest/archive/5ab508a01f9eb089207ee87fd547d290da39d015.zip"], + strip_prefix = "googletest-5ab508a01f9eb089207ee87fd547d290da39d015", +) +``` + +The above configuration declares a dependency on GoogleTest which is downloaded +as a ZIP archive from GitHub. In the above example, +`5ab508a01f9eb089207ee87fd547d290da39d015` is the Git commit hash of the +GoogleTest version to use; we recommend updating the hash often to point to the +latest version. Use a recent hash on the `main` branch. + +Now you're ready to build C++ code that uses GoogleTest. + +## Create and run a binary + +With your Bazel workspace set up, you can now use GoogleTest code within your +own project. + +As an example, create a file named `hello_test.cc` in your `my_workspace` +directory with the following contents: + +```cpp +#include + +// Demonstrate some basic assertions. +TEST(HelloTest, BasicAssertions) { + // Expect two strings not to be equal. + EXPECT_STRNE("hello", "world"); + // Expect equality. + EXPECT_EQ(7 * 6, 42); +} +``` + +GoogleTest provides [assertions](primer.md#assertions) that you use to test the +behavior of your code. The above sample includes the main GoogleTest header file +and demonstrates some basic assertions. + +To build the code, create a file named `BUILD` in the same directory with the +following contents: + +``` +cc_test( + name = "hello_test", + size = "small", + srcs = ["hello_test.cc"], + deps = ["@com_google_googletest//:gtest_main"], +) +``` + +This `cc_test` rule declares the C++ test binary you want to build, and links to +GoogleTest (`//:gtest_main`) using the prefix you specified in the `WORKSPACE` +file (`@com_google_googletest`). For more information about Bazel `BUILD` files, +see the +[Bazel C++ Tutorial](https://docs.bazel.build/versions/main/tutorial/cpp.html). + +{: .callout .note} +NOTE: In the example below, we assume Clang or GCC and set `--cxxopt=-std=c++14` +to ensure that GoogleTest is compiled as C++14 instead of the compiler's default +setting (which could be C++11). For MSVC, the equivalent would be +`--cxxopt=/std:c++14`. See [Supported Platforms](platforms.md) for more details +on supported language versions. + +Now you can build and run your test: + +
+my_workspace$ bazel test --cxxopt=-std=c++14 --test_output=all //:hello_test
+INFO: Analyzed target //:hello_test (26 packages loaded, 362 targets configured).
+INFO: Found 1 test target...
+INFO: From Testing //:hello_test:
+==================== Test output for //:hello_test:
+Running main() from gmock_main.cc
+[==========] Running 1 test from 1 test suite.
+[----------] Global test environment set-up.
+[----------] 1 test from HelloTest
+[ RUN      ] HelloTest.BasicAssertions
+[       OK ] HelloTest.BasicAssertions (0 ms)
+[----------] 1 test from HelloTest (0 ms total)
+
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test suite ran. (0 ms total)
+[  PASSED  ] 1 test.
+================================================================================
+Target //:hello_test up-to-date:
+  bazel-bin/hello_test
+INFO: Elapsed time: 4.190s, Critical Path: 3.05s
+INFO: 27 processes: 8 internal, 19 linux-sandbox.
+INFO: Build completed successfully, 27 total actions
+//:hello_test                                                     PASSED in 0.1s
+
+INFO: Build completed successfully, 27 total actions
+
+ +Congratulations! You've successfully built and run a test binary using +GoogleTest. + +## Next steps + +* [Check out the Primer](primer.md) to start learning how to write simple + tests. +* [See the code samples](samples.md) for more examples showing how to use a + variety of GoogleTest features. diff --git a/cpp/third_party/googletest/docs/quickstart-cmake.md b/cpp/third_party/googletest/docs/quickstart-cmake.md new file mode 100644 index 0000000..4e422b7 --- /dev/null +++ b/cpp/third_party/googletest/docs/quickstart-cmake.md @@ -0,0 +1,157 @@ +# Quickstart: Building with CMake + +This tutorial aims to get you up and running with GoogleTest using CMake. If +you're using GoogleTest for the first time or need a refresher, we recommend +this tutorial as a starting point. If your project uses Bazel, see the +[Quickstart for Bazel](quickstart-bazel.md) instead. + +## Prerequisites + +To complete this tutorial, you'll need: + +* A compatible operating system (e.g. Linux, macOS, Windows). +* A compatible C++ compiler that supports at least C++14. +* [CMake](https://cmake.org/) and a compatible build tool for building the + project. + * Compatible build tools include + [Make](https://www.gnu.org/software/make/), + [Ninja](https://ninja-build.org/), and others - see + [CMake Generators](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html) + for more information. + +See [Supported Platforms](platforms.md) for more information about platforms +compatible with GoogleTest. + +If you don't already have CMake installed, see the +[CMake installation guide](https://cmake.org/install). + +{: .callout .note} +Note: The terminal commands in this tutorial show a Unix shell prompt, but the +commands work on the Windows command line as well. + +## Set up a project + +CMake uses a file named `CMakeLists.txt` to configure the build system for a +project. You'll use this file to set up your project and declare a dependency on +GoogleTest. + +First, create a directory for your project: + +``` +$ mkdir my_project && cd my_project +``` + +Next, you'll create the `CMakeLists.txt` file and declare a dependency on +GoogleTest. There are many ways to express dependencies in the CMake ecosystem; +in this quickstart, you'll use the +[`FetchContent` CMake module](https://cmake.org/cmake/help/latest/module/FetchContent.html). +To do this, in your project directory (`my_project`), create a file named +`CMakeLists.txt` with the following contents: + +```cmake +cmake_minimum_required(VERSION 3.14) +project(my_project) + +# GoogleTest requires at least C++14 +set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +include(FetchContent) +FetchContent_Declare( + googletest + URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip +) +# For Windows: Prevent overriding the parent project's compiler/linker settings +set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) +FetchContent_MakeAvailable(googletest) +``` + +The above configuration declares a dependency on GoogleTest which is downloaded +from GitHub. In the above example, `03597a01ee50ed33e9dfd640b249b4be3799d395` is +the Git commit hash of the GoogleTest version to use; we recommend updating the +hash often to point to the latest version. + +For more information about how to create `CMakeLists.txt` files, see the +[CMake Tutorial](https://cmake.org/cmake/help/latest/guide/tutorial/index.html). + +## Create and run a binary + +With GoogleTest declared as a dependency, you can use GoogleTest code within +your own project. + +As an example, create a file named `hello_test.cc` in your `my_project` +directory with the following contents: + +```cpp +#include + +// Demonstrate some basic assertions. +TEST(HelloTest, BasicAssertions) { + // Expect two strings not to be equal. + EXPECT_STRNE("hello", "world"); + // Expect equality. + EXPECT_EQ(7 * 6, 42); +} +``` + +GoogleTest provides [assertions](primer.md#assertions) that you use to test the +behavior of your code. The above sample includes the main GoogleTest header file +and demonstrates some basic assertions. + +To build the code, add the following to the end of your `CMakeLists.txt` file: + +```cmake +enable_testing() + +add_executable( + hello_test + hello_test.cc +) +target_link_libraries( + hello_test + GTest::gtest_main +) + +include(GoogleTest) +gtest_discover_tests(hello_test) +``` + +The above configuration enables testing in CMake, declares the C++ test binary +you want to build (`hello_test`), and links it to GoogleTest (`gtest_main`). The +last two lines enable CMake's test runner to discover the tests included in the +binary, using the +[`GoogleTest` CMake module](https://cmake.org/cmake/help/git-stage/module/GoogleTest.html). + +Now you can build and run your test: + +
+my_project$ cmake -S . -B build
+-- The C compiler identification is GNU 10.2.1
+-- The CXX compiler identification is GNU 10.2.1
+...
+-- Build files have been written to: .../my_project/build
+
+my_project$ cmake --build build
+Scanning dependencies of target gtest
+...
+[100%] Built target gmock_main
+
+my_project$ cd build && ctest
+Test project .../my_project/build
+    Start 1: HelloTest.BasicAssertions
+1/1 Test #1: HelloTest.BasicAssertions ........   Passed    0.00 sec
+
+100% tests passed, 0 tests failed out of 1
+
+Total Test time (real) =   0.01 sec
+
+ +Congratulations! You've successfully built and run a test binary using +GoogleTest. + +## Next steps + +* [Check out the Primer](primer.md) to start learning how to write simple + tests. +* [See the code samples](samples.md) for more examples showing how to use a + variety of GoogleTest features. diff --git a/cpp/third_party/googletest/docs/reference/actions.md b/cpp/third_party/googletest/docs/reference/actions.md new file mode 100644 index 0000000..ab81a12 --- /dev/null +++ b/cpp/third_party/googletest/docs/reference/actions.md @@ -0,0 +1,115 @@ +# Actions Reference + +[**Actions**](../gmock_for_dummies.md#actions-what-should-it-do) specify what a +mock function should do when invoked. This page lists the built-in actions +provided by GoogleTest. All actions are defined in the `::testing` namespace. + +## Returning a Value + +| Action | Description | +| :-------------------------------- | :-------------------------------------------- | +| `Return()` | Return from a `void` mock function. | +| `Return(value)` | Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type at the time the expectation is set, not when the action is executed. | +| `ReturnArg()` | Return the `N`-th (0-based) argument. | +| `ReturnNew(a1, ..., ak)` | Return `new T(a1, ..., ak)`; a different object is created each time. | +| `ReturnNull()` | Return a null pointer. | +| `ReturnPointee(ptr)` | Return the value pointed to by `ptr`. | +| `ReturnRef(variable)` | Return a reference to `variable`. | +| `ReturnRefOfCopy(value)` | Return a reference to a copy of `value`; the copy lives as long as the action. | +| `ReturnRoundRobin({a1, ..., ak})` | Each call will return the next `ai` in the list, starting at the beginning when the end of the list is reached. | + +## Side Effects + +| Action | Description | +| :--------------------------------- | :-------------------------------------- | +| `Assign(&variable, value)` | Assign `value` to variable. | +| `DeleteArg()` | Delete the `N`-th (0-based) argument, which must be a pointer. | +| `SaveArg(pointer)` | Save the `N`-th (0-based) argument to `*pointer`. | +| `SaveArgPointee(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. | +| `SetArgReferee(value)` | Assign `value` to the variable referenced by the `N`-th (0-based) argument. | +| `SetArgPointee(value)` | Assign `value` to the variable pointed by the `N`-th (0-based) argument. | +| `SetArgumentPointee(value)` | Same as `SetArgPointee(value)`. Deprecated. Will be removed in v1.7.0. | +| `SetArrayArgument(first, last)` | Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-th (0-based) argument, which can be either a pointer or an iterator. The action does not take ownership of the elements in the source range. | +| `SetErrnoAndReturn(error, value)` | Set `errno` to `error` and return `value`. | +| `Throw(exception)` | Throws the given exception, which can be any copyable value. Available since v1.1.0. | + +## Using a Function, Functor, or Lambda as an Action + +In the following, by "callable" we mean a free function, `std::function`, +functor, or lambda. + +| Action | Description | +| :---------------------------------- | :------------------------------------- | +| `f` | Invoke `f` with the arguments passed to the mock function, where `f` is a callable. | +| `Invoke(f)` | Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor. | +| `Invoke(object_pointer, &class::method)` | Invoke the method on the object with the arguments passed to the mock function. | +| `InvokeWithoutArgs(f)` | Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments. | +| `InvokeWithoutArgs(object_pointer, &class::method)` | Invoke the method on the object, which takes no arguments. | +| `InvokeArgument(arg1, arg2, ..., argk)` | Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments. | + +The return value of the invoked function is used as the return value of the +action. + +When defining a callable to be used with `Invoke*()`, you can declare any unused +parameters as `Unused`: + +```cpp +using ::testing::Invoke; +double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); } +... +EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance)); +``` + +`Invoke(callback)` and `InvokeWithoutArgs(callback)` take ownership of +`callback`, which must be permanent. The type of `callback` must be a base +callback type instead of a derived one, e.g. + +```cpp + BlockingClosure* done = new BlockingClosure; + ... Invoke(done) ...; // This won't compile! + + Closure* done2 = new BlockingClosure; + ... Invoke(done2) ...; // This works. +``` + +In `InvokeArgument(...)`, if an argument needs to be passed by reference, +wrap it inside `std::ref()`. For example, + +```cpp +using ::testing::InvokeArgument; +... +InvokeArgument<2>(5, string("Hi"), std::ref(foo)) +``` + +calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by +value, and `foo` by reference. + +## Default Action + +| Action | Description | +| :------------ | :----------------------------------------------------- | +| `DoDefault()` | Do the default action (specified by `ON_CALL()` or the built-in one). | + +{: .callout .note} +**Note:** due to technical reasons, `DoDefault()` cannot be used inside a +composite action - trying to do so will result in a run-time error. + +## Composite Actions + +| Action | Description | +| :----------------------------- | :------------------------------------------ | +| `DoAll(a1, a2, ..., an)` | Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void and will receive a readonly view of the arguments. | +| `IgnoreResult(a)` | Perform action `a` and ignore its result. `a` must not return void. | +| `WithArg(a)` | Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it. | +| `WithArgs(a)` | Pass the selected (0-based) arguments of the mock function to action `a` and perform it. | +| `WithoutArgs(a)` | Perform action `a` without any arguments. | + +## Defining Actions + +| Macro | Description | +| :--------------------------------- | :-------------------------------------- | +| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. | +| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. | +| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`. | + +The `ACTION*` macros cannot be used inside a function or class. diff --git a/cpp/third_party/googletest/docs/reference/assertions.md b/cpp/third_party/googletest/docs/reference/assertions.md new file mode 100644 index 0000000..aa1dbc0 --- /dev/null +++ b/cpp/third_party/googletest/docs/reference/assertions.md @@ -0,0 +1,633 @@ +# Assertions Reference + +This page lists the assertion macros provided by GoogleTest for verifying code +behavior. To use them, include the header `gtest/gtest.h`. + +The majority of the macros listed below come as a pair with an `EXPECT_` variant +and an `ASSERT_` variant. Upon failure, `EXPECT_` macros generate nonfatal +failures and allow the current function to continue running, while `ASSERT_` +macros generate fatal failures and abort the current function. + +All assertion macros support streaming a custom failure message into them with +the `<<` operator, for example: + +```cpp +EXPECT_TRUE(my_condition) << "My condition is not true"; +``` + +Anything that can be streamed to an `ostream` can be streamed to an assertion +macro—in particular, C strings and string objects. If a wide string (`wchar_t*`, +`TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is streamed to an +assertion, it will be translated to UTF-8 when printed. + +## Explicit Success and Failure {#success-failure} + +The assertions in this section generate a success or failure directly instead of +testing a value or expression. These are useful when control flow, rather than a +Boolean expression, determines the test's success or failure, as shown by the +following example: + +```c++ +switch(expression) { + case 1: + ... some checks ... + case 2: + ... some other checks ... + default: + FAIL() << "We shouldn't get here."; +} +``` + +### SUCCEED {#SUCCEED} + +`SUCCEED()` + +Generates a success. This *does not* make the overall test succeed. A test is +considered successful only if none of its assertions fail during its execution. + +The `SUCCEED` assertion is purely documentary and currently doesn't generate any +user-visible output. However, we may add `SUCCEED` messages to GoogleTest output +in the future. + +### FAIL {#FAIL} + +`FAIL()` + +Generates a fatal failure, which returns from the current function. + +Can only be used in functions that return `void`. See +[Assertion Placement](../advanced.md#assertion-placement) for more information. + +### ADD_FAILURE {#ADD_FAILURE} + +`ADD_FAILURE()` + +Generates a nonfatal failure, which allows the current function to continue +running. + +### ADD_FAILURE_AT {#ADD_FAILURE_AT} + +`ADD_FAILURE_AT(`*`file_path`*`,`*`line_number`*`)` + +Generates a nonfatal failure at the file and line number specified. + +## Generalized Assertion {#generalized} + +The following assertion allows [matchers](matchers.md) to be used to verify +values. + +### EXPECT_THAT {#EXPECT_THAT} + +`EXPECT_THAT(`*`value`*`,`*`matcher`*`)` \ +`ASSERT_THAT(`*`value`*`,`*`matcher`*`)` + +Verifies that *`value`* matches the [matcher](matchers.md) *`matcher`*. + +For example, the following code verifies that the string `value1` starts with +`"Hello"`, `value2` matches a regular expression, and `value3` is between 5 and +10: + +```cpp +#include + +using ::testing::AllOf; +using ::testing::Gt; +using ::testing::Lt; +using ::testing::MatchesRegex; +using ::testing::StartsWith; + +... +EXPECT_THAT(value1, StartsWith("Hello")); +EXPECT_THAT(value2, MatchesRegex("Line \\d+")); +ASSERT_THAT(value3, AllOf(Gt(5), Lt(10))); +``` + +Matchers enable assertions of this form to read like English and generate +informative failure messages. For example, if the above assertion on `value1` +fails, the resulting message will be similar to the following: + +``` +Value of: value1 + Actual: "Hi, world!" +Expected: starts with "Hello" +``` + +GoogleTest provides a built-in library of matchers—see the +[Matchers Reference](matchers.md). It is also possible to write your own +matchers—see [Writing New Matchers Quickly](../gmock_cook_book.md#NewMatchers). +The use of matchers makes `EXPECT_THAT` a powerful, extensible assertion. + +*The idea for this assertion was borrowed from Joe Walnes' Hamcrest project, +which adds `assertThat()` to JUnit.* + +## Boolean Conditions {#boolean} + +The following assertions test Boolean conditions. + +### EXPECT_TRUE {#EXPECT_TRUE} + +`EXPECT_TRUE(`*`condition`*`)` \ +`ASSERT_TRUE(`*`condition`*`)` + +Verifies that *`condition`* is true. + +### EXPECT_FALSE {#EXPECT_FALSE} + +`EXPECT_FALSE(`*`condition`*`)` \ +`ASSERT_FALSE(`*`condition`*`)` + +Verifies that *`condition`* is false. + +## Binary Comparison {#binary-comparison} + +The following assertions compare two values. The value arguments must be +comparable by the assertion's comparison operator, otherwise a compiler error +will result. + +If an argument supports the `<<` operator, it will be called to print the +argument when the assertion fails. Otherwise, GoogleTest will attempt to print +them in the best way it can—see +[Teaching GoogleTest How to Print Your Values](../advanced.md#teaching-googletest-how-to-print-your-values). + +Arguments are always evaluated exactly once, so it's OK for the arguments to +have side effects. However, the argument evaluation order is undefined and +programs should not depend on any particular argument evaluation order. + +These assertions work with both narrow and wide string objects (`string` and +`wstring`). + +See also the [Floating-Point Comparison](#floating-point) assertions to compare +floating-point numbers and avoid problems caused by rounding. + +### EXPECT_EQ {#EXPECT_EQ} + +`EXPECT_EQ(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_EQ(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`==`*`val2`*. + +Does pointer equality on pointers. If used on two C strings, it tests if they +are in the same memory location, not if they have the same value. Use +[`EXPECT_STREQ`](#EXPECT_STREQ) to compare C strings (e.g. `const char*`) by +value. + +When comparing a pointer to `NULL`, use `EXPECT_EQ(`*`ptr`*`, nullptr)` instead +of `EXPECT_EQ(`*`ptr`*`, NULL)`. + +### EXPECT_NE {#EXPECT_NE} + +`EXPECT_NE(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_NE(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`!=`*`val2`*. + +Does pointer equality on pointers. If used on two C strings, it tests if they +are in different memory locations, not if they have different values. Use +[`EXPECT_STRNE`](#EXPECT_STRNE) to compare C strings (e.g. `const char*`) by +value. + +When comparing a pointer to `NULL`, use `EXPECT_NE(`*`ptr`*`, nullptr)` instead +of `EXPECT_NE(`*`ptr`*`, NULL)`. + +### EXPECT_LT {#EXPECT_LT} + +`EXPECT_LT(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_LT(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`<`*`val2`*. + +### EXPECT_LE {#EXPECT_LE} + +`EXPECT_LE(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_LE(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`<=`*`val2`*. + +### EXPECT_GT {#EXPECT_GT} + +`EXPECT_GT(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_GT(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`>`*`val2`*. + +### EXPECT_GE {#EXPECT_GE} + +`EXPECT_GE(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_GE(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`>=`*`val2`*. + +## String Comparison {#c-strings} + +The following assertions compare two **C strings**. To compare two `string` +objects, use [`EXPECT_EQ`](#EXPECT_EQ) or [`EXPECT_NE`](#EXPECT_NE) instead. + +These assertions also accept wide C strings (`wchar_t*`). If a comparison of two +wide strings fails, their values will be printed as UTF-8 narrow strings. + +To compare a C string with `NULL`, use `EXPECT_EQ(`*`c_string`*`, nullptr)` or +`EXPECT_NE(`*`c_string`*`, nullptr)`. + +### EXPECT_STREQ {#EXPECT_STREQ} + +`EXPECT_STREQ(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STREQ(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have the same contents. + +### EXPECT_STRNE {#EXPECT_STRNE} + +`EXPECT_STRNE(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STRNE(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have different contents. + +### EXPECT_STRCASEEQ {#EXPECT_STRCASEEQ} + +`EXPECT_STRCASEEQ(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STRCASEEQ(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have the same contents, +ignoring case. + +### EXPECT_STRCASENE {#EXPECT_STRCASENE} + +`EXPECT_STRCASENE(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STRCASENE(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have different contents, +ignoring case. + +## Floating-Point Comparison {#floating-point} + +The following assertions compare two floating-point values. + +Due to rounding errors, it is very unlikely that two floating-point values will +match exactly, so `EXPECT_EQ` is not suitable. In general, for floating-point +comparison to make sense, the user needs to carefully choose the error bound. + +GoogleTest also provides assertions that use a default error bound based on +Units in the Last Place (ULPs). To learn more about ULPs, see the article +[Comparing Floating Point Numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). + +### EXPECT_FLOAT_EQ {#EXPECT_FLOAT_EQ} + +`EXPECT_FLOAT_EQ(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_FLOAT_EQ(`*`val1`*`,`*`val2`*`)` + +Verifies that the two `float` values *`val1`* and *`val2`* are approximately +equal, to within 4 ULPs from each other. + +### EXPECT_DOUBLE_EQ {#EXPECT_DOUBLE_EQ} + +`EXPECT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)` + +Verifies that the two `double` values *`val1`* and *`val2`* are approximately +equal, to within 4 ULPs from each other. + +### EXPECT_NEAR {#EXPECT_NEAR} + +`EXPECT_NEAR(`*`val1`*`,`*`val2`*`,`*`abs_error`*`)` \ +`ASSERT_NEAR(`*`val1`*`,`*`val2`*`,`*`abs_error`*`)` + +Verifies that the difference between *`val1`* and *`val2`* does not exceed the +absolute error bound *`abs_error`*. + +## Exception Assertions {#exceptions} + +The following assertions verify that a piece of code throws, or does not throw, +an exception. Usage requires exceptions to be enabled in the build environment. + +Note that the piece of code under test can be a compound statement, for example: + +```cpp +EXPECT_NO_THROW({ + int n = 5; + DoSomething(&n); +}); +``` + +### EXPECT_THROW {#EXPECT_THROW} + +`EXPECT_THROW(`*`statement`*`,`*`exception_type`*`)` \ +`ASSERT_THROW(`*`statement`*`,`*`exception_type`*`)` + +Verifies that *`statement`* throws an exception of type *`exception_type`*. + +### EXPECT_ANY_THROW {#EXPECT_ANY_THROW} + +`EXPECT_ANY_THROW(`*`statement`*`)` \ +`ASSERT_ANY_THROW(`*`statement`*`)` + +Verifies that *`statement`* throws an exception of any type. + +### EXPECT_NO_THROW {#EXPECT_NO_THROW} + +`EXPECT_NO_THROW(`*`statement`*`)` \ +`ASSERT_NO_THROW(`*`statement`*`)` + +Verifies that *`statement`* does not throw any exception. + +## Predicate Assertions {#predicates} + +The following assertions enable more complex predicates to be verified while +printing a more clear failure message than if `EXPECT_TRUE` were used alone. + +### EXPECT_PRED* {#EXPECT_PRED} + +`EXPECT_PRED1(`*`pred`*`,`*`val1`*`)` \ +`EXPECT_PRED2(`*`pred`*`,`*`val1`*`,`*`val2`*`)` \ +`EXPECT_PRED3(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`EXPECT_PRED4(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` \ +`EXPECT_PRED5(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +`ASSERT_PRED1(`*`pred`*`,`*`val1`*`)` \ +`ASSERT_PRED2(`*`pred`*`,`*`val1`*`,`*`val2`*`)` \ +`ASSERT_PRED3(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`ASSERT_PRED4(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` \ +`ASSERT_PRED5(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +Verifies that the predicate *`pred`* returns `true` when passed the given values +as arguments. + +The parameter *`pred`* is a function or functor that accepts as many arguments +as the corresponding macro accepts values. If *`pred`* returns `true` for the +given arguments, the assertion succeeds, otherwise the assertion fails. + +When the assertion fails, it prints the value of each argument. Arguments are +always evaluated exactly once. + +As an example, see the following code: + +```cpp +// Returns true if m and n have no common divisors except 1. +bool MutuallyPrime(int m, int n) { ... } +... +const int a = 3; +const int b = 4; +const int c = 10; +... +EXPECT_PRED2(MutuallyPrime, a, b); // Succeeds +EXPECT_PRED2(MutuallyPrime, b, c); // Fails +``` + +In the above example, the first assertion succeeds, and the second fails with +the following message: + +``` +MutuallyPrime(b, c) is false, where +b is 4 +c is 10 +``` + +Note that if the given predicate is an overloaded function or a function +template, the assertion macro might not be able to determine which version to +use, and it might be necessary to explicitly specify the type of the function. +For example, for a Boolean function `IsPositive()` overloaded to take either a +single `int` or `double` argument, it would be necessary to write one of the +following: + +```cpp +EXPECT_PRED1(static_cast(IsPositive), 5); +EXPECT_PRED1(static_cast(IsPositive), 3.14); +``` + +Writing simply `EXPECT_PRED1(IsPositive, 5);` would result in a compiler error. +Similarly, to use a template function, specify the template arguments: + +```cpp +template +bool IsNegative(T x) { + return x < 0; +} +... +EXPECT_PRED1(IsNegative, -5); // Must specify type for IsNegative +``` + +If a template has multiple parameters, wrap the predicate in parentheses so the +macro arguments are parsed correctly: + +```cpp +ASSERT_PRED2((MyPredicate), 5, 0); +``` + +### EXPECT_PRED_FORMAT* {#EXPECT_PRED_FORMAT} + +`EXPECT_PRED_FORMAT1(`*`pred_formatter`*`,`*`val1`*`)` \ +`EXPECT_PRED_FORMAT2(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`)` \ +`EXPECT_PRED_FORMAT3(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`EXPECT_PRED_FORMAT4(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` +\ +`EXPECT_PRED_FORMAT5(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +`ASSERT_PRED_FORMAT1(`*`pred_formatter`*`,`*`val1`*`)` \ +`ASSERT_PRED_FORMAT2(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`)` \ +`ASSERT_PRED_FORMAT3(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`ASSERT_PRED_FORMAT4(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` +\ +`ASSERT_PRED_FORMAT5(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +Verifies that the predicate *`pred_formatter`* succeeds when passed the given +values as arguments. + +The parameter *`pred_formatter`* is a *predicate-formatter*, which is a function +or functor with the signature: + +```cpp +testing::AssertionResult PredicateFormatter(const char* expr1, + const char* expr2, + ... + const char* exprn, + T1 val1, + T2 val2, + ... + Tn valn); +``` + +where *`val1`*, *`val2`*, ..., *`valn`* are the values of the predicate +arguments, and *`expr1`*, *`expr2`*, ..., *`exprn`* are the corresponding +expressions as they appear in the source code. The types `T1`, `T2`, ..., `Tn` +can be either value types or reference types; if an argument has type `T`, it +can be declared as either `T` or `const T&`, whichever is appropriate. For more +about the return type `testing::AssertionResult`, see +[Using a Function That Returns an AssertionResult](../advanced.md#using-a-function-that-returns-an-assertionresult). + +As an example, see the following code: + +```cpp +// Returns the smallest prime common divisor of m and n, +// or 1 when m and n are mutually prime. +int SmallestPrimeCommonDivisor(int m, int n) { ... } + +// Returns true if m and n have no common divisors except 1. +bool MutuallyPrime(int m, int n) { ... } + +// A predicate-formatter for asserting that two integers are mutually prime. +testing::AssertionResult AssertMutuallyPrime(const char* m_expr, + const char* n_expr, + int m, + int n) { + if (MutuallyPrime(m, n)) return testing::AssertionSuccess(); + + return testing::AssertionFailure() << m_expr << " and " << n_expr + << " (" << m << " and " << n << ") are not mutually prime, " + << "as they have a common divisor " << SmallestPrimeCommonDivisor(m, n); +} + +... +const int a = 3; +const int b = 4; +const int c = 10; +... +EXPECT_PRED_FORMAT2(AssertMutuallyPrime, a, b); // Succeeds +EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c); // Fails +``` + +In the above example, the final assertion fails and the predicate-formatter +produces the following failure message: + +``` +b and c (4 and 10) are not mutually prime, as they have a common divisor 2 +``` + +## Windows HRESULT Assertions {#HRESULT} + +The following assertions test for `HRESULT` success or failure. For example: + +```cpp +CComPtr shell; +ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application")); +CComVariant empty; +ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty)); +``` + +The generated output contains the human-readable error message associated with +the returned `HRESULT` code. + +### EXPECT_HRESULT_SUCCEEDED {#EXPECT_HRESULT_SUCCEEDED} + +`EXPECT_HRESULT_SUCCEEDED(`*`expression`*`)` \ +`ASSERT_HRESULT_SUCCEEDED(`*`expression`*`)` + +Verifies that *`expression`* is a success `HRESULT`. + +### EXPECT_HRESULT_FAILED {#EXPECT_HRESULT_FAILED} + +`EXPECT_HRESULT_FAILED(`*`expression`*`)` \ +`ASSERT_HRESULT_FAILED(`*`expression`*`)` + +Verifies that *`expression`* is a failure `HRESULT`. + +## Death Assertions {#death} + +The following assertions verify that a piece of code causes the process to +terminate. For context, see [Death Tests](../advanced.md#death-tests). + +These assertions spawn a new process and execute the code under test in that +process. How that happens depends on the platform and the variable +`::testing::GTEST_FLAG(death_test_style)`, which is initialized from the +command-line flag `--gtest_death_test_style`. + +* On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the + child, after which: + * If the variable's value is `"fast"`, the death test statement is + immediately executed. + * If the variable's value is `"threadsafe"`, the child process re-executes + the unit test binary just as it was originally invoked, but with some + extra flags to cause just the single death test under consideration to + be run. +* On Windows, the child is spawned using the `CreateProcess()` API, and + re-executes the binary to cause just the single death test under + consideration to be run - much like the `"threadsafe"` mode on POSIX. + +Other values for the variable are illegal and will cause the death test to fail. +Currently, the flag's default value is +**`"fast"`**. + +If the death test statement runs to completion without dying, the child process +will nonetheless terminate, and the assertion fails. + +Note that the piece of code under test can be a compound statement, for example: + +```cpp +EXPECT_DEATH({ + int n = 5; + DoSomething(&n); +}, "Error on line .* of DoSomething()"); +``` + +### EXPECT_DEATH {#EXPECT_DEATH} + +`EXPECT_DEATH(`*`statement`*`,`*`matcher`*`)` \ +`ASSERT_DEATH(`*`statement`*`,`*`matcher`*`)` + +Verifies that *`statement`* causes the process to terminate with a nonzero exit +status and produces `stderr` output that matches *`matcher`*. + +The parameter *`matcher`* is either a [matcher](matchers.md) for a `const +std::string&`, or a regular expression (see +[Regular Expression Syntax](../advanced.md#regular-expression-syntax))—a bare +string *`s`* (with no matcher) is treated as +[`ContainsRegex(s)`](matchers.md#string-matchers), **not** +[`Eq(s)`](matchers.md#generic-comparison). + +For example, the following code verifies that calling `DoSomething(42)` causes +the process to die with an error message that contains the text `My error`: + +```cpp +EXPECT_DEATH(DoSomething(42), "My error"); +``` + +### EXPECT_DEATH_IF_SUPPORTED {#EXPECT_DEATH_IF_SUPPORTED} + +`EXPECT_DEATH_IF_SUPPORTED(`*`statement`*`,`*`matcher`*`)` \ +`ASSERT_DEATH_IF_SUPPORTED(`*`statement`*`,`*`matcher`*`)` + +If death tests are supported, behaves the same as +[`EXPECT_DEATH`](#EXPECT_DEATH). Otherwise, verifies nothing. + +### EXPECT_DEBUG_DEATH {#EXPECT_DEBUG_DEATH} + +`EXPECT_DEBUG_DEATH(`*`statement`*`,`*`matcher`*`)` \ +`ASSERT_DEBUG_DEATH(`*`statement`*`,`*`matcher`*`)` + +In debug mode, behaves the same as [`EXPECT_DEATH`](#EXPECT_DEATH). When not in +debug mode (i.e. `NDEBUG` is defined), just executes *`statement`*. + +### EXPECT_EXIT {#EXPECT_EXIT} + +`EXPECT_EXIT(`*`statement`*`,`*`predicate`*`,`*`matcher`*`)` \ +`ASSERT_EXIT(`*`statement`*`,`*`predicate`*`,`*`matcher`*`)` + +Verifies that *`statement`* causes the process to terminate with an exit status +that satisfies *`predicate`*, and produces `stderr` output that matches +*`matcher`*. + +The parameter *`predicate`* is a function or functor that accepts an `int` exit +status and returns a `bool`. GoogleTest provides two predicates to handle common +cases: + +```cpp +// Returns true if the program exited normally with the given exit status code. +::testing::ExitedWithCode(exit_code); + +// Returns true if the program was killed by the given signal. +// Not available on Windows. +::testing::KilledBySignal(signal_number); +``` + +The parameter *`matcher`* is either a [matcher](matchers.md) for a `const +std::string&`, or a regular expression (see +[Regular Expression Syntax](../advanced.md#regular-expression-syntax))—a bare +string *`s`* (with no matcher) is treated as +[`ContainsRegex(s)`](matchers.md#string-matchers), **not** +[`Eq(s)`](matchers.md#generic-comparison). + +For example, the following code verifies that calling `NormalExit()` causes the +process to print a message containing the text `Success` to `stderr` and exit +with exit status code 0: + +```cpp +EXPECT_EXIT(NormalExit(), testing::ExitedWithCode(0), "Success"); +``` diff --git a/cpp/third_party/googletest/docs/reference/matchers.md b/cpp/third_party/googletest/docs/reference/matchers.md new file mode 100644 index 0000000..243e3f9 --- /dev/null +++ b/cpp/third_party/googletest/docs/reference/matchers.md @@ -0,0 +1,302 @@ +# Matchers Reference + +A **matcher** matches a *single* argument. You can use it inside `ON_CALL()` or +`EXPECT_CALL()`, or use it to validate a value directly using two macros: + +| Macro | Description | +| :----------------------------------- | :------------------------------------ | +| `EXPECT_THAT(actual_value, matcher)` | Asserts that `actual_value` matches `matcher`. | +| `ASSERT_THAT(actual_value, matcher)` | The same as `EXPECT_THAT(actual_value, matcher)`, except that it generates a **fatal** failure. | + +{: .callout .warning} +**WARNING:** Equality matching via `EXPECT_THAT(actual_value, expected_value)` +is supported, however note that implicit conversions can cause surprising +results. For example, `EXPECT_THAT(some_bool, "some string")` will compile and +may pass unintentionally. + +**BEST PRACTICE:** Prefer to make the comparison explicit via +`EXPECT_THAT(actual_value, Eq(expected_value))` or `EXPECT_EQ(actual_value, +expected_value)`. + +Built-in matchers (where `argument` is the function argument, e.g. +`actual_value` in the example above, or when used in the context of +`EXPECT_CALL(mock_object, method(matchers))`, the arguments of `method`) are +divided into several categories. All matchers are defined in the `::testing` +namespace unless otherwise noted. + +## Wildcard + +Matcher | Description +:-------------------------- | :----------------------------------------------- +`_` | `argument` can be any value of the correct type. +`A()` or `An()` | `argument` can be any value of type `type`. + +## Generic Comparison + +| Matcher | Description | +| :--------------------- | :-------------------------------------------------- | +| `Eq(value)` or `value` | `argument == value` | +| `Ge(value)` | `argument >= value` | +| `Gt(value)` | `argument > value` | +| `Le(value)` | `argument <= value` | +| `Lt(value)` | `argument < value` | +| `Ne(value)` | `argument != value` | +| `IsFalse()` | `argument` evaluates to `false` in a Boolean context. | +| `IsTrue()` | `argument` evaluates to `true` in a Boolean context. | +| `IsNull()` | `argument` is a `NULL` pointer (raw or smart). | +| `NotNull()` | `argument` is a non-null pointer (raw or smart). | +| `Optional(m)` | `argument` is `optional<>` that contains a value matching `m`. (For testing whether an `optional<>` is set, check for equality with `nullopt`. You may need to use `Eq(nullopt)` if the inner type doesn't have `==`.)| +| `VariantWith(m)` | `argument` is `variant<>` that holds the alternative of type T with a value matching `m`. | +| `Ref(variable)` | `argument` is a reference to `variable`. | +| `TypedEq(value)` | `argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded. | + +Except `Ref()`, these matchers make a *copy* of `value` in case it's modified or +destructed later. If the compiler complains that `value` doesn't have a public +copy constructor, try wrap it in `std::ref()`, e.g. +`Eq(std::ref(non_copyable_value))`. If you do that, make sure +`non_copyable_value` is not changed afterwards, or the meaning of your matcher +will be changed. + +`IsTrue` and `IsFalse` are useful when you need to use a matcher, or for types +that can be explicitly converted to Boolean, but are not implicitly converted to +Boolean. In other cases, you can use the basic +[`EXPECT_TRUE` and `EXPECT_FALSE`](assertions.md#boolean) assertions. + +## Floating-Point Matchers {#FpMatchers} + +| Matcher | Description | +| :------------------------------- | :--------------------------------- | +| `DoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal. | +| `FloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal. | +| `NanSensitiveDoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal. | +| `NanSensitiveFloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal. | +| `IsNan()` | `argument` is any floating-point type with a NaN value. | + +The above matchers use ULP-based comparison (the same as used in googletest). +They automatically pick a reasonable error bound based on the absolute value of +the expected value. `DoubleEq()` and `FloatEq()` conform to the IEEE standard, +which requires comparing two NaNs for equality to return false. The +`NanSensitive*` version instead treats two NaNs as equal, which is often what a +user wants. + +| Matcher | Description | +| :------------------------------------------------ | :----------------------- | +| `DoubleNear(a_double, max_abs_error)` | `argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal. | +| `FloatNear(a_float, max_abs_error)` | `argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal. | +| `NanSensitiveDoubleNear(a_double, max_abs_error)` | `argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal. | +| `NanSensitiveFloatNear(a_float, max_abs_error)` | `argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal. | + +## String Matchers + +The `argument` can be either a C string or a C++ string object: + +| Matcher | Description | +| :---------------------- | :------------------------------------------------- | +| `ContainsRegex(string)` | `argument` matches the given regular expression. | +| `EndsWith(suffix)` | `argument` ends with string `suffix`. | +| `HasSubstr(string)` | `argument` contains `string` as a sub-string. | +| `IsEmpty()` | `argument` is an empty string. | +| `MatchesRegex(string)` | `argument` matches the given regular expression with the match starting at the first character and ending at the last character. | +| `StartsWith(prefix)` | `argument` starts with string `prefix`. | +| `StrCaseEq(string)` | `argument` is equal to `string`, ignoring case. | +| `StrCaseNe(string)` | `argument` is not equal to `string`, ignoring case. | +| `StrEq(string)` | `argument` is equal to `string`. | +| `StrNe(string)` | `argument` is not equal to `string`. | +| `WhenBase64Unescaped(m)` | `argument` is a base-64 escaped string whose unescaped string matches `m`. The web-safe format from [RFC 4648](https://www.rfc-editor.org/rfc/rfc4648#section-5) is supported. | + +`ContainsRegex()` and `MatchesRegex()` take ownership of the `RE` object. They +use the regular expression syntax defined +[here](../advanced.md#regular-expression-syntax). All of these matchers, except +`ContainsRegex()` and `MatchesRegex()` work for wide strings as well. + +## Container Matchers + +Most STL-style containers support `==`, so you can use `Eq(expected_container)` +or simply `expected_container` to match a container exactly. If you want to +write the elements in-line, match them more flexibly, or get more informative +messages, you can use: + +| Matcher | Description | +| :---------------------------------------- | :------------------------------- | +| `BeginEndDistanceIs(m)` | `argument` is a container whose `begin()` and `end()` iterators are separated by a number of increments matching `m`. E.g. `BeginEndDistanceIs(2)` or `BeginEndDistanceIs(Lt(2))`. For containers that define a `size()` method, `SizeIs(m)` may be more efficient. | +| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. | +| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. | +| `Contains(e).Times(n)` | `argument` contains elements that match `e`, which can be either a value or a matcher, and the number of matches is `n`, which can be either a value or a matcher. Unlike the plain `Contains` and `Each` this allows to check for arbitrary occurrences including testing for absence with `Contains(e).Times(0)`. | +| `Each(e)` | `argument` is a container where *every* element matches `e`, which can be either a value or a matcher. | +| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the *i*-th element matches `ei`, which can be a value or a matcher. | +| `ElementsAreArray({e0, e1, ..., en})`, `ElementsAreArray(a_container)`, `ElementsAreArray(begin, end)`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `IsEmpty()` | `argument` is an empty container (`container.empty()`). | +| `IsSubsetOf({e0, e1, ..., en})`, `IsSubsetOf(a_container)`, `IsSubsetOf(begin, end)`, `IsSubsetOf(array)`, or `IsSubsetOf(array, count)` | `argument` matches `UnorderedElementsAre(x0, x1, ..., xk)` for some subset `{x0, x1, ..., xk}` of the expected matchers. | +| `IsSupersetOf({e0, e1, ..., en})`, `IsSupersetOf(a_container)`, `IsSupersetOf(begin, end)`, `IsSupersetOf(array)`, or `IsSupersetOf(array, count)` | Some subset of `argument` matches `UnorderedElementsAre(`expected matchers`)`. | +| `Pointwise(m, container)`, `Pointwise(m, {e0, e1, ..., en})` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. | +| `SizeIs(m)` | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`. | +| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under *some* permutation of the elements, each element matches an `ei` (for a different `i`), which can be a value or a matcher. | +| `UnorderedElementsAreArray({e0, e1, ..., en})`, `UnorderedElementsAreArray(a_container)`, `UnorderedElementsAreArray(begin, end)`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `UnorderedPointwise(m, container)`, `UnorderedPointwise(m, {e0, e1, ..., en})` | Like `Pointwise(m, container)`, but ignores the order of elements. | +| `WhenSorted(m)` | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(ElementsAre(1, 2, 3))` verifies that `argument` contains elements 1, 2, and 3, ignoring order. | +| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater(), ElementsAre(3, 2, 1))`. | + +**Notes:** + +* These matchers can also match: + 1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), + and + 2. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, + int len)` -- see [Multi-argument Matchers](#MultiArgMatchers)). +* The array being matched may be multi-dimensional (i.e. its elements can be + arrays). +* `m` in `Pointwise(m, ...)` and `UnorderedPointwise(m, ...)` should be a + matcher for `::std::tuple` where `T` and `U` are the element type of + the actual container and the expected container, respectively. For example, + to compare two `Foo` containers where `Foo` doesn't support `operator==`, + one might write: + + ```cpp + MATCHER(FooEq, "") { + return std::get<0>(arg).Equals(std::get<1>(arg)); + } + ... + EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos)); + ``` + +## Member Matchers + +| Matcher | Description | +| :------------------------------ | :----------------------------------------- | +| `Field(&class::field, m)` | `argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. | +| `Field(field_name, &class::field, m)` | The same as the two-parameter version, but provides a better error message. | +| `Key(e)` | `argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`. | +| `Pair(m1, m2)` | `argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`. | +| `FieldsAre(m...)` | `argument` is a compatible object where each field matches piecewise with the matchers `m...`. A compatible object is any that supports the `std::tuple_size`+`get(obj)` protocol. In C++17 and up this also supports types compatible with structured bindings, like aggregates. | +| `Property(&class::property, m)` | `argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. The method `property()` must take no argument and be declared as `const`. | +| `Property(property_name, &class::property, m)` | The same as the two-parameter version, but provides a better error message. + +**Notes:** + +* You can use `FieldsAre()` to match any type that supports structured + bindings, such as `std::tuple`, `std::pair`, `std::array`, and aggregate + types. For example: + + ```cpp + std::tuple my_tuple{7, "hello world"}; + EXPECT_THAT(my_tuple, FieldsAre(Ge(0), HasSubstr("hello"))); + + struct MyStruct { + int value = 42; + std::string greeting = "aloha"; + }; + MyStruct s; + EXPECT_THAT(s, FieldsAre(42, "aloha")); + ``` + +* Don't use `Property()` against member functions that you do not own, because + taking addresses of functions is fragile and generally not part of the + contract of the function. + +## Matching the Result of a Function, Functor, or Callback + +| Matcher | Description | +| :--------------- | :------------------------------------------------ | +| `ResultOf(f, m)` | `f(argument)` matches matcher `m`, where `f` is a function or functor. | +| `ResultOf(result_description, f, m)` | The same as the two-parameter version, but provides a better error message. + +## Pointer Matchers + +| Matcher | Description | +| :------------------------ | :---------------------------------------------- | +| `Address(m)` | the result of `std::addressof(argument)` matches `m`. | +| `Pointee(m)` | `argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`. | +| `Pointer(m)` | `argument` (either a smart pointer or a raw pointer) contains a pointer that matches `m`. `m` will match against the raw pointer regardless of the type of `argument`. | +| `WhenDynamicCastTo(m)` | when `argument` is passed through `dynamic_cast()`, it matches matcher `m`. | + +## Multi-argument Matchers {#MultiArgMatchers} + +Technically, all matchers match a *single* value. A "multi-argument" matcher is +just one that matches a *tuple*. The following matchers can be used to match a +tuple `(x, y)`: + +Matcher | Description +:------ | :---------- +`Eq()` | `x == y` +`Ge()` | `x >= y` +`Gt()` | `x > y` +`Le()` | `x <= y` +`Lt()` | `x < y` +`Ne()` | `x != y` + +You can use the following selectors to pick a subset of the arguments (or +reorder them) to participate in the matching: + +| Matcher | Description | +| :------------------------- | :---------------------------------------------- | +| `AllArgs(m)` | Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`. | +| `Args(m)` | The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`. | + +## Composite Matchers + +You can make a matcher from one or more other matchers: + +| Matcher | Description | +| :------------------------------- | :-------------------------------------- | +| `AllOf(m1, m2, ..., mn)` | `argument` matches all of the matchers `m1` to `mn`. | +| `AllOfArray({m0, m1, ..., mn})`, `AllOfArray(a_container)`, `AllOfArray(begin, end)`, `AllOfArray(array)`, or `AllOfArray(array, count)` | The same as `AllOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `AnyOf(m1, m2, ..., mn)` | `argument` matches at least one of the matchers `m1` to `mn`. | +| `AnyOfArray({m0, m1, ..., mn})`, `AnyOfArray(a_container)`, `AnyOfArray(begin, end)`, `AnyOfArray(array)`, or `AnyOfArray(array, count)` | The same as `AnyOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `Not(m)` | `argument` doesn't match matcher `m`. | +| `Conditional(cond, m1, m2)` | Matches matcher `m1` if `cond` evaluates to true, else matches `m2`.| + +## Adapters for Matchers + +| Matcher | Description | +| :---------------------- | :------------------------------------ | +| `MatcherCast(m)` | casts matcher `m` to type `Matcher`. | +| `SafeMatcherCast(m)` | [safely casts](../gmock_cook_book.md#SafeMatcherCast) matcher `m` to type `Matcher`. | +| `Truly(predicate)` | `predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor. | + +`AddressSatisfies(callback)` and `Truly(callback)` take ownership of `callback`, +which must be a permanent callback. + +## Using Matchers as Predicates {#MatchersAsPredicatesCheat} + +| Matcher | Description | +| :---------------------------- | :------------------------------------------ | +| `Matches(m)(value)` | evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor. | +| `ExplainMatchResult(m, value, result_listener)` | evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`. | +| `Value(value, m)` | evaluates to `true` if `value` matches `m`. | + +## Defining Matchers + +| Macro | Description | +| :----------------------------------- | :------------------------------------ | +| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. | +| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a matcher `IsDivisibleBy(n)` to match a number divisible by `n`. | +| `MATCHER_P2(IsBetween, a, b, absl::StrCat(negation ? "isn't" : "is", " between ", PrintToString(a), " and ", PrintToString(b))) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. | + +**Notes:** + +1. The `MATCHER*` macros cannot be used inside a function or class. +2. The matcher body must be *purely functional* (i.e. it cannot have any side + effect, and the result must not depend on anything other than the value + being matched and the matcher parameters). +3. You can use `PrintToString(x)` to convert a value `x` of any type to a + string. +4. You can use `ExplainMatchResult()` in a custom matcher to wrap another + matcher, for example: + + ```cpp + MATCHER_P(NestedPropertyMatches, matcher, "") { + return ExplainMatchResult(matcher, arg.nested().property(), result_listener); + } + ``` + +5. You can use `DescribeMatcher<>` to describe another matcher. For example: + + ```cpp + MATCHER_P(XAndYThat, matcher, + "X that " + DescribeMatcher(matcher, negation) + + (negation ? " or" : " and") + " Y that " + + DescribeMatcher(matcher, negation)) { + return ExplainMatchResult(matcher, arg.x(), result_listener) && + ExplainMatchResult(matcher, arg.y(), result_listener); + } + ``` diff --git a/cpp/third_party/googletest/docs/reference/mocking.md b/cpp/third_party/googletest/docs/reference/mocking.md new file mode 100644 index 0000000..e414ffb --- /dev/null +++ b/cpp/third_party/googletest/docs/reference/mocking.md @@ -0,0 +1,589 @@ +# Mocking Reference + +This page lists the facilities provided by GoogleTest for creating and working +with mock objects. To use them, include the header +`gmock/gmock.h`. + +## Macros {#macros} + +GoogleTest defines the following macros for working with mocks. + +### MOCK_METHOD {#MOCK_METHOD} + +`MOCK_METHOD(`*`return_type`*`,`*`method_name`*`, (`*`args...`*`));` \ +`MOCK_METHOD(`*`return_type`*`,`*`method_name`*`, (`*`args...`*`), +(`*`specs...`*`));` + +Defines a mock method *`method_name`* with arguments `(`*`args...`*`)` and +return type *`return_type`* within a mock class. + +The parameters of `MOCK_METHOD` mirror the method declaration. The optional +fourth parameter *`specs...`* is a comma-separated list of qualifiers. The +following qualifiers are accepted: + +| Qualifier | Meaning | +| -------------------------- | -------------------------------------------- | +| `const` | Makes the mocked method a `const` method. Required if overriding a `const` method. | +| `override` | Marks the method with `override`. Recommended if overriding a `virtual` method. | +| `noexcept` | Marks the method with `noexcept`. Required if overriding a `noexcept` method. | +| `Calltype(`*`calltype`*`)` | Sets the call type for the method, for example `Calltype(STDMETHODCALLTYPE)`. Useful on Windows. | +| `ref(`*`qualifier`*`)` | Marks the method with the given reference qualifier, for example `ref(&)` or `ref(&&)`. Required if overriding a method that has a reference qualifier. | + +Note that commas in arguments prevent `MOCK_METHOD` from parsing the arguments +correctly if they are not appropriately surrounded by parentheses. See the +following example: + +```cpp +class MyMock { + public: + // The following 2 lines will not compile due to commas in the arguments: + MOCK_METHOD(std::pair, GetPair, ()); // Error! + MOCK_METHOD(bool, CheckMap, (std::map, bool)); // Error! + + // One solution - wrap arguments that contain commas in parentheses: + MOCK_METHOD((std::pair), GetPair, ()); + MOCK_METHOD(bool, CheckMap, ((std::map), bool)); + + // Another solution - use type aliases: + using BoolAndInt = std::pair; + MOCK_METHOD(BoolAndInt, GetPair, ()); + using MapIntDouble = std::map; + MOCK_METHOD(bool, CheckMap, (MapIntDouble, bool)); +}; +``` + +`MOCK_METHOD` must be used in the `public:` section of a mock class definition, +regardless of whether the method being mocked is `public`, `protected`, or +`private` in the base class. + +### EXPECT_CALL {#EXPECT_CALL} + +`EXPECT_CALL(`*`mock_object`*`,`*`method_name`*`(`*`matchers...`*`))` + +Creates an [expectation](../gmock_for_dummies.md#setting-expectations) that the +method *`method_name`* of the object *`mock_object`* is called with arguments +that match the given matchers *`matchers...`*. `EXPECT_CALL` must precede any +code that exercises the mock object. + +The parameter *`matchers...`* is a comma-separated list of +[matchers](../gmock_for_dummies.md#matchers-what-arguments-do-we-expect) that +correspond to each argument of the method *`method_name`*. The expectation will +apply only to calls of *`method_name`* whose arguments match all of the +matchers. If `(`*`matchers...`*`)` is omitted, the expectation behaves as if +each argument's matcher were a [wildcard matcher (`_`)](matchers.md#wildcard). +See the [Matchers Reference](matchers.md) for a list of all built-in matchers. + +The following chainable clauses can be used to modify the expectation, and they +must be used in the following order: + +```cpp +EXPECT_CALL(mock_object, method_name(matchers...)) + .With(multi_argument_matcher) // Can be used at most once + .Times(cardinality) // Can be used at most once + .InSequence(sequences...) // Can be used any number of times + .After(expectations...) // Can be used any number of times + .WillOnce(action) // Can be used any number of times + .WillRepeatedly(action) // Can be used at most once + .RetiresOnSaturation(); // Can be used at most once +``` + +See details for each modifier clause below. + +#### With {#EXPECT_CALL.With} + +`.With(`*`multi_argument_matcher`*`)` + +Restricts the expectation to apply only to mock function calls whose arguments +as a whole match the multi-argument matcher *`multi_argument_matcher`*. + +GoogleTest passes all of the arguments as one tuple into the matcher. The +parameter *`multi_argument_matcher`* must thus be a matcher of type +`Matcher>`, where `A1, ..., An` are the types of the +function arguments. + +For example, the following code sets the expectation that +`my_mock.SetPosition()` is called with any two arguments, the first argument +being less than the second: + +```cpp +using ::testing::_; +using ::testing::Lt; +... +EXPECT_CALL(my_mock, SetPosition(_, _)) + .With(Lt()); +``` + +GoogleTest provides some built-in matchers for 2-tuples, including the `Lt()` +matcher above. See [Multi-argument Matchers](matchers.md#MultiArgMatchers). + +The `With` clause can be used at most once on an expectation and must be the +first clause. + +#### Times {#EXPECT_CALL.Times} + +`.Times(`*`cardinality`*`)` + +Specifies how many times the mock function call is expected. + +The parameter *`cardinality`* represents the number of expected calls and can be +one of the following, all defined in the `::testing` namespace: + +| Cardinality | Meaning | +| ------------------- | --------------------------------------------------- | +| `AnyNumber()` | The function can be called any number of times. | +| `AtLeast(n)` | The function call is expected at least *n* times. | +| `AtMost(n)` | The function call is expected at most *n* times. | +| `Between(m, n)` | The function call is expected between *m* and *n* times, inclusive. | +| `Exactly(n)` or `n` | The function call is expected exactly *n* times. If *n* is 0, the call should never happen. | + +If the `Times` clause is omitted, GoogleTest infers the cardinality as follows: + +* If neither [`WillOnce`](#EXPECT_CALL.WillOnce) nor + [`WillRepeatedly`](#EXPECT_CALL.WillRepeatedly) are specified, the inferred + cardinality is `Times(1)`. +* If there are *n* `WillOnce` clauses and no `WillRepeatedly` clause, where + *n* >= 1, the inferred cardinality is `Times(n)`. +* If there are *n* `WillOnce` clauses and one `WillRepeatedly` clause, where + *n* >= 0, the inferred cardinality is `Times(AtLeast(n))`. + +The `Times` clause can be used at most once on an expectation. + +#### InSequence {#EXPECT_CALL.InSequence} + +`.InSequence(`*`sequences...`*`)` + +Specifies that the mock function call is expected in a certain sequence. + +The parameter *`sequences...`* is any number of [`Sequence`](#Sequence) objects. +Expected calls assigned to the same sequence are expected to occur in the order +the expectations are declared. + +For example, the following code sets the expectation that the `Reset()` method +of `my_mock` is called before both `GetSize()` and `Describe()`, and `GetSize()` +and `Describe()` can occur in any order relative to each other: + +```cpp +using ::testing::Sequence; +Sequence s1, s2; +... +EXPECT_CALL(my_mock, Reset()) + .InSequence(s1, s2); +EXPECT_CALL(my_mock, GetSize()) + .InSequence(s1); +EXPECT_CALL(my_mock, Describe()) + .InSequence(s2); +``` + +The `InSequence` clause can be used any number of times on an expectation. + +See also the [`InSequence` class](#InSequence). + +#### After {#EXPECT_CALL.After} + +`.After(`*`expectations...`*`)` + +Specifies that the mock function call is expected to occur after one or more +other calls. + +The parameter *`expectations...`* can be up to five +[`Expectation`](#Expectation) or [`ExpectationSet`](#ExpectationSet) objects. +The mock function call is expected to occur after all of the given expectations. + +For example, the following code sets the expectation that the `Describe()` +method of `my_mock` is called only after both `InitX()` and `InitY()` have been +called. + +```cpp +using ::testing::Expectation; +... +Expectation init_x = EXPECT_CALL(my_mock, InitX()); +Expectation init_y = EXPECT_CALL(my_mock, InitY()); +EXPECT_CALL(my_mock, Describe()) + .After(init_x, init_y); +``` + +The `ExpectationSet` object is helpful when the number of prerequisites for an +expectation is large or variable, for example: + +```cpp +using ::testing::ExpectationSet; +... +ExpectationSet all_inits; +// Collect all expectations of InitElement() calls +for (int i = 0; i < element_count; i++) { + all_inits += EXPECT_CALL(my_mock, InitElement(i)); +} +EXPECT_CALL(my_mock, Describe()) + .After(all_inits); // Expect Describe() call after all InitElement() calls +``` + +The `After` clause can be used any number of times on an expectation. + +#### WillOnce {#EXPECT_CALL.WillOnce} + +`.WillOnce(`*`action`*`)` + +Specifies the mock function's actual behavior when invoked, for a single +matching function call. + +The parameter *`action`* represents the +[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function +call will perform. See the [Actions Reference](actions.md) for a list of +built-in actions. + +The use of `WillOnce` implicitly sets a cardinality on the expectation when +`Times` is not specified. See [`Times`](#EXPECT_CALL.Times). + +Each matching function call will perform the next action in the order declared. +For example, the following code specifies that `my_mock.GetNumber()` is expected +to be called exactly 3 times and will return `1`, `2`, and `3` respectively on +the first, second, and third calls: + +```cpp +using ::testing::Return; +... +EXPECT_CALL(my_mock, GetNumber()) + .WillOnce(Return(1)) + .WillOnce(Return(2)) + .WillOnce(Return(3)); +``` + +The `WillOnce` clause can be used any number of times on an expectation. Unlike +`WillRepeatedly`, the action fed to each `WillOnce` call will be called at most +once, so may be a move-only type and/or have an `&&`-qualified call operator. + +#### WillRepeatedly {#EXPECT_CALL.WillRepeatedly} + +`.WillRepeatedly(`*`action`*`)` + +Specifies the mock function's actual behavior when invoked, for all subsequent +matching function calls. Takes effect after the actions specified in the +[`WillOnce`](#EXPECT_CALL.WillOnce) clauses, if any, have been performed. + +The parameter *`action`* represents the +[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function +call will perform. See the [Actions Reference](actions.md) for a list of +built-in actions. + +The use of `WillRepeatedly` implicitly sets a cardinality on the expectation +when `Times` is not specified. See [`Times`](#EXPECT_CALL.Times). + +If any `WillOnce` clauses have been specified, matching function calls will +perform those actions before the action specified by `WillRepeatedly`. See the +following example: + +```cpp +using ::testing::Return; +... +EXPECT_CALL(my_mock, GetName()) + .WillRepeatedly(Return("John Doe")); // Return "John Doe" on all calls + +EXPECT_CALL(my_mock, GetNumber()) + .WillOnce(Return(42)) // Return 42 on the first call + .WillRepeatedly(Return(7)); // Return 7 on all subsequent calls +``` + +The `WillRepeatedly` clause can be used at most once on an expectation. + +#### RetiresOnSaturation {#EXPECT_CALL.RetiresOnSaturation} + +`.RetiresOnSaturation()` + +Indicates that the expectation will no longer be active after the expected +number of matching function calls has been reached. + +The `RetiresOnSaturation` clause is only meaningful for expectations with an +upper-bounded cardinality. The expectation will *retire* (no longer match any +function calls) after it has been *saturated* (the upper bound has been +reached). See the following example: + +```cpp +using ::testing::_; +using ::testing::AnyNumber; +... +EXPECT_CALL(my_mock, SetNumber(_)) // Expectation 1 + .Times(AnyNumber()); +EXPECT_CALL(my_mock, SetNumber(7)) // Expectation 2 + .Times(2) + .RetiresOnSaturation(); +``` + +In the above example, the first two calls to `my_mock.SetNumber(7)` match +expectation 2, which then becomes inactive and no longer matches any calls. A +third call to `my_mock.SetNumber(7)` would then match expectation 1. Without +`RetiresOnSaturation()` on expectation 2, a third call to `my_mock.SetNumber(7)` +would match expectation 2 again, producing a failure since the limit of 2 calls +was exceeded. + +The `RetiresOnSaturation` clause can be used at most once on an expectation and +must be the last clause. + +### ON_CALL {#ON_CALL} + +`ON_CALL(`*`mock_object`*`,`*`method_name`*`(`*`matchers...`*`))` + +Defines what happens when the method *`method_name`* of the object +*`mock_object`* is called with arguments that match the given matchers +*`matchers...`*. Requires a modifier clause to specify the method's behavior. +*Does not* set any expectations that the method will be called. + +The parameter *`matchers...`* is a comma-separated list of +[matchers](../gmock_for_dummies.md#matchers-what-arguments-do-we-expect) that +correspond to each argument of the method *`method_name`*. The `ON_CALL` +specification will apply only to calls of *`method_name`* whose arguments match +all of the matchers. If `(`*`matchers...`*`)` is omitted, the behavior is as if +each argument's matcher were a [wildcard matcher (`_`)](matchers.md#wildcard). +See the [Matchers Reference](matchers.md) for a list of all built-in matchers. + +The following chainable clauses can be used to set the method's behavior, and +they must be used in the following order: + +```cpp +ON_CALL(mock_object, method_name(matchers...)) + .With(multi_argument_matcher) // Can be used at most once + .WillByDefault(action); // Required +``` + +See details for each modifier clause below. + +#### With {#ON_CALL.With} + +`.With(`*`multi_argument_matcher`*`)` + +Restricts the specification to only mock function calls whose arguments as a +whole match the multi-argument matcher *`multi_argument_matcher`*. + +GoogleTest passes all of the arguments as one tuple into the matcher. The +parameter *`multi_argument_matcher`* must thus be a matcher of type +`Matcher>`, where `A1, ..., An` are the types of the +function arguments. + +For example, the following code sets the default behavior when +`my_mock.SetPosition()` is called with any two arguments, the first argument +being less than the second: + +```cpp +using ::testing::_; +using ::testing::Lt; +using ::testing::Return; +... +ON_CALL(my_mock, SetPosition(_, _)) + .With(Lt()) + .WillByDefault(Return(true)); +``` + +GoogleTest provides some built-in matchers for 2-tuples, including the `Lt()` +matcher above. See [Multi-argument Matchers](matchers.md#MultiArgMatchers). + +The `With` clause can be used at most once with each `ON_CALL` statement. + +#### WillByDefault {#ON_CALL.WillByDefault} + +`.WillByDefault(`*`action`*`)` + +Specifies the default behavior of a matching mock function call. + +The parameter *`action`* represents the +[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function +call will perform. See the [Actions Reference](actions.md) for a list of +built-in actions. + +For example, the following code specifies that by default, a call to +`my_mock.Greet()` will return `"hello"`: + +```cpp +using ::testing::Return; +... +ON_CALL(my_mock, Greet()) + .WillByDefault(Return("hello")); +``` + +The action specified by `WillByDefault` is superseded by the actions specified +on a matching `EXPECT_CALL` statement, if any. See the +[`WillOnce`](#EXPECT_CALL.WillOnce) and +[`WillRepeatedly`](#EXPECT_CALL.WillRepeatedly) clauses of `EXPECT_CALL`. + +The `WillByDefault` clause must be used exactly once with each `ON_CALL` +statement. + +## Classes {#classes} + +GoogleTest defines the following classes for working with mocks. + +### DefaultValue {#DefaultValue} + +`::testing::DefaultValue` + +Allows a user to specify the default value for a type `T` that is both copyable +and publicly destructible (i.e. anything that can be used as a function return +type). For mock functions with a return type of `T`, this default value is +returned from function calls that do not specify an action. + +Provides the static methods `Set()`, `SetFactory()`, and `Clear()` to manage the +default value: + +```cpp +// Sets the default value to be returned. T must be copy constructible. +DefaultValue::Set(value); + +// Sets a factory. Will be invoked on demand. T must be move constructible. +T MakeT(); +DefaultValue::SetFactory(&MakeT); + +// Unsets the default value. +DefaultValue::Clear(); +``` + +### NiceMock {#NiceMock} + +`::testing::NiceMock` + +Represents a mock object that suppresses warnings on +[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The +template parameter `T` is any mock class, except for another `NiceMock`, +`NaggyMock`, or `StrictMock`. + +Usage of `NiceMock` is analogous to usage of `T`. `NiceMock` is a subclass +of `T`, so it can be used wherever an object of type `T` is accepted. In +addition, `NiceMock` can be constructed with any arguments that a constructor +of `T` accepts. + +For example, the following code suppresses warnings on the mock `my_mock` of +type `MockClass` if a method other than `DoSomething()` is called: + +```cpp +using ::testing::NiceMock; +... +NiceMock my_mock("some", "args"); +EXPECT_CALL(my_mock, DoSomething()); +... code that uses my_mock ... +``` + +`NiceMock` only works for mock methods defined using the `MOCK_METHOD` macro +directly in the definition of class `T`. If a mock method is defined in a base +class of `T`, a warning might still be generated. + +`NiceMock` might not work correctly if the destructor of `T` is not virtual. + +### NaggyMock {#NaggyMock} + +`::testing::NaggyMock` + +Represents a mock object that generates warnings on +[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The +template parameter `T` is any mock class, except for another `NiceMock`, +`NaggyMock`, or `StrictMock`. + +Usage of `NaggyMock` is analogous to usage of `T`. `NaggyMock` is a +subclass of `T`, so it can be used wherever an object of type `T` is accepted. +In addition, `NaggyMock` can be constructed with any arguments that a +constructor of `T` accepts. + +For example, the following code generates warnings on the mock `my_mock` of type +`MockClass` if a method other than `DoSomething()` is called: + +```cpp +using ::testing::NaggyMock; +... +NaggyMock my_mock("some", "args"); +EXPECT_CALL(my_mock, DoSomething()); +... code that uses my_mock ... +``` + +Mock objects of type `T` by default behave the same way as `NaggyMock`. + +### StrictMock {#StrictMock} + +`::testing::StrictMock` + +Represents a mock object that generates test failures on +[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The +template parameter `T` is any mock class, except for another `NiceMock`, +`NaggyMock`, or `StrictMock`. + +Usage of `StrictMock` is analogous to usage of `T`. `StrictMock` is a +subclass of `T`, so it can be used wherever an object of type `T` is accepted. +In addition, `StrictMock` can be constructed with any arguments that a +constructor of `T` accepts. + +For example, the following code generates a test failure on the mock `my_mock` +of type `MockClass` if a method other than `DoSomething()` is called: + +```cpp +using ::testing::StrictMock; +... +StrictMock my_mock("some", "args"); +EXPECT_CALL(my_mock, DoSomething()); +... code that uses my_mock ... +``` + +`StrictMock` only works for mock methods defined using the `MOCK_METHOD` +macro directly in the definition of class `T`. If a mock method is defined in a +base class of `T`, a failure might not be generated. + +`StrictMock` might not work correctly if the destructor of `T` is not +virtual. + +### Sequence {#Sequence} + +`::testing::Sequence` + +Represents a chronological sequence of expectations. See the +[`InSequence`](#EXPECT_CALL.InSequence) clause of `EXPECT_CALL` for usage. + +### InSequence {#InSequence} + +`::testing::InSequence` + +An object of this type causes all expectations encountered in its scope to be +put in an anonymous sequence. + +This allows more convenient expression of multiple expectations in a single +sequence: + +```cpp +using ::testing::InSequence; +{ + InSequence seq; + + // The following are expected to occur in the order declared. + EXPECT_CALL(...); + EXPECT_CALL(...); + ... + EXPECT_CALL(...); +} +``` + +The name of the `InSequence` object does not matter. + +### Expectation {#Expectation} + +`::testing::Expectation` + +Represents a mock function call expectation as created by +[`EXPECT_CALL`](#EXPECT_CALL): + +```cpp +using ::testing::Expectation; +Expectation my_expectation = EXPECT_CALL(...); +``` + +Useful for specifying sequences of expectations; see the +[`After`](#EXPECT_CALL.After) clause of `EXPECT_CALL`. + +### ExpectationSet {#ExpectationSet} + +`::testing::ExpectationSet` + +Represents a set of mock function call expectations. + +Use the `+=` operator to add [`Expectation`](#Expectation) objects to the set: + +```cpp +using ::testing::ExpectationSet; +ExpectationSet my_expectations; +my_expectations += EXPECT_CALL(...); +``` + +Useful for specifying sequences of expectations; see the +[`After`](#EXPECT_CALL.After) clause of `EXPECT_CALL`. diff --git a/cpp/third_party/googletest/docs/reference/testing.md b/cpp/third_party/googletest/docs/reference/testing.md new file mode 100644 index 0000000..17225a6 --- /dev/null +++ b/cpp/third_party/googletest/docs/reference/testing.md @@ -0,0 +1,1432 @@ +# Testing Reference + + + +This page lists the facilities provided by GoogleTest for writing test programs. +To use them, include the header `gtest/gtest.h`. + +## Macros + +GoogleTest defines the following macros for writing tests. + +### TEST {#TEST} + +
+TEST(TestSuiteName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual test named *`TestName`* in the test suite +*`TestSuiteName`*, consisting of the given statements. + +Both arguments *`TestSuiteName`* and *`TestName`* must be valid C++ identifiers +and must not contain underscores (`_`). Tests in different test suites can have +the same individual name. + +The statements within the test body can be any code under test. +[Assertions](assertions.md) used within the test body determine the outcome of +the test. + +### TEST_F {#TEST_F} + +
+TEST_F(TestFixtureName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual test named *`TestName`* that uses the test fixture class +*`TestFixtureName`*. The test suite name is *`TestFixtureName`*. + +Both arguments *`TestFixtureName`* and *`TestName`* must be valid C++ +identifiers and must not contain underscores (`_`). *`TestFixtureName`* must be +the name of a test fixture class—see +[Test Fixtures](../primer.md#same-data-multiple-tests). + +The statements within the test body can be any code under test. +[Assertions](assertions.md) used within the test body determine the outcome of +the test. + +### TEST_P {#TEST_P} + +
+TEST_P(TestFixtureName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual value-parameterized test named *`TestName`* that uses the +test fixture class *`TestFixtureName`*. The test suite name is +*`TestFixtureName`*. + +Both arguments *`TestFixtureName`* and *`TestName`* must be valid C++ +identifiers and must not contain underscores (`_`). *`TestFixtureName`* must be +the name of a value-parameterized test fixture class—see +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +The statements within the test body can be any code under test. Within the test +body, the test parameter can be accessed with the `GetParam()` function (see +[`WithParamInterface`](#WithParamInterface)). For example: + +```cpp +TEST_P(MyTestSuite, DoesSomething) { + ... + EXPECT_TRUE(DoSomething(GetParam())); + ... +} +``` + +[Assertions](assertions.md) used within the test body determine the outcome of +the test. + +See also [`INSTANTIATE_TEST_SUITE_P`](#INSTANTIATE_TEST_SUITE_P). + +### INSTANTIATE_TEST_SUITE_P {#INSTANTIATE_TEST_SUITE_P} + +`INSTANTIATE_TEST_SUITE_P(`*`InstantiationName`*`,`*`TestSuiteName`*`,`*`param_generator`*`)` +\ +`INSTANTIATE_TEST_SUITE_P(`*`InstantiationName`*`,`*`TestSuiteName`*`,`*`param_generator`*`,`*`name_generator`*`)` + +Instantiates the value-parameterized test suite *`TestSuiteName`* (defined with +[`TEST_P`](#TEST_P)). + +The argument *`InstantiationName`* is a unique name for the instantiation of the +test suite, to distinguish between multiple instantiations. In test output, the +instantiation name is added as a prefix to the test suite name +*`TestSuiteName`*. + +The argument *`param_generator`* is one of the following GoogleTest-provided +functions that generate the test parameters, all defined in the `::testing` +namespace: + + + +| Parameter Generator | Behavior | +| ------------------- | ---------------------------------------------------- | +| `Range(begin, end [, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. | +| `Values(v1, v2, ..., vN)` | Yields values `{v1, v2, ..., vN}`. | +| `ValuesIn(container)` or `ValuesIn(begin,end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. | +| `Bool()` | Yields sequence `{false, true}`. | +| `Combine(g1, g2, ..., gN)` | Yields as `std::tuple` *n*-tuples all combinations (Cartesian product) of the values generated by the given *n* generators `g1`, `g2`, ..., `gN`. | +| `ConvertGenerator(g)` | Yields values generated by generator `g`, `static_cast` to `T`. | + +The optional last argument *`name_generator`* is a function or functor that +generates custom test name suffixes based on the test parameters. The function +must accept an argument of type +[`TestParamInfo`](#TestParamInfo) and return a `std::string`. +The test name suffix can only contain alphanumeric characters and underscores. +GoogleTest provides [`PrintToStringParamName`](#PrintToStringParamName), or a +custom function can be used for more control: + +```cpp +INSTANTIATE_TEST_SUITE_P( + MyInstantiation, MyTestSuite, + testing::Values(...), + [](const testing::TestParamInfo& info) { + // Can use info.param here to generate the test suffix + std::string name = ... + return name; + }); +``` + +For more information, see +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +See also +[`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST`](#GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST). + +### TYPED_TEST_SUITE {#TYPED_TEST_SUITE} + +`TYPED_TEST_SUITE(`*`TestFixtureName`*`,`*`Types`*`)` + +Defines a typed test suite based on the test fixture *`TestFixtureName`*. The +test suite name is *`TestFixtureName`*. + +The argument *`TestFixtureName`* is a fixture class template, parameterized by a +type, for example: + +```cpp +template +class MyFixture : public testing::Test { + public: + ... + using List = std::list; + static T shared_; + T value_; +}; +``` + +The argument *`Types`* is a [`Types`](#Types) object representing the list of +types to run the tests on, for example: + +```cpp +using MyTypes = ::testing::Types; +TYPED_TEST_SUITE(MyFixture, MyTypes); +``` + +The type alias (`using` or `typedef`) is necessary for the `TYPED_TEST_SUITE` +macro to parse correctly. + +See also [`TYPED_TEST`](#TYPED_TEST) and +[Typed Tests](../advanced.md#typed-tests) for more information. + +### TYPED_TEST {#TYPED_TEST} + +
+TYPED_TEST(TestSuiteName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual typed test named *`TestName`* in the typed test suite +*`TestSuiteName`*. The test suite must be defined with +[`TYPED_TEST_SUITE`](#TYPED_TEST_SUITE). + +Within the test body, the special name `TypeParam` refers to the type parameter, +and `TestFixture` refers to the fixture class. See the following example: + +```cpp +TYPED_TEST(MyFixture, Example) { + // Inside a test, refer to the special name TypeParam to get the type + // parameter. Since we are inside a derived class template, C++ requires + // us to visit the members of MyFixture via 'this'. + TypeParam n = this->value_; + + // To visit static members of the fixture, add the 'TestFixture::' + // prefix. + n += TestFixture::shared_; + + // To refer to typedefs in the fixture, add the 'typename TestFixture::' + // prefix. The 'typename' is required to satisfy the compiler. + typename TestFixture::List values; + + values.push_back(n); + ... +} +``` + +For more information, see [Typed Tests](../advanced.md#typed-tests). + +### TYPED_TEST_SUITE_P {#TYPED_TEST_SUITE_P} + +`TYPED_TEST_SUITE_P(`*`TestFixtureName`*`)` + +Defines a type-parameterized test suite based on the test fixture +*`TestFixtureName`*. The test suite name is *`TestFixtureName`*. + +The argument *`TestFixtureName`* is a fixture class template, parameterized by a +type. See [`TYPED_TEST_SUITE`](#TYPED_TEST_SUITE) for an example. + +See also [`TYPED_TEST_P`](#TYPED_TEST_P) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### TYPED_TEST_P {#TYPED_TEST_P} + +
+TYPED_TEST_P(TestSuiteName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual type-parameterized test named *`TestName`* in the +type-parameterized test suite *`TestSuiteName`*. The test suite must be defined +with [`TYPED_TEST_SUITE_P`](#TYPED_TEST_SUITE_P). + +Within the test body, the special name `TypeParam` refers to the type parameter, +and `TestFixture` refers to the fixture class. See [`TYPED_TEST`](#TYPED_TEST) +for an example. + +See also [`REGISTER_TYPED_TEST_SUITE_P`](#REGISTER_TYPED_TEST_SUITE_P) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### REGISTER_TYPED_TEST_SUITE_P {#REGISTER_TYPED_TEST_SUITE_P} + +`REGISTER_TYPED_TEST_SUITE_P(`*`TestSuiteName`*`,`*`TestNames...`*`)` + +Registers the type-parameterized tests *`TestNames...`* of the test suite +*`TestSuiteName`*. The test suite and tests must be defined with +[`TYPED_TEST_SUITE_P`](#TYPED_TEST_SUITE_P) and [`TYPED_TEST_P`](#TYPED_TEST_P). + +For example: + +```cpp +// Define the test suite and tests. +TYPED_TEST_SUITE_P(MyFixture); +TYPED_TEST_P(MyFixture, HasPropertyA) { ... } +TYPED_TEST_P(MyFixture, HasPropertyB) { ... } + +// Register the tests in the test suite. +REGISTER_TYPED_TEST_SUITE_P(MyFixture, HasPropertyA, HasPropertyB); +``` + +See also [`INSTANTIATE_TYPED_TEST_SUITE_P`](#INSTANTIATE_TYPED_TEST_SUITE_P) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### INSTANTIATE_TYPED_TEST_SUITE_P {#INSTANTIATE_TYPED_TEST_SUITE_P} + +`INSTANTIATE_TYPED_TEST_SUITE_P(`*`InstantiationName`*`,`*`TestSuiteName`*`,`*`Types`*`)` + +Instantiates the type-parameterized test suite *`TestSuiteName`*. The test suite +must be registered with +[`REGISTER_TYPED_TEST_SUITE_P`](#REGISTER_TYPED_TEST_SUITE_P). + +The argument *`InstantiationName`* is a unique name for the instantiation of the +test suite, to distinguish between multiple instantiations. In test output, the +instantiation name is added as a prefix to the test suite name +*`TestSuiteName`*. + +The argument *`Types`* is a [`Types`](#Types) object representing the list of +types to run the tests on, for example: + +```cpp +using MyTypes = ::testing::Types; +INSTANTIATE_TYPED_TEST_SUITE_P(MyInstantiation, MyFixture, MyTypes); +``` + +The type alias (`using` or `typedef`) is necessary for the +`INSTANTIATE_TYPED_TEST_SUITE_P` macro to parse correctly. + +For more information, see +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests). + +### FRIEND_TEST {#FRIEND_TEST} + +`FRIEND_TEST(`*`TestSuiteName`*`,`*`TestName`*`)` + +Within a class body, declares an individual test as a friend of the class, +enabling the test to access private class members. + +If the class is defined in a namespace, then in order to be friends of the +class, test fixtures and tests must be defined in the exact same namespace, +without inline or anonymous namespaces. + +For example, if the class definition looks like the following: + +```cpp +namespace my_namespace { + +class MyClass { + friend class MyClassTest; + FRIEND_TEST(MyClassTest, HasPropertyA); + FRIEND_TEST(MyClassTest, HasPropertyB); + ... definition of class MyClass ... +}; + +} // namespace my_namespace +``` + +Then the test code should look like: + +```cpp +namespace my_namespace { + +class MyClassTest : public testing::Test { + ... +}; + +TEST_F(MyClassTest, HasPropertyA) { ... } +TEST_F(MyClassTest, HasPropertyB) { ... } + +} // namespace my_namespace +``` + +See [Testing Private Code](../advanced.md#testing-private-code) for more +information. + +### SCOPED_TRACE {#SCOPED_TRACE} + +`SCOPED_TRACE(`*`message`*`)` + +Causes the current file name, line number, and the given message *`message`* to +be added to the failure message for each assertion failure that occurs in the +scope. + +For more information, see +[Adding Traces to Assertions](../advanced.md#adding-traces-to-assertions). + +See also the [`ScopedTrace` class](#ScopedTrace). + +### GTEST_SKIP {#GTEST_SKIP} + +`GTEST_SKIP()` + +Prevents further test execution at runtime. + +Can be used in individual test cases or in the `SetUp()` methods of test +environments or test fixtures (classes derived from the +[`Environment`](#Environment) or [`Test`](#Test) classes). If used in a global +test environment `SetUp()` method, it skips all tests in the test program. If +used in a test fixture `SetUp()` method, it skips all tests in the corresponding +test suite. + +Similar to assertions, `GTEST_SKIP` allows streaming a custom message into it. + +See [Skipping Test Execution](../advanced.md#skipping-test-execution) for more +information. + +### GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST {#GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST} + +`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(`*`TestSuiteName`*`)` + +Allows the value-parameterized test suite *`TestSuiteName`* to be +uninstantiated. + +By default, every [`TEST_P`](#TEST_P) call without a corresponding +[`INSTANTIATE_TEST_SUITE_P`](#INSTANTIATE_TEST_SUITE_P) call causes a failing +test in the test suite `GoogleTestVerification`. +`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST` suppresses this failure for the +given test suite. + +## Classes and types + +GoogleTest defines the following classes and types to help with writing tests. + +### AssertionResult {#AssertionResult} + +`testing::AssertionResult` + +A class for indicating whether an assertion was successful. + +When the assertion wasn't successful, the `AssertionResult` object stores a +non-empty failure message that can be retrieved with the object's `message()` +method. + +To create an instance of this class, use one of the factory functions +[`AssertionSuccess()`](#AssertionSuccess) or +[`AssertionFailure()`](#AssertionFailure). + +### AssertionException {#AssertionException} + +`testing::AssertionException` + +Exception which can be thrown from +[`TestEventListener::OnTestPartResult`](#TestEventListener::OnTestPartResult). + +### EmptyTestEventListener {#EmptyTestEventListener} + +`testing::EmptyTestEventListener` + +Provides an empty implementation of all methods in the +[`TestEventListener`](#TestEventListener) interface, such that a subclass only +needs to override the methods it cares about. + +### Environment {#Environment} + +`testing::Environment` + +Represents a global test environment. See +[Global Set-Up and Tear-Down](../advanced.md#global-set-up-and-tear-down). + +#### Protected Methods {#Environment-protected} + +##### SetUp {#Environment::SetUp} + +`virtual void Environment::SetUp()` + +Override this to define how to set up the environment. + +##### TearDown {#Environment::TearDown} + +`virtual void Environment::TearDown()` + +Override this to define how to tear down the environment. + +### ScopedTrace {#ScopedTrace} + +`testing::ScopedTrace` + +An instance of this class causes a trace to be included in every test failure +message generated by code in the scope of the lifetime of the `ScopedTrace` +instance. The effect is undone with the destruction of the instance. + +The `ScopedTrace` constructor has the following form: + +```cpp +template +ScopedTrace(const char* file, int line, const T& message) +``` + +Example usage: + +```cpp +testing::ScopedTrace trace("file.cc", 123, "message"); +``` + +The resulting trace includes the given source file path and line number, and the +given message. The `message` argument can be anything streamable to +`std::ostream`. + +See also [`SCOPED_TRACE`](#SCOPED_TRACE). + +### Test {#Test} + +`testing::Test` + +The abstract class that all tests inherit from. `Test` is not copyable. + +#### Public Methods {#Test-public} + +##### SetUpTestSuite {#Test::SetUpTestSuite} + +`static void Test::SetUpTestSuite()` + +Performs shared setup for all tests in the test suite. GoogleTest calls +`SetUpTestSuite()` before running the first test in the test suite. + +##### TearDownTestSuite {#Test::TearDownTestSuite} + +`static void Test::TearDownTestSuite()` + +Performs shared teardown for all tests in the test suite. GoogleTest calls +`TearDownTestSuite()` after running the last test in the test suite. + +##### HasFatalFailure {#Test::HasFatalFailure} + +`static bool Test::HasFatalFailure()` + +Returns true if and only if the current test has a fatal failure. + +##### HasNonfatalFailure {#Test::HasNonfatalFailure} + +`static bool Test::HasNonfatalFailure()` + +Returns true if and only if the current test has a nonfatal failure. + +##### HasFailure {#Test::HasFailure} + +`static bool Test::HasFailure()` + +Returns true if and only if the current test has any failure, either fatal or +nonfatal. + +##### IsSkipped {#Test::IsSkipped} + +`static bool Test::IsSkipped()` + +Returns true if and only if the current test was skipped. + +##### RecordProperty {#Test::RecordProperty} + +`static void Test::RecordProperty(const std::string& key, const std::string& +value)` \ +`static void Test::RecordProperty(const std::string& key, int value)` + +Logs a property for the current test, test suite, or entire invocation of the +test program. Only the last value for a given key is logged. + +The key must be a valid XML attribute name, and cannot conflict with the ones +already used by GoogleTest (`name`, `file`, `line`, `status`, `time`, +`classname`, `type_param`, and `value_param`). + +`RecordProperty` is `public static` so it can be called from utility functions +that are not members of the test fixture. + +Calls to `RecordProperty` made during the lifespan of the test (from the moment +its constructor starts to the moment its destructor finishes) are output in XML +as attributes of the `` element. Properties recorded from a fixture's +`SetUpTestSuite` or `TearDownTestSuite` methods are logged as attributes of the +corresponding `` element. Calls to `RecordProperty` made in the +global context (before or after invocation of `RUN_ALL_TESTS` or from the +`SetUp`/`TearDown` methods of registered `Environment` objects) are output as +attributes of the `` element. + +#### Protected Methods {#Test-protected} + +##### SetUp {#Test::SetUp} + +`virtual void Test::SetUp()` + +Override this to perform test fixture setup. GoogleTest calls `SetUp()` before +running each individual test. + +##### TearDown {#Test::TearDown} + +`virtual void Test::TearDown()` + +Override this to perform test fixture teardown. GoogleTest calls `TearDown()` +after running each individual test. + +### TestWithParam {#TestWithParam} + +`testing::TestWithParam` + +A convenience class which inherits from both [`Test`](#Test) and +[`WithParamInterface`](#WithParamInterface). + +### TestSuite {#TestSuite} + +Represents a test suite. `TestSuite` is not copyable. + +#### Public Methods {#TestSuite-public} + +##### name {#TestSuite::name} + +`const char* TestSuite::name() const` + +Gets the name of the test suite. + +##### type_param {#TestSuite::type_param} + +`const char* TestSuite::type_param() const` + +Returns the name of the parameter type, or `NULL` if this is not a typed or +type-parameterized test suite. See [Typed Tests](../advanced.md#typed-tests) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests). + +##### should_run {#TestSuite::should_run} + +`bool TestSuite::should_run() const` + +Returns true if any test in this test suite should run. + +##### successful_test_count {#TestSuite::successful_test_count} + +`int TestSuite::successful_test_count() const` + +Gets the number of successful tests in this test suite. + +##### skipped_test_count {#TestSuite::skipped_test_count} + +`int TestSuite::skipped_test_count() const` + +Gets the number of skipped tests in this test suite. + +##### failed_test_count {#TestSuite::failed_test_count} + +`int TestSuite::failed_test_count() const` + +Gets the number of failed tests in this test suite. + +##### reportable_disabled_test_count {#TestSuite::reportable_disabled_test_count} + +`int TestSuite::reportable_disabled_test_count() const` + +Gets the number of disabled tests that will be reported in the XML report. + +##### disabled_test_count {#TestSuite::disabled_test_count} + +`int TestSuite::disabled_test_count() const` + +Gets the number of disabled tests in this test suite. + +##### reportable_test_count {#TestSuite::reportable_test_count} + +`int TestSuite::reportable_test_count() const` + +Gets the number of tests to be printed in the XML report. + +##### test_to_run_count {#TestSuite::test_to_run_count} + +`int TestSuite::test_to_run_count() const` + +Get the number of tests in this test suite that should run. + +##### total_test_count {#TestSuite::total_test_count} + +`int TestSuite::total_test_count() const` + +Gets the number of all tests in this test suite. + +##### Passed {#TestSuite::Passed} + +`bool TestSuite::Passed() const` + +Returns true if and only if the test suite passed. + +##### Failed {#TestSuite::Failed} + +`bool TestSuite::Failed() const` + +Returns true if and only if the test suite failed. + +##### elapsed_time {#TestSuite::elapsed_time} + +`TimeInMillis TestSuite::elapsed_time() const` + +Returns the elapsed time, in milliseconds. + +##### start_timestamp {#TestSuite::start_timestamp} + +`TimeInMillis TestSuite::start_timestamp() const` + +Gets the time of the test suite start, in ms from the start of the UNIX epoch. + +##### GetTestInfo {#TestSuite::GetTestInfo} + +`const TestInfo* TestSuite::GetTestInfo(int i) const` + +Returns the [`TestInfo`](#TestInfo) for the `i`-th test among all the tests. `i` +can range from 0 to `total_test_count() - 1`. If `i` is not in that range, +returns `NULL`. + +##### ad_hoc_test_result {#TestSuite::ad_hoc_test_result} + +`const TestResult& TestSuite::ad_hoc_test_result() const` + +Returns the [`TestResult`](#TestResult) that holds test properties recorded +during execution of `SetUpTestSuite` and `TearDownTestSuite`. + +### TestInfo {#TestInfo} + +`testing::TestInfo` + +Stores information about a test. + +#### Public Methods {#TestInfo-public} + +##### test_suite_name {#TestInfo::test_suite_name} + +`const char* TestInfo::test_suite_name() const` + +Returns the test suite name. + +##### name {#TestInfo::name} + +`const char* TestInfo::name() const` + +Returns the test name. + +##### type_param {#TestInfo::type_param} + +`const char* TestInfo::type_param() const` + +Returns the name of the parameter type, or `NULL` if this is not a typed or +type-parameterized test. See [Typed Tests](../advanced.md#typed-tests) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests). + +##### value_param {#TestInfo::value_param} + +`const char* TestInfo::value_param() const` + +Returns the text representation of the value parameter, or `NULL` if this is not +a value-parameterized test. See +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +##### file {#TestInfo::file} + +`const char* TestInfo::file() const` + +Returns the file name where this test is defined. + +##### line {#TestInfo::line} + +`int TestInfo::line() const` + +Returns the line where this test is defined. + +##### is_in_another_shard {#TestInfo::is_in_another_shard} + +`bool TestInfo::is_in_another_shard() const` + +Returns true if this test should not be run because it's in another shard. + +##### should_run {#TestInfo::should_run} + +`bool TestInfo::should_run() const` + +Returns true if this test should run, that is if the test is not disabled (or it +is disabled but the `also_run_disabled_tests` flag has been specified) and its +full name matches the user-specified filter. + +GoogleTest allows the user to filter the tests by their full names. Only the +tests that match the filter will run. See +[Running a Subset of the Tests](../advanced.md#running-a-subset-of-the-tests) +for more information. + +##### is_reportable {#TestInfo::is_reportable} + +`bool TestInfo::is_reportable() const` + +Returns true if and only if this test will appear in the XML report. + +##### result {#TestInfo::result} + +`const TestResult* TestInfo::result() const` + +Returns the result of the test. See [`TestResult`](#TestResult). + +### TestParamInfo {#TestParamInfo} + +`testing::TestParamInfo` + +Describes a parameter to a value-parameterized test. The type `T` is the type of +the parameter. + +Contains the fields `param` and `index` which hold the value of the parameter +and its integer index respectively. + +### UnitTest {#UnitTest} + +`testing::UnitTest` + +This class contains information about the test program. + +`UnitTest` is a singleton class. The only instance is created when +`UnitTest::GetInstance()` is first called. This instance is never deleted. + +`UnitTest` is not copyable. + +#### Public Methods {#UnitTest-public} + +##### GetInstance {#UnitTest::GetInstance} + +`static UnitTest* UnitTest::GetInstance()` + +Gets the singleton `UnitTest` object. The first time this method is called, a +`UnitTest` object is constructed and returned. Consecutive calls will return the +same object. + +##### original_working_dir {#UnitTest::original_working_dir} + +`const char* UnitTest::original_working_dir() const` + +Returns the working directory when the first [`TEST()`](#TEST) or +[`TEST_F()`](#TEST_F) was executed. The `UnitTest` object owns the string. + +##### current_test_suite {#UnitTest::current_test_suite} + +`const TestSuite* UnitTest::current_test_suite() const` + +Returns the [`TestSuite`](#TestSuite) object for the test that's currently +running, or `NULL` if no test is running. + +##### current_test_info {#UnitTest::current_test_info} + +`const TestInfo* UnitTest::current_test_info() const` + +Returns the [`TestInfo`](#TestInfo) object for the test that's currently +running, or `NULL` if no test is running. + +##### random_seed {#UnitTest::random_seed} + +`int UnitTest::random_seed() const` + +Returns the random seed used at the start of the current test run. + +##### successful_test_suite_count {#UnitTest::successful_test_suite_count} + +`int UnitTest::successful_test_suite_count() const` + +Gets the number of successful test suites. + +##### failed_test_suite_count {#UnitTest::failed_test_suite_count} + +`int UnitTest::failed_test_suite_count() const` + +Gets the number of failed test suites. + +##### total_test_suite_count {#UnitTest::total_test_suite_count} + +`int UnitTest::total_test_suite_count() const` + +Gets the number of all test suites. + +##### test_suite_to_run_count {#UnitTest::test_suite_to_run_count} + +`int UnitTest::test_suite_to_run_count() const` + +Gets the number of all test suites that contain at least one test that should +run. + +##### successful_test_count {#UnitTest::successful_test_count} + +`int UnitTest::successful_test_count() const` + +Gets the number of successful tests. + +##### skipped_test_count {#UnitTest::skipped_test_count} + +`int UnitTest::skipped_test_count() const` + +Gets the number of skipped tests. + +##### failed_test_count {#UnitTest::failed_test_count} + +`int UnitTest::failed_test_count() const` + +Gets the number of failed tests. + +##### reportable_disabled_test_count {#UnitTest::reportable_disabled_test_count} + +`int UnitTest::reportable_disabled_test_count() const` + +Gets the number of disabled tests that will be reported in the XML report. + +##### disabled_test_count {#UnitTest::disabled_test_count} + +`int UnitTest::disabled_test_count() const` + +Gets the number of disabled tests. + +##### reportable_test_count {#UnitTest::reportable_test_count} + +`int UnitTest::reportable_test_count() const` + +Gets the number of tests to be printed in the XML report. + +##### total_test_count {#UnitTest::total_test_count} + +`int UnitTest::total_test_count() const` + +Gets the number of all tests. + +##### test_to_run_count {#UnitTest::test_to_run_count} + +`int UnitTest::test_to_run_count() const` + +Gets the number of tests that should run. + +##### start_timestamp {#UnitTest::start_timestamp} + +`TimeInMillis UnitTest::start_timestamp() const` + +Gets the time of the test program start, in ms from the start of the UNIX epoch. + +##### elapsed_time {#UnitTest::elapsed_time} + +`TimeInMillis UnitTest::elapsed_time() const` + +Gets the elapsed time, in milliseconds. + +##### Passed {#UnitTest::Passed} + +`bool UnitTest::Passed() const` + +Returns true if and only if the unit test passed (i.e. all test suites passed). + +##### Failed {#UnitTest::Failed} + +`bool UnitTest::Failed() const` + +Returns true if and only if the unit test failed (i.e. some test suite failed or +something outside of all tests failed). + +##### GetTestSuite {#UnitTest::GetTestSuite} + +`const TestSuite* UnitTest::GetTestSuite(int i) const` + +Gets the [`TestSuite`](#TestSuite) object for the `i`-th test suite among all +the test suites. `i` can range from 0 to `total_test_suite_count() - 1`. If `i` +is not in that range, returns `NULL`. + +##### ad_hoc_test_result {#UnitTest::ad_hoc_test_result} + +`const TestResult& UnitTest::ad_hoc_test_result() const` + +Returns the [`TestResult`](#TestResult) containing information on test failures +and properties logged outside of individual test suites. + +##### listeners {#UnitTest::listeners} + +`TestEventListeners& UnitTest::listeners()` + +Returns the list of event listeners that can be used to track events inside +GoogleTest. See [`TestEventListeners`](#TestEventListeners). + +### TestEventListener {#TestEventListener} + +`testing::TestEventListener` + +The interface for tracing execution of tests. The methods below are listed in +the order the corresponding events are fired. + +#### Public Methods {#TestEventListener-public} + +##### OnTestProgramStart {#TestEventListener::OnTestProgramStart} + +`virtual void TestEventListener::OnTestProgramStart(const UnitTest& unit_test)` + +Fired before any test activity starts. + +##### OnTestIterationStart {#TestEventListener::OnTestIterationStart} + +`virtual void TestEventListener::OnTestIterationStart(const UnitTest& unit_test, +int iteration)` + +Fired before each iteration of tests starts. There may be more than one +iteration if `GTEST_FLAG(repeat)` is set. `iteration` is the iteration index, +starting from 0. + +##### OnEnvironmentsSetUpStart {#TestEventListener::OnEnvironmentsSetUpStart} + +`virtual void TestEventListener::OnEnvironmentsSetUpStart(const UnitTest& +unit_test)` + +Fired before environment set-up for each iteration of tests starts. + +##### OnEnvironmentsSetUpEnd {#TestEventListener::OnEnvironmentsSetUpEnd} + +`virtual void TestEventListener::OnEnvironmentsSetUpEnd(const UnitTest& +unit_test)` + +Fired after environment set-up for each iteration of tests ends. + +##### OnTestSuiteStart {#TestEventListener::OnTestSuiteStart} + +`virtual void TestEventListener::OnTestSuiteStart(const TestSuite& test_suite)` + +Fired before the test suite starts. + +##### OnTestStart {#TestEventListener::OnTestStart} + +`virtual void TestEventListener::OnTestStart(const TestInfo& test_info)` + +Fired before the test starts. + +##### OnTestPartResult {#TestEventListener::OnTestPartResult} + +`virtual void TestEventListener::OnTestPartResult(const TestPartResult& +test_part_result)` + +Fired after a failed assertion or a `SUCCEED()` invocation. If you want to throw +an exception from this function to skip to the next test, it must be an +[`AssertionException`](#AssertionException) or inherited from it. + +##### OnTestEnd {#TestEventListener::OnTestEnd} + +`virtual void TestEventListener::OnTestEnd(const TestInfo& test_info)` + +Fired after the test ends. + +##### OnTestSuiteEnd {#TestEventListener::OnTestSuiteEnd} + +`virtual void TestEventListener::OnTestSuiteEnd(const TestSuite& test_suite)` + +Fired after the test suite ends. + +##### OnEnvironmentsTearDownStart {#TestEventListener::OnEnvironmentsTearDownStart} + +`virtual void TestEventListener::OnEnvironmentsTearDownStart(const UnitTest& +unit_test)` + +Fired before environment tear-down for each iteration of tests starts. + +##### OnEnvironmentsTearDownEnd {#TestEventListener::OnEnvironmentsTearDownEnd} + +`virtual void TestEventListener::OnEnvironmentsTearDownEnd(const UnitTest& +unit_test)` + +Fired after environment tear-down for each iteration of tests ends. + +##### OnTestIterationEnd {#TestEventListener::OnTestIterationEnd} + +`virtual void TestEventListener::OnTestIterationEnd(const UnitTest& unit_test, +int iteration)` + +Fired after each iteration of tests finishes. + +##### OnTestProgramEnd {#TestEventListener::OnTestProgramEnd} + +`virtual void TestEventListener::OnTestProgramEnd(const UnitTest& unit_test)` + +Fired after all test activities have ended. + +### TestEventListeners {#TestEventListeners} + +`testing::TestEventListeners` + +Lets users add listeners to track events in GoogleTest. + +#### Public Methods {#TestEventListeners-public} + +##### Append {#TestEventListeners::Append} + +`void TestEventListeners::Append(TestEventListener* listener)` + +Appends an event listener to the end of the list. GoogleTest assumes ownership +of the listener (i.e. it will delete the listener when the test program +finishes). + +##### Release {#TestEventListeners::Release} + +`TestEventListener* TestEventListeners::Release(TestEventListener* listener)` + +Removes the given event listener from the list and returns it. It then becomes +the caller's responsibility to delete the listener. Returns `NULL` if the +listener is not found in the list. + +##### default_result_printer {#TestEventListeners::default_result_printer} + +`TestEventListener* TestEventListeners::default_result_printer() const` + +Returns the standard listener responsible for the default console output. Can be +removed from the listeners list to shut down default console output. Note that +removing this object from the listener list with +[`Release()`](#TestEventListeners::Release) transfers its ownership to the +caller and makes this function return `NULL` the next time. + +##### default_xml_generator {#TestEventListeners::default_xml_generator} + +`TestEventListener* TestEventListeners::default_xml_generator() const` + +Returns the standard listener responsible for the default XML output controlled +by the `--gtest_output=xml` flag. Can be removed from the listeners list by +users who want to shut down the default XML output controlled by this flag and +substitute it with custom one. Note that removing this object from the listener +list with [`Release()`](#TestEventListeners::Release) transfers its ownership to +the caller and makes this function return `NULL` the next time. + +### TestPartResult {#TestPartResult} + +`testing::TestPartResult` + +A copyable object representing the result of a test part (i.e. an assertion or +an explicit `FAIL()`, `ADD_FAILURE()`, or `SUCCESS()`). + +#### Public Methods {#TestPartResult-public} + +##### type {#TestPartResult::type} + +`Type TestPartResult::type() const` + +Gets the outcome of the test part. + +The return type `Type` is an enum defined as follows: + +```cpp +enum Type { + kSuccess, // Succeeded. + kNonFatalFailure, // Failed but the test can continue. + kFatalFailure, // Failed and the test should be terminated. + kSkip // Skipped. +}; +``` + +##### file_name {#TestPartResult::file_name} + +`const char* TestPartResult::file_name() const` + +Gets the name of the source file where the test part took place, or `NULL` if +it's unknown. + +##### line_number {#TestPartResult::line_number} + +`int TestPartResult::line_number() const` + +Gets the line in the source file where the test part took place, or `-1` if it's +unknown. + +##### summary {#TestPartResult::summary} + +`const char* TestPartResult::summary() const` + +Gets the summary of the failure message. + +##### message {#TestPartResult::message} + +`const char* TestPartResult::message() const` + +Gets the message associated with the test part. + +##### skipped {#TestPartResult::skipped} + +`bool TestPartResult::skipped() const` + +Returns true if and only if the test part was skipped. + +##### passed {#TestPartResult::passed} + +`bool TestPartResult::passed() const` + +Returns true if and only if the test part passed. + +##### nonfatally_failed {#TestPartResult::nonfatally_failed} + +`bool TestPartResult::nonfatally_failed() const` + +Returns true if and only if the test part non-fatally failed. + +##### fatally_failed {#TestPartResult::fatally_failed} + +`bool TestPartResult::fatally_failed() const` + +Returns true if and only if the test part fatally failed. + +##### failed {#TestPartResult::failed} + +`bool TestPartResult::failed() const` + +Returns true if and only if the test part failed. + +### TestProperty {#TestProperty} + +`testing::TestProperty` + +A copyable object representing a user-specified test property which can be +output as a key/value string pair. + +#### Public Methods {#TestProperty-public} + +##### key {#key} + +`const char* key() const` + +Gets the user-supplied key. + +##### value {#value} + +`const char* value() const` + +Gets the user-supplied value. + +##### SetValue {#SetValue} + +`void SetValue(const std::string& new_value)` + +Sets a new value, overriding the previous one. + +### TestResult {#TestResult} + +`testing::TestResult` + +Contains information about the result of a single test. + +`TestResult` is not copyable. + +#### Public Methods {#TestResult-public} + +##### total_part_count {#TestResult::total_part_count} + +`int TestResult::total_part_count() const` + +Gets the number of all test parts. This is the sum of the number of successful +test parts and the number of failed test parts. + +##### test_property_count {#TestResult::test_property_count} + +`int TestResult::test_property_count() const` + +Returns the number of test properties. + +##### Passed {#TestResult::Passed} + +`bool TestResult::Passed() const` + +Returns true if and only if the test passed (i.e. no test part failed). + +##### Skipped {#TestResult::Skipped} + +`bool TestResult::Skipped() const` + +Returns true if and only if the test was skipped. + +##### Failed {#TestResult::Failed} + +`bool TestResult::Failed() const` + +Returns true if and only if the test failed. + +##### HasFatalFailure {#TestResult::HasFatalFailure} + +`bool TestResult::HasFatalFailure() const` + +Returns true if and only if the test fatally failed. + +##### HasNonfatalFailure {#TestResult::HasNonfatalFailure} + +`bool TestResult::HasNonfatalFailure() const` + +Returns true if and only if the test has a non-fatal failure. + +##### elapsed_time {#TestResult::elapsed_time} + +`TimeInMillis TestResult::elapsed_time() const` + +Returns the elapsed time, in milliseconds. + +##### start_timestamp {#TestResult::start_timestamp} + +`TimeInMillis TestResult::start_timestamp() const` + +Gets the time of the test case start, in ms from the start of the UNIX epoch. + +##### GetTestPartResult {#TestResult::GetTestPartResult} + +`const TestPartResult& TestResult::GetTestPartResult(int i) const` + +Returns the [`TestPartResult`](#TestPartResult) for the `i`-th test part result +among all the results. `i` can range from 0 to `total_part_count() - 1`. If `i` +is not in that range, aborts the program. + +##### GetTestProperty {#TestResult::GetTestProperty} + +`const TestProperty& TestResult::GetTestProperty(int i) const` + +Returns the [`TestProperty`](#TestProperty) object for the `i`-th test property. +`i` can range from 0 to `test_property_count() - 1`. If `i` is not in that +range, aborts the program. + +### TimeInMillis {#TimeInMillis} + +`testing::TimeInMillis` + +An integer type representing time in milliseconds. + +### Types {#Types} + +`testing::Types` + +Represents a list of types for use in typed tests and type-parameterized tests. + +The template argument `T...` can be any number of types, for example: + +``` +testing::Types +``` + +See [Typed Tests](../advanced.md#typed-tests) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### WithParamInterface {#WithParamInterface} + +`testing::WithParamInterface` + +The pure interface class that all value-parameterized tests inherit from. + +A value-parameterized test fixture class must inherit from both [`Test`](#Test) +and `WithParamInterface`. In most cases that just means inheriting from +[`TestWithParam`](#TestWithParam), but more complicated test hierarchies may +need to inherit from `Test` and `WithParamInterface` at different levels. + +This interface defines the type alias `ParamType` for the parameter type `T` and +has support for accessing the test parameter value via the `GetParam()` method: + +``` +static const ParamType& GetParam() +``` + +For more information, see +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +## Functions + +GoogleTest defines the following functions to help with writing and running +tests. + +### InitGoogleTest {#InitGoogleTest} + +`void testing::InitGoogleTest(int* argc, char** argv)` \ +`void testing::InitGoogleTest(int* argc, wchar_t** argv)` \ +`void testing::InitGoogleTest()` + +Initializes GoogleTest. This must be called before calling +[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS). In particular, it parses the command line +for the flags that GoogleTest recognizes. Whenever a GoogleTest flag is seen, it +is removed from `argv`, and `*argc` is decremented. + +No value is returned. Instead, the GoogleTest flag variables are updated. + +The `InitGoogleTest(int* argc, wchar_t** argv)` overload can be used in Windows +programs compiled in `UNICODE` mode. + +The argument-less `InitGoogleTest()` overload can be used on Arduino/embedded +platforms where there is no `argc`/`argv`. + +### AddGlobalTestEnvironment {#AddGlobalTestEnvironment} + +`Environment* testing::AddGlobalTestEnvironment(Environment* env)` + +Adds a test environment to the test program. Must be called before +[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS) is called. See +[Global Set-Up and Tear-Down](../advanced.md#global-set-up-and-tear-down) for +more information. + +See also [`Environment`](#Environment). + +### RegisterTest {#RegisterTest} + +```cpp +template +TestInfo* testing::RegisterTest(const char* test_suite_name, const char* test_name, + const char* type_param, const char* value_param, + const char* file, int line, Factory factory) +``` + +Dynamically registers a test with the framework. + +The `factory` argument is a factory callable (move-constructible) object or +function pointer that creates a new instance of the `Test` object. It handles +ownership to the caller. The signature of the callable is `Fixture*()`, where +`Fixture` is the test fixture class for the test. All tests registered with the +same `test_suite_name` must return the same fixture type. This is checked at +runtime. + +The framework will infer the fixture class from the factory and will call the +`SetUpTestSuite` and `TearDownTestSuite` methods for it. + +Must be called before [`RUN_ALL_TESTS()`](#RUN_ALL_TESTS) is invoked, otherwise +behavior is undefined. + +See +[Registering tests programmatically](../advanced.md#registering-tests-programmatically) +for more information. + +### RUN_ALL_TESTS {#RUN_ALL_TESTS} + +`int RUN_ALL_TESTS()` + +Use this function in `main()` to run all tests. It returns `0` if all tests are +successful, or `1` otherwise. + +`RUN_ALL_TESTS()` should be invoked after the command line has been parsed by +[`InitGoogleTest()`](#InitGoogleTest). + +This function was formerly a macro; thus, it is in the global namespace and has +an all-caps name. + +### AssertionSuccess {#AssertionSuccess} + +`AssertionResult testing::AssertionSuccess()` + +Creates a successful assertion result. See +[`AssertionResult`](#AssertionResult). + +### AssertionFailure {#AssertionFailure} + +`AssertionResult testing::AssertionFailure()` + +Creates a failed assertion result. Use the `<<` operator to store a failure +message: + +```cpp +testing::AssertionFailure() << "My failure message"; +``` + +See [`AssertionResult`](#AssertionResult). + +### StaticAssertTypeEq {#StaticAssertTypeEq} + +`testing::StaticAssertTypeEq()` + +Compile-time assertion for type equality. Compiles if and only if `T1` and `T2` +are the same type. The value it returns is irrelevant. + +See [Type Assertions](../advanced.md#type-assertions) for more information. + +### PrintToString {#PrintToString} + +`std::string testing::PrintToString(x)` + +Prints any value `x` using GoogleTest's value printer. + +See +[Teaching GoogleTest How to Print Your Values](../advanced.md#teaching-googletest-how-to-print-your-values) +for more information. + +### PrintToStringParamName {#PrintToStringParamName} + +`std::string testing::PrintToStringParamName(TestParamInfo& info)` + +A built-in parameterized test name generator which returns the result of +[`PrintToString`](#PrintToString) called on `info.param`. Does not work when the +test parameter is a `std::string` or C string. See +[Specifying Names for Value-Parameterized Test Parameters](../advanced.md#specifying-names-for-value-parameterized-test-parameters) +for more information. + +See also [`TestParamInfo`](#TestParamInfo) and +[`INSTANTIATE_TEST_SUITE_P`](#INSTANTIATE_TEST_SUITE_P). diff --git a/cpp/third_party/googletest/docs/samples.md b/cpp/third_party/googletest/docs/samples.md new file mode 100644 index 0000000..dedc590 --- /dev/null +++ b/cpp/third_party/googletest/docs/samples.md @@ -0,0 +1,22 @@ +# Googletest Samples + +If you're like us, you'd like to look at +[googletest samples.](https://github.com/google/googletest/blob/main/googletest/samples) +The sample directory has a number of well-commented samples showing how to use a +variety of googletest features. + +* Sample #1 shows the basic steps of using googletest to test C++ functions. +* Sample #2 shows a more complex unit test for a class with multiple member + functions. +* Sample #3 uses a test fixture. +* Sample #4 teaches you how to use googletest and `googletest.h` together to + get the best of both libraries. +* Sample #5 puts shared testing logic in a base test fixture, and reuses it in + derived fixtures. +* Sample #6 demonstrates type-parameterized tests. +* Sample #7 teaches the basics of value-parameterized tests. +* Sample #8 shows using `Combine()` in value-parameterized tests. +* Sample #9 shows use of the listener API to modify Google Test's console + output and the use of its reflection API to inspect test results. +* Sample #10 shows use of the listener API to implement a primitive memory + leak checker. diff --git a/cpp/third_party/googletest/googlemock/CMakeLists.txt b/cpp/third_party/googletest/googlemock/CMakeLists.txt new file mode 100644 index 0000000..a9aa072 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/CMakeLists.txt @@ -0,0 +1,209 @@ +######################################################################## +# Note: CMake support is community-based. The maintainers do not use CMake +# internally. +# +# CMake build script for Google Mock. +# +# To run the tests for Google Mock itself on Linux, use 'make test' or +# ctest. You can select which tests to run using 'ctest -R regex'. +# For more options, run 'ctest --help'. + +option(gmock_build_tests "Build all of Google Mock's own tests." OFF) + +# A directory to find Google Test sources. +if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/gtest/CMakeLists.txt") + set(gtest_dir gtest) +else() + set(gtest_dir ../googletest) +endif() + +# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build(). +include("${gtest_dir}/cmake/hermetic_build.cmake" OPTIONAL) + +if (COMMAND pre_project_set_up_hermetic_build) + # Google Test also calls hermetic setup functions from add_subdirectory, + # although its changes will not affect things at the current scope. + pre_project_set_up_hermetic_build() +endif() + +######################################################################## +# +# Project-wide settings + +# Name of the project. +# +# CMake files in this project can refer to the root source directory +# as ${gmock_SOURCE_DIR} and to the root binary directory as +# ${gmock_BINARY_DIR}. +# Language "C" is required for find_package(Threads). +cmake_minimum_required(VERSION 3.13) +project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C) + +if (COMMAND set_up_hermetic_build) + set_up_hermetic_build() +endif() + +# Instructs CMake to process Google Test's CMakeLists.txt and add its +# targets to the current scope. We are placing Google Test's binary +# directory in a subdirectory of our own as VC compilation may break +# if they are the same (the default). +add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/${gtest_dir}") + + +# These commands only run if this is the main project +if(CMAKE_PROJECT_NAME STREQUAL "gmock" OR CMAKE_PROJECT_NAME STREQUAL "googletest-distribution") + # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to + # make it prominent in the GUI. + option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF) +else() + mark_as_advanced(gmock_build_tests) +endif() + +# Although Google Test's CMakeLists.txt calls this function, the +# changes there don't affect the current scope. Therefore we have to +# call it again here. +config_compiler_and_linker() # from ${gtest_dir}/cmake/internal_utils.cmake + +# Adds Google Mock's and Google Test's header directories to the search path. +set(gmock_build_include_dirs + "${gmock_SOURCE_DIR}/include" + "${gmock_SOURCE_DIR}" + "${gtest_SOURCE_DIR}/include" + # This directory is needed to build directly from Google Test sources. + "${gtest_SOURCE_DIR}") +include_directories(${gmock_build_include_dirs}) + +######################################################################## +# +# Defines the gmock & gmock_main libraries. User tests should link +# with one of them. + +# Google Mock libraries. We build them using more strict warnings than what +# are used for other targets, to ensure that Google Mock can be compiled by +# a user aggressive about warnings. +if (MSVC) + cxx_library(gmock + "${cxx_strict}" + "${gtest_dir}/src/gtest-all.cc" + src/gmock-all.cc) + + cxx_library(gmock_main + "${cxx_strict}" + "${gtest_dir}/src/gtest-all.cc" + src/gmock-all.cc + src/gmock_main.cc) +else() + cxx_library(gmock "${cxx_strict}" src/gmock-all.cc) + target_link_libraries(gmock PUBLIC gtest) + set_target_properties(gmock PROPERTIES VERSION ${GOOGLETEST_VERSION}) + cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc) + target_link_libraries(gmock_main PUBLIC gmock) + set_target_properties(gmock_main PROPERTIES VERSION ${GOOGLETEST_VERSION}) +endif() + +string(REPLACE ";" "$" dirs "${gmock_build_include_dirs}") +target_include_directories(gmock SYSTEM INTERFACE + "$" + "$/${CMAKE_INSTALL_INCLUDEDIR}>") +target_include_directories(gmock_main SYSTEM INTERFACE + "$" + "$/${CMAKE_INSTALL_INCLUDEDIR}>") + +######################################################################## +# +# Install rules +install_project(gmock gmock_main) + +######################################################################## +# +# Google Mock's own tests. +# +# You can skip this section if you aren't interested in testing +# Google Mock itself. +# +# The tests are not built by default. To build them, set the +# gmock_build_tests option to ON. You can do it by running ccmake +# or specifying the -Dgmock_build_tests=ON flag when running cmake. + +if (gmock_build_tests) + # This must be set in the root directory for the tests to be run by + # 'make test' or ctest. + enable_testing() + + if (MINGW OR CYGWIN) + add_compile_options("-Wa,-mbig-obj") + endif() + + ############################################################ + # C++ tests built with standard compiler flags. + + cxx_test(gmock-actions_test gmock_main) + cxx_test(gmock-cardinalities_test gmock_main) + cxx_test(gmock_ex_test gmock_main) + cxx_test(gmock-function-mocker_test gmock_main) + cxx_test(gmock-internal-utils_test gmock_main) + cxx_test(gmock-matchers-arithmetic_test gmock_main) + cxx_test(gmock-matchers-comparisons_test gmock_main) + cxx_test(gmock-matchers-containers_test gmock_main) + cxx_test(gmock-matchers-misc_test gmock_main) + cxx_test(gmock-more-actions_test gmock_main) + cxx_test(gmock-nice-strict_test gmock_main) + cxx_test(gmock-port_test gmock_main) + cxx_test(gmock-spec-builders_test gmock_main) + cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc) + cxx_test(gmock_test gmock_main) + + if (DEFINED GTEST_HAS_PTHREAD) + cxx_test(gmock_stress_test gmock) + endif() + + # gmock_all_test is commented to save time building and running tests. + # Uncomment if necessary. + # cxx_test(gmock_all_test gmock_main) + + ############################################################ + # C++ tests built with non-standard compiler flags. + + if (MSVC) + cxx_library(gmock_main_no_exception "${cxx_no_exception}" + "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) + + cxx_library(gmock_main_no_rtti "${cxx_no_rtti}" + "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) + + else() + cxx_library(gmock_main_no_exception "${cxx_no_exception}" src/gmock_main.cc) + target_link_libraries(gmock_main_no_exception PUBLIC gmock) + + cxx_library(gmock_main_no_rtti "${cxx_no_rtti}" src/gmock_main.cc) + target_link_libraries(gmock_main_no_rtti PUBLIC gmock) + endif() + cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}" + gmock_main_no_exception test/gmock-more-actions_test.cc) + + cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}" + gmock_main_no_rtti test/gmock-spec-builders_test.cc) + + cxx_shared_library(shared_gmock_main "${cxx_default}" + "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc) + + # Tests that a binary can be built with Google Mock as a shared library. On + # some system configurations, it may not possible to run the binary without + # knowing more details about the system configurations. We do not try to run + # this binary. To get a more robust shared library coverage, configure with + # -DBUILD_SHARED_LIBS=ON. + cxx_executable_with_flags(shared_gmock_test_ "${cxx_default}" + shared_gmock_main test/gmock-spec-builders_test.cc) + set_target_properties(shared_gmock_test_ + PROPERTIES + COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") + + ############################################################ + # Python tests. + + cxx_executable(gmock_leak_test_ test gmock_main) + py_test(gmock_leak_test) + + cxx_executable(gmock_output_test_ test gmock) + py_test(gmock_output_test) +endif() diff --git a/cpp/third_party/googletest/googlemock/README.md b/cpp/third_party/googletest/googlemock/README.md new file mode 100644 index 0000000..7da6065 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/README.md @@ -0,0 +1,40 @@ +# Googletest Mocking (gMock) Framework + +### Overview + +Google's framework for writing and using C++ mock classes. It can help you +derive better designs of your system and write better tests. + +It is inspired by: + +* [jMock](http://www.jmock.org/) +* [EasyMock](http://www.easymock.org/) +* [Hamcrest](http://code.google.com/p/hamcrest/) + +It is designed with C++'s specifics in mind. + +gMock: + +- Provides a declarative syntax for defining mocks. +- Can define partial (hybrid) mocks, which are a cross of real and mock + objects. +- Handles functions of arbitrary types and overloaded functions. +- Comes with a rich set of matchers for validating function arguments. +- Uses an intuitive syntax for controlling the behavior of a mock. +- Does automatic verification of expectations (no record-and-replay needed). +- Allows arbitrary (partial) ordering constraints on function calls to be + expressed. +- Lets a user extend it by defining new matchers and actions. +- Does not use exceptions. +- Is easy to learn and use. + +Details and examples can be found here: + +* [gMock for Dummies](https://google.github.io/googletest/gmock_for_dummies.html) +* [Legacy gMock FAQ](https://google.github.io/googletest/gmock_faq.html) +* [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html) +* [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html) + +GoogleMock is a part of +[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a +subject to the same requirements. diff --git a/cpp/third_party/googletest/googlemock/cmake/gmock.pc.in b/cpp/third_party/googletest/googlemock/cmake/gmock.pc.in new file mode 100644 index 0000000..23c67b5 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/cmake/gmock.pc.in @@ -0,0 +1,10 @@ +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ + +Name: gmock +Description: GoogleMock (without main() function) +Version: @PROJECT_VERSION@ +URL: https://github.com/google/googletest +Requires: gtest = @PROJECT_VERSION@ +Libs: -L${libdir} -lgmock @CMAKE_THREAD_LIBS_INIT@ +Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ diff --git a/cpp/third_party/googletest/googlemock/cmake/gmock_main.pc.in b/cpp/third_party/googletest/googlemock/cmake/gmock_main.pc.in new file mode 100644 index 0000000..66ffea7 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/cmake/gmock_main.pc.in @@ -0,0 +1,10 @@ +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ + +Name: gmock_main +Description: GoogleMock (with main() function) +Version: @PROJECT_VERSION@ +URL: https://github.com/google/googletest +Requires: gmock = @PROJECT_VERSION@ +Libs: -L${libdir} -lgmock_main @CMAKE_THREAD_LIBS_INIT@ +Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ diff --git a/cpp/third_party/googletest/googlemock/docs/README.md b/cpp/third_party/googletest/googlemock/docs/README.md new file mode 100644 index 0000000..1bc57b7 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/docs/README.md @@ -0,0 +1,4 @@ +# Content Moved + +We are working on updates to the GoogleTest documentation, which has moved to +the top-level [docs](../../docs) directory. diff --git a/cpp/third_party/googletest/googlemock/include/gmock/gmock-actions.h b/cpp/third_party/googletest/googlemock/include/gmock/gmock-actions.h new file mode 100644 index 0000000..bd9ba73 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/include/gmock/gmock-actions.h @@ -0,0 +1,2297 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Google Mock - a framework for writing C++ mock classes. +// +// The ACTION* family of macros can be used in a namespace scope to +// define custom actions easily. The syntax: +// +// ACTION(name) { statements; } +// +// will define an action with the given name that executes the +// statements. The value returned by the statements will be used as +// the return value of the action. Inside the statements, you can +// refer to the K-th (0-based) argument of the mock function by +// 'argK', and refer to its type by 'argK_type'. For example: +// +// ACTION(IncrementArg1) { +// arg1_type temp = arg1; +// return ++(*temp); +// } +// +// allows you to write +// +// ...WillOnce(IncrementArg1()); +// +// You can also refer to the entire argument tuple and its type by +// 'args' and 'args_type', and refer to the mock function type and its +// return type by 'function_type' and 'return_type'. +// +// Note that you don't need to specify the types of the mock function +// arguments. However rest assured that your code is still type-safe: +// you'll get a compiler error if *arg1 doesn't support the ++ +// operator, or if the type of ++(*arg1) isn't compatible with the +// mock function's return type, for example. +// +// Sometimes you'll want to parameterize the action. For that you can use +// another macro: +// +// ACTION_P(name, param_name) { statements; } +// +// For example: +// +// ACTION_P(Add, n) { return arg0 + n; } +// +// will allow you to write: +// +// ...WillOnce(Add(5)); +// +// Note that you don't need to provide the type of the parameter +// either. If you need to reference the type of a parameter named +// 'foo', you can write 'foo_type'. For example, in the body of +// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type +// of 'n'. +// +// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support +// multi-parameter actions. +// +// For the purpose of typing, you can view +// +// ACTION_Pk(Foo, p1, ..., pk) { ... } +// +// as shorthand for +// +// template +// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } +// +// In particular, you can provide the template type arguments +// explicitly when invoking Foo(), as in Foo(5, false); +// although usually you can rely on the compiler to infer the types +// for you automatically. You can assign the result of expression +// Foo(p1, ..., pk) to a variable of type FooActionPk. This can be useful when composing actions. +// +// You can also overload actions with different numbers of parameters: +// +// ACTION_P(Plus, a) { ... } +// ACTION_P2(Plus, a, b) { ... } +// +// While it's tempting to always use the ACTION* macros when defining +// a new action, you should also consider implementing ActionInterface +// or using MakePolymorphicAction() instead, especially if you need to +// use the action a lot. While these approaches require more work, +// they give you more control on the types of the mock function +// arguments and the action parameters, which in general leads to +// better compiler error messages that pay off in the long run. They +// also allow overloading actions based on parameter types (as opposed +// to just based on the number of parameters). +// +// CAVEAT: +// +// ACTION*() can only be used in a namespace scope as templates cannot be +// declared inside of a local class. +// Users can, however, define any local functors (e.g. a lambda) that +// can be used as actions. +// +// MORE INFORMATION: +// +// To learn more about using these macros, please search for 'ACTION' on +// https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md + +// IWYU pragma: private, include "gmock/gmock.h" +// IWYU pragma: friend gmock/.* + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ + +#ifndef _WIN32_WCE +#include +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "gmock/internal/gmock-internal-utils.h" +#include "gmock/internal/gmock-port.h" +#include "gmock/internal/gmock-pp.h" + +GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100) + +namespace testing { + +// To implement an action Foo, define: +// 1. a class FooAction that implements the ActionInterface interface, and +// 2. a factory function that creates an Action object from a +// const FooAction*. +// +// The two-level delegation design follows that of Matcher, providing +// consistency for extension developers. It also eases ownership +// management as Action objects can now be copied like plain values. + +namespace internal { + +// BuiltInDefaultValueGetter::Get() returns a +// default-constructed T value. BuiltInDefaultValueGetter::Get() crashes with an error. +// +// This primary template is used when kDefaultConstructible is true. +template +struct BuiltInDefaultValueGetter { + static T Get() { return T(); } +}; +template +struct BuiltInDefaultValueGetter { + static T Get() { + Assert(false, __FILE__, __LINE__, + "Default action undefined for the function return type."); + return internal::Invalid(); + // The above statement will never be reached, but is required in + // order for this function to compile. + } +}; + +// BuiltInDefaultValue::Get() returns the "built-in" default value +// for type T, which is NULL when T is a raw pointer type, 0 when T is +// a numeric type, false when T is bool, or "" when T is string or +// std::string. In addition, in C++11 and above, it turns a +// default-constructed T value if T is default constructible. For any +// other type T, the built-in default T value is undefined, and the +// function will abort the process. +template +class BuiltInDefaultValue { + public: + // This function returns true if and only if type T has a built-in default + // value. + static bool Exists() { return ::std::is_default_constructible::value; } + + static T Get() { + return BuiltInDefaultValueGetter< + T, ::std::is_default_constructible::value>::Get(); + } +}; + +// This partial specialization says that we use the same built-in +// default value for T and const T. +template +class BuiltInDefaultValue { + public: + static bool Exists() { return BuiltInDefaultValue::Exists(); } + static T Get() { return BuiltInDefaultValue::Get(); } +}; + +// This partial specialization defines the default values for pointer +// types. +template +class BuiltInDefaultValue { + public: + static bool Exists() { return true; } + static T* Get() { return nullptr; } +}; + +// The following specializations define the default values for +// specific types we care about. +#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \ + template <> \ + class BuiltInDefaultValue { \ + public: \ + static bool Exists() { return true; } \ + static type Get() { return value; } \ + } + +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, ""); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0'); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0'); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0'); + +// There's no need for a default action for signed wchar_t, as that +// type is the same as wchar_t for gcc, and invalid for MSVC. +// +// There's also no need for a default action for unsigned wchar_t, as +// that type is the same as unsigned int for gcc, and invalid for +// MSVC. +#if GMOCK_WCHAR_T_IS_NATIVE_ +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT +#endif + +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); + +#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ + +// Partial implementations of metaprogramming types from the standard library +// not available in C++11. + +template +struct negation + // NOLINTNEXTLINE + : std::integral_constant {}; + +// Base case: with zero predicates the answer is always true. +template +struct conjunction : std::true_type {}; + +// With a single predicate, the answer is that predicate. +template +struct conjunction : P1 {}; + +// With multiple predicates the answer is the first predicate if that is false, +// and we recurse otherwise. +template +struct conjunction + : std::conditional, P1>::type {}; + +template +struct disjunction : std::false_type {}; + +template +struct disjunction : P1 {}; + +template +struct disjunction + // NOLINTNEXTLINE + : std::conditional, P1>::type {}; + +template +using void_t = void; + +// Detects whether an expression of type `From` can be implicitly converted to +// `To` according to [conv]. In C++17, [conv]/3 defines this as follows: +// +// An expression e can be implicitly converted to a type T if and only if +// the declaration T t=e; is well-formed, for some invented temporary +// variable t ([dcl.init]). +// +// [conv]/2 implies we can use function argument passing to detect whether this +// initialization is valid. +// +// Note that this is distinct from is_convertible, which requires this be valid: +// +// To test() { +// return declval(); +// } +// +// In particular, is_convertible doesn't give the correct answer when `To` and +// `From` are the same non-moveable type since `declval` will be an rvalue +// reference, defeating the guaranteed copy elision that would otherwise make +// this function work. +// +// REQUIRES: `From` is not cv void. +template +struct is_implicitly_convertible { + private: + // A function that accepts a parameter of type T. This can be called with type + // U successfully only if U is implicitly convertible to T. + template + static void Accept(T); + + // A function that creates a value of type T. + template + static T Make(); + + // An overload be selected when implicit conversion from T to To is possible. + template (Make()))> + static std::true_type TestImplicitConversion(int); + + // A fallback overload selected in all other cases. + template + static std::false_type TestImplicitConversion(...); + + public: + using type = decltype(TestImplicitConversion(0)); + static constexpr bool value = type::value; +}; + +// Like std::invoke_result_t from C++17, but works only for objects with call +// operators (not e.g. member function pointers, which we don't need specific +// support for in OnceAction because std::function deals with them). +template +using call_result_t = decltype(std::declval()(std::declval()...)); + +template +struct is_callable_r_impl : std::false_type {}; + +// Specialize the struct for those template arguments where call_result_t is +// well-formed. When it's not, the generic template above is chosen, resulting +// in std::false_type. +template +struct is_callable_r_impl>, R, F, Args...> + : std::conditional< + std::is_void::value, // + std::true_type, // + is_implicitly_convertible, R>>::type {}; + +// Like std::is_invocable_r from C++17, but works only for objects with call +// operators. See the note on call_result_t. +template +using is_callable_r = is_callable_r_impl; + +// Like std::as_const from C++17. +template +typename std::add_const::type& as_const(T& t) { + return t; +} + +} // namespace internal + +// Specialized for function types below. +template +class OnceAction; + +// An action that can only be used once. +// +// This is accepted by WillOnce, which doesn't require the underlying action to +// be copy-constructible (only move-constructible), and promises to invoke it as +// an rvalue reference. This allows the action to work with move-only types like +// std::move_only_function in a type-safe manner. +// +// For example: +// +// // Assume we have some API that needs to accept a unique pointer to some +// // non-copyable object Foo. +// void AcceptUniquePointer(std::unique_ptr foo); +// +// // We can define an action that provides a Foo to that API. Because It +// // has to give away its unique pointer, it must not be called more than +// // once, so its call operator is &&-qualified. +// struct ProvideFoo { +// std::unique_ptr foo; +// +// void operator()() && { +// AcceptUniquePointer(std::move(Foo)); +// } +// }; +// +// // This action can be used with WillOnce. +// EXPECT_CALL(mock, Call) +// .WillOnce(ProvideFoo{std::make_unique(...)}); +// +// // But a call to WillRepeatedly will fail to compile. This is correct, +// // since the action cannot correctly be used repeatedly. +// EXPECT_CALL(mock, Call) +// .WillRepeatedly(ProvideFoo{std::make_unique(...)}); +// +// A less-contrived example would be an action that returns an arbitrary type, +// whose &&-qualified call operator is capable of dealing with move-only types. +template +class OnceAction final { + private: + // True iff we can use the given callable type (or lvalue reference) directly + // via StdFunctionAdaptor. + template + using IsDirectlyCompatible = internal::conjunction< + // It must be possible to capture the callable in StdFunctionAdaptor. + std::is_constructible::type, Callable>, + // The callable must be compatible with our signature. + internal::is_callable_r::type, + Args...>>; + + // True iff we can use the given callable type via StdFunctionAdaptor once we + // ignore incoming arguments. + template + using IsCompatibleAfterIgnoringArguments = internal::conjunction< + // It must be possible to capture the callable in a lambda. + std::is_constructible::type, Callable>, + // The callable must be invocable with zero arguments, returning something + // convertible to Result. + internal::is_callable_r::type>>; + + public: + // Construct from a callable that is directly compatible with our mocked + // signature: it accepts our function type's arguments and returns something + // convertible to our result type. + template ::type>>, + IsDirectlyCompatible> // + ::value, + int>::type = 0> + OnceAction(Callable&& callable) // NOLINT + : function_(StdFunctionAdaptor::type>( + {}, std::forward(callable))) {} + + // As above, but for a callable that ignores the mocked function's arguments. + template ::type>>, + // Exclude callables for which the overload above works. + // We'd rather provide the arguments if possible. + internal::negation>, + IsCompatibleAfterIgnoringArguments>::value, + int>::type = 0> + OnceAction(Callable&& callable) // NOLINT + // Call the constructor above with a callable + // that ignores the input arguments. + : OnceAction(IgnoreIncomingArguments::type>{ + std::forward(callable)}) {} + + // We are naturally copyable because we store only an std::function, but + // semantically we should not be copyable. + OnceAction(const OnceAction&) = delete; + OnceAction& operator=(const OnceAction&) = delete; + OnceAction(OnceAction&&) = default; + + // Invoke the underlying action callable with which we were constructed, + // handing it the supplied arguments. + Result Call(Args... args) && { + return function_(std::forward(args)...); + } + + private: + // An adaptor that wraps a callable that is compatible with our signature and + // being invoked as an rvalue reference so that it can be used as an + // StdFunctionAdaptor. This throws away type safety, but that's fine because + // this is only used by WillOnce, which we know calls at most once. + // + // Once we have something like std::move_only_function from C++23, we can do + // away with this. + template + class StdFunctionAdaptor final { + public: + // A tag indicating that the (otherwise universal) constructor is accepting + // the callable itself, instead of e.g. stealing calls for the move + // constructor. + struct CallableTag final {}; + + template + explicit StdFunctionAdaptor(CallableTag, F&& callable) + : callable_(std::make_shared(std::forward(callable))) {} + + // Rather than explicitly returning Result, we return whatever the wrapped + // callable returns. This allows for compatibility with existing uses like + // the following, when the mocked function returns void: + // + // EXPECT_CALL(mock_fn_, Call) + // .WillOnce([&] { + // [...] + // return 0; + // }); + // + // Such a callable can be turned into std::function. If we use an + // explicit return type of Result here then it *doesn't* work with + // std::function, because we'll get a "void function should not return a + // value" error. + // + // We need not worry about incompatible result types because the SFINAE on + // OnceAction already checks this for us. std::is_invocable_r_v itself makes + // the same allowance for void result types. + template + internal::call_result_t operator()( + ArgRefs&&... args) const { + return std::move(*callable_)(std::forward(args)...); + } + + private: + // We must put the callable on the heap so that we are copyable, which + // std::function needs. + std::shared_ptr callable_; + }; + + // An adaptor that makes a callable that accepts zero arguments callable with + // our mocked arguments. + template + struct IgnoreIncomingArguments { + internal::call_result_t operator()(Args&&...) { + return std::move(callable)(); + } + + Callable callable; + }; + + std::function function_; +}; + +// When an unexpected function call is encountered, Google Mock will +// let it return a default value if the user has specified one for its +// return type, or if the return type has a built-in default value; +// otherwise Google Mock won't know what value to return and will have +// to abort the process. +// +// The DefaultValue class allows a user to specify the +// default value for a type T that is both copyable and publicly +// destructible (i.e. anything that can be used as a function return +// type). The usage is: +// +// // Sets the default value for type T to be foo. +// DefaultValue::Set(foo); +template +class DefaultValue { + public: + // Sets the default value for type T; requires T to be + // copy-constructable and have a public destructor. + static void Set(T x) { + delete producer_; + producer_ = new FixedValueProducer(x); + } + + // Provides a factory function to be called to generate the default value. + // This method can be used even if T is only move-constructible, but it is not + // limited to that case. + typedef T (*FactoryFunction)(); + static void SetFactory(FactoryFunction factory) { + delete producer_; + producer_ = new FactoryValueProducer(factory); + } + + // Unsets the default value for type T. + static void Clear() { + delete producer_; + producer_ = nullptr; + } + + // Returns true if and only if the user has set the default value for type T. + static bool IsSet() { return producer_ != nullptr; } + + // Returns true if T has a default return value set by the user or there + // exists a built-in default value. + static bool Exists() { + return IsSet() || internal::BuiltInDefaultValue::Exists(); + } + + // Returns the default value for type T if the user has set one; + // otherwise returns the built-in default value. Requires that Exists() + // is true, which ensures that the return value is well-defined. + static T Get() { + return producer_ == nullptr ? internal::BuiltInDefaultValue::Get() + : producer_->Produce(); + } + + private: + class ValueProducer { + public: + virtual ~ValueProducer() = default; + virtual T Produce() = 0; + }; + + class FixedValueProducer : public ValueProducer { + public: + explicit FixedValueProducer(T value) : value_(value) {} + T Produce() override { return value_; } + + private: + const T value_; + FixedValueProducer(const FixedValueProducer&) = delete; + FixedValueProducer& operator=(const FixedValueProducer&) = delete; + }; + + class FactoryValueProducer : public ValueProducer { + public: + explicit FactoryValueProducer(FactoryFunction factory) + : factory_(factory) {} + T Produce() override { return factory_(); } + + private: + const FactoryFunction factory_; + FactoryValueProducer(const FactoryValueProducer&) = delete; + FactoryValueProducer& operator=(const FactoryValueProducer&) = delete; + }; + + static ValueProducer* producer_; +}; + +// This partial specialization allows a user to set default values for +// reference types. +template +class DefaultValue { + public: + // Sets the default value for type T&. + static void Set(T& x) { // NOLINT + address_ = &x; + } + + // Unsets the default value for type T&. + static void Clear() { address_ = nullptr; } + + // Returns true if and only if the user has set the default value for type T&. + static bool IsSet() { return address_ != nullptr; } + + // Returns true if T has a default return value set by the user or there + // exists a built-in default value. + static bool Exists() { + return IsSet() || internal::BuiltInDefaultValue::Exists(); + } + + // Returns the default value for type T& if the user has set one; + // otherwise returns the built-in default value if there is one; + // otherwise aborts the process. + static T& Get() { + return address_ == nullptr ? internal::BuiltInDefaultValue::Get() + : *address_; + } + + private: + static T* address_; +}; + +// This specialization allows DefaultValue::Get() to +// compile. +template <> +class DefaultValue { + public: + static bool Exists() { return true; } + static void Get() {} +}; + +// Points to the user-set default value for type T. +template +typename DefaultValue::ValueProducer* DefaultValue::producer_ = nullptr; + +// Points to the user-set default value for type T&. +template +T* DefaultValue::address_ = nullptr; + +// Implement this interface to define an action for function type F. +template +class ActionInterface { + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + ActionInterface() = default; + virtual ~ActionInterface() = default; + + // Performs the action. This method is not const, as in general an + // action can have side effects and be stateful. For example, a + // get-the-next-element-from-the-collection action will need to + // remember the current element. + virtual Result Perform(const ArgumentTuple& args) = 0; + + private: + ActionInterface(const ActionInterface&) = delete; + ActionInterface& operator=(const ActionInterface&) = delete; +}; + +template +class Action; + +// An Action is a copyable and IMMUTABLE (except by assignment) +// object that represents an action to be taken when a mock function of type +// R(Args...) is called. The implementation of Action is just a +// std::shared_ptr to const ActionInterface. Don't inherit from Action! You +// can view an object implementing ActionInterface as a concrete action +// (including its current state), and an Action object as a handle to it. +template +class Action { + private: + using F = R(Args...); + + // Adapter class to allow constructing Action from a legacy ActionInterface. + // New code should create Actions from functors instead. + struct ActionAdapter { + // Adapter must be copyable to satisfy std::function requirements. + ::std::shared_ptr> impl_; + + template + typename internal::Function::Result operator()(InArgs&&... args) { + return impl_->Perform( + ::std::forward_as_tuple(::std::forward(args)...)); + } + }; + + template + using IsCompatibleFunctor = std::is_constructible, G>; + + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + // Constructs a null Action. Needed for storing Action objects in + // STL containers. + Action() = default; + + // Construct an Action from a specified callable. + // This cannot take std::function directly, because then Action would not be + // directly constructible from lambda (it would require two conversions). + template < + typename G, + typename = typename std::enable_if, std::is_constructible, + G>>::value>::type> + Action(G&& fun) { // NOLINT + Init(::std::forward(fun), IsCompatibleFunctor()); + } + + // Constructs an Action from its implementation. + explicit Action(ActionInterface* impl) + : fun_(ActionAdapter{::std::shared_ptr>(impl)}) {} + + // This constructor allows us to turn an Action object into an + // Action, as long as F's arguments can be implicitly converted + // to Func's and Func's return type can be implicitly converted to F's. + template + Action(const Action& action) // NOLINT + : fun_(action.fun_) {} + + // Returns true if and only if this is the DoDefault() action. + bool IsDoDefault() const { return fun_ == nullptr; } + + // Performs the action. Note that this method is const even though + // the corresponding method in ActionInterface is not. The reason + // is that a const Action means that it cannot be re-bound to + // another concrete action, not that the concrete action it binds to + // cannot change state. (Think of the difference between a const + // pointer and a pointer to const.) + Result Perform(ArgumentTuple args) const { + if (IsDoDefault()) { + internal::IllegalDoDefault(__FILE__, __LINE__); + } + return internal::Apply(fun_, ::std::move(args)); + } + + // An action can be used as a OnceAction, since it's obviously safe to call it + // once. + operator OnceAction() const { // NOLINT + // Return a OnceAction-compatible callable that calls Perform with the + // arguments it is provided. We could instead just return fun_, but then + // we'd need to handle the IsDoDefault() case separately. + struct OA { + Action action; + + R operator()(Args... args) && { + return action.Perform( + std::forward_as_tuple(std::forward(args)...)); + } + }; + + return OA{*this}; + } + + private: + template + friend class Action; + + template + void Init(G&& g, ::std::true_type) { + fun_ = ::std::forward(g); + } + + template + void Init(G&& g, ::std::false_type) { + fun_ = IgnoreArgs::type>{::std::forward(g)}; + } + + template + struct IgnoreArgs { + template + Result operator()(const InArgs&...) const { + return function_impl(); + } + + FunctionImpl function_impl; + }; + + // fun_ is an empty function if and only if this is the DoDefault() action. + ::std::function fun_; +}; + +// The PolymorphicAction class template makes it easy to implement a +// polymorphic action (i.e. an action that can be used in mock +// functions of than one type, e.g. Return()). +// +// To define a polymorphic action, a user first provides a COPYABLE +// implementation class that has a Perform() method template: +// +// class FooAction { +// public: +// template +// Result Perform(const ArgumentTuple& args) const { +// // Processes the arguments and returns a result, using +// // std::get(args) to get the N-th (0-based) argument in the tuple. +// } +// ... +// }; +// +// Then the user creates the polymorphic action using +// MakePolymorphicAction(object) where object has type FooAction. See +// the definition of Return(void) and SetArgumentPointee(value) for +// complete examples. +template +class PolymorphicAction { + public: + explicit PolymorphicAction(const Impl& impl) : impl_(impl) {} + + template + operator Action() const { + return Action(new MonomorphicImpl(impl_)); + } + + private: + template + class MonomorphicImpl : public ActionInterface { + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} + + Result Perform(const ArgumentTuple& args) override { + return impl_.template Perform(args); + } + + private: + Impl impl_; + }; + + Impl impl_; +}; + +// Creates an Action from its implementation and returns it. The +// created Action object owns the implementation. +template +Action MakeAction(ActionInterface* impl) { + return Action(impl); +} + +// Creates a polymorphic action from its implementation. This is +// easier to use than the PolymorphicAction constructor as it +// doesn't require you to explicitly write the template argument, e.g. +// +// MakePolymorphicAction(foo); +// vs +// PolymorphicAction(foo); +template +inline PolymorphicAction MakePolymorphicAction(const Impl& impl) { + return PolymorphicAction(impl); +} + +namespace internal { + +// Helper struct to specialize ReturnAction to execute a move instead of a copy +// on return. Useful for move-only types, but could be used on any type. +template +struct ByMoveWrapper { + explicit ByMoveWrapper(T value) : payload(std::move(value)) {} + T payload; +}; + +// The general implementation of Return(R). Specializations follow below. +template +class ReturnAction final { + public: + explicit ReturnAction(R value) : value_(std::move(value)) {} + + template >, // + negation>, // + std::is_convertible, // + std::is_move_constructible>::value>::type> + operator OnceAction() && { // NOLINT + return Impl(std::move(value_)); + } + + template >, // + negation>, // + std::is_convertible, // + std::is_copy_constructible>::value>::type> + operator Action() const { // NOLINT + return Impl(value_); + } + + private: + // Implements the Return(x) action for a mock function that returns type U. + template + class Impl final { + public: + // The constructor used when the return value is allowed to move from the + // input value (i.e. we are converting to OnceAction). + explicit Impl(R&& input_value) + : state_(new State(std::move(input_value))) {} + + // The constructor used when the return value is not allowed to move from + // the input value (i.e. we are converting to Action). + explicit Impl(const R& input_value) : state_(new State(input_value)) {} + + U operator()() && { return std::move(state_->value); } + U operator()() const& { return state_->value; } + + private: + // We put our state on the heap so that the compiler-generated copy/move + // constructors work correctly even when U is a reference-like type. This is + // necessary only because we eagerly create State::value (see the note on + // that symbol for details). If we instead had only the input value as a + // member then the default constructors would work fine. + // + // For example, when R is std::string and U is std::string_view, value is a + // reference to the string backed by input_value. The copy constructor would + // copy both, so that we wind up with a new input_value object (with the + // same contents) and a reference to the *old* input_value object rather + // than the new one. + struct State { + explicit State(const R& input_value_in) + : input_value(input_value_in), + // Make an implicit conversion to Result before initializing the U + // object we store, avoiding calling any explicit constructor of U + // from R. + // + // This simulates the language rules: a function with return type U + // that does `return R()` requires R to be implicitly convertible to + // U, and uses that path for the conversion, even U Result has an + // explicit constructor from R. + value(ImplicitCast_(internal::as_const(input_value))) {} + + // As above, but for the case where we're moving from the ReturnAction + // object because it's being used as a OnceAction. + explicit State(R&& input_value_in) + : input_value(std::move(input_value_in)), + // For the same reason as above we make an implicit conversion to U + // before initializing the value. + // + // Unlike above we provide the input value as an rvalue to the + // implicit conversion because this is a OnceAction: it's fine if it + // wants to consume the input value. + value(ImplicitCast_(std::move(input_value))) {} + + // A copy of the value originally provided by the user. We retain this in + // addition to the value of the mock function's result type below in case + // the latter is a reference-like type. See the std::string_view example + // in the documentation on Return. + R input_value; + + // The value we actually return, as the type returned by the mock function + // itself. + // + // We eagerly initialize this here, rather than lazily doing the implicit + // conversion automatically each time Perform is called, for historical + // reasons: in 2009-11, commit a070cbd91c (Google changelist 13540126) + // made the Action conversion operator eagerly convert the R value to + // U, but without keeping the R alive. This broke the use case discussed + // in the documentation for Return, making reference-like types such as + // std::string_view not safe to use as U where the input type R is a + // value-like type such as std::string. + // + // The example the commit gave was not very clear, nor was the issue + // thread (https://github.com/google/googlemock/issues/86), but it seems + // the worry was about reference-like input types R that flatten to a + // value-like type U when being implicitly converted. An example of this + // is std::vector::reference, which is often a proxy type with an + // reference to the underlying vector: + // + // // Helper method: have the mock function return bools according + // // to the supplied script. + // void SetActions(MockFunction& mock, + // const std::vector& script) { + // for (size_t i = 0; i < script.size(); ++i) { + // EXPECT_CALL(mock, Call(i)).WillOnce(Return(script[i])); + // } + // } + // + // TEST(Foo, Bar) { + // // Set actions using a temporary vector, whose operator[] + // // returns proxy objects that references that will be + // // dangling once the call to SetActions finishes and the + // // vector is destroyed. + // MockFunction mock; + // SetActions(mock, {false, true}); + // + // EXPECT_FALSE(mock.AsStdFunction()(0)); + // EXPECT_TRUE(mock.AsStdFunction()(1)); + // } + // + // This eager conversion helps with a simple case like this, but doesn't + // fully make these types work in general. For example the following still + // uses a dangling reference: + // + // TEST(Foo, Baz) { + // MockFunction()> mock; + // + // // Return the same vector twice, and then the empty vector + // // thereafter. + // auto action = Return(std::initializer_list{ + // "taco", "burrito", + // }); + // + // EXPECT_CALL(mock, Call) + // .WillOnce(action) + // .WillOnce(action) + // .WillRepeatedly(Return(std::vector{})); + // + // EXPECT_THAT(mock.AsStdFunction()(), + // ElementsAre("taco", "burrito")); + // EXPECT_THAT(mock.AsStdFunction()(), + // ElementsAre("taco", "burrito")); + // EXPECT_THAT(mock.AsStdFunction()(), IsEmpty()); + // } + // + U value; + }; + + const std::shared_ptr state_; + }; + + R value_; +}; + +// A specialization of ReturnAction when R is ByMoveWrapper for some T. +// +// This version applies the type system-defeating hack of moving from T even in +// the const call operator, checking at runtime that it isn't called more than +// once, since the user has declared their intent to do so by using ByMove. +template +class ReturnAction> final { + public: + explicit ReturnAction(ByMoveWrapper wrapper) + : state_(new State(std::move(wrapper.payload))) {} + + T operator()() const { + GTEST_CHECK_(!state_->called) + << "A ByMove() action must be performed at most once."; + + state_->called = true; + return std::move(state_->value); + } + + private: + // We store our state on the heap so that we are copyable as required by + // Action, despite the fact that we are stateful and T may not be copyable. + struct State { + explicit State(T&& value_in) : value(std::move(value_in)) {} + + T value; + bool called = false; + }; + + const std::shared_ptr state_; +}; + +// Implements the ReturnNull() action. +class ReturnNullAction { + public: + // Allows ReturnNull() to be used in any pointer-returning function. In C++11 + // this is enforced by returning nullptr, and in non-C++11 by asserting a + // pointer type on compile time. + template + static Result Perform(const ArgumentTuple&) { + return nullptr; + } +}; + +// Implements the Return() action. +class ReturnVoidAction { + public: + // Allows Return() to be used in any void-returning function. + template + static void Perform(const ArgumentTuple&) { + static_assert(std::is_void::value, "Result should be void."); + } +}; + +// Implements the polymorphic ReturnRef(x) action, which can be used +// in any function that returns a reference to the type of x, +// regardless of the argument types. +template +class ReturnRefAction { + public: + // Constructs a ReturnRefAction object from the reference to be returned. + explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT + + // This template type conversion operator allows ReturnRef(x) to be + // used in ANY function that returns a reference to x's type. + template + operator Action() const { + typedef typename Function::Result Result; + // Asserts that the function return type is a reference. This + // catches the user error of using ReturnRef(x) when Return(x) + // should be used, and generates some helpful error message. + static_assert(std::is_reference::value, + "use Return instead of ReturnRef to return a value"); + return Action(new Impl(ref_)); + } + + private: + // Implements the ReturnRef(x) action for a particular function type F. + template + class Impl : public ActionInterface { + public: + typedef typename Function::Result Result; + typedef typename Function::ArgumentTuple ArgumentTuple; + + explicit Impl(T& ref) : ref_(ref) {} // NOLINT + + Result Perform(const ArgumentTuple&) override { return ref_; } + + private: + T& ref_; + }; + + T& ref_; +}; + +// Implements the polymorphic ReturnRefOfCopy(x) action, which can be +// used in any function that returns a reference to the type of x, +// regardless of the argument types. +template +class ReturnRefOfCopyAction { + public: + // Constructs a ReturnRefOfCopyAction object from the reference to + // be returned. + explicit ReturnRefOfCopyAction(const T& value) : value_(value) {} // NOLINT + + // This template type conversion operator allows ReturnRefOfCopy(x) to be + // used in ANY function that returns a reference to x's type. + template + operator Action() const { + typedef typename Function::Result Result; + // Asserts that the function return type is a reference. This + // catches the user error of using ReturnRefOfCopy(x) when Return(x) + // should be used, and generates some helpful error message. + static_assert(std::is_reference::value, + "use Return instead of ReturnRefOfCopy to return a value"); + return Action(new Impl(value_)); + } + + private: + // Implements the ReturnRefOfCopy(x) action for a particular function type F. + template + class Impl : public ActionInterface { + public: + typedef typename Function::Result Result; + typedef typename Function::ArgumentTuple ArgumentTuple; + + explicit Impl(const T& value) : value_(value) {} // NOLINT + + Result Perform(const ArgumentTuple&) override { return value_; } + + private: + T value_; + }; + + const T value_; +}; + +// Implements the polymorphic ReturnRoundRobin(v) action, which can be +// used in any function that returns the element_type of v. +template +class ReturnRoundRobinAction { + public: + explicit ReturnRoundRobinAction(std::vector values) { + GTEST_CHECK_(!values.empty()) + << "ReturnRoundRobin requires at least one element."; + state_->values = std::move(values); + } + + template + T operator()(Args&&...) const { + return state_->Next(); + } + + private: + struct State { + T Next() { + T ret_val = values[i++]; + if (i == values.size()) i = 0; + return ret_val; + } + + std::vector values; + size_t i = 0; + }; + std::shared_ptr state_ = std::make_shared(); +}; + +// Implements the polymorphic DoDefault() action. +class DoDefaultAction { + public: + // This template type conversion operator allows DoDefault() to be + // used in any function. + template + operator Action() const { + return Action(); + } // NOLINT +}; + +// Implements the Assign action to set a given pointer referent to a +// particular value. +template +class AssignAction { + public: + AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {} + + template + void Perform(const ArgumentTuple& /* args */) const { + *ptr_ = value_; + } + + private: + T1* const ptr_; + const T2 value_; +}; + +#ifndef GTEST_OS_WINDOWS_MOBILE + +// Implements the SetErrnoAndReturn action to simulate return from +// various system calls and libc functions. +template +class SetErrnoAndReturnAction { + public: + SetErrnoAndReturnAction(int errno_value, T result) + : errno_(errno_value), result_(result) {} + template + Result Perform(const ArgumentTuple& /* args */) const { + errno = errno_; + return result_; + } + + private: + const int errno_; + const T result_; +}; + +#endif // !GTEST_OS_WINDOWS_MOBILE + +// Implements the SetArgumentPointee(x) action for any function +// whose N-th argument (0-based) is a pointer to x's type. +template +struct SetArgumentPointeeAction { + A value; + + template + void operator()(const Args&... args) const { + *::std::get(std::tie(args...)) = value; + } +}; + +// Implements the Invoke(object_ptr, &Class::Method) action. +template +struct InvokeMethodAction { + Class* const obj_ptr; + const MethodPtr method_ptr; + + template + auto operator()(Args&&... args) const + -> decltype((obj_ptr->*method_ptr)(std::forward(args)...)) { + return (obj_ptr->*method_ptr)(std::forward(args)...); + } +}; + +// Implements the InvokeWithoutArgs(f) action. The template argument +// FunctionImpl is the implementation type of f, which can be either a +// function pointer or a functor. InvokeWithoutArgs(f) can be used as an +// Action as long as f's type is compatible with F. +template +struct InvokeWithoutArgsAction { + FunctionImpl function_impl; + + // Allows InvokeWithoutArgs(f) to be used as any action whose type is + // compatible with f. + template + auto operator()(const Args&...) -> decltype(function_impl()) { + return function_impl(); + } +}; + +// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action. +template +struct InvokeMethodWithoutArgsAction { + Class* const obj_ptr; + const MethodPtr method_ptr; + + using ReturnType = + decltype((std::declval()->*std::declval())()); + + template + ReturnType operator()(const Args&...) const { + return (obj_ptr->*method_ptr)(); + } +}; + +// Implements the IgnoreResult(action) action. +template +class IgnoreResultAction { + public: + explicit IgnoreResultAction(const A& action) : action_(action) {} + + template + operator Action() const { + // Assert statement belongs here because this is the best place to verify + // conditions on F. It produces the clearest error messages + // in most compilers. + // Impl really belongs in this scope as a local class but can't + // because MSVC produces duplicate symbols in different translation units + // in this case. Until MS fixes that bug we put Impl into the class scope + // and put the typedef both here (for use in assert statement) and + // in the Impl class. But both definitions must be the same. + typedef typename internal::Function::Result Result; + + // Asserts at compile time that F returns void. + static_assert(std::is_void::value, "Result type should be void."); + + return Action(new Impl(action_)); + } + + private: + template + class Impl : public ActionInterface { + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + explicit Impl(const A& action) : action_(action) {} + + void Perform(const ArgumentTuple& args) override { + // Performs the action and ignores its result. + action_.Perform(args); + } + + private: + // Type OriginalFunction is the same as F except that its return + // type is IgnoredValue. + typedef + typename internal::Function::MakeResultIgnoredValue OriginalFunction; + + const Action action_; + }; + + const A action_; +}; + +template +struct WithArgsAction { + InnerAction inner_action; + + // The signature of the function as seen by the inner action, given an out + // action with the given result and argument types. + template + using InnerSignature = + R(typename std::tuple_element>::type...); + + // Rather than a call operator, we must define conversion operators to + // particular action types. This is necessary for embedded actions like + // DoDefault(), which rely on an action conversion operators rather than + // providing a call operator because even with a particular set of arguments + // they don't have a fixed return type. + + template < + typename R, typename... Args, + typename std::enable_if< + std::is_convertible>...)>>::value, + int>::type = 0> + operator OnceAction() && { // NOLINT + struct OA { + OnceAction> inner_action; + + R operator()(Args&&... args) && { + return std::move(inner_action) + .Call(std::get( + std::forward_as_tuple(std::forward(args)...))...); + } + }; + + return OA{std::move(inner_action)}; + } + + template < + typename R, typename... Args, + typename std::enable_if< + std::is_convertible>...)>>::value, + int>::type = 0> + operator Action() const { // NOLINT + Action> converted(inner_action); + + return [converted](Args&&... args) -> R { + return converted.Perform(std::forward_as_tuple( + std::get(std::forward_as_tuple(std::forward(args)...))...)); + }; + } +}; + +template +class DoAllAction; + +// Base case: only a single action. +template +class DoAllAction { + public: + struct UserConstructorTag {}; + + template + explicit DoAllAction(UserConstructorTag, T&& action) + : final_action_(std::forward(action)) {} + + // Rather than a call operator, we must define conversion operators to + // particular action types. This is necessary for embedded actions like + // DoDefault(), which rely on an action conversion operators rather than + // providing a call operator because even with a particular set of arguments + // they don't have a fixed return type. + + template >::value, + int>::type = 0> + operator OnceAction() && { // NOLINT + return std::move(final_action_); + } + + template < + typename R, typename... Args, + typename std::enable_if< + std::is_convertible>::value, + int>::type = 0> + operator Action() const { // NOLINT + return final_action_; + } + + private: + FinalAction final_action_; +}; + +// Recursive case: support N actions by calling the initial action and then +// calling through to the base class containing N-1 actions. +template +class DoAllAction + : private DoAllAction { + private: + using Base = DoAllAction; + + // The type of reference that should be provided to an initial action for a + // mocked function parameter of type T. + // + // There are two quirks here: + // + // * Unlike most forwarding functions, we pass scalars through by value. + // This isn't strictly necessary because an lvalue reference would work + // fine too and be consistent with other non-reference types, but it's + // perhaps less surprising. + // + // For example if the mocked function has signature void(int), then it + // might seem surprising for the user's initial action to need to be + // convertible to Action. This is perhaps less + // surprising for a non-scalar type where there may be a performance + // impact, or it might even be impossible, to pass by value. + // + // * More surprisingly, `const T&` is often not a const reference type. + // By the reference collapsing rules in C++17 [dcl.ref]/6, if T refers to + // U& or U&& for some non-scalar type U, then InitialActionArgType is + // U&. In other words, we may hand over a non-const reference. + // + // So for example, given some non-scalar type Obj we have the following + // mappings: + // + // T InitialActionArgType + // ------- ----------------------- + // Obj const Obj& + // Obj& Obj& + // Obj&& Obj& + // const Obj const Obj& + // const Obj& const Obj& + // const Obj&& const Obj& + // + // In other words, the initial actions get a mutable view of an non-scalar + // argument if and only if the mock function itself accepts a non-const + // reference type. They are never given an rvalue reference to an + // non-scalar type. + // + // This situation makes sense if you imagine use with a matcher that is + // designed to write through a reference. For example, if the caller wants + // to fill in a reference argument and then return a canned value: + // + // EXPECT_CALL(mock, Call) + // .WillOnce(DoAll(SetArgReferee<0>(17), Return(19))); + // + template + using InitialActionArgType = + typename std::conditional::value, T, const T&>::type; + + public: + struct UserConstructorTag {}; + + template + explicit DoAllAction(UserConstructorTag, T&& initial_action, + U&&... other_actions) + : Base({}, std::forward(other_actions)...), + initial_action_(std::forward(initial_action)) {} + + template ...)>>, + std::is_convertible>>::value, + int>::type = 0> + operator OnceAction() && { // NOLINT + // Return an action that first calls the initial action with arguments + // filtered through InitialActionArgType, then forwards arguments directly + // to the base class to deal with the remaining actions. + struct OA { + OnceAction...)> initial_action; + OnceAction remaining_actions; + + R operator()(Args... args) && { + std::move(initial_action) + .Call(static_cast>(args)...); + + return std::move(remaining_actions).Call(std::forward(args)...); + } + }; + + return OA{ + std::move(initial_action_), + std::move(static_cast(*this)), + }; + } + + template < + typename R, typename... Args, + typename std::enable_if< + conjunction< + // Both the initial action and the rest must support conversion to + // Action. + std::is_convertible...)>>, + std::is_convertible>>::value, + int>::type = 0> + operator Action() const { // NOLINT + // Return an action that first calls the initial action with arguments + // filtered through InitialActionArgType, then forwards arguments directly + // to the base class to deal with the remaining actions. + struct OA { + Action...)> initial_action; + Action remaining_actions; + + R operator()(Args... args) const { + initial_action.Perform(std::forward_as_tuple( + static_cast>(args)...)); + + return remaining_actions.Perform( + std::forward_as_tuple(std::forward(args)...)); + } + }; + + return OA{ + initial_action_, + static_cast(*this), + }; + } + + private: + InitialAction initial_action_; +}; + +template +struct ReturnNewAction { + T* operator()() const { + return internal::Apply( + [](const Params&... unpacked_params) { + return new T(unpacked_params...); + }, + params); + } + std::tuple params; +}; + +template +struct ReturnArgAction { + template ::type> + auto operator()(Args&&... args) const -> decltype(std::get( + std::forward_as_tuple(std::forward(args)...))) { + return std::get(std::forward_as_tuple(std::forward(args)...)); + } +}; + +template +struct SaveArgAction { + Ptr pointer; + + template + void operator()(const Args&... args) const { + *pointer = std::get(std::tie(args...)); + } +}; + +template +struct SaveArgPointeeAction { + Ptr pointer; + + template + void operator()(const Args&... args) const { + *pointer = *std::get(std::tie(args...)); + } +}; + +template +struct SetArgRefereeAction { + T value; + + template + void operator()(Args&&... args) const { + using argk_type = + typename ::std::tuple_element>::type; + static_assert(std::is_lvalue_reference::value, + "Argument must be a reference type."); + std::get(std::tie(args...)) = value; + } +}; + +template +struct SetArrayArgumentAction { + I1 first; + I2 last; + + template + void operator()(const Args&... args) const { + auto value = std::get(std::tie(args...)); + for (auto it = first; it != last; ++it, (void)++value) { + *value = *it; + } + } +}; + +template +struct DeleteArgAction { + template + void operator()(const Args&... args) const { + delete std::get(std::tie(args...)); + } +}; + +template +struct ReturnPointeeAction { + Ptr pointer; + template + auto operator()(const Args&...) const -> decltype(*pointer) { + return *pointer; + } +}; + +#if GTEST_HAS_EXCEPTIONS +template +struct ThrowAction { + T exception; + // We use a conversion operator to adapt to any return type. + template + operator Action() const { // NOLINT + T copy = exception; + return [copy](Args...) -> R { throw copy; }; + } +}; +#endif // GTEST_HAS_EXCEPTIONS + +} // namespace internal + +// An Unused object can be implicitly constructed from ANY value. +// This is handy when defining actions that ignore some or all of the +// mock function arguments. For example, given +// +// MOCK_METHOD3(Foo, double(const string& label, double x, double y)); +// MOCK_METHOD3(Bar, double(int index, double x, double y)); +// +// instead of +// +// double DistanceToOriginWithLabel(const string& label, double x, double y) { +// return sqrt(x*x + y*y); +// } +// double DistanceToOriginWithIndex(int index, double x, double y) { +// return sqrt(x*x + y*y); +// } +// ... +// EXPECT_CALL(mock, Foo("abc", _, _)) +// .WillOnce(Invoke(DistanceToOriginWithLabel)); +// EXPECT_CALL(mock, Bar(5, _, _)) +// .WillOnce(Invoke(DistanceToOriginWithIndex)); +// +// you could write +// +// // We can declare any uninteresting argument as Unused. +// double DistanceToOrigin(Unused, double x, double y) { +// return sqrt(x*x + y*y); +// } +// ... +// EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); +// EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); +typedef internal::IgnoredValue Unused; + +// Creates an action that does actions a1, a2, ..., sequentially in +// each invocation. All but the last action will have a readonly view of the +// arguments. +template +internal::DoAllAction::type...> DoAll( + Action&&... action) { + return internal::DoAllAction::type...>( + {}, std::forward(action)...); +} + +// WithArg(an_action) creates an action that passes the k-th +// (0-based) argument of the mock function to an_action and performs +// it. It adapts an action accepting one argument to one that accepts +// multiple arguments. For convenience, we also provide +// WithArgs(an_action) (defined below) as a synonym. +template +internal::WithArgsAction::type, k> WithArg( + InnerAction&& action) { + return {std::forward(action)}; +} + +// WithArgs(an_action) creates an action that passes +// the selected arguments of the mock function to an_action and +// performs it. It serves as an adaptor between actions with +// different argument lists. +template +internal::WithArgsAction::type, k, ks...> +WithArgs(InnerAction&& action) { + return {std::forward(action)}; +} + +// WithoutArgs(inner_action) can be used in a mock function with a +// non-empty argument list to perform inner_action, which takes no +// argument. In other words, it adapts an action accepting no +// argument to one that accepts (and ignores) arguments. +template +internal::WithArgsAction::type> WithoutArgs( + InnerAction&& action) { + return {std::forward(action)}; +} + +// Creates an action that returns a value. +// +// The returned type can be used with a mock function returning a non-void, +// non-reference type U as follows: +// +// * If R is convertible to U and U is move-constructible, then the action can +// be used with WillOnce. +// +// * If const R& is convertible to U and U is copy-constructible, then the +// action can be used with both WillOnce and WillRepeatedly. +// +// The mock expectation contains the R value from which the U return value is +// constructed (a move/copy of the argument to Return). This means that the R +// value will survive at least until the mock object's expectations are cleared +// or the mock object is destroyed, meaning that U can safely be a +// reference-like type such as std::string_view: +// +// // The mock function returns a view of a copy of the string fed to +// // Return. The view is valid even after the action is performed. +// MockFunction mock; +// EXPECT_CALL(mock, Call).WillOnce(Return(std::string("taco"))); +// const std::string_view result = mock.AsStdFunction()(); +// EXPECT_EQ("taco", result); +// +template +internal::ReturnAction Return(R value) { + return internal::ReturnAction(std::move(value)); +} + +// Creates an action that returns NULL. +inline PolymorphicAction ReturnNull() { + return MakePolymorphicAction(internal::ReturnNullAction()); +} + +// Creates an action that returns from a void function. +inline PolymorphicAction Return() { + return MakePolymorphicAction(internal::ReturnVoidAction()); +} + +// Creates an action that returns the reference to a variable. +template +inline internal::ReturnRefAction ReturnRef(R& x) { // NOLINT + return internal::ReturnRefAction(x); +} + +// Prevent using ReturnRef on reference to temporary. +template +internal::ReturnRefAction ReturnRef(R&&) = delete; + +// Creates an action that returns the reference to a copy of the +// argument. The copy is created when the action is constructed and +// lives as long as the action. +template +inline internal::ReturnRefOfCopyAction ReturnRefOfCopy(const R& x) { + return internal::ReturnRefOfCopyAction(x); +} + +// DEPRECATED: use Return(x) directly with WillOnce. +// +// Modifies the parent action (a Return() action) to perform a move of the +// argument instead of a copy. +// Return(ByMove()) actions can only be executed once and will assert this +// invariant. +template +internal::ByMoveWrapper ByMove(R x) { + return internal::ByMoveWrapper(std::move(x)); +} + +// Creates an action that returns an element of `vals`. Calling this action will +// repeatedly return the next value from `vals` until it reaches the end and +// will restart from the beginning. +template +internal::ReturnRoundRobinAction ReturnRoundRobin(std::vector vals) { + return internal::ReturnRoundRobinAction(std::move(vals)); +} + +// Creates an action that returns an element of `vals`. Calling this action will +// repeatedly return the next value from `vals` until it reaches the end and +// will restart from the beginning. +template +internal::ReturnRoundRobinAction ReturnRoundRobin( + std::initializer_list vals) { + return internal::ReturnRoundRobinAction(std::vector(vals)); +} + +// Creates an action that does the default action for the give mock function. +inline internal::DoDefaultAction DoDefault() { + return internal::DoDefaultAction(); +} + +// Creates an action that sets the variable pointed by the N-th +// (0-based) function argument to 'value'. +template +internal::SetArgumentPointeeAction SetArgPointee(T value) { + return {std::move(value)}; +} + +// The following version is DEPRECATED. +template +internal::SetArgumentPointeeAction SetArgumentPointee(T value) { + return {std::move(value)}; +} + +// Creates an action that sets a pointer referent to a given value. +template +PolymorphicAction> Assign(T1* ptr, T2 val) { + return MakePolymorphicAction(internal::AssignAction(ptr, val)); +} + +#ifndef GTEST_OS_WINDOWS_MOBILE + +// Creates an action that sets errno and returns the appropriate error. +template +PolymorphicAction> SetErrnoAndReturn( + int errval, T result) { + return MakePolymorphicAction( + internal::SetErrnoAndReturnAction(errval, result)); +} + +#endif // !GTEST_OS_WINDOWS_MOBILE + +// Various overloads for Invoke(). + +// Legacy function. +// Actions can now be implicitly constructed from callables. No need to create +// wrapper objects. +// This function exists for backwards compatibility. +template +typename std::decay::type Invoke(FunctionImpl&& function_impl) { + return std::forward(function_impl); +} + +// Creates an action that invokes the given method on the given object +// with the mock function's arguments. +template +internal::InvokeMethodAction Invoke(Class* obj_ptr, + MethodPtr method_ptr) { + return {obj_ptr, method_ptr}; +} + +// Creates an action that invokes 'function_impl' with no argument. +template +internal::InvokeWithoutArgsAction::type> +InvokeWithoutArgs(FunctionImpl function_impl) { + return {std::move(function_impl)}; +} + +// Creates an action that invokes the given method on the given object +// with no argument. +template +internal::InvokeMethodWithoutArgsAction InvokeWithoutArgs( + Class* obj_ptr, MethodPtr method_ptr) { + return {obj_ptr, method_ptr}; +} + +// Creates an action that performs an_action and throws away its +// result. In other words, it changes the return type of an_action to +// void. an_action MUST NOT return void, or the code won't compile. +template +inline internal::IgnoreResultAction IgnoreResult(const A& an_action) { + return internal::IgnoreResultAction(an_action); +} + +// Creates a reference wrapper for the given L-value. If necessary, +// you can explicitly specify the type of the reference. For example, +// suppose 'derived' is an object of type Derived, ByRef(derived) +// would wrap a Derived&. If you want to wrap a const Base& instead, +// where Base is a base class of Derived, just write: +// +// ByRef(derived) +// +// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper. +// However, it may still be used for consistency with ByMove(). +template +inline ::std::reference_wrapper ByRef(T& l_value) { // NOLINT + return ::std::reference_wrapper(l_value); +} + +// The ReturnNew(a1, a2, ..., a_k) action returns a pointer to a new +// instance of type T, constructed on the heap with constructor arguments +// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. +template +internal::ReturnNewAction::type...> ReturnNew( + Params&&... params) { + return {std::forward_as_tuple(std::forward(params)...)}; +} + +// Action ReturnArg() returns the k-th argument of the mock function. +template +internal::ReturnArgAction ReturnArg() { + return {}; +} + +// Action SaveArg(pointer) saves the k-th (0-based) argument of the +// mock function to *pointer. +template +internal::SaveArgAction SaveArg(Ptr pointer) { + return {pointer}; +} + +// Action SaveArgPointee(pointer) saves the value pointed to +// by the k-th (0-based) argument of the mock function to *pointer. +template +internal::SaveArgPointeeAction SaveArgPointee(Ptr pointer) { + return {pointer}; +} + +// Action SetArgReferee(value) assigns 'value' to the variable +// referenced by the k-th (0-based) argument of the mock function. +template +internal::SetArgRefereeAction::type> SetArgReferee( + T&& value) { + return {std::forward(value)}; +} + +// Action SetArrayArgument(first, last) copies the elements in +// source range [first, last) to the array pointed to by the k-th +// (0-based) argument, which can be either a pointer or an +// iterator. The action does not take ownership of the elements in the +// source range. +template +internal::SetArrayArgumentAction SetArrayArgument(I1 first, + I2 last) { + return {first, last}; +} + +// Action DeleteArg() deletes the k-th (0-based) argument of the mock +// function. +template +internal::DeleteArgAction DeleteArg() { + return {}; +} + +// This action returns the value pointed to by 'pointer'. +template +internal::ReturnPointeeAction ReturnPointee(Ptr pointer) { + return {pointer}; +} + +// Action Throw(exception) can be used in a mock function of any type +// to throw the given exception. Any copyable value can be thrown. +#if GTEST_HAS_EXCEPTIONS +template +internal::ThrowAction::type> Throw(T&& exception) { + return {std::forward(exception)}; +} +#endif // GTEST_HAS_EXCEPTIONS + +namespace internal { + +// A macro from the ACTION* family (defined later in gmock-generated-actions.h) +// defines an action that can be used in a mock function. Typically, +// these actions only care about a subset of the arguments of the mock +// function. For example, if such an action only uses the second +// argument, it can be used in any mock function that takes >= 2 +// arguments where the type of the second argument is compatible. +// +// Therefore, the action implementation must be prepared to take more +// arguments than it needs. The ExcessiveArg type is used to +// represent those excessive arguments. In order to keep the compiler +// error messages tractable, we define it in the testing namespace +// instead of testing::internal. However, this is an INTERNAL TYPE +// and subject to change without notice, so a user MUST NOT USE THIS +// TYPE DIRECTLY. +struct ExcessiveArg {}; + +// Builds an implementation of an Action<> for some particular signature, using +// a class defined by an ACTION* macro. +template +struct ActionImpl; + +template +struct ImplBase { + struct Holder { + // Allows each copy of the Action<> to get to the Impl. + explicit operator const Impl&() const { return *ptr; } + std::shared_ptr ptr; + }; + using type = typename std::conditional::value, + Impl, Holder>::type; +}; + +template +struct ActionImpl : ImplBase::type { + using Base = typename ImplBase::type; + using function_type = R(Args...); + using args_type = std::tuple; + + ActionImpl() = default; // Only defined if appropriate for Base. + explicit ActionImpl(std::shared_ptr impl) : Base{std::move(impl)} {} + + R operator()(Args&&... arg) const { + static constexpr size_t kMaxArgs = + sizeof...(Args) <= 10 ? sizeof...(Args) : 10; + return Apply(MakeIndexSequence{}, + MakeIndexSequence<10 - kMaxArgs>{}, + args_type{std::forward(arg)...}); + } + + template + R Apply(IndexSequence, IndexSequence, + const args_type& args) const { + // Impl need not be specific to the signature of action being implemented; + // only the implementing function body needs to have all of the specific + // types instantiated. Up to 10 of the args that are provided by the + // args_type get passed, followed by a dummy of unspecified type for the + // remainder up to 10 explicit args. + static constexpr ExcessiveArg kExcessArg{}; + return static_cast(*this) + .template gmock_PerformImpl< + /*function_type=*/function_type, /*return_type=*/R, + /*args_type=*/args_type, + /*argN_type=*/ + typename std::tuple_element::type...>( + /*args=*/args, std::get(args)..., + ((void)excess_id, kExcessArg)...); + } +}; + +// Stores a default-constructed Impl as part of the Action<>'s +// std::function<>. The Impl should be trivial to copy. +template +::testing::Action MakeAction() { + return ::testing::Action(ActionImpl()); +} + +// Stores just the one given instance of Impl. +template +::testing::Action MakeAction(std::shared_ptr impl) { + return ::testing::Action(ActionImpl(std::move(impl))); +} + +#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \ + , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_ +#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \ + const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_ARG_UNUSED, , 10) + +#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i +#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \ + const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10) + +#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type +#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \ + GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10)) + +#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type +#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params)) + +#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type +#define GMOCK_ACTION_TYPE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params)) + +#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \ + , param##_type gmock_p##i +#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params)) + +#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \ + , std::forward(gmock_p##i) +#define GMOCK_ACTION_GVALUE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params)) + +#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \ + , param(::std::forward(gmock_p##i)) +#define GMOCK_ACTION_INIT_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params)) + +#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param; +#define GMOCK_ACTION_FIELD_PARAMS_(params) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params) + +#define GMOCK_INTERNAL_ACTION(name, full_name, params) \ + template \ + class full_name { \ + public: \ + explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ + : impl_(std::make_shared( \ + GMOCK_ACTION_GVALUE_PARAMS_(params))) {} \ + full_name(const full_name&) = default; \ + full_name(full_name&&) noexcept = default; \ + template \ + operator ::testing::Action() const { \ + return ::testing::internal::MakeAction(impl_); \ + } \ + \ + private: \ + class gmock_Impl { \ + public: \ + explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ + : GMOCK_ACTION_INIT_PARAMS_(params) {} \ + template \ + return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ + GMOCK_ACTION_FIELD_PARAMS_(params) \ + }; \ + std::shared_ptr impl_; \ + }; \ + template \ + inline full_name name( \ + GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_; \ + template \ + inline full_name name( \ + GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \ + return full_name( \ + GMOCK_ACTION_GVALUE_PARAMS_(params)); \ + } \ + template \ + template \ + return_type \ + full_name::gmock_Impl::gmock_PerformImpl( \ + GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const + +} // namespace internal + +// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored. +#define ACTION(name) \ + class name##Action { \ + public: \ + explicit name##Action() noexcept {} \ + name##Action(const name##Action&) noexcept {} \ + template \ + operator ::testing::Action() const { \ + return ::testing::internal::MakeAction(); \ + } \ + \ + private: \ + class gmock_Impl { \ + public: \ + template \ + return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ + }; \ + }; \ + inline name##Action name() GTEST_MUST_USE_RESULT_; \ + inline name##Action name() { return name##Action(); } \ + template \ + return_type name##Action::gmock_Impl::gmock_PerformImpl( \ + GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const + +#define ACTION_P(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__)) + +#define ACTION_P2(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__)) + +#define ACTION_P3(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__)) + +#define ACTION_P4(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__)) + +#define ACTION_P5(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__)) + +#define ACTION_P6(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__)) + +#define ACTION_P7(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__)) + +#define ACTION_P8(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__)) + +#define ACTION_P9(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__)) + +#define ACTION_P10(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__)) + +} // namespace testing + +GTEST_DISABLE_MSC_WARNINGS_POP_() // 4100 + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ diff --git a/cpp/third_party/googletest/googlemock/include/gmock/gmock-cardinalities.h b/cpp/third_party/googletest/googlemock/include/gmock/gmock-cardinalities.h new file mode 100644 index 0000000..533e604 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/include/gmock/gmock-cardinalities.h @@ -0,0 +1,159 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Google Mock - a framework for writing C++ mock classes. +// +// This file implements some commonly used cardinalities. More +// cardinalities can be defined by the user implementing the +// CardinalityInterface interface if necessary. + +// IWYU pragma: private, include "gmock/gmock.h" +// IWYU pragma: friend gmock/.* + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ + +#include + +#include +#include // NOLINT + +#include "gmock/internal/gmock-port.h" +#include "gtest/gtest.h" + +GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ +/* class A needs to have dll-interface to be used by clients of class B */) + +namespace testing { + +// To implement a cardinality Foo, define: +// 1. a class FooCardinality that implements the +// CardinalityInterface interface, and +// 2. a factory function that creates a Cardinality object from a +// const FooCardinality*. +// +// The two-level delegation design follows that of Matcher, providing +// consistency for extension developers. It also eases ownership +// management as Cardinality objects can now be copied like plain values. + +// The implementation of a cardinality. +class CardinalityInterface { + public: + virtual ~CardinalityInterface() = default; + + // Conservative estimate on the lower/upper bound of the number of + // calls allowed. + virtual int ConservativeLowerBound() const { return 0; } + virtual int ConservativeUpperBound() const { return INT_MAX; } + + // Returns true if and only if call_count calls will satisfy this + // cardinality. + virtual bool IsSatisfiedByCallCount(int call_count) const = 0; + + // Returns true if and only if call_count calls will saturate this + // cardinality. + virtual bool IsSaturatedByCallCount(int call_count) const = 0; + + // Describes self to an ostream. + virtual void DescribeTo(::std::ostream* os) const = 0; +}; + +// A Cardinality is a copyable and IMMUTABLE (except by assignment) +// object that specifies how many times a mock function is expected to +// be called. The implementation of Cardinality is just a std::shared_ptr +// to const CardinalityInterface. Don't inherit from Cardinality! +class GTEST_API_ Cardinality { + public: + // Constructs a null cardinality. Needed for storing Cardinality + // objects in STL containers. + Cardinality() = default; + + // Constructs a Cardinality from its implementation. + explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {} + + // Conservative estimate on the lower/upper bound of the number of + // calls allowed. + int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); } + int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); } + + // Returns true if and only if call_count calls will satisfy this + // cardinality. + bool IsSatisfiedByCallCount(int call_count) const { + return impl_->IsSatisfiedByCallCount(call_count); + } + + // Returns true if and only if call_count calls will saturate this + // cardinality. + bool IsSaturatedByCallCount(int call_count) const { + return impl_->IsSaturatedByCallCount(call_count); + } + + // Returns true if and only if call_count calls will over-saturate this + // cardinality, i.e. exceed the maximum number of allowed calls. + bool IsOverSaturatedByCallCount(int call_count) const { + return impl_->IsSaturatedByCallCount(call_count) && + !impl_->IsSatisfiedByCallCount(call_count); + } + + // Describes self to an ostream + void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); } + + // Describes the given actual call count to an ostream. + static void DescribeActualCallCountTo(int actual_call_count, + ::std::ostream* os); + + private: + std::shared_ptr impl_; +}; + +// Creates a cardinality that allows at least n calls. +GTEST_API_ Cardinality AtLeast(int n); + +// Creates a cardinality that allows at most n calls. +GTEST_API_ Cardinality AtMost(int n); + +// Creates a cardinality that allows any number of calls. +GTEST_API_ Cardinality AnyNumber(); + +// Creates a cardinality that allows between min and max calls. +GTEST_API_ Cardinality Between(int min, int max); + +// Creates a cardinality that allows exactly n calls. +GTEST_API_ Cardinality Exactly(int n); + +// Creates a cardinality from its implementation. +inline Cardinality MakeCardinality(const CardinalityInterface* c) { + return Cardinality(c); +} + +} // namespace testing + +GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ diff --git a/cpp/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h b/cpp/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h new file mode 100644 index 0000000..1a1f126 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h @@ -0,0 +1,518 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Google Mock - a framework for writing C++ mock classes. +// +// This file implements MOCK_METHOD. + +// IWYU pragma: private, include "gmock/gmock.h" +// IWYU pragma: friend gmock/.* + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_ + +#include // IWYU pragma: keep +#include // IWYU pragma: keep + +#include "gmock/gmock-spec-builders.h" +#include "gmock/internal/gmock-internal-utils.h" +#include "gmock/internal/gmock-pp.h" + +namespace testing { +namespace internal { +template +using identity_t = T; + +template +struct ThisRefAdjuster { + template + using AdjustT = typename std::conditional< + std::is_const::type>::value, + typename std::conditional::value, + const T&, const T&&>::type, + typename std::conditional::value, T&, + T&&>::type>::type; + + template + static AdjustT Adjust(const MockType& mock) { + return static_cast>(const_cast(mock)); + } +}; + +constexpr bool PrefixOf(const char* a, const char* b) { + return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1)); +} + +template +constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) { + return N <= M && internal::PrefixOf(prefix, str); +} + +template +constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) { + return N <= M && internal::PrefixOf(suffix, str + M - N); +} + +template +constexpr bool Equals(const char (&a)[N], const char (&b)[M]) { + return N == M && internal::PrefixOf(a, b); +} + +template +constexpr bool ValidateSpec(const char (&spec)[N]) { + return internal::Equals("const", spec) || + internal::Equals("override", spec) || + internal::Equals("final", spec) || + internal::Equals("noexcept", spec) || + (internal::StartsWith("noexcept(", spec) && + internal::EndsWith(")", spec)) || + internal::Equals("ref(&)", spec) || + internal::Equals("ref(&&)", spec) || + (internal::StartsWith("Calltype(", spec) && + internal::EndsWith(")", spec)); +} + +} // namespace internal + +// The style guide prohibits "using" statements in a namespace scope +// inside a header file. However, the FunctionMocker class template +// is meant to be defined in the ::testing namespace. The following +// line is just a trick for working around a bug in MSVC 8.0, which +// cannot handle it if we define FunctionMocker in ::testing. +using internal::FunctionMocker; +} // namespace testing + +#define MOCK_METHOD(...) \ + GMOCK_INTERNAL_WARNING_PUSH() \ + GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \ + GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) \ + GMOCK_INTERNAL_WARNING_POP() + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ + GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec) \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ + GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ + GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ + GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ + GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ + GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ + (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_WRONG_ARITY(...) \ + static_assert( \ + false, \ + "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ + "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ + "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ + "it must also be enclosed in parentheses.") + +#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ + static_assert( \ + GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ + GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.") + +#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \ + static_assert( \ + std::is_function<__VA_ARGS__>::value, \ + "Signature must be a function type, maybe return type contains " \ + "unprotected comma."); \ + static_assert( \ + ::testing::tuple_size::ArgumentTuple>::value == _N, \ + "This method does not take " GMOCK_PP_STRINGIZE( \ + _N) " arguments. Parenthesize all types with unprotected commas.") + +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) + +#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ + _Override, _Final, _NoexceptSpec, \ + _CallType, _RefSpec, _Signature) \ + typename ::testing::internal::Function::Result \ + GMOCK_INTERNAL_EXPAND(_CallType) \ + _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) \ + _RefSpec _NoexceptSpec GMOCK_PP_IF(_Override, override, ) \ + GMOCK_PP_IF(_Final, final, ) { \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .SetOwnerAndName(this, #_MethodName); \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ + } \ + ::testing::MockSpec gmock_##_MethodName( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ + GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ + } \ + ::testing::MockSpec gmock_##_MethodName( \ + const ::testing::internal::WithoutMatchers&, \ + GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ + GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ + return ::testing::internal::ThisRefAdjuster::Adjust(*this) \ + .gmock_##_MethodName(GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ + } \ + mutable ::testing::FunctionMocker \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) + +#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ + +// Valid modifiers. +#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ + GMOCK_PP_HAS_COMMA( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) + +#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) + +#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem) \ + GMOCK_PP_IF( \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ + _elem, ) + +#define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE, ~, _Tuple) + +#define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem) \ + GMOCK_PP_IF( \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)), \ + GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) + +#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) + +#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem) \ + GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ + GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) + +#ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ + static_assert( \ + ::testing::internal::ValidateSpec(GMOCK_PP_STRINGIZE(_elem)), \ + "Token \'" GMOCK_PP_STRINGIZE( \ + _elem) "\' cannot be recognized as a valid specification " \ + "modifier. Is a ',' missing?"); +#else +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ + static_assert( \ + (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem))) == 1, \ + GMOCK_PP_STRINGIZE( \ + _elem) " cannot be recognized as a valid specification modifier."); +#endif // GMOCK_INTERNAL_STRICT_SPEC_ASSERT + +// Modifiers implementation. +#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_CONST_I_const , + +#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , + +#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_FINAL_I_final , + +#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , + +#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_REF_I_ref , + +#define GMOCK_INTERNAL_UNPACK_ref(x) x + +#define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CALLTYPE_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype , + +#define GMOCK_INTERNAL_UNPACK_Calltype(...) __VA_ARGS__ + +// Note: The use of `identity_t` here allows _Ret to represent return types that +// would normally need to be specified in a different way. For example, a method +// returning a function pointer must be written as +// +// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) +// +// But we only support placing the return type at the beginning. To handle this, +// we wrap all calls in identity_t, so that a declaration will be expanded to +// +// identity_t method(method_args_t...) +// +// This allows us to work around the syntactic oddities of function/method +// types. +#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ + ::testing::internal::identity_t( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) + +#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ + GMOCK_PP_IDENTITY) \ + (_elem) + +#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ + gmock_a##_i + +#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::std::forward(gmock_a##_i) + +#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ + gmock_a##_i + +#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ + GMOCK_PP_COMMA_IF(_i) \ + gmock_a##_i + +#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::testing::A() + +#define GMOCK_INTERNAL_ARG_O(_i, ...) \ + typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type + +#define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ + const ::testing::Matcher::template Arg<_i>::type>& + +#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) +#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) +#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) +#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) +#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) +#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) +#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) +#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) +#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) +#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) +#define MOCK_METHOD10(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) + +#define MOCK_CONST_METHOD0(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) +#define MOCK_CONST_METHOD1(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) +#define MOCK_CONST_METHOD2(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) +#define MOCK_CONST_METHOD3(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) +#define MOCK_CONST_METHOD4(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) +#define MOCK_CONST_METHOD5(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) +#define MOCK_CONST_METHOD6(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) +#define MOCK_CONST_METHOD7(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) +#define MOCK_CONST_METHOD8(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) +#define MOCK_CONST_METHOD9(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) +#define MOCK_CONST_METHOD10(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) + +#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) +#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) +#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) +#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) +#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) +#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) +#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) +#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) +#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) +#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) +#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) +#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) +#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) +#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) +#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) +#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) +#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) +#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) +#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) +#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) +#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) + +#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) +#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) +#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) +#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) +#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) +#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) +#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) +#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) +#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) +#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) +#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) +#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) +#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) +#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) +#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) +#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) +#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) +#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) +#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) +#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) +#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) + +#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ + GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ + args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ + (::testing::internal::identity_t<__VA_ARGS__>)) + +#define GMOCK_MOCKER_(arity, constness, Method) \ + GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_ diff --git a/cpp/third_party/googletest/googlemock/include/gmock/gmock-matchers.h b/cpp/third_party/googletest/googlemock/include/gmock/gmock-matchers.h new file mode 100644 index 0000000..0f67713 --- /dev/null +++ b/cpp/third_party/googletest/googlemock/include/gmock/gmock-matchers.h @@ -0,0 +1,5623 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Google Mock - a framework for writing C++ mock classes. +// +// The MATCHER* family of macros can be used in a namespace scope to +// define custom matchers easily. +// +// Basic Usage +// =========== +// +// The syntax +// +// MATCHER(name, description_string) { statements; } +// +// defines a matcher with the given name that executes the statements, +// which must return a bool to indicate if the match succeeds. Inside +// the statements, you can refer to the value being matched by 'arg', +// and refer to its type by 'arg_type'. +// +// The description string documents what the matcher does, and is used +// to generate the failure message when the match fails. Since a +// MATCHER() is usually defined in a header file shared by multiple +// C++ source files, we require the description to be a C-string +// literal to avoid possible side effects. It can be empty, in which +// case we'll use the sequence of words in the matcher name as the +// description. +// +// For example: +// +// MATCHER(IsEven, "") { return (arg % 2) == 0; } +// +// allows you to write +// +// // Expects mock_foo.Bar(n) to be called where n is even. +// EXPECT_CALL(mock_foo, Bar(IsEven())); +// +// or, +// +// // Verifies that the value of some_expression is even. +// EXPECT_THAT(some_expression, IsEven()); +// +// If the above assertion fails, it will print something like: +// +// Value of: some_expression +// Expected: is even +// Actual: 7 +// +// where the description "is even" is automatically calculated from the +// matcher name IsEven. +// +// Argument Type +// ============= +// +// Note that the type of the value being matched (arg_type) is +// determined by the context in which you use the matcher and is +// supplied to you by the compiler, so you don't need to worry about +// declaring it (nor can you). This allows the matcher to be +// polymorphic. For example, IsEven() can be used to match any type +// where the value of "(arg % 2) == 0" can be implicitly converted to +// a bool. In the "Bar(IsEven())" example above, if method Bar() +// takes an int, 'arg_type' will be int; if it takes an unsigned long, +// 'arg_type' will be unsigned long; and so on. +// +// Parameterizing Matchers +// ======================= +// +// Sometimes you'll want to parameterize the matcher. For that you +// can use another macro: +// +// MATCHER_P(name, param_name, description_string) { statements; } +// +// For example: +// +// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } +// +// will allow you to write: +// +// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); +// +// which may lead to this message (assuming n is 10): +// +// Value of: Blah("a") +// Expected: has absolute value 10 +// Actual: -9 +// +// Note that both the matcher description and its parameter are +// printed, making the message human-friendly. +// +// In the matcher definition body, you can write 'foo_type' to +// reference the type of a parameter named 'foo'. For example, in the +// body of MATCHER_P(HasAbsoluteValue, value) above, you can write +// 'value_type' to refer to the type of 'value'. +// +// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to +// support multi-parameter matchers. +// +// Describing Parameterized Matchers +// ================================= +// +// The last argument to MATCHER*() is a string-typed expression. The +// expression can reference all of the matcher's parameters and a +// special bool-typed variable named 'negation'. When 'negation' is +// false, the expression should evaluate to the matcher's description; +// otherwise it should evaluate to the description of the negation of +// the matcher. For example, +// +// using testing::PrintToString; +// +// MATCHER_P2(InClosedRange, low, hi, +// std::string(negation ? "is not" : "is") + " in range [" + +// PrintToString(low) + ", " + PrintToString(hi) + "]") { +// return low <= arg && arg <= hi; +// } +// ... +// EXPECT_THAT(3, InClosedRange(4, 6)); +// EXPECT_THAT(3, Not(InClosedRange(2, 4))); +// +// would generate two failures that contain the text: +// +// Expected: is in range [4, 6] +// ... +// Expected: is not in range [2, 4] +// +// If you specify "" as the description, the failure message will +// contain the sequence of words in the matcher name followed by the +// parameter values printed as a tuple. For example, +// +// MATCHER_P2(InClosedRange, low, hi, "") { ... } +// ... +// EXPECT_THAT(3, InClosedRange(4, 6)); +// EXPECT_THAT(3, Not(InClosedRange(2, 4))); +// +// would generate two failures that contain the text: +// +// Expected: in closed range (4, 6) +// ... +// Expected: not (in closed range (2, 4)) +// +// Types of Matcher Parameters +// =========================== +// +// For the purpose of typing, you can view +// +// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } +// +// as shorthand for +// +// template +// FooMatcherPk +// Foo(p1_type p1, ..., pk_type pk) { ... } +// +// When you write Foo(v1, ..., vk), the compiler infers the types of +// the parameters v1, ..., and vk for you. If you are not happy with +// the result of the type inference, you can specify the types by +// explicitly instantiating the template, as in Foo(5, +// false). As said earlier, you don't get to (or need to) specify +// 'arg_type' as that's determined by the context in which the matcher +// is used. You can assign the result of expression Foo(p1, ..., pk) +// to a variable of type FooMatcherPk. This +// can be useful when composing matchers. +// +// While you can instantiate a matcher template with reference types, +// passing the parameters by pointer usually makes your code more +// readable. If, however, you still want to pass a parameter by +// reference, be aware that in the failure message generated by the +// matcher you will see the value of the referenced object but not its +// address. +// +// Explaining Match Results +// ======================== +// +// Sometimes the matcher description alone isn't enough to explain why +// the match has failed or succeeded. For example, when expecting a +// long string, it can be very helpful to also print the diff between +// the expected string and the actual one. To achieve that, you can +// optionally stream additional information to a special variable +// named result_listener, whose type is a pointer to class +// MatchResultListener: +// +// MATCHER_P(EqualsLongString, str, "") { +// if (arg == str) return true; +// +// *result_listener << "the difference: " +/// << DiffStrings(str, arg); +// return false; +// } +// +// Overloading Matchers +// ==================== +// +// You can overload matchers with different numbers of parameters: +// +// MATCHER_P(Blah, a, description_string1) { ... } +// MATCHER_P2(Blah, a, b, description_string2) { ... } +// +// Caveats +// ======= +// +// When defining a new matcher, you should also consider implementing +// MatcherInterface or using MakePolymorphicMatcher(). These +// approaches require more work than the MATCHER* macros, but also +// give you more control on the types of the value being matched and +// the matcher parameters, which may leads to better compiler error +// messages when the matcher is used wrong. They also allow +// overloading matchers based on parameter types (as opposed to just +// based on the number of parameters). +// +// MATCHER*() can only be used in a namespace scope as templates cannot be +// declared inside of a local class. +// +// More Information +// ================ +// +// To learn more about using these macros, please search for 'MATCHER' +// on +// https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md +// +// This file also implements some commonly used argument matchers. More +// matchers can be defined by the user implementing the +// MatcherInterface interface if necessary. +// +// See googletest/include/gtest/gtest-matchers.h for the definition of class +// Matcher, class MatcherInterface, and others. + +// IWYU pragma: private, include "gmock/gmock.h" +// IWYU pragma: friend gmock/.* + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // NOLINT +#include +#include +#include +#include +#include + +#include "gmock/internal/gmock-internal-utils.h" +#include "gmock/internal/gmock-port.h" +#include "gmock/internal/gmock-pp.h" +#include "gtest/gtest.h" + +// MSVC warning C5046 is new as of VS2017 version 15.8. +#if defined(_MSC_VER) && _MSC_VER >= 1915 +#define GMOCK_MAYBE_5046_ 5046 +#else +#define GMOCK_MAYBE_5046_ +#endif + +GTEST_DISABLE_MSC_WARNINGS_PUSH_( + 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by + clients of class B */ + /* Symbol involving type with internal linkage not defined */) + +namespace testing { + +// To implement a matcher Foo for type T, define: +// 1. a class FooMatcherImpl that implements the +// MatcherInterface interface, and +// 2. a factory function that creates a Matcher object from a +// FooMatcherImpl*. +// +// The two-level delegation design makes it possible to allow a user +// to write "v" instead of "Eq(v)" where a Matcher is expected, which +// is impossible if we pass matchers by pointers. It also eases +// ownership management as Matcher objects can now be copied like +// plain values. + +// A match result listener that stores the explanation in a string. +class StringMatchResultListener : public MatchResultListener { + public: + StringMatchResultListener() : MatchResultListener(&ss_) {} + + // Returns the explanation accumulated so far. + std::string str() const { return ss_.str(); } + + // Clears the explanation accumulated so far. + void Clear() { ss_.str(""); } + + private: + ::std::stringstream ss_; + + StringMatchResultListener(const StringMatchResultListener&) = delete; + StringMatchResultListener& operator=(const StringMatchResultListener&) = + delete; +}; + +// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION +// and MUST NOT BE USED IN USER CODE!!! +namespace internal { + +// The MatcherCastImpl class template is a helper for implementing +// MatcherCast(). We need this helper in order to partially +// specialize the implementation of MatcherCast() (C++ allows +// class/struct templates to be partially specialized, but not +// function templates.). + +// This general version is used when MatcherCast()'s argument is a +// polymorphic matcher (i.e. something that can be converted to a +// Matcher but is not one yet; for example, Eq(value)) or a value (for +// example, "hello"). +template +class MatcherCastImpl { + public: + static Matcher Cast(const M& polymorphic_matcher_or_value) { + // M can be a polymorphic matcher, in which case we want to use + // its conversion operator to create Matcher. Or it can be a value + // that should be passed to the Matcher's constructor. + // + // We can't call Matcher(polymorphic_matcher_or_value) when M is a + // polymorphic matcher because it'll be ambiguous if T has an implicit + // constructor from M (this usually happens when T has an implicit + // constructor from any type). + // + // It won't work to unconditionally implicit_cast + // polymorphic_matcher_or_value to Matcher because it won't trigger + // a user-defined conversion from M to T if one exists (assuming M is + // a value). + return CastImpl(polymorphic_matcher_or_value, + std::is_convertible>{}, + std::is_convertible{}); + } + + private: + template + static Matcher CastImpl(const M& polymorphic_matcher_or_value, + std::true_type /* convertible_to_matcher */, + std::integral_constant) { + // M is implicitly convertible to Matcher, which means that either + // M is a polymorphic matcher or Matcher has an implicit constructor + // from M. In both cases using the implicit conversion will produce a + // matcher. + // + // Even if T has an implicit constructor from M, it won't be called because + // creating Matcher would require a chain of two user-defined conversions + // (first to create T from M and then to create Matcher from T). + return polymorphic_matcher_or_value; + } + + // M can't be implicitly converted to Matcher, so M isn't a polymorphic + // matcher. It's a value of a type implicitly convertible to T. Use direct + // initialization to create a matcher. + static Matcher CastImpl(const M& value, + std::false_type /* convertible_to_matcher */, + std::true_type /* convertible_to_T */) { + return Matcher(ImplicitCast_(value)); + } + + // M can't be implicitly converted to either Matcher or T. Attempt to use + // polymorphic matcher Eq(value) in this case. + // + // Note that we first attempt to perform an implicit cast on the value and + // only fall back to the polymorphic Eq() matcher afterwards because the + // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end + // which might be undefined even when Rhs is implicitly convertible to Lhs + // (e.g. std::pair vs. std::pair). + // + // We don't define this method inline as we need the declaration of Eq(). + static Matcher CastImpl(const M& value, + std::false_type /* convertible_to_matcher */, + std::false_type /* convertible_to_T */); +}; + +// This more specialized version is used when MatcherCast()'s argument +// is already a Matcher. This only compiles when type T can be +// statically converted to type U. +template +class MatcherCastImpl> { + public: + static Matcher Cast(const Matcher& source_matcher) { + return Matcher(new Impl(source_matcher)); + } + + private: + class Impl : public MatcherInterface { + public: + explicit Impl(const Matcher& source_matcher) + : source_matcher_(source_matcher) {} + + // We delegate the matching logic to the source matcher. + bool MatchAndExplain(T x, MatchResultListener* listener) const override { + using FromType = typename std::remove_cv::type>::type>::type; + using ToType = typename std::remove_cv::type>::type>::type; + // Do not allow implicitly converting base*/& to derived*/&. + static_assert( + // Do not trigger if only one of them is a pointer. That implies a + // regular conversion and not a down_cast. + (std::is_pointer::type>::value != + std::is_pointer::type>::value) || + std::is_same::value || + !std::is_base_of::value, + "Can't implicitly convert from to "); + + // Do the cast to `U` explicitly if necessary. + // Otherwise, let implicit conversions do the trick. + using CastType = + typename std::conditional::value, + T&, U>::type; + + return source_matcher_.MatchAndExplain(static_cast(x), + listener); + } + + void DescribeTo(::std::ostream* os) const override { + source_matcher_.DescribeTo(os); + } + + void DescribeNegationTo(::std::ostream* os) const override { + source_matcher_.DescribeNegationTo(os); + } + + private: + const Matcher source_matcher_; + }; +}; + +// This even more specialized version is used for efficiently casting +// a matcher to its own type. +template +class MatcherCastImpl> { + public: + static Matcher Cast(const Matcher& matcher) { return matcher; } +}; + +// Template specialization for parameterless Matcher. +template +class MatcherBaseImpl { + public: + MatcherBaseImpl() = default; + + template + operator ::testing::Matcher() const { // NOLINT(runtime/explicit) + return ::testing::Matcher(new + typename Derived::template gmock_Impl()); + } +}; + +// Template specialization for Matcher with parameters. +template