ngrislain/2023-02-dp-sgd-bias.ipynb Secret

## 2023-02-dp-sgd-bias.ipynb
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard",
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/ngrislain/7a6afd0d7f4f31877a15bf318538e10c/2023-02-dp-sgd-bias.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Histograms with Differential Privacy using JAX and DP-SGD (a tutorial)\n",
        "\n",
        "In [📔 this notebook](https://colab.research.google.com/drive/1g7V6X6wUGbCKl-JEr_RYPt7g36Bi3i_Z?usp=sharing) we demonstrate how powerful it is to use [JAX](https://jax.readthedocs.io/en/latest/index.html) based [DP-SGD](https://arxiv.org/pdf/1607.00133.pdf) along with the [dp-accounting](https://github.com/google/differential-privacy/tree/main/python) library to train deep learning models with [Differential Privacy](https://privacytools.seas.harvard.edu/files/privacytools/files/pedagogical-document-dp_0.pdf) (DP).\n",
        " We show how to use these tools on a small toy problem: *histogram estimation*, and compare this generic approach to some well known benchmarks.\n",
        "\n",
        "Along the way we get to discover some of the problems one is commonly faced with when tuning the hyper-parameters of a DP-SGD, in particular its clipping threshold.\n",
        "\n",
        "If you own *privacy-sensitive* data and would like more people to use this data without having to worry about privacy risk, you might be interested by what [Sarus Technologies](https://www.sarus.tech/) does.\n",
        "\n",
        "## Introduction\n",
        "\n",
        "Every calculation on personal data, whether it is a simple statistics like a *sum* or a more advanced calculation like *training a deep-learning model* can potentially leak private information about individuals. Avoiding this risk is highly non-trivial, and with larger models being trained on ever larger datasets, the scale of the risk increases (see [Carlini et al. 2021](https://arxiv.org/pdf/2012.07805.pdf)).\n",
        "\n",
        "The theory of *Differential Privacy* (DP) has been developped precisely to answer this question (see [Dwork et al. 2006](https://uvammm.github.io/docs/dwork.pdf)). DP has now become the standard way to estimate statistical models on personal data while guaranteeing privacy.\n",
        "\n",
        "### Histograms and DP-SGD\n",
        "\n",
        "The simple problem of histogram estimation with DP is a well-known and mostly solved question (see Example 3.2 in [Dwork and Roth 2014](https://www.cis.upenn.edu/~aaroth/Papers/privacybook.pdf)). The procedure to estimate a histogram with DP is a mechanism called *Histogram Query*.\n",
        "\n",
        "On its side *Differentially Private Stochastic Gradient Descent* (DP-SGD) is a very generic method to estimate machine learning models with DP guarantees (see [Abadi et al. 2016](https://arxiv.org/pdf/1607.00133.pdf)).\n",
        "\n",
        "Expressing histogram estimation as an optimization problem and solve it with DP-SGD seems like a silly thing to do. But, because DP histogram estimation is a simple problem with a canonical benchmark solution, it is a nice problem to discover DP-SGD and some of its pitfalls.\n",
        "\n",
        "In this post we implement a simple model in [JAX](https://jax.readthedocs.io/en/latest/index.html) and [Flax](https://flax.readthedocs.io/en/latest/index.html), estimating histograms as [maximum likelihood estimators](https://en.wikipedia.org/wiki/Maximum_likelihood_estimation) using a [DP-SGD implementation from Optax](https://optax.readthedocs.io/en/latest/api.html#differentially-private-sgd). And we account for privacy loss using the [dp-accounting](https://github.com/google/differential-privacy/tree/main/python) library. We then show a few problems that arise if one is not careful enough with DP-SGD hyper-parameters.\n",
        "\n"
      ],
      "metadata": {
        "id": "cZX8fYMDf39c"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem setup\n",
        "\n",
        "To compare different methods of private histogram estimation. We first generate different datasets.\n",
        "* One where observations can take 2 possible values ($0$ and $1$) with different frequencies\n",
        "* One with many possible values ($0, \\ldots,n-1$) with different frequencies but no value with dominant frequency\n",
        "\n",
        "Both datasets are 200 observations long. Note that in real-world application it is preferable to have much more data to run private computations but for our tutorial, using less observation makes the added noise more visible.\n",
        "\n",
        "All the histograms are normalized by their sum, so they are more *empirical probabilities*.\n",
        "\n",
        "The methods are implemented in [numpy](https://numpy.org/), those involving DP-SGD use [JAX](https://jax.readthedocs.io/en/latest/index.html), [Flax](https://flax.readthedocs.io/en/latest/index.html) and [Optax](https://optax.readthedocs.io/en/latest/api.html#differentially-private-sgd). We account for privacy loss using the [dp-accounting](https://github.com/google/differential-privacy/tree/main/python) library.\n",
        "\n",
        "Note that the use of JAX is particularily useful in the case of DP-SGD, because the per-observation gradient clipping is a [notoriously expensive and memory intensive operation](https://arxiv.org/pdf/1510.01799.pdf) that the [JAX JIT](https://jax.readthedocs.io/en/latest/jax-101/02-jitting.html) handles particularily well.\n"
      ],
      "metadata": {
        "id": "oFKGpqDsJ4FL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "!pip install --upgrade pip jax flax optax dp_accounting"
      ],
      "metadata": {
        "id": "7VwkQ-xK6-iu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "from dataclasses import dataclass\n",
        "import numpy as np\n",
        "import scipy.optimize as opt # type: ignore\n",
        "import matplotlib.pyplot as plt # type: ignore\n",
        "import pandas as pd # type: ignore\n",
        "import seaborn as sns # type: ignore\n",
        "from typing import Callable, Tuple, Protocol\n",
        "from collections.abc import Iterator\n",
        "import jax\n",
        "from jax import tree_util, numpy as jnp\n",
        "from flax import linen as nn\n",
        "from flax.training import train_state\n",
        "import optax # type: ignore\n",
        "import math\n",
        "from dp_accounting import GaussianDpEvent, SelfComposedDpEvent # type: ignore\n",
        "from dp_accounting.rdp import RdpAccountant # type: ignore\n",
        "\n",
        "@dataclass\n",
        "class Dataset:\n",
        "    \"\"\"This is the data definition object\"\"\"\n",
        "    freqs: np.ndarray\n",
        "    num_batches: int\n",
        "    batch_size: int\n",
        "    seed: int = 0\n",
        "\n",
        "    def num_values(self) -> int:\n",
        "        return self.freqs.shape[0]\n",
        "\n",
        "    def probas(self) -> np.ndarray:\n",
        "        return self.freqs/np.sum(self.freqs)\n",
        "\n",
        "    # Generate data\n",
        "    def batches(self) -> Iterator[np.ndarray]:\n",
        "        rng = np.random.default_rng(self.seed)\n",
        "        for _ in range(self.num_batches):\n",
        "            yield rng.choice(self.num_values(), self.batch_size, True, self.probas())\n",
        "\n",
        "    # Return all data at once\n",
        "    def data(self) -> np.ndarray:\n",
        "        return np.concatenate([batch for batch in self.batches()])\n",
        "\n",
        "@dataclass\n",
        "class EstimatorDistribution:\n",
        "    \"\"\"An object to store experiment results and plot them\"\"\"\n",
        "    num_samples: int\n",
        "    mean: np.ndarray\n",
        "    quantiles: dict[float, np.ndarray]\n",
        "    samples: np.ndarray\n",
        "\n",
        "    def plot(self, ax, quantiles=(0.025, 0.975)):\n",
        "        yerr = np.vstack([self.mean-self.quantiles[quantiles[0]], self.quantiles[quantiles[1]]-self.mean])\n",
        "        yerr = np.maximum(yerr, 0)\n",
        "        ax.bar(np.arange(self.mean.shape[0]), self.mean, yerr=yerr, ecolor='black', capsize=10, color='tab:blue')\n",
        "        ax.scatter(np.arange(self.mean.shape[0]), self.quantiles[0.5], color='tab:orange')\n",
        "    \n",
        "    def plot_samples(self, ax, value=0):\n",
        "        ax.hist(self.samples[:, value], color='tab:orange')\n",
        "\n",
        "class Estimator(Protocol):\n",
        "    \"\"\"Estimators should implement these methods (used by mypy)\"\"\"\n",
        "    def dp_estimation(self, seed=0) -> np.ndarray:\n",
        "        ...\n",
        "\n",
        "    def dp_estimator_distribution(self, num_samples=1000, quantiles=[0.025, 0.25, 0.5, 0.75, 0.975]) -> EstimatorDistribution:\n",
        "        ...\n",
        "\n",
        "    def privacy_loss(self) -> Tuple[float, float]:\n",
        "        ...\n",
        "\n",
        "@dataclass\n",
        "class Histogram:\n",
        "    \"\"\"A simple DP estimator based on the Histogram Query with gaussian noise\"\"\"\n",
        "    experiment: Dataset\n",
        "    noise_multiplier: float\n",
        "    delta: float = 1e-5\n",
        "\n",
        "    def dp_estimation(self, seed=0) -> np.ndarray:\n",
        "        freqs = np.bincount(self.experiment.data(), minlength=self.experiment.num_values())\n",
        "        # We add some noise\n",
        "        rng = np.random.default_rng(seed)\n",
        "        noisy_freqs = np.maximum(freqs + self.noise_multiplier*rng.standard_normal(self.experiment.num_values()), 0.)\n",
        "        return noisy_freqs/np.sum(noisy_freqs)\n",
        "\n",
        "    def dp_estimator_distribution(self, num_samples=1000, quantiles=[0.025, 0.25, 0.5, 0.75, 0.975]) -> EstimatorDistribution:\n",
        "        seeds = np.arange(num_samples)[:, None]\n",
        "        samples = np.apply_along_axis(lambda s: self.dp_estimation(s), 1, seeds)\n",
        "        return EstimatorDistribution(num_samples, samples.mean(0), dict(zip(quantiles, np.quantile(samples, quantiles, 0))), samples)\n",
        "\n",
        "    def privacy_loss(self) -> Tuple[float, float]:\n",
        "        \"\"\"Computes add-or-remove-one-example DP epsilon\"\"\"\n",
        "        event = GaussianDpEvent(self.noise_multiplier)\n",
        "        accountant = RdpAccountant()\n",
        "        accountant.compose(event)\n",
        "        return (accountant.get_epsilon(self.delta), self.delta)\n",
        "\n",
        "\n",
        "@dataclass\n",
        "class DPSGD:\n",
        "    \"\"\"DP-SGD estimator\"\"\"\n",
        "    dataset: Dataset\n",
        "    num_epochs: int = 100\n",
        "    learning_rate: float = 1e-2\n",
        "    momentum: float = 0.9\n",
        "    l2_norm_clip: float = 1.0\n",
        "    noise_multiplier: float = 1.0\n",
        "    delta: float = 1e-5\n",
        "\n",
        "    # A basic model of discrete distribution\n",
        "    class Basic(nn.Module):\n",
        "        \"\"\"A basic model of discrete distribution\"\"\"\n",
        "        features: int\n",
        "        logits_init: Callable = nn.initializers.zeros_init()\n",
        "        # bias_init: Callable = nn.initializers.normal()\n",
        "\n",
        "        def setup(self):\n",
        "            self.logits = self.param('logits', self.logits_init, (self.features,))\n",
        "\n",
        "        def __call__(self, x):\n",
        "            # Always return the same probas, use the input only for its size\n",
        "            def probas(x):\n",
        "                return self.logits\n",
        "            return jax.vmap(probas)(x)\n",
        "    \n",
        "    # The train state\n",
        "    class TrainState(train_state.TrainState):\n",
        "        loss: float = 0\n",
        "\n",
        "    # The DP train state\n",
        "    def create_train_state(self, module, seed):\n",
        "        \"\"\"Creates an initial `TrainState`\"\"\"\n",
        "        params = module.init(jax.random.PRNGKey(seed), next(self.dataset.batches()))\n",
        "        tx = optax.dpsgd(self.learning_rate, self.l2_norm_clip, self.noise_multiplier, seed, self.momentum)\n",
        "        return DPSGD.TrainState.create(apply_fn=module.apply, params=params, tx=tx, loss=0)\n",
        "    \n",
        "    # The train step\n",
        "    @jax.jit\n",
        "    def dp_train_step(state, batch):\n",
        "        \"\"\"Train for a single step\"\"\"\n",
        "        # The loss function\n",
        "        def loss_fn(params, batch):\n",
        "            logits = state.apply_fn(params, batch)\n",
        "            loss = optax.softmax_cross_entropy_with_integer_labels(logits=logits, labels=batch).mean()\n",
        "            return loss\n",
        "        grad_fn = jax.grad(loss_fn)\n",
        "        # Insert dummy dimension in axis 1 to use jax.vmap over the batch\n",
        "        batch = jax.tree_map(lambda x: x[:, None], batch)\n",
        "        # Use jax.vmap across the batch to extract per-example gradients\n",
        "        grad_fn = jax.vmap(grad_fn, in_axes=(None, 0))\n",
        "        # Compute gradients\n",
        "        grads = grad_fn(state.params, batch)\n",
        "        # Apply clipped gradients\n",
        "        state = state.apply_gradients(grads=grads)\n",
        "        return state\n",
        "\n",
        "    @jax.jit\n",
        "    def compute_metrics(state, batch):\n",
        "        \"\"\"Compute the loss\"\"\"\n",
        "        # The loss function\n",
        "        def loss_fn(params):\n",
        "            logits = state.apply_fn(params, batch)\n",
        "            loss = optax.softmax_cross_entropy_with_integer_labels(logits=logits, labels=batch).mean()\n",
        "            return loss\n",
        "        loss = loss_fn(state.params)\n",
        "        state = state.replace(loss=loss)\n",
        "        return state\n",
        "\n",
        "    def dp_estimation(self, seed=0) -> np.ndarray:\n",
        "        if isinstance(seed, np.ndarray):\n",
        "            seed = seed[0]\n",
        "        # Create an instance of the model\n",
        "        module = DPSGD.Basic(self.dataset.num_values())\n",
        "        # Initialize the parameters\n",
        "        state = self.create_train_state(module, seed)\n",
        "        # Run the training loop\n",
        "        for epoch in range(self.num_epochs):\n",
        "            for batch in self.dataset.batches():\n",
        "                state = DPSGD.dp_train_step(state, batch)\n",
        "            state = DPSGD.compute_metrics(state, batch)\n",
        "        return np.array(nn.softmax(state.params['params']['logits']))\n",
        "\n",
        "    def dp_estimator_distribution(self, num_samples=1000, quantiles=[0.025, 0.25, 0.5, 0.75, 0.975]) -> EstimatorDistribution:\n",
        "        seeds = np.arange(num_samples)[:, None]\n",
        "        samples = np.apply_along_axis(lambda s: self.dp_estimation(s), 1, seeds)\n",
        "        return EstimatorDistribution(num_samples, samples.mean(0), dict(zip(quantiles, np.quantile(samples, quantiles, 0))), samples)\n",
        "\n",
        "    def privacy_loss(self) -> Tuple[float, float]:\n",
        "        \"\"\"Computes add-or-remove-one-example DP epsilon\"\"\"\n",
        "        event = GaussianDpEvent(self.noise_multiplier)\n",
        "        count = int(math.ceil(self.num_epochs))\n",
        "        event = SelfComposedDpEvent(count=count, event=event)\n",
        "        accountant = RdpAccountant()\n",
        "        accountant.compose(event)\n",
        "        return (accountant.get_epsilon(self.delta), self.delta)\n",
        "\n",
        "# Help build a given experiment\n",
        "def builder(fun, target, interval=None) -> float:\n",
        "    \"\"\"Build an experiment with the right consumption\"\"\"\n",
        "    return opt.minimize_scalar(fun=lambda x: np.abs(fun(x)-target), bracket=interval).x\n",
        "\n",
        "def build_histogram(dataset: Dataset, epsilon: float, delta: float=1e-5) -> Estimator:\n",
        "    \"\"\"Build an histogram\"\"\"\n",
        "    noise_multiplier = builder(lambda nm: Histogram(dataset, nm, delta).privacy_loss()[0], epsilon, (0.01, 10.))\n",
        "    return Histogram(dataset, noise_multiplier, delta)\n",
        "\n",
        "def build_dpsgd(dataset: Dataset, epsilon: float, delta: float=1e-5, num_epochs: int=100, learning_rate: float=10., momentum: float=0.9, l2_norm_clip: float=1e-3) -> Estimator:\n",
        "    \"\"\"Build an histogram\"\"\"\n",
        "    noise_multiplier = builder(lambda nm: DPSGD(dataset, num_epochs, learning_rate, momentum, l2_norm_clip, nm, delta).privacy_loss()[0], epsilon, (0.01, 10.))\n",
        "    return DPSGD(dataset, num_epochs, learning_rate, momentum, l2_norm_clip, noise_multiplier, delta)\n",
        "\n",
        "@dataclass\n",
        "class Experiment:\n",
        "    \"\"\"An experiment object storing all hyper-parameters\"\"\"\n",
        "    dataset_name: str\n",
        "    estimator_name: str\n",
        "    path: str = 'dpsgd_bias'\n",
        "    epsilon: float = 1.0\n",
        "    delta: float = 1e-5\n",
        "    num_epochs: int = 100\n",
        "    learning_rate: float = 1e-2\n",
        "    momentum: float = 0.9\n",
        "    l2_norm_clip: float = 1e-3\n",
        "    noise_multiplier: float = 1.\n",
        "    num_samples: int = 100\n",
        "\n",
        "    def dataset(self) -> Dataset:\n",
        "        return {\n",
        "            'balanced': Dataset(np.array([50., 50.]), 1, 200),\n",
        "            'unbalanced': Dataset(np.array([100., 50.]), 1, 200),\n",
        "            'many_unbalanced': Dataset(np.array([100., 50., 100., 50., 100., 50., 100., 50., 100., 50., 100., 50., 100., 50., 100., 50.]), 1, 200),\n",
        "        }[self.dataset_name]\n",
        "\n",
        "    def estimator(self) -> Estimator:\n",
        "        return {\n",
        "            'exact': Histogram(self.dataset(), 0.0),\n",
        "            'histogram': build_histogram(self.dataset(), self.epsilon, self.delta),\n",
        "            'dpsgd': build_dpsgd(self.dataset(), self.epsilon, self.delta, self.num_epochs, self.adjusted_learning_rate(), self.momentum, self.l2_norm_clip),\n",
        "        }[self.estimator_name]\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        if self.estimator_name == 'exact':\n",
        "            return f\"{self.estimator_name} on {self.dataset_name} data\"\n",
        "        elif self.estimator_name == 'histogram':\n",
        "            return f\"{self.estimator_name} on {self.dataset_name} data\\nε={self.epsilon:02} δ={self.delta:02}\"\n",
        "        else:\n",
        "            return f\"{self.estimator_name} on {self.dataset_name} data\\nepochs={self.num_epochs} clip={self.l2_norm_clip} ε={self.epsilon:02} δ={self.delta:02}\"\n",
        "    \n",
        "    def __repr__(self) -> str:\n",
        "        if self.estimator_name == 'exact':\n",
        "            return f\"{self.estimator_name}_{self.dataset_name}\".replace(\".\", \"_\")\n",
        "        elif self.estimator_name == 'histogram':\n",
        "            return f\"{self.estimator_name}_{self.dataset_name}_eps_{self.epsilon}\".replace(\".\", \"_\")\n",
        "        else:\n",
        "            return f\"{self.estimator_name}_{self.dataset_name}_epochs_{self.num_epochs}_clip_{self.l2_norm_clip}_eps_{self.epsilon}\".replace(\".\", \"_\")\n",
        "    \n",
        "    def adjusted_learning_rate(self) -> float:\n",
        "        return self.learning_rate/self.l2_norm_clip\n",
        "\n",
        "    def run(self):\n",
        "        os.makedirs(self.path, exist_ok=True)\n",
        "        if not os.path.isfile(f'{self.path}/{repr(self)}.png'):\n",
        "            estimator = self.estimator()\n",
        "            print(f\"{self}\")\n",
        "            print(f\"Estimation = {estimator.dp_estimation()}\")\n",
        "            est_dist = estimator.dp_estimator_distribution(self.num_samples)\n",
        "            fig, ax = plt.subplots()\n",
        "            ax.set_title(f\"{self}\")\n",
        "            ax.set_ylim(0,1)\n",
        "            est_dist.plot(ax)\n",
        "            plt.savefig(f'{self.path}/{repr(self)}.png')\n",
        "            plt.show()\n",
        "            plt.close(fig)\n",
        "            # The distribution\n",
        "            fig, ax = plt.subplots()\n",
        "            ax.set_title(f\"{self} distribution of the first value estimated probability\")\n",
        "            est_dist.plot_samples(ax, 0)\n",
        "            plt.savefig(f'{self.path}/dist_{repr(self)}.png')\n",
        "            plt.show()\n",
        "            plt.close(fig)"
      ],
      "metadata": {
        "id": "S1B8nhCd7Efm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Simple estimation of an histogram with the Histogram Query Mechanism\n",
        "\n",
        "Histogram estimation with DP is a classical problem solved by the Histogram Query Mechanism. We implement a very simple version of this mechanism and leverage the [dp-accounting](https://github.com/google/differential-privacy/tree/main/python) library to compute the privacy loss $(\\epsilon, \\delta)$ of the mechanism.\n",
        "\n",
        "To compare all the DP approaches to histogram estimation the total privacy loss of each is chosen to be bound by $(\\epsilon=1, \\delta=1e^{-5})$.\n",
        "\n",
        "We run the experiments 200 times to display the mean (blue bar), confidence intervals (2.5 and 97.5 percentiles displayed as black bars) and median (orange dot) of the DP noisy estimators. We also display a distribution of the 200 estimations for the first possible value (orange bars)."
      ],
      "metadata": {
        "id": "XLQdzq_o3qWF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('unbalanced', 'histogram', num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 983
        },
        "id": "vW5fjucF499O",
        "outputId": "94b1f154-406a-4a1c-acba-c052b434a8ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "histogram on unbalanced data\n",
            "ε=1.0 δ=1e-05\n",
            "Estimation = [0.60762148 0.39237852]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also estimate the histogram without DP $(\\epsilon=+\\infty)$ for comparison."
      ],
      "metadata": {
        "id": "RHnalFEDGnhS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('unbalanced', 'exact', num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 922
        },
        "id": "9xRsS1upGq9m",
        "outputId": "820ad9dd-6c4a-46d7-d130-cca9581d6674"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "exact on unbalanced data\n",
            "Estimation = [0.605 0.395]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Estimation of an histogram with DP-SGD\n",
        "\n",
        "To estimate the histogram with DP-SGD, we express our histogram problem as a maximum-likelihood estimation problem.\n",
        "\n",
        "Our model has $n$ parameters $\\left(l_0, l_1, \\ldots, l_{n-1}\\right)$ and directly outputs these parameters as a vector of logits.\n",
        "\n",
        "The estimated probability of an observation $i$ is:\n",
        "$$q_i=\\frac{e^{l_i}}{\\sum_k e^{l_k}}$$\n",
        "so the log-likelihood of an observation $i$ will be:\n",
        "$$l_i-\\log\\left[\\sum_k e^{l_k}\\right]$$\n",
        "We use this as the opposite of our *loss*.\n",
        "\n",
        "An important parameter of the DP-SGD is the *threshold used to clip the per-sample gradients*. The idea behind this clipping is that no observation (belonging to some individual whose privacy has to be protected) has any impact on the model larger than this clipping threshold. Because this impact is bounded it is then easy to add a perturbation sufficient to make the presence or the absence of an individual statistically not discernible.\n",
        "\n",
        "Setting this threshold is easy in the case of simple models. One can use some Lipschitz property of the objective function and use it to set the gradient clipping threshold.\n",
        "In practice, when models are complex deep-learning models, the threshold is usually empirically tuned to obtain the best utility / privacy tradeoff.\n",
        "\n",
        "We can first run our experiment with a threshold `l2_norm_clip` of 1.\n"
      ],
      "metadata": {
        "id": "tUFz7_V5JuRJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('unbalanced', 'dpsgd', num_epochs=50, learning_rate=1e-1, l2_norm_clip=1.0, num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 981
        },
        "id": "8QxSu07ILcVg",
        "outputId": "1ed2d6af-e570-4002-e194-8d9b37f3e8ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dpsgd on unbalanced data\n",
            "epochs=50 clip=1.0 ε=1.0 δ=1e-05\n",
            "Estimation = [0.6411129  0.35888708]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The result is slightly noisier than the benchmark, but reasonably close.\n",
        "\n",
        "If we increase the clipping threshold to 2, then we notice an increase in the amount of noise."
      ],
      "metadata": {
        "id": "t6Q52SBLMQh6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('unbalanced', 'dpsgd', num_epochs=50, learning_rate=1e-1, l2_norm_clip=2.0, num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 981
        },
        "id": "vYIuYGzTMoDZ",
        "outputId": "2a61ca5f-e660-45bd-f776-eaad2fa8a3e8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dpsgd on unbalanced data\n",
            "epochs=50 clip=2.0 ε=1.0 δ=1e-05\n",
            "Estimation = [0.63629997 0.3637    ]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The increase in the noise of the estimation suggests the clipping threshold is too high, because the amount of noise added is directly proportional to the clipping threshold.\n",
        "\n",
        "Let's reduce the clipping threshold to 0.5."
      ],
      "metadata": {
        "id": "ikBFwfyHMxhm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('unbalanced', 'dpsgd', num_epochs=50, learning_rate=1e-1, l2_norm_clip=0.5, num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 981
        },
        "id": "TxW-IHkZNIIV",
        "outputId": "453cd42f-4a53-47f1-d7a8-b6e7737d7ed7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dpsgd on unbalanced data\n",
            "epochs=50 clip=0.5 ε=1.0 δ=1e-05\n",
            "Estimation = [0.8076257  0.19237424]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHICAYAAACcQeptAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIWUlEQVR4nO3de3zO9eP/8ee12a7NZpvD7MBsTjkzhywiZBktUonkg5bog8qhEx3MoaKUjz6lUKH6JKTCN5okKhI5FaFymFO2YdmcMna9fn/47cplB7tmvB0e99vtunG9rtfr/X693u/r8Nz7aDPGGAEAAFjEw+oOAACA6xthBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEE14WRI0fKZrNZ3Y18LV++XDabTcuXL7e6K5fMAw88IH9//2KdZlRUlB544IFinaYVZsyYIZvNpuTk5CK1f+CBBxQVFVWsfQIuJ8IIAFzHXnrpJc2bN8/qbuA6RxgBgOsYYQRXAsIIAACwFGEE15wVK1boxhtvlI+Pj6pWraopU6bkWc9ms+mRRx7RRx99pBo1asjHx0eNGzfWd99951Lv6NGjGjx4sKKiomS321W+fHnddtttWr9+vUu9SZMmqUqVKvL19VXTpk31/fffq3Xr1mrdurVLvX379qlz587y8/NT+fLlNWTIEJ06darQ49uwYYM6dOiggIAA+fv7q23btvrxxx9d6uQcg7By5UoNHTpUwcHB8vPz01133aWDBw9ecB559VvKfWxCcnKybDabXn31VU2dOlVVq1aV3W7XjTfeqJ9++inPae/cuVNxcXHy8/NTeHi4Ro8erfNvHv7qq6+qefPmKlu2rHx9fdW4cWPNnTv3gv1OT0/XE088oXr16snf318BAQHq0KGDfv75Z5d6OcfozJkzRy+++KIqVqwoHx8ftW3bVtu3b8813dWrV+v2229X6dKl5efnp/r16+v11193qbNt2zZ16dJFZcqUkY+Pj5o0aaIFCxbkmtavv/6qW2+9Vb6+vqpYsaJeeOEFORyOC44tx7x581S3bl35+Piobt26+vzzz/OsV5hlaLPZdPz4cb3//vuy2Wyy2WzOY3B2796tAQMGqEaNGvL19VXZsmV17733Fvm4FqAgJazuAFCcNm3apHbt2ik4OFgjR47UmTNnlJiYqJCQkDzrf/vtt5o9e7Yee+wx2e12vfXWW2rfvr3WrFmjunXrSpL+/e9/a+7cuXrkkUdUu3ZtHT58WCtWrNDWrVvVqFEjSdLbb7+tRx55RC1bttSQIUOUnJyszp07q3Tp0qpYsaJzfidPnlTbtm21Z88ePfbYYwoPD9eHH36ob775plDj+/XXX9WyZUsFBAToqaeekpeXl6ZMmaLWrVvr22+/VUxMjEv9Rx99VKVLl1ZiYqKSk5M1ceJEPfLII5o9e3ZRFm++Zs6cqaNHj+rhhx+WzWbTK6+8orvvvls7d+6Ul5eXs152drbat2+vm266Sa+88oqSkpKUmJioM2fOaPTo0c56r7/+ujp16qQePXooKytLs2bN0r333qsvvvhC8fHx+fZj586dmjdvnu69915VrlxZqampmjJlilq1aqUtW7YoPDzcpf64cePk4eGhJ554QhkZGXrllVfUo0cPrV692llnyZIluuOOOxQWFqZBgwYpNDRUW7du1RdffKFBgwZJOrtebr75ZlWoUEHDhg2Tn5+f5syZo86dO+vTTz/VXXfdJUlKSUlRmzZtdObMGWe9qVOnytfXt1DL+auvvtI999yj2rVra+zYsTp8+LASEhJc3mPuLMMPP/xQDz30kJo2bap+/fpJkqpWrSpJ+umnn/TDDz/ovvvuU8WKFZWcnKy3335brVu31pYtW1SyZMlC9RkoFANcQzp37mx8fHzM7t27nWVbtmwxnp6e5vy3uyQjyaxdu9ZZtnv3buPj42PuuusuZ1lgYKAZOHBgvvM8deqUKVu2rLnxxhvN6dOnneUzZswwkkyrVq2cZRMnTjSSzJw5c5xlx48fN9WqVTOSzLJlyy44Pm9vb7Njxw5n2Z9//mlKlSplbrnlFmfZ9OnTjSQTGxtrHA6Hs3zIkCHG09PTHDlypMD5tGrVyqXfOXr37m0iIyOdz3ft2mUkmbJly5r09HRn+fz5840k83//938ubSWZRx991FnmcDhMfHy88fb2NgcPHnSWnzhxwmW+WVlZpm7duubWW291KY+MjDS9e/d2Pv/7779Ndna2S51du3YZu91uRo8e7SxbtmyZkWRq1aplTp065Sx//fXXjSSzadMmY4wxZ86cMZUrVzaRkZHmr7/+cpnuucu1bdu2pl69eubvv/92eb158+amevXqzrLBgwcbSWb16tXOsrS0NBMYGGgkmV27dpmCREdHm7CwMJf199VXXxlJLuvFmMIvQz8/P5dlmF97Y4xZtWqVkWQ++OCDAvsJuIvdNLhmZGdna/HixercubMqVarkLK9Vq5bi4uLybNOsWTM1btzY+bxSpUq68847tXjxYmVnZ0uSgoKCtHr1av355595TmPt2rU6fPiw+vbtqxIl/tnY2KNHD5UuXdql7qJFixQWFqYuXbo4y0qWLOn8q/RC4/vqq6/UuXNnValSxVkeFham+++/XytWrFBmZqZLm379+rmc0tyyZUtlZ2dr9+7dF5yfO7p16+Yy1pYtW0o6u6XifI888ojz/zm7yrKysvT11187y8/dUvDXX38pIyNDLVu2zLVr7Hx2u10eHme/1rKzs3X48GH5+/urRo0aebZNSEiQt7d3vv3esGGDdu3apcGDBysoKMilbc5yTU9P1zfffKOuXbvq6NGjOnTokA4dOqTDhw8rLi5Of/zxh/bv3y/p7Pq/6aab1LRpU+d0goOD1aNHjwLHJUkHDhzQxo0b1bt3bwUGBjrLb7vtNtWuXTtX/aIuw7zanz59WocPH1a1atUUFBRU6GkAhUUYwTXj4MGDOnnypKpXr57rtRo1auTZJq+6N9xwg06cOOE8tuKVV17R5s2bFRERoaZNm2rkyJEuP7I5P+zVqlVzmU6JEiVyXfth9+7dqlatWq5rnuTXv/PHd+LEiTzr1qpVSw6HQ3v37nUpPzeUSXIGhr/++uuC83NHYefj4eHhEqSks8tbksuxCF988YVuuukm+fj4qEyZMgoODtbbb7+tjIyMAvvhcDj0n//8R9WrV5fdble5cuUUHBysX375Jc+2F+r3jh07JMm5yy4v27dvlzFGzz//vIKDg10eiYmJkqS0tDRJZ9e/O+/Pc+W8zwrbvqjLMMfJkyc1YsQIRUREuCzLI0eOFHoaQGFxzAhwAV27dlXLli31+eef66uvvtL48eP18ssv67PPPlOHDh2s7l6BPD098yw35x0wej6bzZZnnZytRcU1n7x8//336tSpk2655Ra99dZbCgsLk5eXl6ZPn66ZM2cW2Pall17S888/rwcffFBjxoxRmTJl5OHhocGDB+d5kGhx9Dtnuk888US+W+DOD6qX2sUswxyPPvqopk+frsGDB6tZs2YKDAyUzWbTfffd59YBt0BhEEZwzQgODpavr6/++OOPXK/99ttvebbJq+7vv/+ukiVLKjg42FkWFhamAQMGaMCAAUpLS1OjRo304osvqkOHDoqMjJR09i/kNm3aONucOXNGycnJql+/vrMsMjJSmzdvljHGZetIfv07f3wlS5bMs+62bdvk4eGhiIiIC06nMEqXLp3nLpaL3b3jcDi0c+dO59YQ6ezyluTcivTpp5/Kx8dHixcvlt1ud9abPn36Bac/d+5ctWnTRu+9955L+ZEjR1SuXDm3+5tzMOfmzZsVGxubZ52cLT1eXl751skRGRnp1vvz/LZS3u/Z89u7swzzuzLx3Llz1bt3b7322mvOsr///ltHjhy5YF8Bd7GbBtcMT09PxcXFad68edqzZ4+zfOvWrVq8eHGebVatWuWy/3vv3r2aP3++2rVrJ09PT2VnZ+faJF2+fHmFh4c7T8dt0qSJypYtq3feeUdnzpxx1vvoo49y7aa4/fbb9eeff7qcYnnixAlNnTq1UONr166d5s+f77JLIzU1VTNnzlSLFi0UEBBwwekURtWqVbVt2zaX04B//vlnrVy58qKn/eabbzr/b4zRm2++KS8vL7Vt21bS2XHabDaXrTDJycmFujCXp6dnrq0an3zyifOYDXc1atRIlStX1sSJE3P9COfMp3z58mrdurWmTJmiAwcO5JrGucvw9ttv148//qg1a9a4vP7RRx9dsC9hYWGKjo7W+++/7/KeXLJkibZs2eJS151l6Ofnl2fAyGtZvvHGG/luHQMuBltGcE0ZNWqUkpKS1LJlSw0YMEBnzpzRG2+8oTp16uiXX37JVb9u3bqKi4tzObU3ZzrS2WuMVKxYUV26dFGDBg3k7++vr7/+Wj/99JPzL0Zvb2+NHDlSjz76qG699VZ17dpVycnJmjFjhqpWreryl2ffvn315ptvqlevXlq3bp3CwsL04YcfFvo0yRdeeEFLlixRixYtNGDAAJUoUUJTpkzRqVOn9Morr1zs4nN68MEHNWHCBMXFxalPnz5KS0vT5MmTVadOnVwHybrDx8dHSUlJ6t27t2JiYvTll19q4cKFeuaZZ5xbouLj4zVhwgS1b99e999/v9LS0jRp0iRVq1Ytz3V4rjvuuEOjR49WQkKCmjdvrk2bNumjjz7KdZxKYXl4eOjtt99Wx44dFR0drYSEBIWFhWnbtm369ddfnSF30qRJatGiherVq6e+ffuqSpUqSk1N1apVq7Rv3z7ndU6eeuopffjhh2rfvr0GDRrkPLU3MjLygmOTpLFjxyo+Pl4tWrTQgw8+qPT0dOf7+9ixY8567izDxo0b6+uvv9aECRMUHh6uypUrKyYmRnfccYc+/PBDBQYGqnbt2lq1apW+/vprlS1btkjLEiiQVafxAJfKt99+axo3bmy8vb1NlSpVzOTJk01iYmKep/YOHDjQ/O9//zPVq1c3drvdNGzY0OX02lOnTpknn3zSNGjQwJQqVcr4+fmZBg0amLfeeivXfP/73/+ayMhIY7fbTdOmTc3KlStN48aNTfv27V3q7d6923Tq1MmULFnSlCtXzgwaNMgkJSUV6tReY4xZv369iYuLM/7+/qZkyZKmTZs25ocffnCpk3Nq708//eRSnnNKa2Hm87///c9UqVLFeHt7m+joaLN48eJ8T+0dP358rvaSTGJiovN57969jZ+fn9mxY4dp166dKVmypAkJCTGJiYm5Tsd97733nOukZs2aZvr06Xmuw7xO7X388cdNWFiY8fX1NTfffLNZtWpVrlOVc5bDJ5984jK9nPFMnz7dpXzFihXmtttuc74H6tevb9544w2XOjt27DC9evUyoaGhxsvLy1SoUMHccccdZu7cuS71fvnlF9OqVSvj4+NjKlSoYMaMGWPee++9Qp3aa4wxn376qalVq5ax2+2mdu3a5rPPPsu1XtxZhtu2bTO33HKL8fX1NZKcy/Ovv/4yCQkJply5csbf39/ExcWZbdu25VrmQHGwGVOEI8yAa4DNZtPAgQNddhsUJ4fDoeDgYN1999165513Lsk8AOBawDEjQDH4+++/c+1f/+CDD5Senp7nZdUBAP/gmBGgGPz4448aMmSI7r33XpUtW1br16/Xe++9p7p16+ree++1unsAcEUjjADFICoqShEREfrvf/+r9PR0lSlTRr169dK4ceNcrvAJAMiNY0YAAIClOGYEAABYijACAAAsRRjBNWfkyJGy2Ww6dOiQ1V25YkRFRemBBx5wPl++fLlsNpuWL19uWZ8AIAdhBLgEkpOTZbPZ8nzMmjUrV/2tW7eqffv28vf3V5kyZdSzZ0+Xy4hfKxwOh1555RVVrlxZPj4+ql+/vj7++ONCtZ0xY0a+yzQlJeUS97xgX331lfr06aO6devK09Mz192aC2PBggVq1KiRfHx8VKlSJSUmJrrcXqAgGzduVMeOHRUSEiK73a4KFSqoW7duSk1NdbsfeXnxxRfVqVMnhYSEyGazaeTIkcUy3bwcOXJE/fr1U3BwsPz8/NSmTRuXWzbkiIqKyvO98O9///uS9Q2XDmfTAJdQ9+7ddfvtt7uUNWvWzOX5vn37dMsttygwMFAvvfSSjh07pldffVWbNm3SmjVrLsnZOLfccotOnjx52c/0efbZZzVu3Dj17dtXN954o+bPn6/777/feTfYwhg9erQqV67sUhYUFHQJelt4M2fO1OzZs9WoUSOFh4e73f7LL79U586d1bp1a73xxhvatGmTXnjhBaWlpentt98usK0xRu3bt5eXl5eGDh2q0NBQHT16VOvWrdOff/6pkJCQog7L6bnnnlNoaKgaNmyY732eioPD4VB8fLx+/vlnPfnkkypXrpzeeusttW7dWuvWrVP16tVd6kdHR+vxxx93KTv3Joy4ilh5+VfgUsi55PXBgwct60NBl0k/X//+/Y2vr6/ZvXu3s2zJkiVGkpkyZUqx9OdKuIT3vn37jJeXlxk4cKCzzOFwmJYtW5qKFSuaM2fOFNg+v0vcXwn2799vsrKyjDHGxMfH57o0+4XUrl3bNGjQwJw+fdpZ9uyzzxqbzWa2bt1aYNuDBw8aSebf//632/0urJzL1OfM69zL/Ben2bNn57pMf1pamgkKCjLdu3d3qRsZGWni4+MvST9w+bGbBkWyf/9+Pfjgg87NwnXq1NG0adNc6uQclzB79mw988wzCg0NlZ+fnzp16qS9e/fmmuYnn3yixo0by9fXV+XKldO//vWvPO+2um3bNnXt2lXBwcHy9fVVjRo19Oyzz+aqd+TIET3wwAMKCgpSYGCgEhISdOLECZc6OTedCwoKkr+/v2rUqKFnnnnmIpeOq+PHjysrKyvf1z/99FPdcccdqlSpkrMsNjZWN9xwg+bMmXPB6TscDr3++uuqV6+efHx8FBwcrPbt22vt2rX5tsnrmJHWrVurbt26WrdunZo3by5fX19VrlxZkydPLtxAL2D+/Pk6ffq0BgwY4Cyz2Wzq37+/9u3bp1WrVhV6WkePHnX77rF//fWXBgwYoIiICNntdoWGhqpt27b67bff3JpOXsLDw+Xl5VWktlu2bNGWLVvUr18/lSjxz8bqAQMGyBjjcofnvOR8ViZPnqyYmBiNGDHC5a7AxcGd3U6rV69W+/btFRgYqJIlS6pVq1aFvtvz3LlzFRISorvvvttZFhwcrK5du2r+/PnOO2WfKysrS8ePHy90/3BlYjcN3JaamqqbbrpJNptNjzzyiIKDg/Xll1+qT58+yszM1ODBg13qv/jii7LZbHr66aeVlpamiRMnKjY2Vhs3bpSvr6+ks8cDJCQk6MYbb9TYsWOVmpqq119/XStXrtSGDRucm+F/+eUXtWzZUl5eXurXr5+ioqK0Y8cO/d///Z9efPFFl/l27dpVlStX1tixY7V+/Xq9++67Kl++vF5++WVJ0q+//qo77rhD9evX1+jRo2W327V9+/ZcX5yFPRC2VKlSstvtLmWjRo3Sk08+KZvNpsaNG+vFF19Uu3btnK/v379faWlpatKkSa7pNW3aVIsWLbrgfPv06aMZM2aoQ4cOeuihh3TmzBl9//33+vHHH/OcbkH++usv3X777eratau6d++uOXPmqH///vL29taDDz7orFeUZbJhwwb5+fmpVq1aLnWaNm3qfL1FixYXnGabNm107NgxeXt7Ky4uTq+99lquzfd56d27t5KSkjRw4EDVrVtXmZmZ2rBhg8sP2bFjx/T3339fcFpeXl4KDAy8YL3C2LBhgyTlWlfh4eGqWLGi8/WCxMfHKzk5WcOHD9f69evVpUsX1ahRQx999JHKly/vrHcx7+XC+Oabb9ShQwc1btxYiYmJ8vDw0PTp03Xrrbfq+++/d67r/GzYsEGNGjWSh4fr38lNmzbV1KlT9fvvv6tevXou8ytZsqSys7MVGRmpIUOGaNCgQW73G1cAqzfN4OrTp08fExYWZg4dOuRSft9995nAwEBz4sQJY8w/d0atUKGCyczMdNabM2eOkWRef/11Y4wxWVlZpnz58qZu3brm5MmTznpffPGFkWRGjBjhLLvllltMqVKlXHZpGHN2c3+OnN00Dz74oEudu+66y5QtW9b5/D//+U+hdudIKtTj3Du97t6927Rr1868/fbbZsGCBWbixImmUqVKxsPDw3zxxRfOej/99JORZD744INc833yySeNJPP333/n27dvvvnGSDKPPfZYrtfOXSbn76bJ6+69rVq1MpLMa6+95iw7deqUiY6ONuXLl3fuhijqMomPjzdVqlTJ1c/jx48bSWbYsGH5jtOYs5vwH3jgAfP++++bzz//3Dz33HPOOx/v2bOnwLbGGOPv728GDBhQYJ3evXsXalzn3gH4fO7uphk/fryRlOcYbrzxRnPTTTcV2P7HH380drvdpX1aWpqpUKFCrjtGF2W9naug3TQOh8NUr17dxMXFubz3Tpw4YSpXrmxuu+22AsdhjDF+fn65PrfGGLNw4UIjySQlJTnLOnbsaF5++WUzb948895775mWLVsaSeapp5664Hxw5WHLCNxijNGnn36qrl27yhjj8pdWXFycZs2apfXr1+vmm292lvfq1UulSpVyPu/SpYvCwsK0aNEiPfbYY1q7dq3S0tI0cuRI+fj4OOvFx8erZs2aWrhwoUaNGqWDBw/qu+++06BBg1x2aUhnN/ef7/yj6lu2bKnPP/9cmZmZCggIcG5tmT9/vhISEnL9NZZjyZIlhVo2derUcf6/UqVKuQ7069mzp2rXrq3HH39c8fHxkqSTJ09KUp5/heYsi5MnT+b7V+qnn34qm82mxMTEXK/ltUwupESJEnr44Yedz729vfXwww+rf//+WrdunW666SZJRVsm+Y3j3HEWpGvXruratavzeefOnRUXF6dbbrlFL7744gV3J7Vs2VKLFi3S8uXLVatWLfn4+OTauvHUU0/pX//61wXHVbp06QvWKawLvQcyMzMLbD9mzBjdfPPNioiIcJYFBwfr0Ucf1bBhw7R3717na0VZb4W1ceNG/fHHH3ruued0+PBhl9fatm2rDz/8UA6HI9/PmeTee2TBggUudRISEtShQwdNmDBBjz76qCpWrOj2GGAdwgjccvDgQR05ckRTp07V1KlT86yTlpbm8vz8Teg2m03VqlVTcnKyJGn37t2SpBo1auSaVs2aNbVixQpJ0s6dOyVJdevWLVRfzw8sOT8gf/31lwICAtStWze9++67euihhzRs2DC1bdtWd999t7p06eLyhRkbG1uo+V1ImTJllJCQoHHjxmnfvn2qWLGiczdVXvvCc3YX5NTJy44dOxQeHq4yZcoUSx/Dw8Pl5+fnUpZzdkJycrIzjBRlmfj6+hZ5nPlp0aKFYmJi9PXXX1+w7pw5c3TvvfeqTZs2kqRWrVrlus5K7dq1Vbt2bbf7cTEu9B640HL5/vvvdc899+Qqz9kdtmXLFmcYKa73cl7++OMPSWd3h+UnIyNDfn5+Sk9PdykPDg6Wp6fnRb1HbDabhgwZosWLF2v58uWFCpW4chBG4BaHwyFJ+te//pXvl079+vUvZ5fy5enpmWe5+f+3Y/L19dV3332nZcuWaeHChUpKStLs2bN166236quvvnK2L+w1LAIDAy/4w5Hzo5Cenq6KFSsqLCxMknTgwIFcdQ8cOKAyZcoUad/9pVaUZRIWFqZly5bJGOOy1SZn7EU5JVY6u0wLcxDqww8/rLVr1+q1115T7dq1FRwcnKtORkbGBbfQSGe3GBVXADz3PXDu1o2csgsdZ/H333/n+QOec4DvuQdPF+d7+Xw53w3jx49XdHR0nnX8/f21cuVKZyDMsWvXLkVFRSksLCzfz4J04ffIuZ8vXF0II3BLcHCwSpUqpezs7EL/lZXzF1MOY4y2b9/uDC2RkZGSpN9++0233nqrS93ffvvN+XqVKlUkSZs3b76oMZzLw8NDbdu2Vdu2bTVhwgS99NJLevbZZ7Vs2TLn+HJ+LC5k+vTpLlc5zUvO1p2cH8IKFSooODg4zzNf1qxZk++Xeo6qVatq8eLFzjsFX6w///xTx48fd9k68vvvv0tyPaOiKMskOjpa7777rrZu3eqy9WH16tXO14ti586deQaLc23dulUzZ87UBx98oJ49e+Zbb9CgQXr//fcvOM+8tqoUVc64165d6xI8/vzzT+3bt0/9+vUrsH1ERIS2bduWq3zr1q2S5LK7ojjfy+erWrWqJCkgIKDA74YGDRrk2l0UGhoq6eyy+P7773Ptzlm9erVKlix5wWuInP/5wtWDMAK3eHp66p577tHMmTO1efPmXLtMDh48mOuL4IMPPtDw4cOdx43MnTtXBw4c0NNPPy3p7FkE5cuX1+TJk/Xggw86twR8+eWX2rp1q0aMGCHp7BfMLbfcomnTpmno0KEuu2HO/2u7MPL6Ac/5YTj3L82i7GfPazns379f06ZNU/369V1+FO655x69//77Lvv2ly5dqt9//11DhgwpcJ733HOPJk2apFGjRun11193ea0oy+TMmTOaMmWKhg4dKunsX9VTpkxRcHCwGjdu7KxXlGVy5513asiQIXrrrbf05ptvOvs4efJkVahQQc2bN3fWPXDggDIyMlS1alXnKbN5LdNFixZp3bp1euyxxwrsR85m/vOPZTjfpT5m5PTp09qxY4cCAwOd74E6deqoZs2amjp1qh5++GHnFrm3335bNptNXbp0KXCat99+u9544w19++23atWqlaSzpz5PnTpVFSpUcNlSeSmPGWncuLGqVq2qV199Vffff7/8/f1dXs9Zf6VLl843rHTp0kVz587VZ5995hz3oUOH9Mknn6hjx47O74b09HQFBga6bP08ffq0xo0bJ29v71xbXnDlI4zAbePGjdOyZcsUExOjvn37qnbt2kpPT9f69ev19ddf59pEWqZMGbVo0UIJCQlKTU3VxIkTVa1aNfXt21fS2dMkX375ZSUkJKhVq1bq3r2789TeqKgolx/k//73v2rRooUaNWqkfv36qXLlykpOTtbChQu1ceNGt8YxevRofffdd4qPj1dkZKTS0tL01ltvqWLFii6nmBZlP/tTTz2lHTt2qG3btgoPD1dycrKmTJmi48eP5woNzzzzjD755BO1adNGgwYN0rFjxzR+/HjVq1dPCQkJBc6nTZs26tmzp/773//qjz/+UPv27eVwOPT999+rTZs2euSRR9zqd3h4uF5++WUlJyfrhhtu0OzZs7Vx40ZNnTrV5ToaRVkmFStW1ODBgzV+/HidPn1aN954o+bNm6fvv/9eH330kcsPy/Dhw/X+++87N99LUvPmzdWwYUM1adJEgYGBWr9+vaZNm6aIiIgLXhumQYMGqlevnoYNG6bff/9dDRs21IkTJ/Tzzz+rbt26zvBV1GNGfvnlF+cBldu3b1dGRoZeeOEF57w7duwo6WwgrVWrlnr37q0ZM2Y4248fP16dOnVSu3btdN9992nz5s1688039dBDD+U6Ffp8w4cP1+zZs9WxY0c99thjKlu2rGbMmKE9e/bo448/dlmuRT1m5MMPP9Tu3bud1+n57rvvnOPr2bOnIiMj5eHhoXfffVcdOnRQnTp1lJCQoAoVKmj//v1atmyZAgIC9H//938FzqdLly666aablJCQoC1btjivwJqdna1Ro0Y56y1YsEAvvPCCunTposqVKys9Pd35B9JLL73k3NKCq4h1J/LgapaammoGDhxoIiIijJeXlwkNDTVt27Y1U6dOddbJOX30448/NsOHDzfly5c3vr6+Jj4+PtepucacPXWzYcOGxm63mzJlypgePXqYffv25aq3efNmc9ddd5mgoCDj4+NjatSoYZ5//nnn6/ldgTXnCp45V5NcunSpufPOO014eLjx9vY24eHhpnv37ub333+/6OUzc+ZMc8stt5jg4GBTokQJU65cOXPXXXeZdevW5Vl/8+bNpl27dqZkyZImKCjI9OjRw6SkpBRqXmfOnDHjx483NWvWNN7e3iY4ONh06NDBZV6FPbW3Tp06Zu3ataZZs2bGx8fHREZGmjfffLNIyyAv2dnZ5qWXXjKRkZHG29vb1KlTx/zvf//LVS/nFNucdWXM2SuSRkdHm8DAQOPl5WUqVapk+vfvX+jldPDgQfP444+b6tWrG19fXxMUFGRuvvlm8+WXX170uHLeW3k9zl3uOVfmzetquJ9//rmJjo42drvdVKxY0Tz33HMup1MXZPv27eaee+4xgYGBxm63myZNmph58+Zd9Lhy5Jz2ndfj3PeQMcZs2LDB3H333aZs2bLGbrebyMhI07VrV7N06dJCzSs9Pd306dPHlC1b1pQsWdK0atUq11V3165dazp27GgqVKhgvL29jb+/v2nRooWZM2dOcQ0Zl5nNmP9/NB9QzJYvX642bdrok08+ueCmZlivdevWOnToULEekwMAhcHl4AEAgKUIIwAAwFKEEQAAYCm3w8h3332njh07Kjw8XDabTfPmzbtgm+XLl6tRo0ay2+2qVq2ay1HkuHa1bt1axhiOF7lKLF++nONFAFjC7TBy/PhxNWjQQJMmTSpU/V27dik+Pl5t2rTRxo0bNXjwYD300EO57tsBAACuTxd1No3NZtPnn3+uzp0751vn6aef1sKFC13+4rrvvvt05MgRJSUlFXXWAADgGnHJL3q2atWqXBfaiYuL0+DBg/Ntc+rUKZcrYDocDqWnp6ts2bJFuhMpAAC4/IwxOnr0qMLDwwu8Y/MlDyMpKSkKCQlxKQsJCVFmZqZOnjyZ582Yxo4d63K1PQAAcPXau3evy32SzndFXg5++PDhzsszS2fvpFmpUiXt3btXAQEBFvYMAAAUVmZmpiIiIpz3JsvPJQ8joaGhSk1NdSlLTU1VQEBAvreottvted42PSAggDACAMBV5kKHWFzy64w0a9ZMS5cudSlbsmSJmjVrdqlnDQAArgJuh5Fjx45p48aNzjuk7tq1Sxs3btSePXsknd3F0qtXL2f9f//739q5c6eeeuopbdu2TW+99ZbmzJlzwVujAwCA64PbYWTt2rVq2LChGjZsKEkaOnSoGjZsqBEjRkiSDhw44AwmklS5cmUtXLhQS5YsUYMGDfTaa6/p3XffVVxcXDENAQAAXM2uirv2ZmZmKjAwUBkZGRwzAgDAVaKwv9/cmwYAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxVwuoO4Np04MABHThw4LLNLywsTGFhYZdtfgCA4kMYwSUxZcoUjRo16rLNLzExUSNHjrxs8wMAFB/CCC6Jhx9+WJ06dSp0/ZMnT6pFixaSpBUrVsjX19et+bFVBACuXoQRXBLu7jY5fvy48//R0dHy8/O7FN0CAFyBOIAVAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiqSGFk0qRJioqKko+Pj2JiYrRmzZoC60+cOFE1atSQr6+vIiIiNGTIEP39999F6jAAALi2uB1GZs+eraFDhyoxMVHr169XgwYNFBcXp7S0tDzrz5w5U8OGDVNiYqK2bt2q9957T7Nnz9Yzzzxz0Z0HAABXP7fDyIQJE9S3b18lJCSodu3amjx5skqWLKlp06blWf+HH37QzTffrPvvv19RUVFq166dunfvfsGtKQAA4PrgVhjJysrSunXrFBsb+88EPDwUGxurVatW5dmmefPmWrdunTN87Ny5U4sWLdLtt9+e73xOnTqlzMxMlweucY7sf/6fvNL1OQDgmuZWGDl06JCys7MVEhLiUh4SEqKUlJQ829x///0aPXq0WrRoIS8vL1WtWlWtW7cucDfN2LFjFRgY6HxERES4001cbbYskN688Z/nH3WRJtY9Ww4AuOZd8rNpli9frpdeeklvvfWW1q9fr88++0wLFy7UmDFj8m0zfPhwZWRkOB979+691N2EVbYskOb0ko4ecC3PPHC2nEACANe8Eu5ULleunDw9PZWamupSnpqaqtDQ0DzbPP/88+rZs6ceeughSVK9evV0/Phx9evXT88++6w8PHLnIbvdLrvd7k7XcDVyZEtJT0syebxoJNmkpGFSzXjJw/Mydw4AcLm4tWXE29tbjRs31tKlS51lDodDS5cuVbNmzfJsc+LEiVyBw9Pz7A+LMXn9COG6sfsHKfPPAioYKXP/2XoAgGuWW1tGJGno0KHq3bu3mjRpoqZNm2rixIk6fvy4EhISJEm9evVShQoVNHbsWElSx44dNWHCBDVs2FAxMTHavn27nn/+eXXs2NEZSnCdOpZ64Tru1AMAXJXcDiPdunXTwYMHNWLECKWkpCg6OlpJSUnOg1r37NnjsiXkueeek81m03PPPaf9+/crODhYHTt21Isvvlh8o7gIUcMWWt2F69ZNHrs0y/vC9e77eJd+/Ij1ZJXkcfFWdwHANc5mroJ9JZmZmQoMDFRGRoYCAgKKddqEEet4yKEV9scUqnSdPG3kP/aoJOnY8FLy87bJYaQUlVWLU6/LwZ0LLEMYAVBUhf395hselnHIQ6NO9zr7//Micc7zUad7EkQA4BrHtzwstdjRVP1PD1aqSruUp6is+p8erMWOphb1DABwubh9zAhQ3BY7mmpxVl1JXSVJvbOe1npHfbaIAMB1gm97XBHODR5rHDUJIgBwHeEbHwAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALBUCas7gGvTmWPpyj6WXuj65nSW8/9ZqTtl8/J2a36e/mVUwr+MW20AAFcGwgguiWMbv1TGyo+L1DZ15lNutwm8ubuCWvQo0vwAANYijOCS8I/uIN9qMZdtfp5sFQGAqxZhBJdECXabAAAKiQNYAQCApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxVpDAyadIkRUVFycfHRzExMVqzZk2B9Y8cOaKBAwcqLCxMdrtdN9xwgxYtWlSkDgMAgGtLCXcbzJ49W0OHDtXkyZMVExOjiRMnKi4uTr/99pvKly+fq35WVpZuu+02lS9fXnPnzlWFChW0e/duBQUFFUf/AQDAVc7tMDJhwgT17dtXCQkJkqTJkydr4cKFmjZtmoYNG5ar/rRp05Senq4ffvhBXl5ekqSoqKiL6zUAALhmuLWbJisrS+vWrVNsbOw/E/DwUGxsrFatWpVnmwULFqhZs2YaOHCgQkJCVLduXb300kvKzs6+uJ4DAIBrgltbRg4dOqTs7GyFhIS4lIeEhGjbtm15ttm5c6e++eYb9ejRQ4sWLdL27ds1YMAAnT59WomJiXm2OXXqlE6dOuV8npmZ6U43AQDAVeSSn03jcDhUvnx5TZ06VY0bN1a3bt307LPPavLkyfm2GTt2rAIDA52PiIiIS91NAABgEbfCSLly5eTp6anU1FSX8tTUVIWGhubZJiwsTDfccIM8PT2dZbVq1VJKSoqysrLybDN8+HBlZGQ4H3v37nWnmwAA4CriVhjx9vZW48aNtXTpUmeZw+HQ0qVL1axZszzb3Hzzzdq+fbscDoez7Pfff1dYWJi8vb3zbGO32xUQEODyAAAA1ya3d9MMHTpU77zzjt5//31t3bpV/fv31/Hjx51n1/Tq1UvDhw931u/fv7/S09M1aNAg/f7771q4cKFeeuklDRw4sPhGAQAArlpun9rbrVs3HTx4UCNGjFBKSoqio6OVlJTkPKh1z5498vD4J+NERERo8eLFGjJkiOrXr68KFSpo0KBBevrpp4tvFAAA4KplM8YYqztxIZmZmQoMDFRGRkax77KJGrawWKcHXGuSx8Vb3QUAV6nC/n5zbxoAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApYoURiZNmqSoqCj5+PgoJiZGa9asKVS7WbNmyWazqXPnzkWZLQAAuAa5HUZmz56toUOHKjExUevXr1eDBg0UFxentLS0AtslJyfriSeeUMuWLYvcWQAAcO1xO4xMmDBBffv2VUJCgmrXrq3JkyerZMmSmjZtWr5tsrOz1aNHD40aNUpVqlS5qA4DAIBri1thJCsrS+vWrVNsbOw/E/DwUGxsrFatWpVvu9GjR6t8+fLq06dPoeZz6tQpZWZmujwAAMC1ya0wcujQIWVnZyskJMSlPCQkRCkpKXm2WbFihd577z298847hZ7P2LFjFRgY6HxERES4000AAHAVuaRn0xw9elQ9e/bUO++8o3LlyhW63fDhw5WRkeF87N279xL2EgAAWKmEO5XLlSsnT09PpaamupSnpqYqNDQ0V/0dO3YoOTlZHTt2dJY5HI6zMy5RQr/99puqVq2aq53dbpfdbnenawAA4Crl1pYRb29vNW7cWEuXLnWWORwOLV26VM2aNctVv2bNmtq0aZM2btzofHTq1Elt2rTRxo0b2f0CAADc2zIiSUOHDlXv3r3VpEkTNW3aVBMnTtTx48eVkJAgSerVq5cqVKigsWPHysfHR3Xr1nVpHxQUJEm5ygEAwPXJ7TDSrVs3HTx4UCNGjFBKSoqio6OVlJTkPKh1z5498vDgwq4AAKBwbMYYY3UnLiQzM1OBgYHKyMhQQEBAsU47atjCYp0ecK1JHhdvdRcAXKUK+/vNJgwAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliphdQcAAFevAwcO6MCBA5dtfmFhYQoLC7ts88PlQRgBABTZlClTNGrUqMs2v8TERI0cOfKyzQ+XB2EEAFBkDz/8sDp16lTo+idPnlSLFi0kSStWrJCvr69b82OryLWJMAIAKDJ3d5scP37c+f/o6Gj5+fldim7hKsMBrAAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAwOXjyP7n/8krXZ/jukUYAQBcHlsWSG/e+M/zj7pIE+ueLcd1jTACALj0tiyQ5vSSjh5wLc88cLacQHJdI4wAAC4tR7aU9LQkk8eL/78saRi7bK5jJazuAABcDlHDFlrdhevWTR5bNMv7zwJqGClzv+57boJ+dNS+bP3CP5LHxVs6/yJtGZk0aZKioqLk4+OjmJgYrVmzJt+677zzjlq2bKnSpUurdOnSio2NLbA+AODaUl5HirUerj1uh5HZs2dr6NChSkxM1Pr169WgQQPFxcUpLS0tz/rLly9X9+7dtWzZMq1atUoRERFq166d9u/ff9GdBwBc+dIUVKz1cO1xO4xMmDBBffv2VUJCgmrXrq3JkyerZMmSmjZtWp71P/roIw0YMEDR0dGqWbOm3n33XTkcDi1duvSiOw8AuPKtcdTUn6aMHHkdMiLJYaQ/TVmtcdS8vB3DFcOtMJKVlaV169YpNjb2nwl4eCg2NlarVq0q1DROnDih06dPq0yZMvnWOXXqlDIzM10eAICrk0MeGnW619n/nxdIcp6POt1TDs6puG65teYPHTqk7OxshYSEuJSHhIQoJSWlUNN4+umnFR4e7hJozjd27FgFBgY6HxEREe50EwBwhVnsaKr+pwcrVaVdylNUVv1PD9ZiR1OLeoYrwWWNoePGjdOsWbP0+eefy8fHJ996w4cPV0ZGhvOxd+/ey9hLAMClsNjRVLGnXnU+7531tFqcep0gAvdO7S1Xrpw8PT2VmprqUp6amqrQ0NAC27766qsaN26cvv76a9WvX7/Auna7XXa73Z2uAQCuAufuilnjqCkPds1Abm4Z8fb2VuPGjV0OPs05GLVZs2b5tnvllVc0ZswYJSUlqUmTJkXvLQAAuOa4fdGzoUOHqnfv3mrSpImaNm2qiRMn6vjx40pISJAk9erVSxUqVNDYsWMlSS+//LJGjBihmTNnKioqynlsib+/v/z9/YtxKAAA4Grkdhjp1q2bDh48qBEjRiglJUXR0dFKSkpyHtS6Z88eeXj8s8Hl7bffVlZWlrp06eIyncTERI0cOfLieg8AAK56Rboc/COPPKJHHnkkz9eWL1/u8jw5ObkoswAAANcJjhwCAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxVpIueAQAgSWeOpSv7WHqh65vTWc7/Z6XulM3L2635efqXUQn/Mm61wZWPMAIAKLJjG79UxsqPi9Q2deZTbrcJvLm7glr0KNL8cOUijAAAisw/uoN8q8Vctvl5slXkmkQYAQAUWQl2m6AYcAArAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsRRgBAACWIowAAABLEUYAAIClCCMAAMBShBEAAGApwggAALAUYQQAAFiKMAIAACxFGAEAAJYijAAAAEsRRgAAgKUIIwAAwFKEEQAAYCnCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAsVaQwMmnSJEVFRcnHx0cxMTFas2ZNgfU/+eQT1axZUz4+PqpXr54WLVpUpM4CAIBrj9thZPbs2Ro6dKgSExO1fv16NWjQQHFxcUpLS8uz/g8//KDu3burT58+2rBhgzp37qzOnTtr8+bNF915AABw9XM7jEyYMEF9+/ZVQkKCateurcmTJ6tkyZKaNm1anvVff/11tW/fXk8++aRq1aqlMWPGqFGjRnrzzTcvuvMAAODqV8KdyllZWVq3bp2GDx/uLPPw8FBsbKxWrVqVZ5tVq1Zp6NChLmVxcXGaN29evvM5deqUTp065XyekZEhScrMzHSnu4XiOHWi2KcJXEsuxefOCnzWgfxdqs95znSNMQXWcyuMHDp0SNnZ2QoJCXEpDwkJ0bZt2/Jsk5KSkmf9lJSUfOczduxYjRo1Kld5RESEO90FUAwCJ1rdAwCX2qX+nB89elSBgYH5vu5WGLlchg8f7rI1xeFwKD09XWXLlpXNZrOwZ5dHZmamIiIitHfvXgUEBFjdncvmeh23xNivx7Ffr+OWGPv1NHZjjI4eParw8PAC67kVRsqVKydPT0+lpqa6lKempio0NDTPNqGhoW7VlyS73S673e5SFhQU5E5XrwkBAQHXxZv1fNfruCXGfj2O/Xodt8TYr5exF7RFJIdbB7B6e3urcePGWrp0qbPM4XBo6dKlatasWZ5tmjVr5lJfkpYsWZJvfQAAcH1xezfN0KFD1bt3bzVp0kRNmzbVxIkTdfz4cSUkJEiSevXqpQoVKmjs2LGSpEGDBqlVq1Z67bXXFB8fr1mzZmnt2rWaOnVq8Y4EAABcldwOI926ddPBgwc1YsQIpaSkKDo6WklJSc6DVPfs2SMPj382uDRv3lwzZ87Uc889p2eeeUbVq1fXvHnzVLdu3eIbxTXGbrcrMTEx166qa931Om6JsV+PY79exy0x9ut17AWxmQudbwMAAHAJcW8aAABgKcIIAACwFGEEAABYijACAAAsRRixQHp6unr06KGAgAAFBQWpT58+OnbsWIH1H330UdWoUUO+vr6qVKmSHnvsMec9e3LYbLZcj1mzZl3q4RRo0qRJioqKko+Pj2JiYrRmzZoC63/yySeqWbOmfHx8VK9ePS1atMjldWOMRowYobCwMPn6+io2NlZ//PHHpRxCkbkz9nfeeUctW7ZU6dKlVbp0acXGxuaq/8ADD+Rav+3bt7/Uw3CbO+OeMWNGrjH5+Pi41LlW13nr1q3z/MzGx8c761wN6/y7775Tx44dFR4eLpvNVuB9x3IsX75cjRo1kt1uV7Vq1TRjxoxcddz97rCCu2P/7LPPdNtttyk4OFgBAQFq1qyZFi9e7FJn5MiRudZ5zZo1L+EorhAGl1379u1NgwYNzI8//mi+//57U61aNdO9e/d862/atMncfffdZsGCBWb79u1m6dKlpnr16uaee+5xqSfJTJ8+3Rw4cMD5OHny5KUeTr5mzZplvL29zbRp08yvv/5q+vbta4KCgkxqamqe9VeuXGk8PT3NK6+8YrZs2WKee+454+XlZTZt2uSsM27cOBMYGGjmzZtnfv75Z9OpUydTuXJlS8eZF3fHfv/995tJkyaZDRs2mK1bt5oHHnjABAYGmn379jnr9O7d27Rv395l/aanp1+uIRWKu+OePn26CQgIcBlTSkqKS51rdZ0fPnzYZdybN282np6eZvr06c46V8M6X7RokXn22WfNZ599ZiSZzz//vMD6O3fuNCVLljRDhw41W7ZsMW+88Ybx9PQ0SUlJzjruLkuruDv2QYMGmZdfftmsWbPG/P7772b48OHGy8vLrF+/3lknMTHR1KlTx2WdHzx48BKPxHqEkctsy5YtRpL56aefnGVffvmlsdlsZv/+/YWezpw5c4y3t7c5ffq0s6wwH4bLqWnTpmbgwIHO59nZ2SY8PNyMHTs2z/pdu3Y18fHxLmUxMTHm4YcfNsYY43A4TGhoqBk/frzz9SNHjhi73W4+/vjjSzCConN37Oc7c+aMKVWqlHn//fedZb179zZ33nlncXe1WLk77unTp5vAwMB8p3c9rfP//Oc/plSpUubYsWPOsqthnZ+rMN9BTz31lKlTp45LWbdu3UxcXJzz+cUuSysU9fu3du3aZtSoUc7niYmJpkGDBsXXsasEu2kus1WrVikoKEhNmjRxlsXGxsrDw0OrV68u9HQyMjIUEBCgEiVcr1s3cOBAlStXTk2bNtW0adMueNvmSyUrK0vr1q1TbGyss8zDw0OxsbFatWpVnm1WrVrlUl+S4uLinPV37dqllJQUlzqBgYGKiYnJd5pWKMrYz3fixAmdPn1aZcqUcSlfvny5ypcvrxo1aqh///46fPhwsfb9YhR13MeOHVNkZKQiIiJ055136tdff3W+dj2t8/fee0/33Xef/Pz8XMqv5HVeFBf6nBfHsrxaOBwOHT16NNfn/I8//lB4eLiqVKmiHj16aM+ePRb18PIhjFxmKSkpKl++vEtZiRIlVKZMGaWkpBRqGocOHdKYMWPUr18/l/LRo0drzpw5WrJkie655x4NGDBAb7zxRrH13R2HDh1Sdna288q8OUJCQvIdZ0pKSoH1c/51Z5pWKMrYz/f0008rPDzc5Qu5ffv2+uCDD7R06VK9/PLL+vbbb9WhQwdlZ2cXa/+LqijjrlGjhqZNm6b58+frf//7nxwOh5o3b659+/ZJun7W+Zo1a7R582Y99NBDLuVX+jovivw+55mZmTp58mSxfH6uFq+++qqOHTumrl27OstiYmI0Y8YMJSUl6e2339auXbvUsmVLHT161MKeXnpuXw4eeRs2bJhefvnlAuts3br1oueTmZmp+Ph41a5dWyNHjnR57fnnn3f+v2HDhjp+/LjGjx+vxx577KLni8tn3LhxmjVrlpYvX+5yMOd9993n/H+9evVUv359Va1aVcuXL1fbtm2t6OpFa9asmctNM5s3b65atWppypQpGjNmjIU9u7zee+891atXT02bNnUpvxbXOc6aOXOmRo0apfnz57v8gdqhQwfn/+vXr6+YmBhFRkZqzpw56tOnjxVdvSzYMlJMHn/8cW3durXAR5UqVRQaGqq0tDSXtmfOnFF6erpCQ0MLnMfRo0fVvn17lSpVSp9//rm8vLwKrB8TE6N9+/bp1KlTFz0+d5UrV06enp5KTU11KU9NTc13nKGhoQXWz/nXnWlaoShjz/Hqq69q3Lhx+uqrr1S/fv0C61apUkXlypXT9u3bL7rPxeFixp3Dy8tLDRs2dI7peljnx48f16xZswr1Q3OlrfOiyO9zHhAQIF9f32J5H13pZs2apYceekhz5szJtcvqfEFBQbrhhhuu6nVeGISRYhIcHKyaNWsW+PD29lazZs105MgRrVu3ztn2m2++kcPhUExMTL7Tz8zMVLt27eTt7a0FCxbkOv0xLxs3blTp0qUtuSGTt7e3GjdurKVLlzrLHA6Hli5d6vKX8LmaNWvmUl+SlixZ4qxfuXJlhYaGutTJzMzU6tWr852mFYoydkl65ZVXNGbMGCUlJbkcU5Sfffv26fDhwwoLCyuWfl+soo77XNnZ2dq0aZNzTNf6OpfOns5+6tQp/etf/7rgfK60dV4UF/qcF8f76Er28ccfKyEhQR9//LHLadz5OXbsmHbs2HFVr/NCsfoI2utR+/btTcOGDc3q1avNihUrTPXq1V1O7d23b5+pUaOGWb16tTHGmIyMDBMTE2Pq1atntm/f7nLK15kzZ4wxxixYsMC88847ZtOmTeaPP/4wb731lilZsqQZMWKEJWM05uzpeXa73cyYMcNs2bLF9OvXzwQFBTlP3ezZs6cZNmyYs/7KlStNiRIlzKuvvmq2bt1qEhMT8zy1NygoyMyfP9/88ssv5s4777xiT/N0Z+zjxo0z3t7eZu7cuS7r9+jRo8YYY44ePWqeeOIJs2rVKrNr1y7z9ddfm0aNGpnq1aubv//+25Ix5sXdcY8aNcosXrzY7Nixw6xbt87cd999xsfHx/z666/OOtfqOs/RokUL061bt1zlV8s6P3r0qNmwYYPZsGGDkWQmTJhgNmzYYHbv3m2MMWbYsGGmZ8+ezvo5p/Y++eSTZuvWrWbSpEl5ntpb0LK8Urg79o8++siUKFHCTJo0yeVzfuTIEWedxx9/3Cxfvtzs2rXLrFy50sTGxppy5cqZtLS0yz6+y4kwYoHDhw+b7t27G39/fxMQEGASEhKcPzrGGLNr1y4jySxbtswYY8yyZcuMpDwfu3btMsacPT04Ojra+Pv7Gz8/P9OgQQMzefJkk52dbcEI//HGG2+YSpUqGW9vb9O0aVPz448/Ol9r1aqV6d27t0v9OXPmmBtuuMF4e3ubOnXqmIULF7q87nA4zPPPP29CQkKM3W43bdu2Nb/99tvlGIrb3Bl7ZGRknus3MTHRGGPMiRMnTLt27UxwcLDx8vIykZGRpm/fvlfcl7Mx7o178ODBzrohISHm9ttvd7nmgjHX7jo3xpht27YZSearr77KNa2rZZ3n9/2UM9bevXubVq1a5WoTHR1tvL29TZUqVVyurZKjoGV5pXB37K1atSqwvjFnT3MOCwsz3t7epkKFCqZbt25m+/btl3dgFrAZY9G5nwAAAOKYEQAAYDHCCAAAsBRhBAAAWIowAgAALEUYAQAAliKMAAAASxFGAACApQgjAADAUoQRAABgKcIIAACwFGEEAABYijACAAAs9f8Aqt89CcFsBV8AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The noise is smaller, but **the estimator looks very biased now**.\n",
        "\n",
        "## Understanding the bias introduced by a clipping threshold set too low\n",
        "\n",
        "Let's take a step back and have a look at our simple model.\n",
        "\n",
        "The model outputs a vector of logits: $\\left(l_0, l_1, \\ldots, l_{n-1}\\right)$. As previously shown, the probability of an observation $i$ is:\n",
        "$$q_i=\\frac{e^{l_i}}{\\sum_k e^{l_k}}$$ so our loss is the negative log-lokelihood:\n",
        "$$\\log\\left[\\sum_k e^{l_k}\\right]-l_i$$\n",
        "\n",
        "And the gradient $g^i=\\left(g_0^i, \\ldots, g_{n-1}^i\\right)$ of the loss for observation $=i$ will be:\n",
        "$$\\begin{cases}\n",
        "  g_i^i = \\frac{e^{l_i}}{\\sum_k e^{l_k}}-1 = q_i-1 \\\\\n",
        "  g_{j\\neq i}^i = - \\frac{e^{l_j}}{\\sum_k e^{l_k}} = q_j\n",
        "\\end{cases}$$\n",
        "\n",
        "Around the vector of true probability (i.e. for $q_i = p_i$) the gradient at observation $=i$ is:\n",
        "$$\\begin{cases}\n",
        "  g^i_i = p_i-1 \\\\\n",
        "  g^i_{j\\neq i} = p_j\n",
        "\\end{cases}$$\n",
        "which cancels out, leading the gradient descent to converge.\n",
        "\n",
        "If $n=2$ and $p_0 = p$, the gradient is $g^0=\\left(\\begin{matrix}\n",
        "  p-1 \\\\\n",
        "  1-p\n",
        "\\end{matrix}\\right)$ for observation $=0$ and $g^1=\\left(\\begin{matrix}\n",
        "  p \\\\\n",
        "  -p\n",
        "\\end{matrix}\\right)$ for observation $=1$.\n",
        "\n",
        "The $\\ell^2$ norm of the gradient is $\\|g^0\\|_2=\\sqrt{2}(1-p)$ for observation $=0$ and $\\|g^1\\|_2=\\sqrt{2}p$ for observation $=1$.\n",
        "\n",
        "What happens when the clipping threshold is larger than both norms? The gradient are not clipped:\n",
        "$$\\begin{cases}\n",
        "  \\bar{g^0} = g^0 \\\\\n",
        "  \\bar{g^1} = g^1\n",
        "\\end{cases}$$\n",
        "\n",
        "If the clipping is set to some value smaller than the smallest norm, then both gradients are clipped to the same norm $c$:\n",
        "$$\\begin{cases}\n",
        "  \\bar{g^0} = \\frac{c g^0}{\\sqrt{2}(1-p)} \\\\\n",
        "  \\bar{g^1} = \\frac{c g^1}{\\sqrt{2}p}\n",
        "\\end{cases}$$\n",
        "\n",
        "If $p$ is larger than $\\frac12$ (the observations $=0$ are more frequent than the $1$), then:\n",
        "$$\\frac{c}{\\sqrt{2}(1-p)}>\\frac{c}{\\sqrt{2}p}$$ and **the observations $=0$ will be over-weighted with respect to the $1$**. In a sense, the clipping perturbates an equilibrium where a large number of small norm gradient updates are balanced by a smaller number of larger norm gradients, by normalizing all gradients to the same norm.\n",
        "\n",
        "## Case of a larger number of possible values with no dominant one\n",
        "\n",
        "We see that if all the $p_i$ are relatively small, then all the gradients $g^i$ tend to have a $\\ell^2$ norm close to 1 and the clipping will not re-weight some gradients much more than others.\n",
        "\n",
        "This can be seen in the following experiments:"
      ],
      "metadata": {
        "id": "JpZixP1gNTSo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('many_unbalanced', 'histogram', num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "zJ13R9OPP7r1",
        "outputId": "21d60209-c894-43b3-fd79-b8cd0154d5e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "histogram on many_unbalanced data\n",
            "ε=1.0 δ=1e-05\n",
            "Estimation = [0.10126278 0.03537394 0.07982767 0.04061952 0.05926862 0.051772\n",
            " 0.12187003 0.05378819 0.08290442 0.02123274 0.05732968 0.05562578\n",
            " 0.04154957 0.03892644 0.10373125 0.05491737]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAHICAYAAACVqkoXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABCeklEQVR4nO3dfXzN9eP/8ec2u7LZmLGZJpeRCI2JkvRZrZJSia4YpUvlYgiVq1QjJV2I6EoXPqk+XX0+iiSk6OPD8lUpkctkQ7IxMXZevz/67eTYhZ0523ntnMf9djs39jrvi9frfd7nnOd5v1+v9zvAGGMEAABgiUBvVwAAAOBEhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEE5RqwoQJCggI0L59+045bcOGDdW/f/+KrxRQSQICAnTfffd5bHnLli1TQECAli1b5rFlesvFF1+siy++uNzzBwQEaMKECR6rD3wL4QRe9cknn/ABBaDMNmzYoAkTJmjbtm3ergoqEOEEHrNx40bNmTPHrXk++eQTTZw4sYJqBMDXbNiwQRMnTiSc+DjCCTwmNDRUwcHB3q6GW/Ly8rxdBQDASQgnKJMDBw6of//+qlmzpqKjozVgwAAdPnzYZZqT+5wcO3ZMEydOVLNmzRQWFqbatWvrwgsv1OLFiyVJ/fv314wZMyT9df658FEoLy9Pw4cPV2JiokJDQ9W8eXM9+eSTOvlG2n/++acGDx6s2NhY1ahRQ1dffbV27dpV5Jx2Yf+ZDRs26Oabb1atWrV04YUXSpLWr1+v/v37q3HjxgoLC1N8fLxuu+02/f777y7rKlzGzz//rFtvvVXR0dGqU6eOxo4dK2OMdu7cqWuuuUZRUVGKj4/XU089Vabte/z4cU2aNElNmjRRaGioGjZsqAcffFBHjx4tso2vuuoqffXVV0pOTlZYWJgaN26s119//ZTr2LZtmwICAvTkk09qxowZaty4sapXr67LLrtMO3fulDFGkyZN0hlnnKHw8HBdc8012r9/v8syPvroI3Xv3l0JCQkKDQ1VkyZNNGnSJBUUFLhMd/HFF6tVq1basGGDunXrpurVq6t+/fp64oknnNMcOnRIERERGjJkSJG6/vrrrwoKClJGRkaZtl9h21577bUiz5W0H2zevPmU+3Sht956S82bN1dYWJiSkpL05Zdfujy/fft23XvvvWrevLnCw8NVu3Zt3XDDDWX6db9ixQrdcMMNatCggUJDQ5WYmKhhw4bpzz//dJmuf//+ioyM1K5du9SzZ09FRkaqTp06GjFiRJHt73A49Mwzz6h169YKCwtTnTp1dPnll2vNmjUu07355ptKSkpSeHi4YmJidOONN2rnzp1F6jh79mw1adJE4eHhSk5O1ooVK07ZrkJHjx7VsGHDVKdOHef789dffy0yXVm24WuvvaYbbrhBktStWzfnZ0ZhH56y7p+wXzVvVwBVQ+/evdWoUSNlZGQoMzNTL730kurWraspU6aUOM+ECROUkZGhgQMHKjk5Wbm5uVqzZo0yMzN16aWX6q677tJvv/2mxYsX64033nCZ1xijq6++WkuXLtXtt9+utm3batGiRRo5cqR27dqlp59+2jlt//799c4776hv3746//zztXz5cnXv3r3Eet1www1q1qyZHn/8cWfQWbx4sbZs2aIBAwYoPj5eP/zwg2bPnq0ffvhB33zzjUtokqQ+ffro7LPP1uTJk7VgwQI9+uijiomJ0YsvvqhLLrlEU6ZM0VtvvaURI0aoQ4cOuuiii0rdvgMHDtTcuXPVq1cvDR8+XP/973+VkZGhH3/8UR988IHLtJs3b1avXr10++23Ky0tTa+88or69++vpKQknXPOOaWuR/rrizY/P1/333+/9u/fryeeeEK9e/fWJZdcomXLlmnUqFHavHmznnvuOY0YMUKvvPKKc97XXntNkZGRSk9PV2RkpL744guNGzdOubm5mjp1qst6/vjjD11++eW67rrr1Lt3b7333nsaNWqUWrdurSuuuEKRkZG69tprNX/+fE2bNk1BQUHOef/5z3/KGKNbbrnllO0pr7Lu08uXL9f8+fM1ePBghYaG6oUXXtDll1+u1atXq1WrVpKk//3vf1q5cqVuvPFGnXHGGdq2bZtmzpypiy++WBs2bFD16tVLrMe7776rw4cP65577lHt2rW1evVqPffcc/r111/17rvvukxbUFCg1NRUdezYUU8++aQ+//xzPfXUU2rSpInuuece53S33367XnvtNV1xxRUaOHCgjh8/rhUrVuibb75R+/btJUmPPfaYxo4dq969e2vgwIHau3evnnvuOV100UX69ttvVbNmTUnSyy+/rLvuukudO3fW0KFDtWXLFl199dWKiYlRYmLiKbfzwIED9eabb+rmm29W586d9cUXXxT7/izLNrzooos0ePBgPfvss3rwwQd19tlnS5LzX3f2T1jOAKUYP368kWRuu+02l/Jrr73W1K5d26XszDPPNGlpac6/27RpY7p3717q8gcNGmSK2w0//PBDI8k8+uijLuW9evUyAQEBZvPmzcYYY9auXWskmaFDh7pM179/fyPJjB8/vkhbbrrppiLrO3z4cJGyf/7zn0aS+fLLL4ss484773SWHT9+3JxxxhkmICDATJ482Vn+xx9/mPDwcJdtUpx169YZSWbgwIEu5SNGjDCSzBdffOEsO/PMM4vUac+ePSY0NNQMHz681PVs3brVSDJ16tQxBw4ccJaPGTPGSDJt2rQxx44dc5bfdNNNJiQkxBw5csRZVtx2uuuuu0z16tVdpuvatauRZF5//XVn2dGjR018fLy5/vrrnWWLFi0yksynn37qssxzzz3XdO3atdT2FNe2V199tchzJe0HZdmnJRlJZs2aNc6y7du3m7CwMHPttdc6y4rbLqtWrSqyDZYuXWokmaVLl5Y6b0ZGhgkICDDbt293lqWlpRlJ5pFHHnGZtl27diYpKcn59xdffGEkmcGDBxdZrsPhMMYYs23bNhMUFGQee+wxl+e/++47U61aNWd5fn6+qVu3rmnbtq05evSoc7rZs2cbSad8jQr37Xvvvdel/Oabby7yupR1G7777rtFtmFpyyhu/4T9OK2DMrn77rtd/u7SpYt+//135ebmljhPzZo19cMPP2jTpk1ur++TTz5RUFCQBg8e7FI+fPhwGWP06aefSpIWLlwoSbr33ntdprv//vtLXPbJbZGk8PBw5/+PHDmiffv26fzzz5ckZWZmFpl+4MCBzv8HBQWpffv2Msbo9ttvd5bXrFlTzZs315YtW0qsi/RXWyUpPT3dpXz48OGSpAULFriUt2zZUl26dHH+XadOnTKtp9ANN9yg6Oho598dO3aUJN16662qVq2aS3l+fr527drlLDtxOx08eFD79u1Tly5ddPjwYf30008u64mMjNStt97q/DskJETJycku9UxJSVFCQoLeeustZ9n333+v9evXu8xbEcq6T3fq1ElJSUnOvxs0aKBrrrlGixYtcp4uOHG7HDt2TL///ruaNm2qmjVrFrv/nOjEefPy8rRv3z517txZxhh9++23Zar3idv0X//6lwICAjR+/Pgi8xYeAXz//fflcDjUu3dv7du3z/mIj49Xs2bNtHTpUknSmjVrtGfPHt19990KCQlxLqd///4u+1BJCvftk9/HQ4cOLTLt6WzD4pZxqv0TdiOcoEwaNGjg8netWrUk/XXoviSPPPKIDhw4oLPOOkutW7fWyJEjtX79+jKtb/v27UpISFCNGjVcygsP327fvt35b2BgoBo1auQyXdOmTUtc9snTStL+/fs1ZMgQxcXFKTw8XHXq1HFOl5OTU2T6k7dHdHS0wsLCFBsbW6S8tG10YhtOrnN8fLxq1qzpbGtJ65b+ej1OtZ7S6i6pyCH6wvITl/vDDz/o2muvVXR0tKKiolSnTh1niDh5O51xxhlFToedXM/AwEDdcsst+vDDD539Pd566y2FhYU5+xZUlLLu082aNSsy71lnnaXDhw9r7969kv7q9zRu3Dhn/6jY2FjVqVNHBw4cKHb/OdGOHTvUv39/xcTEOPuRdO3aVVLRbVrYf+Tkep9Y519++UUJCQmKiYkpcZ2bNm2SMUbNmjVTnTp1XB4//vij9uzZI+nv99nJ2yA4OFiNGzcutV2F8wcGBqpJkyYu5c2bNy8y7elsw0Lu7J+wG31OUCYn9gc4kTmpc+qJLrroIv3yyy/66KOP9Nlnn+mll17S008/rVmzZrkceahsJ/66KtS7d2+tXLlSI0eOVNu2bRUZGSmHw6HLL79cDoejyPTFbY/ybKMTnfxFXpLTXU9J859quQcOHFDXrl0VFRWlRx55RE2aNFFYWJgyMzM1atSoItuprPXs16+fpk6dqg8//FA33XST5s2bp6uuuqpMv8wLlbTtSusIebrb8UT333+/Xn31VQ0dOlSdOnVSdHS0AgICdOONNxa7/5xYv0svvVT79+/XqFGj1KJFC0VERGjXrl3q379/mbepuxwOhwICAvTpp58Wu8zIyEiPrMcd5d2GhdzdP2E3wgkqVExMjAYMGKABAwbo0KFDuuiiizRhwgRnOCnpS+XMM8/U559/roMHD7ocPSk8NHvmmWc6/3U4HNq6davLr7vNmzeXuY5//PGHlixZookTJ2rcuHHO8vKcjiqPwjZs2rTJeWRIkrKzs3XgwAFnW71t2bJl+v333/X++++7dPDdunXraS23VatWateund566y2dccYZ2rFjh5577jm3llF41OPAgQMu5ScfdSqP4vaDn3/+WdWrV3cexXjvvfeUlpbmMjrryJEjRepzsu+++04///yz5s6dq379+jnLC0e0lUeTJk20aNEi7d+/v8SjJ02aNJExRo0aNdJZZ51V4rIK971NmzbpkksucZYfO3ZMW7duVZs2bUqtS+G+/csvv7gcLdm4cWORacu6DUv6zKio/RPewWkdVJiTh+FGRkaqadOmLsNjIyIiJBX9UrnyyitVUFCg559/3qX86aefVkBAgK644gpJUmpqqiTphRdecJnOnS+3wl+OJ/9inj59epmXcTquvPLKYtc3bdo0SSp15FFlKm475efnF9n25dG3b1999tlnmj59umrXru18fcsqKipKsbGxRYb4eqJuq1atcunzsHPnTn300Ue67LLLnNskKCioyP7z3HPPnXIIa3Hb1BijZ555ptz1vf7662WMKfbihoXrue666xQUFKSJEycWqbcxxvnebd++verUqaNZs2YpPz/fOc1rr712yuAlyfk6Pvvssy7lxb23yroNS/rMqMj9E5WPIyeoMC1bttTFF1+spKQkxcTEaM2aNXrvvfdc7lVS2NFw8ODBSk1NVVBQkG688Ub16NFD3bp100MPPaRt27apTZs2+uyzz/TRRx9p6NChznPYSUlJuv766zV9+nT9/vvvzqHEP//8s6SynSqJiorSRRddpCeeeELHjh1T/fr19dlnn1XaL642bdooLS1Ns2fPdh6aXr16tebOnauePXuqW7dulVKPU+ncubNq1aqltLQ0DR48WAEBAXrjjTfKdRrkZDfffLMeeOABffDBB7rnnnvKdTG/gQMHavLkyRo4cKDat2+vL7/80rkfnI5WrVopNTXVZSixJJcv/6uuukpvvPGGoqOj1bJlS61atUqff/65ateuXeqyW7RooSZNmmjEiBHatWuXoqKi9K9//avM/YeK061bN/Xt21fPPvusNm3a5Dw1uWLFCnXr1k333XefmjRpokcffVRjxozRtm3b1LNnT9WoUUNbt27VBx98oDvvvFMjRoxQcHCwHn30Ud1111265JJL1KdPH23dulWvvvpqmfqctG3bVjfddJNeeOEF5eTkqHPnzlqyZEmxRzbLug3btm2roKAgTZkyRTk5OQoNDdUll1xSofsnvKDyBgahKiocdrl3716X8ldffdVIMlu3bnWWnTyU+NFHHzXJycmmZs2aJjw83LRo0cI89thjJj8/3znN8ePHzf3332/q1KljAgICXIYVHzx40AwbNswkJCSY4OBg06xZMzN16lTncMhCeXl5ZtCgQSYmJsZERkaanj17mo0bNxpJLkN7S2qLMcb8+uuv5tprrzU1a9Y00dHR5oYbbjC//fZbicNQT15GWlqaiYiIKLLcrl27mnPOOaf4jXuCY8eOmYkTJ5pGjRqZ4OBgk5iYaMaMGVNk+OOZZ55Z7PDsrl27nnJYZ+Fw26lTp7qUFw5vfffdd13KC1/j//3vf86yr7/+2px//vkmPDzcJCQkmAceeMA5HPjEoZ0ltTstLc2ceeaZxdbvyiuvNJLMypUrS21HSQ4fPmxuv/12Ex0dbWrUqGF69+5t9uzZU+bXsLh9WpIZNGiQefPNN02zZs1MaGioadeuXZFhrH/88YcZMGCAiY2NNZGRkSY1NdX89NNPRd4TxQ0l3rBhg0lJSTGRkZEmNjbW3HHHHeb//u//igyNLmkfK2zPiY4fP26mTp1qWrRoYUJCQkydOnXMFVdcYdauXesy3b/+9S9z4YUXmoiICBMREWFatGhhBg0aZDZu3Ogy3QsvvGAaNWpkQkNDTfv27c2XX35Zpn3OGGP+/PNPM3jwYFO7dm0TERFhevToYXbu3FnkdSnrNjTGmDlz5pjGjRuboKAgl+1Z1v0T9gswhlgJ37Nu3Tq1a9dOb775ZoVeyAuec+211+q7775zq78QAN9EnxNUeSdf5lv665x2YGDgKa/MCjvs3r1bCxYsUN++fb1dFQAWoM8JqrwnnnhCa9euVbdu3VStWjV9+umn+vTTT3XnnXeW6fLa8J6tW7fq66+/1ksvvaTg4GDdddddRabJysoqdRnh4eFuDTsGYD/CCaq8zp07a/HixZo0aZIOHTqkBg0aaMKECXrooYe8XTWcwvLlyzVgwAA1aNBAc+fOVXx8fJFp6tWrV+oy0tLSir3hH4Cqiz4nAKz2+eefl/p8QkKCWrZsWUm1AVAZCCcAAMAqdIgFAABWIZwAAACrEE4AP7F7926NHj1a3bp1U40aNRQQEKBly5a5tYxdu3apd+/eqlmzpqKionTNNddoy5YtZZr3yJEjGj58uJo0aaLw8HDFxMTo/PPP1yeffFKO1hT12Wef6fbbb1erVq0UFBSkhg0bemS5JXn55Zd19tlnKywsTM2aNSv2lgkTJkxQQEBAkUdYWFiF1g2o6hitA/iJjRs3asqUKWrWrJlat26tVatWuTX/oUOH1K1bN+Xk5OjBBx9UcHCwnn76aXXt2lXr1q075aXax40bp6efflr33HOPzjvvPBljtGXLFn333XfO+wudjnnz5mn+/Pk677zzlJCQcNrLK82LL76ou+++W9dff73S09O1YsUKDR48WIcPH9aoUaOKTD9z5kyXO/166u7CgM/y4tVpAVSi3Nxc8/vvvxtjjHn33XfdvqT3lClTjCSzevVqZ9mPP/5ogoKCzJgxY045f/fu3U1sbKw5ePCg23Uvi127djlvjdC9e/cSL5N/ug4fPmxq165d5DYCt9xyi4mIiDD79+93lpV2ywQAJeO0DmCZV199VW3btlVERISio6PVtm1bzZo167SXW6NGDcXExJR7/vfee08dOnRQhw4dnGUtWrTQP/7xD73zzjunnP/ee+9Vbm6umjZtqjvuuEPvvfee8vLyyl2fkyUkJJT5hoEHDhzQ0KFDlZiYqNDQUDVt2lRTpkyRw+E45bxLly7V77//rnvvvdelfNCgQcrLy9OCBQuKzGOMUW5uLjehA8qI0zqARd5//33ddtttuvjii/Xkk08qICBAv/zyi3Jzc53THDt2TDk5OWVaXkxMjAIDT/83iMPh0Pr163XbbbcVeS45OVmfffaZDh48qBo1apS4jFatWuncc8/V/fffr2PHjmnOnDkaNGiQ5s6dq8svv9w53aFDh3TkyJFT1ik4OLhcV4Y9fPiwunbtql27dumuu+5SgwYNtHLlSo0ZM0a7d+/W9OnTS53/22+/lSS1b9/epTwpKUmBgYH69ttvdeutt7o817hxYx06dEgRERHq2bOnnnrqKcXFxbldd8BfEE4AiyxdulRRUVH6/PPPS+yX8PXXX6tbt25lWt7WrVs90jF0//79Onr0aLFXay0s++2339S8efNi5y8oKNA111yjPn36qF+/fpKk22+/XXfeeaeuu+46bdiwwVnP++67T3Pnzj1lnbp27ep2h15JmjZtmn755Rd9++23atasmSTprrvuUkJCgqZOnarhw4eXetuD3bt3KygoSHXr1nUpDwkJUe3atfXbb785y2rVqqX77rtPnTp1UmhoqFasWKEZM2Zo9erVWrNmjaKiotyuP+APCCeARbp06aLnn39ezz77rK6//npVr169yNGPNm3aaPHixWVaXnGXgy+PwpsrhoaGFnmucORJcTdgLPTBBx9o3bp1+vjjj13KJ02apDlz5uiNN97Q2LFjJUkPPPBAkSMPxalVq1aZ63+id999V126dFGtWrW0b98+Z3lKSoomT56sL7/8stQ7Wf/5558KCQkp9rmwsDCX7TBkyBCX56+//nolJyfrlltu0QsvvKDRo0eXqw2AryOcABbp3bu39u3bp2HDhik9PV1S0aMftWrVUkpKSqXWKzw8XJJ09OjRIs8VnoIpnKY4K1asUFBQkOrXr+9SHhcXp1q1amnDhg3OspYtW1bo5eg3bdqk9evXq06dOsU+v2fPHknS3r17VVBQ4CyPjIxUZGSkwsPDlZ+fX+y8R44cKXU7SNLNN9+s4cOH6/PPPyecACUgnAAW+c9//qP09HT169dP3bt3V2RkZJGjH/n5+dq/f3+ZllenTh2PDFuNiYlRaGiodu/eXeS5wrLShu8eOXJEDodDx48fL3LUoaCgwOXLPicnp9SjMIVCQkLK1cHX4XDo0ksv1QMPPFDs82eddZYkqUOHDtq+fbuzfPz48ZowYYLq1aungoIC7dmzx+XUTn5+vn7//fcyDWNOTEws82sI+CPCCWCRSZMm6YILLtCcOXNKnGblypWV3uckMDBQrVu31po1a4o899///leNGzcutTNsYmKijDHauHGjWrdu7Sz/7bfflJubqzPOOMNZNmTIkArtc9KkSRMdOnTolEef3nrrLZeQ1LhxY0lS27ZtJUlr1qxxuT7LmjVr5HA4nM+XxBijbdu2qV27dm7XHfAXhBPAIkeOHNHx48flcDhKHGVTGX1OduzYocOHD6tFixbOsl69emn06NFas2aNc6TKxo0b9cUXX2jEiBGlLu/KK6/U2LFjNW3aNL366qvO8ieffFKSdMUVVzjLKrrPSe/evTVhwgQtWrRIqampLs8dOHBAkZGRqlatmi644IJi57/kkksUExOjmTNnuoSTmTNnqnr16urevbuzbO/evUVOH82cOVN79+51GaEEwBV3JQYsMnXqVD3wwAPq0qWLs0Pstm3blJmZqU8//fS0l//oo49Kkn744Qe9/fbbuu2229SoUSNJ0sMPP+yc7uKLL9by5ctdrstx8OBBtWvXTgcPHtSIESMUHBysadOmqaCgQOvWrSuxD0ehfv366Y033lCvXr3UrVs3ffPNN3rjjTd05ZVXFnttEHetX7/e2eH2zTffVHZ2toYPHy7pr0DXo0cPSX8NJe7SpYvWr1+v/v37KykpSXl5efruu+/03nvvadu2bYqNjS11XS+88IIGDRqkXr16KTU1VStWrNDrr7+uxx57TA8++KBzuurVq6tPnz5q3bq1wsLC9NVXX+ntt99WmzZt9PXXX6t69eqn3W7AJ3nxAnAAivH666+b888/38TExJiwsDBz1llnmZEjR3pk2ZJKfJyoa9euRcqMMWbnzp2mV69eJioqykRGRpqrrrrKbNq0qUzrPnbsmJk4caJp1KiRCQ4ONomJieaBBx4whw8f9kjbXn311RLblpaW5jLtwYMHzZgxY0zTpk1NSEiIiY2NNZ07dzZPPvmk8yqzpzJ79mzTvHlzExISYpo0aWKefvpp43A4XKYZOHCgadmypalRo4YJDg42TZs2NaNGjTK5ubkeaTPgqzhyAgAArMLl6wEAgFUIJwAAwCqEEwAAYBW3w8mXX36pHj16KCEhQQEBAfrwww9POc+yZct03nnnOe/++dprr5WjqgAAwB+4HU7y8vLUpk0bzZgxo0zTb926Vd27d1e3bt20bt06DR06VAMHDtSiRYvcriwAAPB9pzVaJyAgQB988IF69uxZ4jSjRo3SggUL9P333zvLbrzxRh04cEALFy4s76oBAICPqvArxK5atarIZaJTU1M1dOjQEuc5evSoyw3GHA6H9u/fr9q1aysgIKCiqgoAADzIGKODBw8qISGhxKteF6fCw0lWVpbi4uJcyuLi4pSbm6s///yz2Dt4ZmRkaOLEiRVdNQAAUAl27tzpcg+tU7Hy3jpjxoxx3i5e+usupQ0aNNDOnTsVFRXlxZoBAICyys3NVWJiYqk3Bi1OhYeT+Ph4ZWdnu5RlZ2crKiqq2KMmkhQaGqrQ0NAi5VFRUYQTAACqGHe7ZFT4dU46deqkJUuWuJQtXrxYnTp1quhVAwCAKsjtcHLo0CGtW7dO69atk/TXUOF169Zpx44dkv46JdOvXz/n9Hfffbe2bNmiBx54QD/99JNeeOEFvfPOOxo2bJhnWgAAAHyK2+FkzZo1ateundq1aydJSk9PV7t27TRu3DhJ0u7du51BRZIaNWqkBQsWaPHixWrTpo2eeuopvfTSS0pNTfVQEwAAgC+pEnclzs3NVXR0tHJycuhzAgBAFVHe72/urQMAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwSrnCyYwZM9SwYUOFhYWpY8eOWr16danTT58+Xc2bN1d4eLgSExM1bNgwHTlypFwVBgAAvs3tcDJ//nylp6dr/PjxyszMVJs2bZSamqo9e/YUO/28efM0evRojR8/Xj/++KNefvllzZ8/Xw8++OBpVx4AAPget8PJtGnTdMcdd2jAgAFq2bKlZs2aperVq+uVV14pdvqVK1fqggsu0M0336yGDRvqsssu00033XTKoy0AAMA/uRVO8vPztXbtWqWkpPy9gMBApaSkaNWqVcXO07lzZ61du9YZRrZs2aJPPvlEV155ZYnrOXr0qHJzc10eAADAP1RzZ+J9+/apoKBAcXFxLuVxcXH66aefip3n5ptv1r59+3ThhRfKGKPjx4/r7rvvLvW0TkZGhiZOnOhO1QAAgI+o8NE6y5Yt0+OPP64XXnhBmZmZev/997VgwQJNmjSpxHnGjBmjnJwc52Pnzp0VXU0AAGAJt46cxMbGKigoSNnZ2S7l2dnZio+PL3aesWPHqm/fvho4cKAkqXXr1srLy9Odd96phx56SIGBRfNRaGioQkND3akaAADwEW4dOQkJCVFSUpKWLFniLHM4HFqyZIk6depU7DyHDx8uEkCCgoIkScYYd+sLAAB8nFtHTiQpPT1daWlpat++vZKTkzV9+nTl5eVpwIABkqR+/fqpfv36ysjIkCT16NFD06ZNU7t27dSxY0dt3rxZY8eOVY8ePZwhBQAAoJDb4aRPnz7au3evxo0bp6ysLLVt21YLFy50dpLdsWOHy5GShx9+WAEBAXr44Ye1a9cu1alTRz169NBjjz3muVYAAACfEWCqwLmV3NxcRUdHKycnR1FRUd6uDgAAKIPyfn9zbx0AAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVcoVTmbMmKGGDRsqLCxMHTt21OrVq0ud/sCBAxo0aJDq1aun0NBQnXXWWfrkk0/KVWEAAODbqrk7w/z585Wenq5Zs2apY8eOmj59ulJTU7Vx40bVrVu3yPT5+fm69NJLVbduXb333nuqX7++tm/frpo1a3qi/gAAwMcEGGOMOzN07NhRHTp00PPPPy9JcjgcSkxM1P3336/Ro0cXmX7WrFmaOnWqfvrpJwUHB5erkrm5uYqOjlZOTo6ioqLKtQwAAFC5yvv97dZpnfz8fK1du1YpKSl/LyAwUCkpKVq1alWx83z88cfq1KmTBg0apLi4OLVq1UqPP/64CgoKSlzP0aNHlZub6/IAAAD+wa1wsm/fPhUUFCguLs6lPC4uTllZWcXOs2XLFr333nsqKCjQJ598orFjx+qpp57So48+WuJ6MjIyFB0d7XwkJia6U00AAFCFVfhoHYfDobp162r27NlKSkpSnz599NBDD2nWrFklzjNmzBjl5OQ4Hzt37qzoagIAAEu41SE2NjZWQUFBys7OdinPzs5WfHx8sfPUq1dPwcHBCgoKcpadffbZysrKUn5+vkJCQorMExoaqtDQUHeqBgAAfIRbR05CQkKUlJSkJUuWOMscDoeWLFmiTp06FTvPBRdcoM2bN8vhcDjLfv75Z9WrV6/YYAIAAPyb26d10tPTNWfOHM2dO1c//vij7rnnHuXl5WnAgAGSpH79+mnMmDHO6e+55x7t379fQ4YM0c8//6wFCxbo8ccf16BBgzzXCgAA4DPcvs5Jnz59tHfvXo0bN05ZWVlq27atFi5c6Owku2PHDgUG/p15EhMTtWjRIg0bNkznnnuu6tevryFDhmjUqFGeawUAAPAZbl/nxBu4zgkAAFVPpVznBAAAoKIRTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsUq5wMmPGDDVs2FBhYWHq2LGjVq9eXab53n77bQUEBKhnz57lWS0AAPADboeT+fPnKz09XePHj1dmZqbatGmj1NRU7dmzp9T5tm3bphEjRqhLly7lriwAAPB9boeTadOm6Y477tCAAQPUsmVLzZo1S9WrV9crr7xS4jwFBQW65ZZbNHHiRDVu3PiU6zh69Khyc3NdHgAAwD+4FU7y8/O1du1apaSk/L2AwEClpKRo1apVJc73yCOPqG7durr99tvLtJ6MjAxFR0c7H4mJie5UEwAAVGFuhZN9+/apoKBAcXFxLuVxcXHKysoqdp6vvvpKL7/8subMmVPm9YwZM0Y5OTnOx86dO92pJgAAqMKqVeTCDx48qL59+2rOnDmKjY0t83yhoaEKDQ2twJoBAABbuRVOYmNjFRQUpOzsbJfy7OxsxcfHF5n+l19+0bZt29SjRw9nmcPh+GvF1app48aNatKkSXnqDQAAfJRbp3VCQkKUlJSkJUuWOMscDoeWLFmiTp06FZm+RYsW+u6777Ru3Trn4+qrr1a3bt20bt06+pIAAIAi3D6tk56errS0NLVv317JycmaPn268vLyNGDAAElSv379VL9+fWVkZCgsLEytWrVymb9mzZqSVKQcAABAKkc46dOnj/bu3atx48YpKytLbdu21cKFC52dZHfs2KHAQC48CwAAyifAGGO8XYlTyc3NVXR0tHJychQVFeXt6gAAgDIo7/c3hzgAAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXACAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxCOAEAAFYhnAAAAKsQTgAAgFUIJwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAVilXOJkxY4YaNmyosLAwdezYUatXry5x2jlz5qhLly6qVauWatWqpZSUlFKnBwAA/s3tcDJ//nylp6dr/PjxyszMVJs2bZSamqo9e/YUO/2yZct00003aenSpVq1apUSExN12WWXadeuXaddeQAA4HsCjDHGnRk6duyoDh066Pnnn5ckORwOJSYm6v7779fo0aNPOX9BQYFq1aql559/Xv369St2mqNHj+ro0aPOv3Nzc5WYmKicnBxFRUW5U10AAOAlubm5io6Odvv7260jJ/n5+Vq7dq1SUlL+XkBgoFJSUrRq1aoyLePw4cM6duyYYmJiSpwmIyND0dHRzkdiYqI71QQAAFWYW+Fk3759KigoUFxcnEt5XFycsrKyyrSMUaNGKSEhwSXgnGzMmDHKyclxPnbu3OlONQEAQBVWrTJXNnnyZL399ttatmyZwsLCSpwuNDRUoaGhlVgzAABgC7fCSWxsrIKCgpSdne1Snp2drfj4+FLnffLJJzV58mR9/vnnOvfcc92vKQAA8AtundYJCQlRUlKSlixZ4ixzOBxasmSJOnXqVOJ8TzzxhCZNmqSFCxeqffv25a8tAADweW6f1klPT1daWprat2+v5ORkTZ8+XXl5eRowYIAkqV+/fqpfv74yMjIkSVOmTNG4ceM0b948NWzY0Nk3JTIyUpGRkR5sCgAA8AVuh5M+ffpo7969GjdunLKystS2bVstXLjQ2Ul2x44dCgz8+4DMzJkzlZ+fr169erksZ/z48ZowYcLp1R4AAPgct69z4g3lHScNAAC8p1KucwIAAFDRCCcAAMAqhBMAAGAVwgkAALAK4QQAAFiFcAIAAKxSqffWAQCgKtu9e7d2795daeurV6+e6tWrV2nrswXhBACAMnrxxRc1ceLESlufv16wlHACAEAZ3XXXXbr66qvLPP2ff/6pCy+8UJL01VdfKTw83K31+eNRE4lwAgBAmbl7miUvL8/5/7Zt2yoiIqIiquVz6BALAACsQjgBAABWIZwAAACrEE4AAIBVCCcAAMAqhBMAAGAVwgkAALAK4QQAgIriKPj7/9u+dv0bJeIibAAAj+C+MyfZ8LH00ci//36rlxRbX7p8itSy7FeZ9Ud+G054EwH24P3oG7jvzAk2fCy900/Kd7iW5+7+q7z36wSUUvhtOOFNBNiD96Nv4L4z/5+jQFo4SpIp5kkjKUBaOFpq0V0KDKrkylUNAcaY4raeVXJzcxUdHa2cnBxFRUV5ZJnu/lLzxJvI2jcS4GW8H/1TXl6eIiMjJUmHDh3ynfvObF0hzb1KkpSXbxSZcVCSdGhMDUWEBPw9Xdp/pEZdvFHDSlPe72+/PXLCzZtQVfjDKQ/ej6iKGo5eUGz51YEr9WzIqecfPGehPnbkFvvctsndT6dqVZ7fhhOgquCUB1C17FFNj07njwgngOU4jw9ULasdLfSbiVG89hf7vMNIWaqt1Y4WlVyzqoNwAliOUx5A1eJQoCYe66eZwdPlOKlXZ+HfE4/1lYNLjZWILQMAgIctciTrnmNDla1aLuVZqq17jg3VIkeyl2pWNXDkBACACrDIkaxF+a0k9ZYkpeWPUqbjXLePmPhDp/iTEU58mD/s0P7QRgBV14lBZLWjhQLLccLCHzvFE07K6uT7I5z9D+svnuMPO7Q/tNFtVXBfdVsVbCNBGuXlj53iCSdlUUXvj+APO7Q/tNEtVXRfdUsVbSNBuhhVMGR6gz92iiecnEoVvj+CP+zQ/tDGMqvC+2qZVeE2EqRPUkVDJioH4aQ03B8BVYU/7KtVvI0E6RNU4ZCJyuH34aSkyw9L0vmBG/R2yG+lzG2k3F268eFp+sbRssiz/n75YVSi7Sul3FPvq9q+0vp7eZT0nuT96COqeMhE5fD7cFKaujrg0emACnMo27PTWcjT70d/6KBqZRt9KEij4hBOSsH9EWCT0o/ybdXbZbjR2I3/3Kpv3iq6nKpwVMHT70d/6KDqzTZW1k3xKjuABQYGyuH463TU0azNp5zeHMt3/j8/e4sCgsvQeEmZmZmS/HfUFeGkFNwfAVWFP+yrnm6jP3RQtbGNVT1kdu3aVcuXLy/XvNnzHijztElz//q3Soy6qgCEk1JwfwQfdJpDF608TC7/2Fc93UbrO6h6YJitjW2s6iHzxCMn3Z9d4da87lgw+K9TWv541EQinJxS4f0RRuo1SQed5VmqrYnH+nJ/hBPY+sXt5IGhizafCvCHfdUf2ijJp4fZ+lLIDI2vuM+78847r/wz+8D1YwgnZeCJ+yNY/8UtnfYObfMXt6eGLtp4mPxEnrqXh818vo1+MMzWb0KmN/hIsCWclNHp3h/B6i9uySM7tLVf3B4cumjjYfKTne6+WhWCtCfuV2IlPxpm6/Mh0xt8KNgSTiqJtV/cksd2aGu/uBm66Bbrg7Qv87N91WdDpjf4WLAlnFQSa7+4fWSHLm2Y7ekOXawKw2w9yeog7ev84Ho1qCA+FmwJJ/7Ox3bo4nC9GvdYG6S9zYOdDEu+Cq6Xr1fjAx0pfZk//Qjz23BSeF69LBfRkcp3IZ3Ci+hI3r2Qjj/t0MXxh2uAoIJVUidDr+6rPtKR0l/52o8wvw0np3NevawX0im8iI5k73l1X9uhi+MP1wBBBarEToZe21d9qCOlv/K1H2F+G04Kz6tXxkV0JHvPq/vaDl0Srw1d5DB5mZw4QqiiLgleriOZXuiTVen7qo/0O/N3vvYjzG/DSeGHk7UX0akkvrZDl6bShy5ymLzMrD2S6aU+WZW6r/pBvzMXPvyDwZeuH+O34cR6lfgG8qUd+lQqbeiiBw+T+0P/qBNHCFXU0cxyHcn04ugZT+6r/t7vzMkPfjD4yvVjCCc28sIbyCs7tK/+gvHwYXJrjyoU8vA9YCrqaGZJRzK523NNj01XGafnpHLesdeP+tX4wvVjCCe28eIbqFJ3aF/+BePhw+RW94/y5ddR/tEny5NtrIwgLZXjjr30q6lyCCc28Zc3kI/8ginpF/fpHiaXXH9xW9s/ykdex9L4Q58sT7axMk7PScXfsbf0I2Ab9HbIqX8w3PjwNH3jaFnk2apwBMzXEE5s4g8d0/wggPnD8Gx/eB0L+UOfLE+1sTJOz0nuh+m6OuDR6VDxCCdeUFm/uK3kBwHMH04F+MPreCJf6WRYGl9uo1/8YPAxhBOL+NIbqLICmI0jWXzpVIBfB+mTePJuz1Zdy+UEvtCRsjh+8YPBxxBOLOIPbyBPBzBbR7L4+qkAXwrSlcXWfdUfVPUfDDb+CKtohBOLePoNZOMO7ekAZvNIFl8+TO4PQdrTrL2Wi5+oyj8Y/DHYEk4s48k3kI07tKcDmLUjWf4/Xz1MXtV/iXqDN6/lgr9U1R8MNv8IqyiEEwt56g1k6w5dlX/B4G+8jqiKquIPBtt/hFUEwomlPPEGsnmHrqq/YOCK1xFAReATBF5zcgDjC61q4nUE4Gl8igAAAKuU67TOjBkzNHXqVGVlZalNmzZ67rnnlJxc8vnld999V2PHjtW2bdvUrFkzTZkyRVdeeWW5Kw0Ap8vG0Wye5g9thG9yO5zMnz9f6enpmjVrljp27Kjp06crNTVVGzduVN26dYtMv3LlSt10003KyMjQVVddpXnz5qlnz57KzMxUq1atPNIIAHCXjaPZPM0f2kgA801uh5Np06bpjjvu0IABAyRJs2bN0oIFC/TKK69o9OjRRaZ/5plndPnll2vkyL/uXDpp0iQtXrxYzz//vGbNmnWa1QeA8rF1NJsn+UMb/SGA+SO3wkl+fr7Wrl2rMWPGOMsCAwOVkpKiVatWFTvPqlWrlJ6e7lKWmpqqDz/8sMT1HD16VEePHnX+nZOTI0nKzS3+Mtinw3H0sMeXWejE+mZlZSkrK0uS9OeO7085rzn+d7o/8usGBVQrw7XCJX35ZQ1JUnx8vOLj4yXRxtNFG0vnyTZKFdfOkz8/IiIi1LRpUwXX+qVC1idJTZs2LbYOtPH0nNjOm2++WZdccolumFX8d5AnvHt3J+f/4+PjK72NhSp7fZ5crjHF3SS0FMYNu3btMpLMypUrXcpHjhxpkpOTi50nODjYzJs3z6VsxowZpm7duiWuZ/z48UZ/3dqUBw8ePHjw4FHFHzt37nQnbhgrr3MyZswYl6MtDodD+/fvV+3atRUQEOC1euXm5ioxMVE7d+5UVFSU1+pRkWijb6CNvoE2+gZ/bqMxRgcPHlRCQoJby3MrnMTGxiooKEjZ2dku5dnZ2S6HZU8UHx/v1vSSFBoaqtDQUJeymjVrulPVChUVFeWzO1gh2ugbaKNvoI2+wV/bGB0d7fZy3LrOSUhIiJKSkrRkyRJnmcPh0JIlS9SpU6di5+nUqZPL9JK0ePHiEqcHAAD+ze3TOunp6UpLS1P79u2VnJys6dOnKy8vzzl6p1+/fqpfv74yMjIkSUOGDFHXrl311FNPqXv37nr77be1Zs0azZ4927MtAQAAPsHtcNKnTx/t3btX48aNU1ZWltq2bauFCxcqLi5OkrRjxw4FBv59QKZz586aN2+eHn74YT344INq1qyZPvzwwyp5jZPQ0FCNHz++yCknX0IbfQNt9A200TfQRvcFGOPu+B4AAICKw711AACAVQgnAADAKoQTAABgFcIJAACwCuEEAABYhXBSRjNmzFDDhg0VFhamjh07avXq1d6uksdkZGSoQ4cOqlGjhurWrauePXtq48aN3q5WhZo8ebICAgI0dOhQb1fFo3bt2qVbb71VtWvXVnh4uFq3bq01a9Z4u1oeVVBQoLFjx6pRo0YKDw9XkyZNNGnSJPdvLGaRL7/8Uj169FBCQoICAgKK3BjVGKNx48apXr16Cg8PV0pKijZt2uSdypZTaW08duyYRo0apdatWysiIkIJCQnq16+ffvvtN+9VuBxO9Tqe6O6771ZAQICmT59eafXzhLK08ccff9TVV1+t6OhoRUREqEOHDtqxY4db6yGclMH8+fOVnp6u8ePHKzMzU23atFFqaqr27Nnj7ap5xPLlyzVo0CB98803Wrx4sY4dO6bLLrtMeXl53q5ahfjf//6nF198Ueeee663q+JRf/zxhy644AIFBwfr008/1YYNG/TUU0+pVq1a3q6aR02ZMkUzZ87U888/rx9//FFTpkzRE088oeeee87bVSu3vLw8tWnTRjNmzCj2+SeeeELPPvusZs2apf/+97+KiIhQamqqjhw5Usk1Lb/S2nj48GFlZmZq7NixyszM1Pvvv6+NGzfq6quv9kJNy+9Ur2OhDz74QN98843b95uxwana+Msvv+jCCy9UixYttGzZMq1fv15jx45VWFiYeyty6zaBfio5OdkMGjTI+XdBQYFJSEgwGRkZXqxVxdmzZ4+RZJYvX+7tqnjcwYMHTbNmzczixYtN165dzZAhQ7xdJY8ZNWqUufDCC71djQrXvXt3c9ttt7mUXXfddeaWW27xUo08S5L54IMPnH87HA4THx9vpk6d6iw7cOCACQ0NNf/85z+9UMPTd3Ibi7N69WojyWzfvr1yKuVhJbXx119/NfXr1zfff/+9OfPMM83TTz9d6XXzlOLa2KdPH3Prrbee9rI5cnIK+fn5Wrt2rVJSUpxlgYGBSklJ0apVq7xYs4qTk5MjSYqJifFyTTxv0KBB6t69u8vr6Ss+/vhjtW/fXjfccIPq1q2rdu3aac6cOd6ulsd17txZS5Ys0c8//yxJ+r//+z999dVXuuKKK7xcs4qxdetWZWVlueyz0dHR6tixo89+Bkl/fQ4FBARYddPX0+VwONS3b1+NHDlS55xzjrer43EOh0MLFizQWWedpdTUVNWtW1cdO3Ys9fRWSQgnp7Bv3z4VFBQ4L89fKC4uTllZWV6qVcVxOBwaOnSoLrjggip5i4HSvP3228rMzHTe98nXbNmyRTNnzlSzZs20aNEi3XPPPRo8eLDmzp3r7ap51OjRo3XjjTeqRYsWCg4OVrt27TR06FDdcsst3q5ahSj8nPGXzyBJOnLkiEaNGqWbbrrJp+7iO2XKFFWrVk2DBw/2dlUqxJ49e3To0CFNnjxZl19+uT777DNde+21uu6667R8+XK3luX2vXXg2wYNGqTvv/9eX331lber4lE7d+7UkCFDtHjxYvfPfVYRDodD7du31+OPPy5Jateunb7//nvNmjVLaWlpXq6d57zzzjt66623NG/ePJ1zzjlat26dhg4dqoSEBJ9qp786duyYevfuLWOMZs6c6e3qeMzatWv1zDPPKDMzUwEBAd6uToVwOBySpGuuuUbDhg2TJLVt21YrV67UrFmz1LVr1zIviyMnpxAbG6ugoCBlZ2e7lGdnZys+Pt5LtaoY9913n/7zn/9o6dKlOuOMM7xdHY9au3at9uzZo/POO0/VqlVTtWrVtHz5cj377LOqVq2aCgoKvF3F01avXj21bNnSpezss892u5e87UaOHOk8etK6dWv17dtXw4YN89kjYoWfM/7wGVQYTLZv367Fixf71FGTFStWaM+ePWrQoIHzM2j79u0aPny4GjZs6O3qeURsbKyqVavmkc8hwskphISEKCkpSUuWLHGWORwOLVmyRJ06dfJizTzHGKP77rtPH3zwgb744gs1atTI21XyuH/84x/67rvvtG7dOuejffv2uuWWW7Ru3ToFBQV5u4qn7YILLigyBPznn3/WmWee6aUaVYzDhw+73PlckoKCgpy/2nxNo0aNFB8f7/IZlJubq//+978+8xkk/R1MNm3apM8//1y1a9f2dpU8qm/fvlq/fr3LZ1BCQoJGjhypRYsWebt6HhESEqIOHTp45HOI0zplkJ6errS0NLVv317JycmaPn268vLyNGDAAG9XzSMGDRqkefPm6aOPPlKNGjWc57Gjo6MVHh7u5dp5Ro0aNYr0oYmIiFDt2rV9pm/NsGHD1LlzZz3++OPq3bu3Vq9erdmzZ2v27NnerppH9ejRQ4899pgaNGigc845R99++62mTZum2267zdtVK7dDhw5p8+bNzr+3bt2qdevWKSYmRg0aNNDQoUP16KOPqlmzZmrUqJHGjh2rhIQE9ezZ03uVdlNpbaxXr5569eqlzMxM/ec//1FBQYHzcygmJkYhISHeqrZbTvU6nhy4goODFR8fr+bNm1d2VcvtVG0cOXKk+vTpo4suukjdunXTwoUL9e9//1vLli1zb0WnPd7HTzz33HOmQYMGJiQkxCQnJ5tvvvnG21XyGEnFPl599VVvV61C+dpQYmOM+fe//21atWplQkNDTYsWLczs2bO9XSWPy83NNUOGDDENGjQwYWFhpnHjxuahhx4yR48e9XbVym3p0qXFvgfT0tKMMX8NJx47dqyJi4szoaGh5h//+IfZuHGjdyvtptLauHXr1hI/h5YuXertqpfZqV7Hk1XFocRlaePLL79smjZtasLCwkybNm3Mhx9+6PZ6AoypwpdVBAAAPoc+JwAAwCqEEwAAYBXCCQAAsArhBAAAWIVwAgAArEI4AQAAViGcAAAAqxBOAACAVQgnAADAKoQTAABgFcIJAACwyv8D6VrRg6cJo38AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('many_unbalanced', 'dpsgd', num_epochs=50, learning_rate=1e-1, l2_norm_clip=1.0, num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "4PvuwKVRPxy3",
        "outputId": "a47272c2-90d5-458c-a031-4786e18199c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dpsgd on many_unbalanced data\n",
            "epochs=50 clip=1.0 ε=1.0 δ=1e-05\n",
            "Estimation = [0.1244318  0.02173599 0.03761424 0.0182004  0.07384571 0.04027335\n",
            " 0.10369678 0.01675482 0.07083497 0.0330266  0.08197539 0.04649788\n",
            " 0.08518316 0.02570162 0.12485266 0.09537463]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Experiment('many_unbalanced', 'dpsgd', num_epochs=50, learning_rate=1e-1, l2_norm_clip=0.5, num_samples=200).run()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "W6Wh-rH7QCJA",
        "outputId": "fd052263-f72c-40fc-8527-6ca31e3345bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dpsgd on many_unbalanced data\n",
            "epochs=50 clip=0.5 ε=1.0 δ=1e-05\n",
            "Estimation = [0.12599061 0.02086442 0.03620606 0.01749259 0.07312071 0.03881756\n",
            " 0.10579664 0.01608775 0.07196794 0.03179027 0.08124515 0.04470989\n",
            " 0.08622168 0.02469707 0.13070653 0.09428503]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAHICAYAAACVqkoXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABLrUlEQVR4nO3deVhUZeM+8HtAGBAElB1EcEUFRUUh91Re0QjT8kXNLSwttVzoa2ruliKaRq6IpbZoapZLaZjxupZLglq+7gvubC8JigrKPL8//M3JkQFmcGAOM/fnuubSOTznnOc5c+ace56zKYQQAkREREQyYWHsChARERE9jeGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSMZubMmVAoFMauRon27t0LhUKBvXv3GrsqVA7q9Ss7O9tg03zxxRfx4osvGmx6xvK867bcv7tU9TGcEBFRpVm+fDnWrl1r7GqQzDGcEBFRpWE4IV0wnBAREZGsMJxQpTh48CDatGkDGxsb1K9fHytXrtRaTqFQ4N1338W6devg7+8PGxsbBAcHY//+/Rrl7t69i3HjxsHPzw9KpRJubm7417/+hdTUVI1yy5YtQ7169WBra4uQkBAcOHBA63kDN27cQO/evWFnZwc3NzeMHz8eBQUFOrfv+PHj6NmzJxwcHGBvb49u3brh8OHDGmXWrl0LhUKB3377DTExMXB1dYWdnR369OmDrKysMufxxhtvwN7eHteuXcPLL78Me3t7eHt7Y9myZQCAv/76C127doWdnR18fX2xfv16jfFzcnLwf//3f2jWrBns7e3h4OCAnj174uTJkxrl1OcjbNq0CXPmzEHt2rVhY2ODbt264eLFi1K5GTNmwMrKSmvdR4wYAScnJzx8+FCn5ffGG2/Az8+v2HBt5zao15GtW7ciMDAQSqUSAQEBSEpK0jrt7OxsREVFwcHBAc7Ozhg7dmyxeq1ZswZdu3aFm5sblEolmjZtihUrVpRZ78LCQkyfPh3BwcFwdHSEnZ0dOnbsiD179miUS0tLg0KhwCeffILExETUr18fSqUSbdq0wR9//FFsumfPnkVUVBRcXV1ha2sLf39/TJkyRaPMzZs3MWzYMLi7u0vLYPXq1cWm9bzrtq7fXV2WoZ+fH/773/9i3759UCgUUCgU0ndR1/WTzIQgqmB//vmnsLW1FXXq1BGxsbHio48+Eu7u7qJ58+bi2VUQgAgMDBQuLi5i9uzZIi4uTvj6+gpbW1vx119/SeVef/11YW1tLWJiYsTnn38u4uLiRGRkpPjmm2+kMsuXLxcARMeOHcXixYtFTEyMqFWrlqhfv77o3LmzVO7+/fuiUaNGwsbGRnzwwQciPj5eBAcHS/Xbs2dPqe07deqUsLOzE56enuKjjz4S8+bNE3Xr1hVKpVIcPnxYKrdmzRoBQLRs2VJ07dpVLFmyRLz//vvC0tJSREVFlbkchw4dKmxsbETTpk3FO++8I5YtWybatWsnAIg1a9YILy8vMWHCBLFkyRIREBAgLC0txeXLl6Xx//jjD1G/fn0xadIksXLlSjF79mzh7e0tHB0dxc2bN6Vye/bskeoZHBwsPv30UzFz5kxRvXp1ERISIpW7cOGCACCWLFmiUc+CggJRs2ZNMWzYsDLb9HTbfH19iw2fMWOG1nUkKChIWt7x8fGiXr16onr16iI7O7vYuM2aNRORkZFi6dKlYtCgQQKAGDx4sMY027RpI9544w3x6aefiiVLloju3bsLAGLp0qUa5Tp37qyx7mRlZQlPT08RExMjVqxYIebPny/8/f2FlZWVOH78uFTuypUr0jJt0KCBiIuLE/PnzxcuLi6idu3aorCwUCp78uRJ4eDgIJydncXkyZPFypUrxQcffCCaNWsmlUlPTxe1a9cWPj4+Yvbs2WLFihWiV69eAoD49NNPpXLPu27r893VZRlu2bJF1K5dWzRu3Fh8/fXX4uuvvxa//PKLEEL39ZPMA8MJVbjevXsLGxsbcfXqVWnY6dOnhaWlpdYdDwBx7NgxadjVq1eFjY2N6NOnjzTM0dFRjB49usR5FhQUCGdnZ9GmTRvx6NEjafjatWsFAI0dTHx8vAAgNm3aJA3Lz88XDRo00GkD3rt3b2FtbS0uXbokDbt165aoUaOG6NSpkzRMHU7CwsKESqWSho8fP15YWlqKO3fulDqfoUOHCgBi7ty50rC///5b2NraCoVCITZs2CANP3v2rAAgZsyYIQ17+PChKCoq0pjmlStXhFKpFLNnz5aGqcNJkyZNREFBgTT8s88+EwA0QmLbtm1FaGioxjR/+OEHnZbbs23TJ5xYW1uLixcvSsNOnjxZLCipx+3Vq5fG+KNGjRIAxMmTJ6Vh9+/fLzbv8PBwUa9ePY1hz4aTx48faywjIZ58Ju7u7hrhTB1OnJ2dRU5OjjR827ZtAoD48ccfpWGdOnUSNWrU0Pi+CCE01pk333xTeHp6aoQxIYTo37+/cHR0lNpjiHVb1++ursswICBAYxmq6bp+knngYR2qUEVFRdi1axd69+6NOnXqSMObNGmC8PBwreO0bdsWwcHB0vs6derglVdewa5du1BUVAQAcHJywpEjR3Dr1i2t0zh27Bj+97//Yfjw4ahWrZo0fODAgahZs6ZG2Z07d8LT0xN9+/aVhlWvXh0jRozQqX2//PILevfujXr16knDPT098frrr+PgwYPIy8vTGGfEiBEahyo6duyIoqIiXL16tcz5AcBbb70l/d/JyQn+/v6ws7NDVFSUNNzf3x9OTk64fPmyNEypVMLCwkKq9//+9z/Y29vD39+/2OEwAIiOjoa1tbVGPQFoTHPIkCE4cuQILl26JA1bt24dfHx80LlzZ53aUx5hYWGoX7++9L558+ZwcHDQqJva6NGjNd6/9957AJ587mq2trbS/3Nzc5GdnY3OnTvj8uXLyM3NLbEelpaW0jJSqVTIycnB48eP0bp1a63LtF+/fhrr37PLNCsrC/v378ewYcM0vi8ApHVGCIHvv/8ekZGREEIgOztbeoWHhyM3N1ea9/Ou2/p8d8u7DNX0XT/JtDGcUIXKysrCgwcP0LBhw2J/8/f31zqOtrKNGjXC/fv3pfMb5s+fj1OnTsHHxwchISGYOXOmxo5JvaNv0KCBxnSqVatW7NyGq1evokGDBsXObSipfs+27/79+1rLNmnSBCqVCtevX9cY/uxOR72z+vvvv8ucn42NDVxdXTWGOTo6onbt2sXq7+joqDFNlUqFTz/9FA0bNoRSqYSLiwtcXV3x559/at156FLPfv36QalUYt26dQCe7JR++uknDBw4sELvg/Fs3dT107YMn12f6tevDwsLC6SlpUnDfvvtN4SFhcHOzg5OTk5wdXXFhx9+CABl7li//PJLNG/eHDY2NnB2doarqyt27NhRrmWqXocDAwNLnF9WVhbu3LmDxMREuLq6aryio6MBAJmZmQCef93W57v7PMsQ0H/9JNPGcEJVUlRUFC5fvowlS5bAy8sLCxYsQEBAAH7++WdjV61MlpaWWocLIco9ri7TnDt3LmJiYtCpUyd888032LVrF3bv3o2AgACoVKpyTbNmzZp4+eWXpXCyefNmFBQUYNCgQWW25WklBRl1T1l56qbrvC5duoRu3bohOzsbixYtwo4dO7B7926MHz8eALQuG7VvvvkGb7zxBurXr48vvvgCSUlJ2L17N7p27VruZVoW9XQHDRqE3bt3a321b99e5+kZwvMsQzV9108ybdXKLkJUfuqrDS5cuFDsb+fOndM6jray58+fR/Xq1TV6DTw9PTFq1CiMGjUKmZmZaNWqFebMmYOePXvC19cXAHDx4kV06dJFGufx48dIS0tD8+bNpWG+vr44deoUhBAaO66S6vds+6pXr6617NmzZ2FhYQEfH58yp1MZNm/ejC5duuCLL77QGH7nzh24uLiUe7pDhgzBK6+8gj/++APr1q1Dy5YtERAQoNc0atasiTt37hQbruuhrtJcuHABdevWld5fvHgRKpVK6kH78ccfUVBQgO3bt2v0bDx7xY02mzdvRr169fDDDz9orDszZswoV13VhwZPnTpVYhlXV1fUqFEDRUVFCAsLK3V6z7tu6/rd1WcZlhREK2r9pKqJPSdUoSwtLREeHo6tW7fi2rVr0vAzZ85g165dWsc5dOiQxjHm69evY9u2bejevTssLS1RVFRUrJvXzc0NXl5e0iWSrVu3hrOzM1atWoXHjx9L5datW1es6/+ll17CrVu3sHnzZmnY/fv3kZiYqFP7unfvjm3btmkcJsjIyMD69evRoUMHODg4lDmdymBpaVnsF/p3332HmzdvPtd0e/bsCRcXF8TFxWHfvn1695oATw615Obm4s8//5SG3b59G1u2bHmuugGQLrVWW7JkCYAn9Qb+6c14etnk5uZizZo1ZU5b27hHjhzBoUOHylVXV1dXdOrUCatXr9b4vjw9D0tLS7z22mv4/vvvtYaYpy/tft51W9fvrj7L0M7OTmsQraj1k6om9pxQhZs1axaSkpLQsWNHjBo1Co8fP8aSJUsQEBCgsTNSCwwMRHh4OMaMGQOlUonly5dL0wGe3OOkdu3a6Nu3L4KCgmBvb49ff/0Vf/zxBxYuXAgAsLa2xsyZM/Hee++ha9euiIqKQlpaGtauXYv69etr/HobPnw4li5diiFDhiAlJQWenp74+uuvUb16dZ3a9/HHH2P37t3o0KEDRo0ahWrVqmHlypUoKCjA/Pnzn3fxGczLL7+M2bNnIzo6Gu3atcNff/2FdevWaZzIWx5WVlbo378/li5dCktLSwwYMEDvafTv3x8TJ05Enz59MGbMGNy/fx8rVqxAo0aNnvtkyCtXrqBXr17o0aMHDh06hG+++Qavv/46goKCAADdu3eHtbU1IiMj8fbbb+PevXtYtWoV3NzccPv27VKn/fLLL+OHH35Anz59EBERgStXriAhIQFNmzbFvXv3ylXfxYsXo0OHDmjVqhVGjBiBunXrIi0tDTt27MCJEycAAPPmzcOePXsQGhqK4cOHo2nTpsjJyUFqaip+/fVX5OTkAHj+dVvX764+yzA4OBgrVqzAxx9/jAYNGsDNzQ1du3atsPWTqigjXCFEZmjfvn0iODhYWFtbi3r16omEhIQSLxMdPXq0+Oabb0TDhg2FUqkULVu21LjksaCgQEyYMEEEBQWJGjVqCDs7OxEUFCSWL19ebL6LFy8Wvr6+QqlUipCQEPHbb7+J4OBg0aNHD41yV69eFb169RLVq1cXLi4uYuzYsSIpKUnnS2JTU1NFeHi4sLe3F9WrVxddunQRv//+u0YZ9aXEf/zxh8Zw9aW7Zc1n6NChws7Ortjwzp07i4CAgGLDfX19RUREhPT+4cOH4v333xeenp7C1tZWtG/fXhw6dKjY5bHq+nz33Xca01NfDrtmzZpi8zp69KgAILp3715qG0rzyy+/iMDAQGFtbS38/f3FN998U+o6oq29Q4cOld6rxz19+rTo27evqFGjhqhZs6Z49913xYMHDzTG3b59u2jevLmwsbERfn5+Ii4uTqxevVoAEFeuXJHKPbusVCqVmDt3rrSOtWzZUvz000/FLo1WL7sFCxYUqzeeueRbiCf3zunTp49wcnISNjY2wt/fX0ybNk2jTEZGhhg9erTw8fERVlZWwsPDQ3Tr1k0kJiZqlHvedVvX766uyzA9PV1ERESIGjVqaFzWr+v6SeZBIYQeZ2IRVTCFQoHRo0dj6dKlFTJ9lUoFV1dXvPrqq1i1alWFzMMcnTx5Ei1atMBXX32FwYMHG7s6RFTF8ZwTMlkPHz4sdgz7q6++Qk5Ojkk89l5OVq1aBXt7e7z66qvGrgoRmQCec0Im6/Dhwxg/fjz+/e9/w9nZGampqfjiiy8QGBiIf//738aunkn48ccfcfr0aSQmJuLdd9+FnZ2dxt/v3btX5rkXrq6uJV5iS0TmieGETJafnx98fHywePFi5OTkoFatWhgyZAjmzZuncedTKr/33nsPGRkZeOmll6QTlp/2ySefaB3+tCtXrmh96B8RmS+ec0JEFeby5ctabyn/tA4dOsDGxqaSakREVQHDCREREckKT4glIiIiWWE4IZMzc+ZMKBQKZGdnG7sqsuHn54c33nhDer93714oFArs3bvXaHUiIioJwwlRBUhLS4NCodD62rBhQ7HyZ86cQY8ePWBvb49atWph8ODBGrchNxUqlQrz589H3bp1YWNjg+bNm+Pbb7/Vady1a9eWuEzT09MruOal++WXX/Dmm28iMDAQlpaW5TrBd/v27WjVqhVsbGxQp04dzJgxQ+PRC6U5ceIEIiMj4e7uDqVSCW9vb/Tr1w8ZGRl610ObOXPmoFevXnB3d4dCocDMmTMNMl1t7ty5gxEjRsDV1RV2dnbo0qWL1rsE+/n5aV0X3nnnnQqrG1UeXq1DVIEGDBiAl156SWNY27ZtNd7fuHEDnTp1gqOjI+bOnYt79+7hk08+wV9//YWjR49WyJVFnTp1woMHDyr9qqUpU6Zg3rx5GD58ONq0aYNt27bh9ddfh0KhQP/+/XWaxuzZszUe5AcATk5OFVBb3a1fvx4bN25Eq1at4OXlpff4P//8M3r37o0XX3wRS5YswV9//YWPP/4YmZmZWLFiRanjCiHQo0cPWFlZISYmBh4eHrh79y5SUlJw69YtuLu7l7dZkqlTp8LDwwMtW7Ys8ZlYhqBSqRAREYGTJ09iwoQJcHFxwfLly/Hiiy8iJSUFDRs21CjfokULvP/++xrDGjVqVGH1o0pkvJvTElUM9a21s7KyjFaH0m5X/qyRI0cKW1tbcfXqVWnY7t27BQCxcuVKg9Tn2Vu7G8ONGzeElZWVxq3nVSqV6Nixo6hdu7Z4/PhxqeOXdPt/Obh586YoLCwUQggRERGhcet6XTRt2lQEBQWJR48eScOmTJkiFAqFOHPmTKnjZmVlCQDinXfe0bveulLffl49r2dvt28oGzduLPbohMzMTOHk5CQGDBigUfbZxzOQaeFhHSqXmzdvYtiwYVI3ckBAAFavXq1RRn1ew8aNG/Hhhx/Cw8MDdnZ26NWrF65fv15smt999x2Cg4Nha2sLFxcXDBo0SOsTSc+ePYuoqCjpke7+/v6YMmVKsXJ37tzBG2+8AScnJzg6OiI6Ohr379/XKKN+YJ+TkxPs7e3h7++PDz/88DmXjqb8/HwUFhaW+Pfvv/8eL7/8ssaj5sPCwtCoUSNs2rSpzOmrVCp89tlnaNasGWxsbODq6ooePXrg2LFjJY6j7ZyTF198EYGBgUhJSUG7du1ga2uLunXrIiEhQbeGlmHbtm149OgRRo0aJQ1TKBQYOXIkbty4odeTfO/evYuioiK95v/3339j1KhR8PHxgVKphIeHB7p164Zz587pNR1tvLy8YGVlVa5xT58+jdOnT2PEiBGoVu2fzuxRo0ZBCKHxRGFt1N+VhIQEhIaGYvr06Th69Gi56lISfQ5THTlyBD169ICjoyOqV6+Ozp0747ffftNp3M2bN8Pd3V3jTsOurq6IiorCtm3bpKeOP62wsBD5+fk614+qBh7WIb1lZGTghRdegEKhwLvvvgtXV1f8/PPPePPNN5GXl4dx48ZplJ8zZw4UCgUmTpyIzMxMxMfHIywsDCdOnICtrS2AJ+cTREdHo02bNoiNjUVGRgY+++wz/Pbbbzh+/LjUbf/nn3+iY8eOsLKywogRI+Dn54dLly7hxx9/xJw5czTmGxUVhbp16yI2Nhapqan4/PPP4ebmhri4OADAf//7X7z88sto3rw5Zs+eDaVSiYsXLxbbkOp6Ym2NGjWgVCo1hs2aNQsTJkyAQqFAcHAw5syZg+7du0t/v3nzJjIzM9G6deti0wsJCcHOnTvLnO+bb76JtWvXomfPnnjrrbfw+PFjHDhwAIcPH9Y63dL8/fffeOmllxAVFYUBAwZg06ZNGDlyJKytrTFs2DCpXHmWyfHjx2FnZ4cmTZpolAkJCZH+3qFDhzKn2aVLF9y7dw/W1tYIDw/HwoULi3X3azN06FAkJSVh9OjRCAwMRF5eHo4fP66xY7t37x4ePnxY5rSsrKzg6OhYZjldHD9+HACKfVZeXl6oXbu29PfSREREIC0tDZMnT0Zqair69u0Lf39/rFu3Dm5ublK551mXdfGf//wHPXv2RHBwMGbMmAELCwusWbMGXbt2xYEDB6TPuiTHjx9Hq1atYGGh+bs5JCQEiYmJOH/+PJo1a6Yxv+rVq6OoqAi+vr4YP348xo4dq3e9SYaM3XVDVc+bb74pPD09RXZ2tsbw/v37C0dHR3H//n0hxD9Pt/X29hZ5eXlSuU2bNgkA4rPPPhNCCFFYWCjc3NxEYGCgxtNif/rpJwFATJ8+XRrWqVMnUaNGDY1DIEI8OTygpj6sM2zYMI0yffr0Ec7OztL7Tz/9VKfDPwB0ej39tN6rV6+K7t27ixUrVojt27eL+Ph4UadOHWFhYSF++uknqdwff/whAIivvvqq2HwnTJggAIiHDx+WWLf//Oc/AoAYM2ZMsb89vUyePayj7UnInTt3FgDEwoULpWEFBQWiRYsWws3NTTpsUd5lEhERIerVq1esnvn5+QKAmDRpUontFOJJl/8bb7whvvzyS7FlyxYxdepU6Um7165dK3VcIYSwt7cXo0aNKrXM0KFDdWpXaU/J1fewzoIFCwQArW1o06aNeOGFF0od//Dhw0KpVGqMn5mZKby9vYs9fbs8n9vTSjuso1KpRMOGDUV4eLjGunf//n1Rt25d8a9//avUdgghhJ2dXbHvrRBC7NixQwAQSUlJ0rDIyEgRFxcntm7dKr744gvRsWNHAUB88MEHZc6H5I89J6QXIQS+//57REVFQQih8UssPDwcGzZsQGpqKtq3by8NHzJkCGrUqCG979u3Lzw9PbFz506MGTMGx44dQ2ZmJmbOnKlxp9CIiAg0btwYO3bswKxZs5CVlYX9+/dj7NixGodAgCeHB5717Fn7HTt2xJYtW5CXlwcHBwepN2bbtm2Ijo4u9mtNbffu3Totm4CAAOn/derUKXbi4ODBg9G0aVO8//77iIiIAAA8ePAAALT+SlUviwcPHpT4K/b777+HQqHAjBkziv1N2zIpS7Vq1fD2229L762trfH2229j5MiRSElJwQsvvACgfMukpHY83c7SREVFISoqSnrfu3dvhIeHo1OnTpgzZ06Zh586duyInTt3Yu/evWjSpAlsbGyK9X588MEHGDRoUJntqlmzZplldFXWOpCXl1fq+B999BHat28PHx8faZirqyvee+89TJo0CdevX5f+Vp7PTVcnTpzAhQsXMHXqVPzvf//T+Fu3bt3w9ddfQ6VSlfg9A/RbR7Zv365RJjo6Gj179sSiRYvw3nvvoXbt2nq3geSD4YT0kpWVhTt37iAxMRGJiYlay2RmZmq8f7bLXaFQoEGDBkhLSwMAXL16FQDg7+9fbFqNGzfGwYMHAUC6DXpgYKBOdX02wKh3KH///TccHBzQr18/fP7553jrrbcwadIkdOvWDa+++ir69u2rsQENCwvTaX5lqVWrFqKjozFv3jzcuHEDtWvXlg5raTuWrj68oC6jzaVLl+Dl5YVatWoZpI5eXl7FHt6nvvohLS1NCiflWSa2trblbmdJOnTogNDQUPz6669llt20aRP+/e9/o0uXLgCAzp07F7vPS9OmTdG0aVO96/E8yloHylouBw4cwGuvvVZsuPrw2enTp6VwYqh1WZsLFy4AeHL4rCS5ubmws7NDTk6OxnD1wx+fZx1RKBQYP348du3ahb179+oUMkm+GE5ILyqVCgAwaNCgEjdCzZs3r8wqlaikJ92K///EBltbW+zfvx979uzBjh07kJSUhI0bN6Jr16745ZdfpPF1vYeGo6NjmTsS9U4iJycHtWvXhqenJwDg9u3bxcrevn0btWrVKtex/4pWnmXi6emJPXv2QAih0aujbnt5LsEFnixTXU5qffvtt3Hs2DEsXLgQTZs2haura7Eyubm5ZfbgAE96lAwVCJ9eB57u/VAPK+s8jYcPH2rdoatPGH76ZGxDrsvPUm8bFixYgBYtWmgtY29vj99++00KiGrqhz96enqW+F0Ayl5Hnv5+UdXGcEJ6cXV1RY0aNVBUVKTzrzD1Lyo1IQQuXrwohRhfX18AwLlz59C1a1eNsufOnZP+Xq9ePQDAqVOnnqsNT7OwsEC3bt3QrVs3LFq0CHPnzsWUKVOwZ88eqX3qnUdZ1qxZo3EXVm3UvT/qHaO3tzdcXV21Xllz9OjREjfyavXr18euXbukpy4/r1u3biE/P1+j9+T8+fMANK/YKM8yadGiBT7//HOcOXNGo3fiyJEj0t/L4/Lly1qDxtPOnDmD9evX46uvvsLgwYNLLDd27Fh8+eWXZc5TW69LeanbfezYMY0gcuvWLdy4cQMjRowodXwfHx+cPXu22PAzZ84AgMbhDUOuy8+qX78+AMDBwaHUbUNQUFCxw0seHh4AniyLAwcOFDv8c+TIEVSvXr3Me5g8+/2iqovhhPRiaWmJ1157DevXr8epU6eKHWLJysoqtmH46quvMHnyZOm8k82bN+P27duYOHEigCdXKbi5uSEhIQHDhg2Tegp+/vlnnDlzBtOnTwfwZIPTqVMnrF69GjExMRqHbZ79Na4LbTt09Y7i6V+i5TlOr2053Lx5E6tXr0bz5s01dhKvvfYavvzyS41zA5KTk3H+/HmMHz++1Hm+9tprWLZsGWbNmoXPPvtM42/lWSaPHz/GypUrERMTA+DJr+6VK1fC1dUVwcHBUrnyLJNXXnkF48ePx/Lly7F06VKpjgkJCfD29ka7du2ksrdv30Zubi7q168vXaKrbZnu3LkTKSkpGDNmTKn1UB8WePZciGdV9Dknjx49wqVLl+Do6CitAwEBAWjcuDESExPx9ttvSz12K1asgEKhQN++fUud5ksvvYQlS5Zg37596Ny5M4Anl1onJibC29tboyezIs85CQ4ORv369fHJJ5/g9ddfh729vcbf1Z9fzZo1Swwvffv2xebNm/HDDz9I7c7OzsZ3332HyMhIaduQk5MDR0dHjd7RR48eYd68ebC2ti7WM0NVD8MJ6W3evHnYs2cPQkNDMXz4cDRt2hQ5OTlITU3Fr7/+WqxLtVatWujQoQOio6ORkZGB+Ph4NGjQAMOHDwfw5LLMuLg4REdHo3PnzhgwYIB0KbGfn5/GDnrx4sXo0KEDWrVqhREjRqBu3bpIS0vDjh07cOLECb3aMXv2bOzfvx8RERHw9fVFZmYmli9fjtq1a2tc0lqe4/QffPABLl26hG7dusHLywtpaWlYuXIl8vPzi4WIDz/8EN999x26dOmCsWPH4t69e1iwYAGaNWuG6OjoUufTpUsXDB48GIsXL8aFCxfQo0cPqFQqHDhwAF26dMG7776rV729vLwQFxeHtLQ0NGrUCBs3bsSJEyeQmJiocR+P8iyT2rVrY9y4cViwYAEePXqENm3aYOvWrThw4ADWrVunsaOZPHkyvvzyS6m7HwDatWuHli1bonXr1nB0dERqaipWr14NHx+fMu9NExQUhGbNmmHSpEk4f/48WrZsifv37+PkyZMIDAyUwlh5zzn5888/pRM0L168iNzcXHz88cfSvCMjIwE8CahNmjTB0KFDsXbtWmn8BQsWoFevXujevTv69++PU6dOYenSpXjrrbeKXXr9rMmTJ2Pjxo2IjIzEmDFj4OzsjLVr1+LatWv49ttvNZZrec85+frrr3H16lXpPkH79++X2jd48GD4+vrCwsICn3/+OXr27ImAgABER0fD29sbN2/exJ49e+Dg4IAff/yx1Pn07dsXL7zwAqKjo3H69GnpDrFFRUWYNWuWVG779u34+OOP0bdvX9StWxc5OTnSD6a5c+dKPTFUhRnvQiGqyjIyMsTo0aOFj4+PsLKyEh4eHqJbt24iMTFRKqO+XPXbb78VkydPFm5ubsLW1lZEREQUuxRYiCeXirZs2VIolUpRq1YtMXDgQHHjxo1i5U6dOiX69OkjnJychI2NjfD39xfTpk2T/l7SHWLVdxhV3+0yOTlZvPLKK8LLy0tYW1sLLy8vMWDAAHH+/PnnXj7r168XnTp1Eq6urqJatWrCxcVF9OnTR6SkpGgtf+rUKdG9e3dRvXp14eTkJAYOHCjS09N1mtfjx4/FggULROPGjYW1tbVwdXUVPXv21JiXrpcSBwQEiGPHjom2bdsKGxsb4evrK5YuXVquZaBNUVGRmDt3rvD19RXW1tYiICBAfPPNN8XKqS/pVX9WQjy5Y2qLFi2Eo6OjsLKyEnXq1BEjR47UeTllZWWJ999/XzRs2FDY2toKJycn0b59e/Hzzz8/d7vU65a219PLXX3nYG13692yZYto0aKFUCqVonbt2mLq1Kkal2+X5uLFi+K1114Tjo6OQqlUitatW4utW7c+d7vU1JeZa3s9vQ4JIcTx48fFq6++KpydnYVSqRS+vr4iKipKJCcn6zSvnJwc8eabbwpnZ2dRvXp10blz52J3BT527JiIjIwU3t7ewtraWtjb24sOHTqITZs2GarJZGQKIf7/2YFEBrZ371506dIF3333XZld02R8L774IrKzsw16Tg8RUXnw9vVEREQkKwwnREREJCsMJ0RERCQreoeT/fv3IzIyEl5eXlAoFNi6dWuZ4+zduxetWrWCUqlEgwYNNM5SJ9P14osvQgjB802qiL179/J8EyKSBb3DSX5+PoKCgrBs2TKdyl+5cgURERHo0qULTpw4gXHjxuGtt94q9twRIiIiIgB4rqt1FAoFtmzZgt69e5dYZuLEidixY4fGL7L+/fvjzp07SEpKKu+siYiIyERV+E3YDh06VOzGP+Hh4Rg3blyJ4xQUFGjcoVOlUiEnJwfOzs7letIqERERVT4hBO7evQsvL69Sn0j9rAoPJ+np6XB3d9cY5u7ujry8PDx48EDrw6ViY2M17gZIREREVdf169c1nvNUFlnevn7y5MnS7aSBJ08KrVOnDq5fvw4HBwcj1oyIiIh0lZeXBx8fH+nZarqq8HDi4eGBjIwMjWEZGRlwcHAo8ZHcSqVS62PiHRwcGE6IiIiqGH1Pyajw+5y0bdsWycnJGsN2796Ntm3bVvSsiYiIqArSO5zcu3cPJ06ckJ4Ae+XKFZw4cQLXrl0D8OSQzJAhQ6Ty77zzDi5fvowPPvgAZ8+exfLly7Fp06YyHwVPRERE5knvcHLs2DG0bNkSLVu2BADExMSgZcuWmD59OgDg9u3bUlABgLp162LHjh3YvXs3goKCsHDhQnz++ecIDw83UBOIiIjIlFSJpxLn5eXB0dERubm5POeEiIioiijv/pvP1iEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIllhOCEiIiJZYTghIiIiWWE4ISIiIlkpVzhZtmwZ/Pz8YGNjg9DQUBw9erTU8vHx8fD394etrS18fHwwfvx4PHz4sFwVJiIiItOmdzjZuHEjYmJiMGPGDKSmpiIoKAjh4eHIzMzUWn79+vWYNGkSZsyYgTNnzuCLL77Axo0b8eGHHz535YmIiMj06B1OFi1ahOHDhyM6OhpNmzZFQkICqlevjtWrV2st//vvv6N9+/Z4/fXX4efnh+7du2PAgAFl9rYQERGRedIrnBQWFiIlJQVhYWH/TMDCAmFhYTh06JDWcdq1a4eUlBQpjFy+fBk7d+7ESy+9VOJ8CgoKkJeXp/EiIiIi81BNn8LZ2dkoKiqCu7u7xnB3d3ecPXtW6zivv/46srOz0aFDBwgh8PjxY7zzzjulHtaJjY3FrFmz9KkaERERmYgKv1pn7969mDt3LpYvX47U1FT88MMP2LFjBz766KMSx5k8eTJyc3Ol1/Xr1yu6mkRERCQTevWcuLi4wNLSEhkZGRrDMzIy4OHhoXWcadOmYfDgwXjrrbcAAM2aNUN+fj5GjBiBKVOmwMKieD5SKpVQKpX6VI2IiIhMhF49J9bW1ggODkZycrI0TKVSITk5GW3bttU6zv3794sFEEtLSwCAEELf+hIREZGJ06vnBABiYmIwdOhQtG7dGiEhIYiPj0d+fj6io6MBAEOGDIG3tzdiY2MBAJGRkVi0aBFatmyJ0NBQXLx4EdOmTUNkZKQUUoiIiIjU9A4n/fr1Q1ZWFqZPn4709HS0aNECSUlJ0kmy165d0+gpmTp1KhQKBaZOnYqbN2/C1dUVkZGRmDNnjuFaQURERCZDIarAsZW8vDw4OjoiNzcXDg4Oxq4OERER6aC8+28+W4eIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSF4YSIiIhkheGEiIiIZIXhhIiIiGSlXOFk2bJl8PPzg42NDUJDQ3H06NFSy9+5cwejR4+Gp6cnlEolGjVqhJ07d5arwkRERGTaquk7wsaNGxETE4OEhASEhoYiPj4e4eHhOHfuHNzc3IqVLywsxL/+9S+4ublh8+bN8Pb2xtWrV+Hk5GSI+hMREZGJUQghhD4jhIaGok2bNli6dCkAQKVSwcfHB++99x4mTZpUrHxCQgIWLFiAs2fPwsrKqlyVzMvLg6OjI3Jzc+Hg4FCuaRAREVHlKu/+W6/DOoWFhUhJSUFYWNg/E7CwQFhYGA4dOqR1nO3bt6Nt27YYPXo03N3dERgYiLlz56KoqKjE+RQUFCAvL0/jRUREROZBr3CSnZ2NoqIiuLu7awx3d3dHenq61nEuX76MzZs3o6ioCDt37sS0adOwcOFCfPzxxyXOJzY2Fo6OjtLLx8dHn2oSERFRFVbhV+uoVCq4ubkhMTERwcHB6NevH6ZMmYKEhIQSx5k8eTJyc3Ol1/Xr1yu6mkRERCQTep0Q6+LiAktLS2RkZGgMz8jIgIeHh9ZxPD09YWVlBUtLS2lYkyZNkJ6ejsLCQlhbWxcbR6lUQqlU6lM1IiIiMhF69ZxYW1sjODgYycnJ0jCVSoXk5GS0bdtW6zjt27fHxYsXoVKppGHnz5+Hp6en1mBCRERE5k3vwzoxMTFYtWoVvvzyS5w5cwYjR45Efn4+oqOjAQBDhgzB5MmTpfIjR45ETk4Oxo4di/Pnz2PHjh2YO3cuRo8ebbhWEBERkcnQ+z4n/fr1Q1ZWFqZPn4709HS0aNECSUlJ0kmy165dg4XFP5nHx8cHu3btwvjx49G8eXN4e3tj7NixmDhxouFaQURERCZD7/ucGAPvc0JERFT1VMp9ToiIiIgqGsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREclKucLJsmXL4OfnBxsbG4SGhuLo0aM6jbdhwwYoFAr07t27PLMlIiIiM6B3ONm4cSNiYmIwY8YMpKamIigoCOHh4cjMzCx1vLS0NPzf//0fOnbsWO7KEhERkenTO5wsWrQIw4cPR3R0NJo2bYqEhARUr14dq1evLnGcoqIiDBw4ELNmzUK9evXKnEdBQQHy8vI0XkRERGQe9AonhYWFSElJQVhY2D8TsLBAWFgYDh06VOJ4s2fPhpubG958802d5hMbGwtHR0fp5ePjo081iYiIqArTK5xkZ2ejqKgI7u7uGsPd3d2Rnp6udZyDBw/iiy++wKpVq3Sez+TJk5Gbmyu9rl+/rk81iYiIqAqrVpETv3v3LgYPHoxVq1bBxcVF5/GUSiWUSmUF1oyIiIjkSq9w4uLiAktLS2RkZGgMz8jIgIeHR7Hyly5dQlpaGiIjI6VhKpXqyYyrVcO5c+dQv3798tSbiIiITJReh3Wsra0RHByM5ORkaZhKpUJycjLatm1brHzjxo3x119/4cSJE9KrV69e6NKlC06cOMFzSYiIiKgYvQ/rxMTEYOjQoWjdujVCQkIQHx+P/Px8REdHAwCGDBkCb29vxMbGwsbGBoGBgRrjOzk5AUCx4URERERAOcJJv379kJWVhenTpyM9PR0tWrRAUlKSdJLstWvXYGHBG88SERFR+SiEEMLYlShLXl4eHB0dkZubCwcHB2NXh4iIiHRQ3v03uziIiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWGE6IiIhIVhhOiIiISFYYToiIiEhWyhVOli1bBj8/P9jY2CA0NBRHjx4tseyqVavQsWNH1KxZEzVr1kRYWFip5YmIiMi8VdN3hI0bNyImJgYJCQkIDQ1FfHw8wsPDce7cObi5uRUrv3fvXgwYMADt2rWDjY0N4uLi0L17d/z3v/+Ft7e3QRpBRERUGW7fvo3bt29X2vw8PT3h6elZafOTC4UQQugzQmhoKNq0aYOlS5cCAFQqFXx8fPDee+9h0qRJZY5fVFSEmjVrYunSpRgyZIjWMgUFBSgoKJDe5+XlwcfHB7m5uXBwcNCnukRERAYzc+ZMzJo1q9LmN2PGDMycObPS5mdoeXl5cHR01Hv/rVfPSWFhIVJSUjB58mRpmIWFBcLCwnDo0CGdpnH//n08evQItWrVKrFMbGxspX74REREunj77bfRq1cvncs/ePAAHTp0AAAcPHgQtra2es3PHHtNAD3DSXZ2NoqKiuDu7q4x3N3dHWfPntVpGhMnToSXlxfCwsJKLDN58mTExMRI79U9J0RERMak72GW/Px86f8tWrSAnZ1dRVTL5Oh9zsnzmDdvHjZs2IC9e/fCxsamxHJKpRJKpbISa0ZERERyoVc4cXFxgaWlJTIyMjSGZ2RkwMPDo9RxP/nkE8ybNw+//vormjdvrn9NiYiIyCzodSmxtbU1goODkZycLA1TqVRITk5G27ZtSxxv/vz5+Oijj5CUlITWrVuXv7ZERERk8vQ+rBMTE4OhQ4eidevWCAkJQXx8PPLz8xEdHQ0AGDJkCLy9vREbGwsAiIuLw/Tp07F+/Xr4+fkhPT0dAGBvbw97e3sDNoWIiIhMgd7hpF+/fsjKysL06dORnp6OFi1aICkpSTpJ9tq1a7Cw+KdDZsWKFSgsLETfvn01plPVL48iIiKiiqH3fU6MobzXSRMRERlTfn6+dJTg3r17Zne1Tnn333y2DhEREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyQrDCREREckKwwkRERHJCsMJERERyYret68nIjK027dv4/bt25U2P09PT3h6elba/IhIPwwnRGR0K1euxKxZsyptfny2F5G8mW044S81qirMYV19++230atXL53LP3jwAB06dAAAHDx4ELa2tnrNj99FInkz23DCX2pUVZjDuqpvIMrPz5f+36JFC7N7mBqRqTPbpxLr+2vUEL/U+GuNyoPranHm/qRXqjrMfV0t7/7bbHtO+EuNqgquq1RVmMMhSL2piv75f9pvQJNugIWl8epTRZhtOCEiIsMyh0OQejm9Hdg24Z/36/oCLt5Ajzigqe7nWJkjhhMiIjIIntj8lNPbgU1DgEKV5vC820+GR33FgFIKhhMiIjIIHoL8/1RFQNJEANpO6RQAFEDSJKBxBA/xlIDhhIiIqBz8Ju3QOvwFi9PYYH2rlDEFkHcT/acuwmFVU60l0uZFGKCGVRdvX09ERGRAbrhj0HLmiD0nRESVgFeymI9MOBm0nDliOKEqjRt8qip4JYv5OKpqjFuiFjyQo/XvKgGkwxlHVY0ruWZVB8MJVWnc4FNVwStZzIcKFpj1aAhWWMVD9cw5ser3sx4NhopnVpSI4YSqNG7wqarglSzmZZcqBCMfjcMErAVwVxqeDmfMejQYu1QhOk/LHHuIGU5MmDms0NzgE5Fc7VKFYFdhIIAoAMDQwolIVTXXu8fEHHuIGU5MmDmu0EREcvJ0EDmqagyLchzKMcceYoYTE2aOKzQRkakxxx5ihhMTZo4rNBERVX08VZjI1Dz7FNSn35sKc2gjkRljz4mu+NhrqgrM4Smo5tBGAzGHk+LJNDGc6IIbQ6oKzOEpqObQRgPiSfFUVTGclIUbQ6oKzOEpqObQRgOT/Unx7JGmEph9OCnpqZIAYAEVDirHwqOEjaFKAOkbx6FDgULrdevm/lRJqkRXfwfyyn4KKq7+DtTtWGnVMihzaKOByfqkePZIUynMPpyUJsTiLLwU2p+NAAAWCsAL/0OIxdkSH3tNpsWYx/BLC9K9LH7HYuuypzdmVRK2q/KKDZdTkC6pnabURrPHHmkqA8NJKfjYa3qWXI/hm8NTUM2hjWaBh+dIBwwnpTDkxpBnzZsGuR7DN4enoJpDG01JST1gL1icxgbrsg/P9Z+6qMQe6ad7wbhtNU0MJ6Uw5MZQrr+4ST9yPYZvDk9BNXQbuVMzDkP3SHPbapoYTkphyI2hXH9xk+kw5FNQ5cqQbeROzTgMfXiO21bTxHBSBkNtDOX6i5tMi6Gegipnhmojd2rGYejDc5W9bb19+zZSU1MBAAXpF8ssLx4VSv8vzLgMhZUOZ3UD0jzK1eNmApdoM5zowBw2+IbAbnJ5MMRTUOXOEG2U/Q8GE9jBaFPVD0E+T49bxvoPdC4b/OWTf/XucTORS7QZTnRkDhv851UluslNdINPJsZEdjAlqcqHIJ/ucYtYfKDC5rNjzJN79ej1A8yELtFmOKF/POeOW/bd5Ca+wScTYUI7mNJU1R7pp3vclB4V11PcqlUr/UYwsUu0GU7oCQPsuGXdTW4mG3xD4OG5ilfSZbbmdldq9kgbkIndQZnhhEx/x21ivygqWpU4PGeieFdqKo253CUaYDghE9lxl/alfd6bPsntS1vRZH94zoTxrtRUXqZ2B2WGE3NnYl2B2nCDrx9ZH54zcUbfwfCE8SrL1O6gzHBiBsypK1Abo2/wiXRk1B0MTxiv0qr6JdrPqhq1pApjDjtu9Qb/2S+smkoAt0TV+UVBpku9gwFQuTsY9Xlnd585EVp93tnp7YadnzE92zv09PsqTn2JdgZqagxPhzNGPhon60u0n8VwYubMYcdttA0+YNIbQrNTSZ9lpe9gyjzvDE/OOzOFdff0dmBpm3/er+sLxAeaVPjapQpBWMEn0vuhhRPRoeCzKhVMAB7Wka9KOvZral2BJTHKTZ8M1E2uvrRXl1tlA+W7Xbb6VtmAcS7tffry5Yq6JfhztbGSD3kY+h4gPGEcpn9V4lNM4RJtsw0nst7gG2FDaJS7NVbyyXeVetMnA24IK+N22epbZQPGubRX1m000k6tsnYwZnHCuIlclWhOzDacyHZjaKQNYaXfrdFIJ99VygbfwBtC9aW9lXGrbKAcl/YaIGRWxi3By9VGM9ipmcp5Z+wdMi1mG05kucE38oaw0roCTaR7taSN4fNuCAHNjaG6101Wt8pWM1DIrIxbgpfURnPfqZnaJajamEXvkIkx23Aiyw2+GdxzxNgBrDKYzYbQREJmaczhszTkeWeVce4Q8M8hc10Pl5tK75A5MdtwYkwl/VJ73nuOAPL5pVZZvQpyZBYbQjMImYCZfJYw3HlnlXG4HPjnkLmuh8vNoXfI1DCcyIg5bAjN4ZeoKW0IzTlkAqb1WZbFEOedVca5Q8A/h8x1PXeoql+VKOsLOCoIw4mMmMOG0BwCWFXfEOrCHEImYB6f5dOe97yzyjh3CCjfOVJGuyrRAGR7AUcFYjiREUNvCOWYtg0dwOTYRqBqbwh1YQ4hU81Qn6Xs7+ViBir9qkQDkeUFHBWM4URmDLlTk2PaNnQAk2Mb1arqhlAX5tDL9zRDfJZyXlfNSVW8QZksL+CoYAwnMmSonZpc07YhA5hc26hWFTeEujC3wx3A83+WxriXi1x7FonKwnAiU4bYqck5bRsqgMm5jaauqh+6MsaOW70uVda9XGbOnGnyvTUMYKaJ4aSSyPX6f0N6njYevG0NhdVlneZTVdtYVT5HfVTlQ1fmcJhF7j2LhmAOn6M5Klc4WbZsGRYsWID09HQEBQVhyZIlCAkp+VfSd999h2nTpiEtLQ0NGzZEXFwcXnrppXJXuiqS6/X/hsQ2lq6qtNEcQiZgHjtuc+hZNIfP0RzpHU42btyImJgYJCQkIDQ0FPHx8QgPD8e5c+fg5uZWrPzvv/+OAQMGIDY2Fi+//DLWr1+P3r17IzU1FYGBgQZpRFUg1+v/DYltNBxjttEcAhhgHjtuc8DP0TTpHU4WLVqE4cOHIzo6GgCQkJCAHTt2YPXq1Zg0aVKx8p999hl69OiBCROePH/jo48+wu7du7F06VIkJCQ8Z/WrDjlf/28obKPhGLON5hDAiEje9AonhYWFSElJweTJk6VhFhYWCAsLw6FDh7SOc+jQIcTExGgMCw8Px9atW0ucT0FBAQoKCqT3ubm5AIC8PO23bH8eqoL7Bp+mWkn1rex5so2Gn58x5llZ87Ozs0ODBg0AAFY1L1XYPNXzeHb+FdVOuXyOFTlPc2hjSfNkGw0/P0NOVwhtj7oohdDDzZs3BQDx+++/awyfMGGCCAkJ0TqOlZWVWL9+vcawZcuWCTc3txLnM2PGDIEnD+jgiy+++OKLL76q+Ov69ev6xA0hy6t1Jk+erNHbolKpkJOTA2dnZygUCqPVKy8vDz4+Prh+/TocHByMVo+KxDaaBrbRNLCNpsGc2yiEwN27d+Hl5aXX9PQKJy4uLrC0tERGRobG8IyMDHh4eGgdx8PDQ6/yAKBUKqFUKjWGOTk56VPVCuXg4GCyK5ga22ga2EbTwDaaBnNto6Ojo97T0etmBNbW1ggODkZycrI0TKVSITk5GW3bttU6Ttu2bTXKA8Du3btLLE9ERETmTe/DOjExMRg6dChat26NkJAQxMfHIz8/X7p6Z8iQIfD29kZsbCwAYOzYsejcuTMWLlyIiIgIbNiwAceOHUNiYqJhW0JEREQmQe9w0q9fP2RlZWH69OlIT09HixYtkJSUBHd3dwDAtWvXYGHxT4dMu3btsH79ekydOhUffvghGjZsiK1bt1bJe5wolUrMmDGj2CEnU8I2mga20TSwjaaBbdSfQgh9r+8hIiIiqjjyfwAGERERmRWGEyIiIpIVhhMiIiKSFYYTIiIikhWGEyIiIpIVhhMdLVu2DH5+frCxsUFoaCiOHj1q7CoZTGxsLNq0aYMaNWrAzc0NvXv3xrlz54xdrQo1b948KBQKjBs3zthVMaibN29i0KBBcHZ2hq2tLZo1a4Zjx44Zu1oGVVRUhGnTpqFu3bqwtbVF/fr18dFHH+n/YDEZ2b9/PyIjI+Hl5QWFQlHswahCCEyfPh2enp6wtbVFWFgYLly4YJzKllNpbXz06BEmTpyIZs2awc7ODl5eXhgyZAhu3bplvAqXQ1mf49PeeecdKBQKxMfHV1r9DEGXNp45cwa9evWCo6Mj7Ozs0KZNG1y7dk2v+TCc6GDjxo2IiYnBjBkzkJqaiqCgIISHhyMzM9PYVTOIffv2YfTo0Th8+DB2796NR48eoXv37sjPzzd21SrEH3/8gZUrV6J58+bGropB/f3332jfvj2srKzw888/4/Tp01i4cCFq1qxp7KoZVFxcHFasWIGlS5fizJkziIuLw/z587FkyRJjV63c8vPzERQUhGXLlmn9+/z587F48WIkJCTgyJEjsLOzQ3h4OB4+fFjJNS2/0tp4//59pKamYtq0aUhNTcUPP/yAc+fOoVevXkaoafmV9TmqbdmyBYcPH9b7eTNyUFYbL126hA4dOqBx48bYu3cv/vzzT0ybNg02Njb6zUivxwSaqZCQEDF69GjpfVFRkfDy8hKxsbFGrFXFyczMFADEvn37jF0Vg7t7965o2LCh2L17t+jcubMYO3assatkMBMnThQdOnQwdjUqXEREhBg2bJjGsFdffVUMHDjQSDUyLABiy5Yt0nuVSiU8PDzEggULpGF37twRSqVSfPvtt0ao4fN7to3aHD16VAAQV69erZxKGVhJbbxx44bw9vYWp06dEr6+vuLTTz+t9LoZirY29uvXTwwaNOi5p82ekzIUFhYiJSUFYWFh0jALCwuEhYXh0KFDRqxZxcnNzQUA1KpVy8g1MbzRo0cjIiJC4/M0Fdu3b0fr1q3x73//G25ubmjZsiVWrVpl7GoZXLt27ZCcnIzz588DAE6ePImDBw+iZ8+eRq5Zxbhy5QrS09M11llHR0eEhoaa7DYIeLIdUigUsnro6/NSqVQYPHgwJkyYgICAAGNXx+BUKhV27NiBRo0aITw8HG5ubggNDS318FZJGE7KkJ2djaKiIun2/Gru7u5IT083Uq0qjkqlwrhx49C+ffsq+YiB0mzYsAGpqanSc59MzeXLl7FixQo0bNgQu3btwsiRIzFmzBh8+eWXxq6aQU2aNAn9+/dH48aNYWVlhZYtW2LcuHEYOHCgsatWIdTbGXPZBgHAw4cPMXHiRAwYMMCknuIbFxeHatWqYcyYMcauSoXIzMzEvXv3MG/ePPTo0QO//PIL+vTpg1dffRX79u3Ta1p6P1uHTNvo0aNx6tQpHDx40NhVMajr169j7Nix2L17t/7HPqsIlUqF1q1bY+7cuQCAli1b4tSpU0hISMDQoUONXDvD2bRpE9atW4f169cjICAAJ06cwLhx4+Dl5WVS7TRXjx49QlRUFIQQWLFihbGrYzApKSn47LPPkJqaCoVCYezqVAiVSgUAeOWVVzB+/HgAQIsWLfD7778jISEBnTt31nla7Dkpg4uLCywtLZGRkaExPCMjAx4eHkaqVcV499138dNPP2HPnj2oXbu2satjUCkpKcjMzESrVq1QrVo1VKtWDfv27cPixYtRrVo1FBUVGbuKz83T0xNNmzbVGNakSRO9z5KXuwkTJki9J82aNcPgwYMxfvx4k+0RU29nzGEbpA4mV69exe7du02q1+TAgQPIzMxEnTp1pG3Q1atX8f7778PPz8/Y1TMIFxcXVKtWzSDbIYaTMlhbWyM4OBjJycnSMJVKheTkZLRt29aINTMcIQTeffddbNmyBf/5z39Qt25dY1fJ4Lp164a//voLJ06ckF6tW7fGwIEDceLECVhaWhq7is+tffv2xS4BP3/+PHx9fY1Uo4px//59jSefA4ClpaX0q83U1K1bFx4eHhrboLy8PBw5csRktkHAP8HkwoUL+PXXX+Hs7GzsKhnU4MGD8eeff2psg7y8vDBhwgTs2rXL2NUzCGtra7Rp08Yg2yEe1tFBTEwMhg4ditatWyMkJATx8fHIz89HdHS0satmEKNHj8b69euxbds21KhRQzqO7ejoCFtbWyPXzjBq1KhR7BwaOzs7ODs7m8y5NePHj0e7du0wd+5cREVF4ejRo0hMTERiYqKxq2ZQkZGRmDNnDurUqYOAgAAcP34cixYtwrBhw4xdtXK7d+8eLl68KL2/cuUKTpw4gVq1aqFOnToYN24cPv74YzRs2BB169bFtGnT4OXlhd69exuv0noqrY2enp7o27cvUlNT8dNPP6GoqEjaDtWqVQvW1tbGqrZeyvocnw1cVlZW8PDwgL+/f2VXtdzKauOECRPQr18/dOrUCV26dEFSUhJ+/PFH7N27V78ZPff1PmZiyZIlok6dOsLa2lqEhISIw4cPG7tKBgNA62vNmjXGrlqFMrVLiYUQ4scffxSBgYFCqVSKxo0bi8TERGNXyeDy8vLE2LFjRZ06dYSNjY2oV6+emDJliigoKDB21cptz549Wr+DQ4cOFUI8uZx42rRpwt3dXSiVStGtWzdx7tw541ZaT6W18cqVKyVuh/bs2WPsquusrM/xWVXxUmJd2vjFF1+IBg0aCBsbGxEUFCS2bt2q93wUQlTh2yoSERGRyeE5J0RERCQrDCdEREQkKwwnREREJCsMJ0RERCQrDCdEREQkKwwnREREJCsMJ0RERCQrDCdEREQkKwwnREREJCsMJ0RERCQrDCdEREQkK/8Pg4GboqICiD4AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "These experiments show that a relatively small clipping will not bias the estimates too much. It will not reduce the noise either, nor have an impact on the convergence, since we compensate the small clipping by a larger learning-rate.\n",
        "\n",
        "## Conclusion\n",
        "\n",
        "This post is a simple demonstration of how powerful it is to use [JAX](https://jax.readthedocs.io/en/latest/index.html) based DP-SGD along with the [dp-accounting](https://github.com/google/differential-privacy/tree/main/python) library to estimate complex models with DP.\n",
        "\n",
        "Along the way we get to discover some of the problems one is commonly faced with when tuning the clipping threshold of a DP-SGD. The topic of gradient clipping in DP-SGD has been recently studied in papers such as [Chen et al. 2020](https://proceedings.neurips.cc/paper/2020/file/9ecff5455677b38d19f49ce658ef0608-Paper.pdf).\n",
        "\n",
        "Overall, once well tuned, DP-SGD performs reasonably well compared to the specialized histogram query mechanism, which is rather noticeable considering the generality of this mechanism.\n",
        "\n",
        "At [Sarus Technologies](https://www.sarus.tech/) we use [JAX](https://jax.readthedocs.io/en/latest/index.html) and DP-SGD to train our [synthetic data generator model](https://arxiv.org/pdf/2202.02145.pdf) with DP. Thanks to the modularity of our generative model (see [Canale et al. 2022](https://arxiv.org/pdf/2202.02145.pdf)) and the flexibility of JAX, we provide unique guarantees on the market such as user-level Differential Privacy where a same user can have many rows from different tables."
      ],
      "metadata": {
        "id": "SDpqjciz6-xR"
      }
    }
  ]
}