tutorials/bope.ipynb

{
  "metadata": {
    "dataExplorerConfig": {},
    "kernelspec": {
      "display_name": "python3",
      "language": "python",
      "name": "python3",
      "metadata": {
        "is_prebuilt": false,
        "kernel_name": "ae_local",
        "cinder_runtime": false
      }
    },
    "last_server_session_id": "2cd152fe-4c86-4926-93c2-26f4f744e773",
    "last_kernel_id": "ebea52b3-26f7-4a26-a267-f127723b8267",
    "last_base_url": "https://devvm8344.prn0.facebook.com:8090/",
    "last_msg_id": "41b90a1f-87ec9c5c617f30a028c3d2ed_49",
    "captumWidgetMessage": {},
    "outputWidgetContext": {}
  },
  "nbformat": 4,
  "nbformat_minor": 2,
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "6778d143-3808-45b3-bcbe-da7c7475280a",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "# Bayesian Optimization with Preference Exploration\n",
        "\n",
        "In this tutorial, we demonstrate how to implement a closed loop of Bayesian optimization with preference exploration, or BOPE [1].\n",
        "BOPE is designed for Bayesian optimization of expensive-to-evaluate experiments,\n",
        "where the response surface function of the experiment $f_\\mathrm{true}$ generates vector-valued outcomes over which a decision-maker (DM) has preferences.\n",
        "These preferences are encoded by a utility function $g_\\mathrm{true}$ that is not known in closed form but can be estimated by\n",
        "asking the DM to express preferences over pairs of outcome vectors.\n",
        "\n",
        "In other words, with BOPE, we wish to solve the following optimization problem:\n",
        "\n",
        "$$\n",
        " \\max_{x \\in \\mathcal{X}} g_\\mathrm{true}(f_\\mathrm{true}(x))\n",
        "$$\n",
        "\n",
        "Unlike many other Bayesian optimization setups where multiple consecutive batches of experiments are performed,\n",
        "in BOPE, we alternate between two stages: *preference exploration* and *experimentation*.\n",
        "\n",
        "In the preference exploration stage, we use an acquisition function (i.e., a preference exploratoin strategy, or PE strategy)\n",
        "to adaptively generate pairs of hypothetical outcome and ask the decision-maker’s preference within each pair.\n",
        "In the experimentation stage, we use a batch version of noisy expected improvement that integrates over our uncertainty in the\n",
        "utility function called $\\text{qNEIUU}$ to generate experimental candidates for evaluation.\n",
        "\n",
        "\n",
        "[1] [Z.J. Lin, R. Astudillo, P.I. Frazier, and E. Bakshy, Preference Exploration for Efficient Bayesian Optimization with Multiple Outcomes. AISTATS, 2022.](https://arxiv.org/abs/2203.11382)"
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": false,
        "originalKey": "478e5c4b-1157-442a-b4d4-737dee1b1efd",
        "code_folding": [],
        "hidden_ranges": [],
        "requestMsgId": "6b6a9507-5a7f-42bb-8663-130c58a67976",
        "executionStartTime": 1652334021849,
        "executionStopTime": 1652334027816,
        "customOutput": null
      },
      "source": [
        "import os\n",
        "import warnings\n",
        "\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pylab as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "from botorch.acquisition import GenericMCObjective, LearnedObjective\n",
        "from botorch.acquisition.monte_carlo import qNoisyExpectedImprovement, qSimpleRegret\n",
        "from botorch.acquisition.preference import AnalyticExpectedUtilityOfBestOption\n",
        "from botorch.fit import fit_gpytorch_model\n",
        "from botorch.models.deterministic import FixedSingleSampleModel\n",
        "from botorch.models.gp_regression import SingleTaskGP\n",
        "from botorch.models.pairwise_gp import PairwiseGP, PairwiseLaplaceMarginalLogLikelihood\n",
        "from botorch.optim.optimize import optimize_acqf\n",
        "from botorch.sampling.samplers import SobolQMCNormalSampler\n",
        "from botorch.test_functions.multi_objective import DTLZ2\n",
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood\n",
        "\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "# Suppress potential optimization warnings for cleaner notebook\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# Set plotting colors\n",
        "colors = [\"tab:blue\", \"tab:orange\", \"tab:green\", \"tab:red\"]\n",
        "mpl.rcParams[\"axes.prop_cycle\"] = mpl.cycler(color=colors)\n",
        "\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "7729000d-0661-4689-8f2b-f99e32c52b70",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "## Problem Setup\n",
        "\n",
        "In this tutorial, we use the DTLZ2 problem with d=5 inputs and k=4 outcomes as our test problem $f_\\mathrm{true}$.\n",
        "\n",
        "For the utility function $g_\\mathrm{true}$, we use the negative L1 distance from a Pareto-optimal point the outcome space:\n",
        "$Y^* = f(X^*)$ where $X^* = [0.5, 0.5, 0.5, 0.5, 0.5]$. "
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "a39603ec-ef75-4f78-bac4-acf1b94bb9f1",
        "showInput": true,
        "customInput": null,
        "collapsed": false,
        "requestMsgId": "e6c9e7dc-51d5-48b3-b9a6-4f8b16faddb0",
        "executionStartTime": 1652334027848,
        "executionStopTime": 1652334028214,
        "code_folding": [],
        "hidden_ranges": [],
        "customOutput": null
      },
      "source": [
        "def neg_l1_dist(Y):\n",
        "    \"\"\"Negative L1 distance from a Pareto optimal points\"\"\"\n",
        "    if len(Y.shape) == 1:\n",
        "        Y = Y.unsqueeze(0)\n",
        "    dist = torch.cdist(Y, torch.full(Y.shape[-1:], fill_value=0.5).unsqueeze(0), p=1).squeeze(-1)\n",
        "    return -dist\n",
        "\n",
        "\n",
        "if SMOKE_TEST:\n",
        "    NUM_RESTARTS = 2\n",
        "    NUM_PREF_SAMPLES = 1\n",
        "    NUM_OUTCOME_SAMPLES = 4\n",
        "    RAW_SAMPLES = 8\n",
        "    BATCH_LIMIT = 2\n",
        "else:\n",
        "    NUM_RESTARTS = 8\n",
        "    NUM_PREF_SAMPLES = 1\n",
        "    NUM_OUTCOME_SAMPLES = 64\n",
        "    RAW_SAMPLES = 64\n",
        "    BATCH_LIMIT = 4\n",
        "\n",
        "X_dim = 5\n",
        "Y_dim = 4\n",
        "problem = DTLZ2(dim=X_dim, num_objectives=Y_dim)\n",
        "util_func = neg_l1_dist"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "bf98ebb8-36d5-423a-9eea-5ff99c44975b",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "Here we define a collection of helper functions for BOPE:"
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "6ad2d0bc-6534-4757-9fe3-f25f7918484e",
        "showInput": true,
        "customInput": null,
        "collapsed": false,
        "requestMsgId": "98c5de6b-3fbf-418f-9ff9-9e5d1a464adf",
        "executionStopTime": 1652334029205,
        "executionStartTime": 1652334028250,
        "code_folding": [],
        "hidden_ranges": [],
        "customOutput": null
      },
      "source": [
        "def fit_outcome_model(X, Y, X_bounds):\n",
        "    \"\"\"Fit the outcome model f\"\"\"\n",
        "    outcome_model = SingleTaskGP(train_X=X, train_Y=Y)\n",
        "    mll = ExactMarginalLogLikelihood(outcome_model.likelihood, outcome_model)\n",
        "    fit_gpytorch_model(mll)\n",
        "    return outcome_model\n",
        "\n",
        "\n",
        "def fit_pref_model(Y, comps):\n",
        "    \"\"\"Fit the preference model g\"\"\"\n",
        "    model = PairwiseGP(Y, comps, jitter=1e-4)\n",
        "    mll = PairwiseLaplaceMarginalLogLikelihood(model.likelihood, model)\n",
        "    fit_gpytorch_model(mll)\n",
        "    return model\n",
        "\n",
        "\n",
        "def gen_rand_X(problem, n):\n",
        "    \"\"\"Generate n quasi-random Sobol points in the design space\"\"\"\n",
        "    return draw_sobol_samples(bounds=problem.bounds, n=1, q=n).squeeze(0)\n",
        "\n",
        "\n",
        "def generate_random_exp_data(problem, n):\n",
        "    \"\"\"Generate n observations of (X, Y) Pairs\"\"\"\n",
        "    X = gen_rand_X(problem, n)\n",
        "    Y = problem(X)\n",
        "    return X, Y\n",
        "\n",
        "\n",
        "def generate_random_pref_data(outcome_model, n):\n",
        "    \"\"\"Generate n pairwise comparison data between 2n points\"\"\"\n",
        "    X = gen_rand_X(problem, 2 * n)\n",
        "    Y = outcome_model.posterior(X).sample().squeeze(0)\n",
        "    util = util_func(Y)\n",
        "    comps = gen_comps(util)\n",
        "    return Y, comps\n",
        "\n",
        "\n",
        "def gen_comps(util):\n",
        "    \"\"\"Given an 1-d tensor of utility, create pairwise comparisons between adjacent items\"\"\"\n",
        "    util = util.reshape(-1, 2)\n",
        "    comps = torch.arange(util.numel()).reshape(-1, 2)\n",
        "    flip = util[:, 0] < util[:, 1]\n",
        "    comps[flip, [0]], comps[flip, [1]] = comps[flip, [1]], comps[flip, [0]]\n",
        "\n",
        "    return comps\n",
        "\n",
        "\n",
        "def run_pref_learn(outcome_model, train_Y, train_comps, n_comps, pe_strategy, verbose=False):\n",
        "    \"\"\"Perform preference exploration with a given PE strategy for n_comps rounds\"\"\"\n",
        "    for i in range(n_comps):\n",
        "        if verbose:\n",
        "            print(f\"Running {i+1}/{n_comps} preference learning using {pe_strategy}\")\n",
        "        pref_model = fit_pref_model(train_Y, train_comps)\n",
        "        if pe_strategy == \"EUBO-zeta\":\n",
        "            # EUBO-zeta\n",
        "            one_sample_outcome_model = FixedSingleSampleModel(model=outcome_model)\n",
        "            acqf = AnalyticExpectedUtilityOfBestOption(pref_model=pref_model, outcome_model=one_sample_outcome_model)\n",
        "            cand_X, acqf_val = optimize_acqf(\n",
        "                acq_function=acqf,\n",
        "                q=2,\n",
        "                bounds=problem.bounds,\n",
        "                num_restarts=NUM_RESTARTS,\n",
        "                raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "                options={\"batch_limit\": BATCH_LIMIT},\n",
        "            )\n",
        "            cand_Y = one_sample_outcome_model(cand_X)\n",
        "        elif pe_strategy == \"Random-f\":\n",
        "            # Random-f\n",
        "            cand_X = gen_rand_X(problem, n=2)\n",
        "            cand_Y = outcome_model.posterior(cand_X).sample().squeeze(0)\n",
        "        else:\n",
        "            raise RuntimeError(\"Unknown preference exploration strategy!\")\n",
        "\n",
        "        cand_Y = cand_Y.detach().clone()\n",
        "        cand_comps = gen_comps(util_func(cand_Y))\n",
        "\n",
        "        train_comps = torch.cat((train_comps, cand_comps + train_Y.shape[0]))\n",
        "        train_Y = torch.cat((train_Y, cand_Y))\n",
        "\n",
        "    return train_Y, train_comps\n",
        "\n",
        "\n",
        "def gen_exp_cand(outcome_model, objective, q, acqf_name):\n",
        "    \"\"\"Given an outcome model and an objective, generate q experimental candidates\n",
        "    using specified acquisition function.\"\"\"\n",
        "    sampler = SobolQMCNormalSampler(num_samples=NUM_OUTCOME_SAMPLES)\n",
        "    if acqf_name == \"qNEI\":\n",
        "        # generate experimental candidates with qNEI/qNEIUU\n",
        "        acq_func = qNoisyExpectedImprovement(\n",
        "            model=outcome_model,\n",
        "            objective=objective,\n",
        "            X_baseline=X,\n",
        "            sampler=sampler,\n",
        "            prune_baseline=True,\n",
        "        )\n",
        "    elif acqf_name == \"posterior_mean\":\n",
        "        # generate experimental candidates with maximum posterior mean\n",
        "        acq_func = qSimpleRegret(\n",
        "            model=outcome_model,\n",
        "            sampler=sampler,\n",
        "            objective=objective,\n",
        "        )\n",
        "    else:\n",
        "        raise RuntimeError(\"Unknown acquisition function name!\")\n",
        "\n",
        "    # optimize the acquisition function\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        q=q,\n",
        "        bounds=problem.bounds,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,\n",
        "        options={\"batch_limit\": BATCH_LIMIT},\n",
        "        sequential=True,\n",
        "    )\n",
        "    return candidates\n",
        "\n",
        "\n",
        "def find_max_posterior_mean(outcome_model, train_Y, train_comps, verbose=False):\n",
        "    \"\"\"Helper function that find the max posterior mean under current outcome and\n",
        "    preference model\"\"\"\n",
        "    pref_model = fit_pref_model(train_Y, train_comps)\n",
        "    sampler = SobolQMCNormalSampler(num_samples=NUM_PREF_SAMPLES)\n",
        "    pref_obj = LearnedObjective(pref_model=pref_model, sampler=sampler)\n",
        "    post_mean_cand_X = gen_exp_cand(outcome_model, pref_obj, q=1, acqf_name=\"posterior_mean\")\n",
        "\n",
        "    post_mean_util = util_func(problem(post_mean_cand_X)).item()\n",
        "    if verbose:\n",
        "        print(f\"Max posterior mean utility: {post_mean_util:.3f}\")\n",
        "    within_result = {\n",
        "        \"n_comps\": train_comps.shape[0],\n",
        "        \"util\": post_mean_util,\n",
        "    }\n",
        "    return within_result"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "7d9d4982-ca40-4744-88d5-775a5c306ddd",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "## Closed Loop BOPE\n",
        "\n",
        "### Setup\n",
        "The following cell shows the core part of this tutorial.\n",
        "In BOPE, we use two probablistic models (in this case, two Gaussian processes) $f$ and $g$\n",
        "to model $f_\\mathrm{true}$ and $g_\\mathrm{true}$ respectively.\n",
        "\n",
        "We start by initializing the outcome model $f$ with 16 quasi-random points (the initial experimentation stage).\n",
        "\n",
        "Next, we enter the preference exploration (PE) stage.\n",
        "A straightforward strategy of performing PE is to present the decision-maker with comparisons using outcomes estimated\n",
        "by sampling from the outcome model using random design points. We refer this method as $\\text{Random}\\mathrm{-}f$.\n",
        "\n",
        "Alternatively, we could initialize the preference model with $\\text{Random}\\mathrm{-}f$,\n",
        "then perform PE using the $\\text{EUBO}\\mathrm{-}\\zeta$ acquisition function as proposed in [1].\n",
        "<!-- \\tilde{f} somehow is not rendering --> \n",
        "\n",
        "In this tutorial, we examine both strategies by starting with initializating the preference model with 3 comparisons using $\\text{Random}\\mathrm{-}f$.\n",
        "After that, we perform 3 * 4 = 12 pairwise comparisons using either $\\text{EUBO}\\mathrm{-}\\zeta$ or $\\text{Random}\\mathrm{-}f$.\n",
        "Then we move on to the 2nd experimentation stage by generating a candidate using qNEIUU by\n",
        "leveraging both the outcome model and the learned preference model.\n",
        "\n",
        "We additionally examine two other experimental canadidate generation strategies:\n",
        "In the first one, we assume the true utility function is known and generate experiment candidate(s) using qNEI.\n",
        "This represents the performance upper bound of PE strategies.\n",
        "For the second experiment canadidate generation strategy, we use random design points to generate new candidates."
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "09229f3c-f7d6-4013-88f3-3c9cfa857eb4",
        "showInput": true,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": [],
        "collapsed": false,
        "requestMsgId": "87413602-bfbf-4b32-b114-1080a68ce445",
        "executionStartTime": 1652334029213,
        "executionStopTime": 1652334273258,
        "customOutput": null
      },
      "source": [
        "verbose = False\n",
        "# Number of pairwise comparisons performed before checking posterior mean\n",
        "every_n_comps = 3\n",
        "# Total number of checking the maximum posterior mean\n",
        "n_check_post_mean = 3\n",
        "n_reps = 1\n",
        "within_session_results = []\n",
        "exp_candidate_results = []\n",
        "\n",
        "for i in range(n_reps):\n",
        "    print(f\"Run {i}\")\n",
        "    # Experimentation stage: initial exploration batch\n",
        "    torch.manual_seed(i)\n",
        "    np.random.seed(i)\n",
        "    X, Y = generate_random_exp_data(problem, 16)\n",
        "    outcome_model = fit_outcome_model(X, Y, problem.bounds)\n",
        "\n",
        "    # Preference exploration stage: initialize the preference model with comparsions\n",
        "    # between pairs of outcomes estimated using random design points\n",
        "    init_train_Y, init_train_comps = generate_random_pref_data(outcome_model, n=1)\n",
        "\n",
        "    # Perform preference exploration using either Random-f or EUBO-zeta\n",
        "    for pe_strategy in [\"EUBO-zeta\", \"Random-f\"]:\n",
        "        train_Y, train_comps = init_train_Y.clone(), init_train_comps.clone()\n",
        "        within_result = find_max_posterior_mean(outcome_model, train_Y, train_comps)\n",
        "        within_result.update({\"run_id\": i, \"pe_strategy\": pe_strategy})\n",
        "        within_session_results.append(within_result)\n",
        "\n",
        "        for j in range(n_check_post_mean):\n",
        "            train_Y, train_comps = run_pref_learn(\n",
        "                outcome_model, train_Y, train_comps, n_comps=every_n_comps, pe_strategy=pe_strategy, verbose=verbose\n",
        "            )\n",
        "            if verbose:\n",
        "                print(f\"Checking posterior mean after {(j+1) * every_n_comps} comps using PE strategy {pe_strategy}\")\n",
        "            within_result = find_max_posterior_mean(outcome_model, train_Y, train_comps, verbose=verbose)\n",
        "            within_result.update({\"run_id\": i, \"pe_strategy\": pe_strategy})\n",
        "            within_session_results.append(within_result)\n",
        "\n",
        "        # Going back to the experimentation stage: generate an additional batch of experimental evaluations\n",
        "        # with the learned preference model and qNEIUU\n",
        "        pref_model = fit_pref_model(train_Y, train_comps)\n",
        "        sampler = SobolQMCNormalSampler(num_samples=NUM_PREF_SAMPLES)\n",
        "        pref_obj = LearnedObjective(pref_model=pref_model, sampler=sampler)\n",
        "        exp_cand_X = gen_exp_cand(outcome_model, pref_obj, q=1, acqf_name=\"qNEI\")\n",
        "        qneiuu_util = util_func(problem(exp_cand_X)).item()\n",
        "        print(f\"{pe_strategy} qNEIUU candidate utility: {qneiuu_util:.3f}\")\n",
        "        exp_result = {\n",
        "            \"util\": qneiuu_util,\n",
        "            \"strategy\": pe_strategy,\n",
        "            \"run_id\": i,\n",
        "        }\n",
        "        exp_candidate_results.append(exp_result)\n",
        "\n",
        "    # Generate a batch of experimental evaluations using oracle and random baselines\n",
        "    # True utility\n",
        "    true_obj = GenericMCObjective(util_func)\n",
        "    true_obj_cand_X = gen_exp_cand(outcome_model, true_obj, q=1, acqf_name=\"qNEI\")\n",
        "    true_obj_util = util_func(problem(true_obj_cand_X)).item()\n",
        "    print(f\"True objective utility: {true_obj_util:.3f}\")\n",
        "    exp_result = {\n",
        "        \"util\": true_obj_util,\n",
        "        \"strategy\": \"True Utility\",\n",
        "        \"run_id\": i,\n",
        "    }\n",
        "    exp_candidate_results.append(exp_result)\n",
        "\n",
        "    # Random experiment\n",
        "    _, random_Y = generate_random_exp_data(problem, 1)\n",
        "    random_util = util_func(random_Y).item()\n",
        "    print(f\"Random experiment utility: {random_util:.3f}\")\n",
        "    exp_result = {\n",
        "        \"util\": random_util,\n",
        "        \"strategy\": \"Random Experiment\",\n",
        "        \"run_id\": i,\n",
        "    }\n",
        "    exp_candidate_results.append(exp_result)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Run 0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EUBO-zeta qNEIUU candidate utility: -0.447\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Random-f qNEIUU candidate utility: -0.584\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True objective utility: -0.141\nRandom experiment utility: -1.231\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "64f2fb33-46bc-47ac-b169-ea702e41f6cd",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "## Plot the Results\n",
        "\n",
        "We evaluate our results by creating two plots.\n",
        "\n",
        "In the first plot, we focus on comparing how $\\text{EUBO}\\mathrm{-}\\zeta$ can efficiently identify the maximizer \n",
        "of $g_\\mathrm{true}(f_\\mathrm{true}(x))$ within a preference exploration stage.\n",
        "We examine this by estimatig the maximum posterior mean after every 3 pairwise comparisons.\n",
        "\n",
        "Here, we plot the the max utility value identified using $\\text{EUBO}\\mathrm{-}\\zeta$ and $\\text{Random}\\mathrm{-}f$\n",
        "with increasing number of pairwise comparisons.\n",
        "As we can see in this plot, the preference model learned using $\\text{EUBO}\\mathrm{-}\\zeta$ is able to identify the maximum utility more efficiently."
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "15612657-0038-4c19-a679-043b6165f3b4",
        "showInput": true,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": [],
        "collapsed": false,
        "requestMsgId": "b38d0039-a154-4821-a26f-06c581786ca2",
        "executionStartTime": 1652334273282,
        "executionStopTime": 1652334274347,
        "customOutput": null
      },
      "source": [
        "# Prepare PE data for plots\n",
        "within_df = pd.DataFrame(within_session_results)\n",
        "within_df[\"pe_strategy\"] = within_df[\"pe_strategy\"].str.replace(\"EUBO-zeta\", r\"$EUBO-\\\\zeta$\")\n",
        "within_df = (\n",
        "    within_df.groupby([\"n_comps\", \"pe_strategy\"])\n",
        "    .agg({\"util\": [\"mean\", \"sem\"]})\n",
        "    .droplevel(level=0, axis=1)\n",
        "    .reset_index()\n",
        ")\n",
        "within_df\n",
        "\n",
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "for name, group in within_df.groupby(\"pe_strategy\", sort=True):\n",
        "    plt.errorbar(\n",
        "        x=group[\"n_comps\"], y=group[\"mean\"], yerr=1.96 * group[\"sem\"], label=name, linewidth=1.5, capsize=3, alpha=0.6\n",
        "    )\n",
        "plt.xlabel(\"Number of comparisons\")\n",
        "plt.ylabel(\"Max value identified\")\n",
        "plt.legend(title=\"PE Strategy\")"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": "<matplotlib.legend.Legend at 0x7fe7e1455400>"
          },
          "metadata": {
            "bento_obj_id": "140633893590016"
          },
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 576x432 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {
            "bento_obj_id": "140633871556224",
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "e407a6c3-0cf3-4ec2-886a-4973db669ceb",
        "showInput": false,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": []
      },
      "source": [
        "In the following cell, we show the average utility values achieved using different methods in the 2nd experimentation stage.\n",
        "\n",
        "We see that $\\text{EUBO}\\mathrm{-}\\zeta$, as a one-step Bayesian optimal PE strategy, performs very similarly to the true utility strategy.\n",
        "\n",
        "On the other hand, despite that $\\text{Random}\\mathrm{-}f$ is a relatively straightforward PE strategy,\n",
        "it is still able to suggest experimental candidates with generally higher utility values than the random experiment baseline."
      ],
      "attachments": {}
    },
    {
      "cell_type": "code",
      "metadata": {
        "originalKey": "9e3389bd-9964-4027-b27d-6bbc3d99492b",
        "showInput": true,
        "customInput": null,
        "code_folding": [],
        "hidden_ranges": [],
        "collapsed": false,
        "requestMsgId": "fec5343a-4532-4182-999f-8c12f10674e5",
        "executionStartTime": 1652334274358,
        "executionStopTime": 1652334275091,
        "customOutput": null
      },
      "source": [
        "# Prepare the 2nd experimentation batch data for plot\n",
        "exp_df = pd.DataFrame(exp_candidate_results)\n",
        "exp_df[\"strategy\"] = exp_df[\"strategy\"].str.replace(\"EUBO-zeta\", r\"$EUBO-\\\\zeta$\")\n",
        "exp_df[\"strategy\"] = pd.Categorical(\n",
        "    exp_df[\"strategy\"], [\"True Utility\", \"$EUBO-\\zeta$\", \"Random-f\", \"Random Experiment\"]\n",
        ")\n",
        "exp_df = exp_df.groupby([\"strategy\"]).agg({\"util\": [\"mean\", \"sem\"]}).droplevel(level=0, axis=1).reset_index()\n",
        "\n",
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "for name, group in exp_df.groupby(\"strategy\", sort=True):\n",
        "    plt.errorbar(\n",
        "        x=group[\"strategy\"],\n",
        "        y=group[\"mean\"],\n",
        "        yerr=1.96 * group[\"sem\"],\n",
        "        fmt=\"o\",\n",
        "        markersize=10,\n",
        "        label=name,\n",
        "        linewidth=1.5,\n",
        "        capsize=3,\n",
        "    )\n",
        "\n",
        "plt.xlabel(\"Experimentation Strategy\")\n",
        "plt.ylabel(\"Utility achieved in the 2nd experiment stage\")\n",
        "plt.legend(title=\"Experimentation Strategy\")"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": "<matplotlib.legend.Legend at 0x7fe6161d3700>"
          },
          "metadata": {
            "bento_obj_id": "140626190219008"
          },
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 576x432 with 1 Axes>",
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjQAAAF/CAYAAABe/FMxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3wU1frH8U+a9GLovRdR8YIVFBV1FEcsg4oFpKgodgUVC1hAREGKitgbdhTGOlfvqIgoKjZERYr0YqS3ULKb3d8fGfILSXYzCbtpfN+vF6/snjkz+2yYe3k8c855EsLhMCIiIiJlWWJJByAiIiJyoJTQiIiISJmnhEZERETKPCU0IiIiUuYpoREREZEyTwmNiIiIlHnJJR1ACYr5evXNG9JIrVM/1peVckD3hkSie0MiidO9kRDrC5YWGqGJoVBmqKRDkFJK94ZEontDItG9UThKaERERKTMU0IjIiIiZZ4SGhERESnzDuZJwSIi5V44HGbz5s2EQpqPUdbsyQiyYcOGIp2bmJhIamoqCQnldg5wHkpoRETKsc2bN1OlShUqVqxY0qFIIQUCGaSkHFKkc/fs2cPmzZupVatWzOMqrfTISUSkHAuFQkpmDkIVK1Y86EbllNCIiIhImadHTgdo5aZ0np+9jPd/XUf63iBVKvzOBZ0aMqhbS5rVqlLS4YmIRJT273quuf4W2rRutV/7/cOHUb1atZh9zo8//ULav+s595weMbsmwPr1G9i8ZQvt27WN2Ofrb+Zw8kldYxLD7G+/470ZH5KSksyuXbu5+MLz6X5KN19x5DTn+7kce3QnUlJSihyL5KWE5gDMXLSe61//hUBmiGAoa+PhnXuDvD13NdN/XsuUvp3p3q5uSYcpIhJR40aNGP/oQ3G7figU4thjOsfl2r/+9ju79+yJmEgEg0Gm2x9y8kldDziGjECAZ59/meeffpxKlSqxbdt27r1/FCd1PSHfOEKhEImJ+T8EmW5/SKejjlRCE2NKaIpo5aZ0rn/9F3YHMvMcC4bCBEOZXP/6L3x6azeN1IhImTPsnge4ckAf2rVtw7B7H6Bfn0v56JNPqVy5EmvWrmPbtu3cMeQmWrdqyQcfOXz19TeEQmFO6daVXhecy9gJT5CclMT27TvocsJxrFi5iqsHXsHAQTfQ9YTj+PHnXzmt+8ls3LiJP/5cwOmnncqlF/di5arVTH76eQiHqVy5MncOvZlt27fz2MTJNGxQn7+XLqdd29YM7N+H1954m6TkZOrWqU3FihV5ZeobJCcnU61qVYbffTtPP/cSy1es5ImnnqVd2zasWLmKa68ewIz3P2LmrG9ISICuXY7n0ot78crUN9m9Zw+rV69h7T9p3Dj46v2SoEBGBrt272ZvRgaVKlWiRo3qTJ40jq3btu0Xx3T7Q1o0b0YoFOLySy7ikccmgZdc3Tn0Zv5csIi/Fi7mnvtGMfbhB3E+dfP87pYvX8mj4x+natUqtGvTms1btpJ6aE0aN27E2WedAcBV197ExHGjqV69eondI6WN5tAU0fOzlxEoYFvqQGaIF2YvL7aYRERi5cbrB/HiK6/z3Q8/Ur9eXQ7v0J7EpEQSEhIY+/CDXDmgL2+89S7//rueb+Z8z4Sxo5n02MPMmv0t6zdsBKBG9eo8MOKu7GsmJSWR9u96eppnMW7MSKa+/jYX9TqfR0c/iPPf/wEw5ZkXufWm6xj3yCg6dzqKDz/+lMTEJJYsWcqV/fvy1OPjmPvjLyQnJXPmGadhnd+TriccR/rOdG6/7SYmjB1NlapV+OmXefS+yKJxo0bcfMO12TH8k/Yvn33+JRPHjWbiuIeZ9fW3rPvnHxITE1m/fgMPj7qPG669ik+8ePapUqUK5/U8m4GDbmDUw+P4zP2SvXv3UrNGjf3iAGjerCk333AtmzZv4ZKLLB57ZBRnn2Xw4cefYpx+KqmH1uThkSPYvHlLvr+719+aRr++lzJm1Ag2bd5MQmICxhnd+errbwBYuWo1DerXUzKTi0Zoiuj9X9dlP2aKJBgKY/+6llEXHFFscYmIFMaatWsZOmx49vsmjRtx603X0aRxIzq0b8czz73Ek5PGZh/veOThALRr25oXXnqVJUuXsWbNOm6/awQAu3bt5t9/1wPQtm3rPJ9XuXIlGjduBEClShVp1LBB9nkAS5YuZcLjTwEQCARo17YNAA0bNSA19VAADj20Junp6ftdt2rVKjz51LNkhkKkpf3LUUfm//+7fy9dxuGHtSc5Oeufv8Pat2XpshUAHHlEBwDq1KnNzlzXBxhwxeWYPc5k7o8/8/kXM3nnvRk8/cT4PP3aed+7Ro3qvPn2u7w1bTo7duykTZv95ypF+t2tWr2aDoe1A6Bzp6OYN/8PmjdrSnp6Olu2bmXOd3M5rfsp+X6/g5kSmiJK3xv01y/DXz8RkZIQbQ7N5i1bSE5OJn1nep5JwuFwOLtw87HHdGLILTfsd/y///uclOS8/8QkJSXl+zpM1n8gJiUm8tgjo/bbEC7t3/UkJSbtd53c/zn52MTJjB45nObNmvL45Gd8fPP//x6JCVkPKxJzxhPO+x+se/fupW6d2vQ0z6KneRa33zWChYuX5Om3L1ma+vpbHN35P5zX82y+mvUNc3/+JU/f/H534TAkeL/bhIT/f5By2qknM+e7ufz623xG3neP7+94sNAjpyKqUsFfLljlEOWMIlL2LPhrIenpu7hjyE1MfuaF7Pbf/1gAwOLFf9O0SWPatm7Fb7//yZ49ewmHwzz1zAvs3bu3yJ/bsmUL5v6U9Q//zFmz+WXe/Ih9ExITCGVmzWPcvWc39erVZfv27fw2/w+CwSCJCQlkhvaf59i2dSv+XLCQYDBIMBjkr4WLad2qRYFx/fzLPIbd+wCBQAC8ScI7d6ZTr27d/eLIaceOnTRs2IBwOMzsb78jGAh6cSeSmRmK+Ltr2LA+i5f8DcBPP/+afb3up3bj0/99Qa3UVCpWrODzN3rw0L+2RXRBp4a8PXd11MdOyYkJWJ0aFWtcIiKFkfuRE8CgK/vx9LMvcc9dQ7PmalSrxqzZ34I3SnHH3fexY8dOhg29hbp163DhBecydNjw7Em2FSoU/R/b66+9iklPPs0702ZQoWIF7r7ztuzHUbl1aN+OxyZOpmaNGlxw7jncdvs9NG7UkMsvvYjX3pzGscd0JhgI8tCYx7In+NarV5ceZ57ObXfcC+EwPc46g3r1Cl6NenTn//D30uXcevs9VKpUkWAwyEW9zqN+vbr7xZFTz3N6MOXZF6hfty4XnHcOk558mp9/mcdRRx7O0GHDGfvwg/n+7i7rfRHjJ02mTp1aNG/WjJ07sx5/HVqzJpUqVaT7KScV+fdbniXkN6x2kDigL75yUzo9Js3Od5XTPpVSkrTKSQDYmLaO2vUblnQYUgrF+97YsGEDderUicm1xk54gpNP7MIJxx8bk+tJ/hYsXETFChVo0rgh7834CIDLLrmQ7du3M+zeB5k8aex+j+siifB3X26LO2mEpoia1arClL6d8+xDgzcyk5KUyJS+nZXMiIhIoRySksKEx58iOTmZSpUqcc+dQ5jz/Vxee+Mdrrmqv69k5mBUqBEaw7SSgSauY5eHtcgxGZpauSmdF2Yvx/51rbdTcDJWp0Zc3a2FkhnJphEaiaQsjdBI8TqQ4pRohCZ/hmlVBiYBA4EQUMEwrUOBN4DLXcfeGv9QS6dmtaow6oIjGHXBEfpHS0REpIT4XeX0ENAZ6OUlNHg/Q8DEOMYnIiIiUiC/Cc15QG/XsT/a96jGdextwNWAGd8QRURERKLzOym4IZDfvJktQOxKsoqISIm5/4M/ePW7lXna+3dpxoPna8dzKd38jtD8DZyZT/tA75iIiJRhMxetZ9pPa0hO3H/OaHJiAtN+WsPMReuLdN1nnn+ZocOGc+U1N3J5v6sZOmw4Dzz0SIyihgsv7bff+9/m/8HI0VmlGub//idbtmZN8bxv5MMADB02nOUrVvKZ+yXfzPkegK+/mROzeKTk+B2heQiYYZjWe0CyYVqTgE7AicDlcY5RRETiaOWmdK5//Zd899UKhsIEQ5lc//ovRdpXa/CggQB85n6ZXe06t1AoRGJi7Deu/9T9got7nc+hNWvmKRVwlnEaeFWwp9sfcvJJXWP++VK8fN1BrmNPA04HKgB/At2AdcBJ3jERESmjnp+9jEBmKGqfQGaIF2bHbseO3+b/wfD7H+L2u0aweMnf+420jBw9lt/m/0FmZiYTHn+KO+4awS1D72beb7/7vv7Pv8xjznc/8NjEyaxfvyHPSM7U19/m/Y8cpjz7IstXrOSJp57lplvvZN0//wCwYeNGrr95aMy+r8Sf7431XMf+Hrg0nsEYplUJGAdcDFT3kqc7Xcf+Mso59YBHgR5AJe+ce1zH/iqesYqIlBfv/7ouahkXvJEa+9e1jLogdnNpVqxcxcvPP0VKSkq+x2fOmk3qoYcy5JYb2LZtO3fecz/PPuVvYe3Rnf9Dq5YtuPG6QdStG3kfnt4XWSxctISbb7iW9z9y+Orrb7n8kov47vsf6X5KtyJ/Nyl+fvehGQUEIhzOBFYDruvY/xxgPFOALkB3YCUwGPjEMK2OrmPnLWma5QNvcvJ/gK3A/cDHhmm1dR173QHGIyJS7qXvDfrrl+Gvn18tWjSPmMwALFr8N/N+m8/vf2YVxNy7dy+BQCDqOVD0reNOO+Uk7ho+kssvuYjvf/iR2265vmgXkhLhd4TGApp4K5q2eEu3U4Ed3p/aQIZhWue4jj27KIEYppUK9AUuch17gdc83jCtPl5ik2fszzCtfaM441zHTvPaHgXuAk4AZhQlFhGRg0mVCsns9JHUVDkkttVyUpLzv15mjsrVl/a+kNO7nxL1Ojnn4GzfvoOqVYq2S3v16tWpU7sWixYvIQzUqV27SNeRkuF3Ftb9wCygrevYtVzHrg20Bj7zVjpVBZ4ExhxALJ29BOvHXO1zveQkD9ext7uOfZXr2AtzNLf0fmp0RkTEhws6Ncyzuim35MQErE6N4hZDUlISGYEAmZmZLFuRtXT8sHZtmfPdXAC2bN3KS6++nue8jkcczlezvgFvgu9n7heccNwxACQmJJBZwNygxIQEMkP/n0CdcdqpPPHUc3Q7sUtMv5/En990ewxwguvYm/c1uI69zDCt64CvXMc+0nssFXF8zqsDVTXKZ+yr374pV/tGoL6fIL0Rm5eBT7w5PxFt3pBGqIAbvbCCwQAb05RHSV66NySSeN8bezKCBAIZUfsM6NKE6T+viTqPJiUpgf5dGhd4rUgyM4OEQpnZ5weDAUKhUPb7s886gzvvvo+mTRrTpHEjMgIZdO1yLD//Oo+bbxtGZiiTPpddnOfzr7t2IE9Mfo73P/qEQCDISV2P59hjOhEIZHD44e15aMw4ht89FMJZtZHC4TDBYIDMUCahzCDVqlUhkBFg5Oix3H3nrRzd+SgmPPEUJxx/dJG/a8yEwwcUw57du/PcW+W5PI/fhKZelL7NvZ9Vc5RFyM+pgBvleJ8I7Ql+CkkaptUM+BhYD1xWUP/UOr5ypEJRLSeJRPeGRFIcxSkLKnDYut4hTOl7NNe//guBzNB+iU1yYgIpSYlM6duZ1vVqFjkOs8f+W5kd3bkTR3fulP1+YL/8/wm4Y8jNUa9bt05dHnpweL7HBlzRhwFXZF13+jtTAZgwdjQAbVq3zu730nOTs1//uWARxx97DKmHpvr4VvF1oMUpK1aqRO2DqDCp34RmDvCBYVqPAEu9BKOZN69lnmFahwDvATMjXcB17M+jTdUyTOs072UdYE2OQ3WBtGjBGaZ1rJfM2MBNrmNHmsAsIiL56N6uLr2PaZxnp+BgKEyf4xvTvV3diOeWF6+98Q4//TKPEffcUdKhSBH4TWiu8ibY2jlGSxKAhUAv17EzDNPaCtx4ALH8DGR4q5zezdHe1UtW8mWY1hHAp8BI17EfP4DPFxE5qD14/hEHdYmDK/pcwhV9LinpMKSIfCU03vLnEwzTauCNzCQC61zHXmGYVkuvzwUHEojr2NsM03oRGGOY1gJv2fZQ7/Om7OtnmNYYoKnr2H0M00oCXgWmKJkRERE5eBVqDZ63z0z2XjOGaTUGfvAeE8XCbd4meTO9JeLzgDNdx845BrovqcIbzekMHGGYVu4xwtdcxx4Uo7hERESkFEsIhwucb4thWi2Al4DjvfIHOf3lOnZZHKMs+IsXkiZ+SiS6NySS4pgUXOcgmhhanhzopOAIf/dF3Haw9PO7D81kb6fg272dgQcDz3ujMyfHOUYRERGRqPwmNCcAF7qOPQUIuo79vOvYg4HXgTvjHKOIiIhIVH7n0CQCu73XGYZpVXAdey/wnLfE+q44xigiIsXBuRPmPpu3/bhrwRxbEhGJ+OY3ofkdGGuY1jBgGXAt8ARwVD5zakREpKxZ4sKvr0FiCoRybOWVmJLV3sbI+lNEHzuf8dob71Dz0BrZbXcNvRX3y5kcWrMmF1+YtVA2HA5j9e7L26+9xOdffpV9zp7de2jerCnD7749uzjl7G++Y9p7NhmBAElJSQzs34djj+4UMYZovvxqNu+8N4NQZogVK1fRqmULnpk8ocjfV4qf34RmGPAhMMJLZF4yTGsEUBN4Jc4xiohIPG1eBtP6QWBX3mOhQNafaf3gum8htWV+VyjQsuUrGNDvcs4+64z92lesWEVn6z/Z79PS/qVGjRpUrFiBZctXMLB/H3qceTqhUIiBg25g2fKVtGvbmi9nfs37H33Cg/fdTWrqoaxZu44hd97L5EnjqFun8EUlTzu1G23btGLchCfoceYZ9L+iwA3npZTxNYfGdezvgIauY6e7jv0K0A14xCsxcE38wxQRkbiZMxkyC9hgPTMA3z1V5I9YsSJr1CO35StW0bJ5s+z3y5avzH6/YsUqWrfKSqDWrfuHcDhM48YN2b1nDy+88hrD776D1NRDAWjcqCFHHXkEv86bX7T4Vq7ivpEP0/ey3gy99QZq1yr50gdSOL5GaAzTetx17Fv2vXcd+1vgW8O0angb2/WLa5QiIhI/86ft/5gpP6EAzH8HzhlfpI9YsWoVj018kgSvqvd555zNySd1JRgMZCclAMtWrKBli+bZ54wd/zjBzCAbN27ioQeGU6VyZf772ee0adUyz0hMSkoy6enphY4tGAwydvzj3HbT9Rx5RIcifT8peVETGsO0agKpwDWGaU3KZ/36YcCFSmhERMqwjJ2x7ZfL+g0bqVmzBs9NmbRf+/zf/6RFi+b7tS1fvpLTup+c5xz3i5m88da7dDzycFasXEXLlvufB7B0+QqM07vv13bnPfezZcuWPH0H9utD1y7HA/Djz7/SrGlTJTNlXEEjNH2ASd6jqb/zOZ4AfBGn2EREpDgcUhUydvjrVwTLl6+gaePGedrXrF1Lwwb1s9+HQiH+XLCQW24czMJFi2nWpEn2sZYtmrN124cAVKlcmUBg/xGlBX8tZNeu3XQ88vD92sc+/GCB8S1atISjOpbF/WElp6hzaFzHfsoraxAETsvnz3HA2cUXroiIxFzH3lmrmaJJTIGORSvcuHzFSpo0bpSnvW7duixa/DcZGRkAvPXOdI48ogM1alRn+YqVNG2SlQSFw2Hcz2fS6T8dATj+uGOYNftbtm7bBsCaNWuZ8PgUbr/tRpKSkgodX6VKlfhr4aIifTcpPfyWPjjMdey/crVVdx17ezyDizOVPpBio3tDIikVpQ82L4OnT8x/ldM+KZWLvMppzNiJzP/9T6rXqAZAAglMHDeaSpUq8czzL/PNt9+RkpLCYe3bct01V1GtWtXsc2rUqE5CQgKHtW/LNVcNoGLFrJ1CPnO/ZLr9IQkJCVSpXJmB/fsU+ZHRjh07GT9pMqvWrKFh/frcfedtVKlSpUjXiiWVPigc3wkN8Jzr2N289y8D/YE0wHQde15xBBtjSmik2OjekEhKRUKDtw/NtH5Zq5ly70OTlAK9px7QPjRlxb33P0Tfy3pzWPu2JR2KEppC8lv6YBLwK1nJzOlAL+AUb0+aR+MbooiIxF0bAzpdkXe1UyiQ1X4QJDNfzJxF9WrVaNe2dUmHIkXgd2O9YwHLe30B8K7r2LMN05rrFawUEZGyzhx7UJc4OL37KZze/ZSSDkOKyO8ITaLr2Pserp4B/M97HQCKPh4mIiIiEgN+R2gWGqZ1tZfAtMiR0JwOrIpjfCIiIiIF8pvQDAdmAJWBO1zH3mqYVi2v7bY4xygiIiISld9aTp97OwbXcR17ote2CejhOvYLcY9SREREJAq/IzS4jh0EtuRq+zYuUYmIiIgUgu+ERkREyrcxP4zhzYVv5mm/vP3l3H383SUSk4hfSmhERITZa2Yz4+8ZJCckEwwHs9uTE5KZ8fcMTmp0Et0adyvStdP+Xc81199Cm9atAAgEAjRv1pRbbhxcpFIFACNHj+X8c82Y1WC6f+QYdqanM/7Rh2JyPSl+SmhERA5yq7evZsisIewJ7slzLBgOEgwGGTJrCDPOnUGT6k3yvUZBGjdqtF+yMHb843z51WyM0089oNhj5fc/FjBj2mslHYYcAF8JjWFa77uOfUE+7TWB913HLh13pIiIFNqrC14lmBmM2ieYGWTqgqnce8K9MfnMw9q3Y+26dTz7wiss+GsRgUCAnuZZmD0MXpn6Jrv37GH16jWs/SeNGwdfzbHHdOadd21mzppN/Xp1SU9PByA9PZ1xE59k+/YdhEIhbrxuEK1btaTvgGvoeU4PZs6aTYf27ahRozo/zP2ZDoe146brr9kvlmeef5ldu3dzz4iRPDzqvph8Pyl+URMaw7SaAy2BHoZpdc+nBkR7bxdhEREpoz5e9vF+j5nyEwwH+XjZxzFJaILBIN/98CM9zz6Ttf+kMemxh8nIyKD/1ddj9jBITExk/foNPDzqPub++DOf/Pd/HNa+HR//9zNefPZJMoNB+l11HQAzPviYdm3acNklF7J4yVKmPPMiE8aNBqBt61Zc3Ot8el3Sj/uHD+OKyy/h4ssGcMPgq0lM/P9FvoMHDcT9YqaSmTKuoBGaE4GJQArwRYQ+r8chLhERKSa7olXZziE9kF7kz1izdi1Dhw0HYPmKlVx6cS+6djmel159ndvuuIekpCS2bt2W3X9f5ew6dWqzMz2dtev+oWmTxhySkgIpKdnzcRYvWUqfSy8CoG2bVqxZty77Gm3btCYpKYlqVavQtnUrkpKSqFy5EnszMqhUsWKRv4uUTlETGtex3zBM601gN9Auny7prmNvjF94IiISb5VTKvtKVqqkVCnyZ+ScQzNy9FgaNmzAvN9+57f5fzL+0VEkJiZy/oWXZ/dPzDFZOBwOA+H9HhFkteWVkKNXUlJivq8Jh5n05NOsXrOWzp2Oos+lFxf5e0npUeAcGtexw4Zppeao5SQiIuVIz5Y9mb54etTHTskJyfRs2TMmnzfoqv7cM2IkfS/vTb26dUhOTubrb+YQCocJBAL5ntOgQX1WrV5DMBgkIyPAkiVLAWjftg2/zJtP+3ZtWfDXQpo18zdp+dabrovJd5HSw+8qp8qGad0PHO6VP9iP69inxT40EREpDv079OeDpR8QDEZJaJKS6dehX0w+r0H9epx0YheWLFnKP2n/csddIzjuuGPo2uU4Jj/9PLVSU/OcU71aNc484zRuHjKM+vXr0bZta0KhEBecZzJu4pMMuTNrbs/NN1wbkxil7EmINGyXk2Fa/wX+A3zrPX7aj+vYV8QrwDgq+IsX0sa0ddSu3zDWl5VyQPeGRBLve2PDhg3UqVOnwH6z18xmyKwhBDODefahSU5KZsIpE4q8D40UTSCQQUrKIUU+P8Lffe7FPeWG3xGaE4H2rmOv89FXRETKmG6Nu9Grda88OwUHw0F6t+6tZEZKPb8JzVZgU5xjERGREnT38XerxIGUWb6qbQOPAnfFORYRERGRIvE7QtMN6G6Y1jXAciCU86Dr2CfHJzwRERGRgvlNaIKAE+dYRERERIrEV0LjOnbf+IciIiIlKe2h0Wx5Pe/m74f27Uv94bGp4SQSL76rbXt1nQYATV3HvtJrO9517B/iGqGIiMTdzq+/Zuv06ZCcDDn3o0lOZuv06VQ9uRtVTy787IK0f9dzzfW3ZJcqCAQCNG/WlFtuHExSjt2AC2vk6LGcf67JUR2PKPI19hk74QmWLFlK9erVstu6HH8sF/U6/4CvndPoR8Zz+203UqFChZhe9+tv5nDySV1jes2yyG+17ZOB/wF/AEcAV3oJzkzDtPq6jj0j/qGKiEg8ZKxaxZpbbiW8O882YxAMEg4GWXPLrbT84H0Oadq00NfPWfYAYOz4x/nyq9kYp596oKHHzFUD+nLC8fGrtRwKhbj3rqFxufbb02YooSnECM1o4FbXsZ8xTGs3WY+hVhim1Qe4D1BCIyJSRm16+WXCEUoO7BMOBNj0yqs0uG/EAX/eYe3bsdYrIvnsC6+w4K9FBAIBeppnYfYweGXqm+zes4fVq9ew9p80bhx8Ncce05l33rWZOWs29evVJT09q/ZUeno64yY+yfbtOwiFQtx43SBat2pJ3wHX0POcHsycNZsO7dtRo0Z1fpj7Mx0Oa8dN11/jK875v//JuzM+YNT99/DHnwt48+33uPH6QTw0ZjxNGjdizdp1tGndkltvuo6NmzYz8YkpZGRkkJSUxJBbbiAUCjFm7ESqVKlMT/MspjzzAs8//TjvvGuzY+dO1q77h/UbNnDF5ZfwmfslmzZtZuyYBzm0Zk1eevV1fv9jAaFQCOu8npx6ykk8Mm4SderUZvHiv9mwcSP3DBvCL7/+xrLlK3jgoUd4YPjBvRjZ77Ltw4EXvdc5d9j9AGgTh7hERKSYbP/wo/0fM+UnGGT7hx8e8GcFg0G+++FH2rZpTUYgQGrqoUx67GEmjhvN1DfeBiAxMZH16zfw8Kj7uOHaq/jkv/9j5850Pv7vZzwx8VGG3X4LK1atBmDGBx/Trk0bJowdzfXXXs2UZ17M/qy2rVsx5fHH+PKr2XQ88ggmTxrLzK9mEwqFIsaXU8cjD6datar8/Ms8XnrlDW68fhCJiUksX7GSQVf1Z/KksTzv4rgAACAASURBVCxdupzly1fy6mtvcaF1HuPGjMQ67xzefPtdAJYtW85dd9xK1xOOy75uYmIi6enpPPLQ/XQ84nB+/OkXHnnofg7v0J6ffp7HH38uYP36jYx9+AHGjRnJ629NIyMjg8SkRAKBAI8+/ADW+T1xv/iK3hdZVKlS+aBPZijECE0YqJ7P5notgL1xiEtERIpJaJe/2sOh9IIrcudnzdq1DB02HIDlK1Zy6cW9sv+B37FjB7fdcQ9JSUls3bot+5wjj+gAQJ06tdmZns7adf/QtEljDklJgZSU7Dk5i5cspc+lFwHQtk0r1qz7/w3t27ZpTVJSEtWqVqFt61YkJSVRuXIl9mZkUKlixf1ifPGV13l3xgfZ768a0JcOh7Xnmqv6c9NtwzjrjNNo2KABaf+up1HDBtSulVVvqk2bVqxeu5bFS/5m9Zo1vPHWNEKhEDVr1ACvqGb1atXIrW2b1gCkHnooVatWyX69a9cuFi3+m78WLmLYvQ+SkJBAKBxi0+YtWb+Xw73fS+1aLFy0pEh/H+WV34TGAZ4zTOt2subU1AA6A+OAT+IbooiIxFNi5cq+kpXEKlWKdP2cc2hGjh5Lw4YNAJj32+/8Nv9Pxj86isTERM6/8PL//6wcE4azag6G9ytCFKkOYUKOXklJifm+Jp9zI82h2bVrFykpyWzcFHmz/H2fOfyu26ldu1Z2e9q/60lOzv+f2Zzfb7/v6v080ziN3heen6eWU87vEY59ScIyze8jp1u8KttLgYrAZuBzYANwW5xjFBGROKp+3rlZq5uiSU6m+nnnHfBnDbqqPy++/Bp79uxlx46d1Ktbh+TkZL6Z8z2hcJhAhLk8DRrUZ9XqNQSDQXbt2s2SJUsBaN+2Db/Mmw/Agr8W0qxZkwOOMaennnmRe4cNZdOmzSxYuAiAdev+YdPmzYTDYZYsWUrTpo1p364Nc76fC8Cv8+bz5Vezi/yZ7du15Ye5P5GZGSIjI4Onnnkhav9wSIkNhdiHZjNwtmFahwFtvZ2CF7uOvSj+IYqISDzVGjiQbe9/QDjKPJqElBRqDeh/wJ/VoH49TjqxC2+8/S6X9u7FtOnvc8ddIzjuuGPo2uU4Jj/9PLVSU/OcV71aNc484zRuHjKM+vXr0bZta0KhEBecZzJu4pMMuTNrn5ybb7i2SHHlfuTUrGkTjup4BHVq16JVyxZcc/UAHhk3iXuGDaFRo4Y8+/wrrF33Dx0Oa0ezpk24os+ljJvwBF/N+gYS4I4hNxf5d3R4h/b856gjGTpsBAkJ0NPsEbV/q1YtuHnIMJ6Y8GiRP7M8SIg0bFcSDNOq5D3Gutibs/MncKfr2F/6PP9E4GtglOvYDxTQPeZffGPaOmrXbxjry0o5oHtDIon3vbFhwwbq1KlTYL+dX3+dtXQ7EMizD01CSgqNH59UpH1oypu0f9czcvRYpjzxWNw/KxDIyPPIqTAi/N0n5N+77CvMPjSTgHbeI6f9uI5d9N2R9jcF6AJ0B1YCg4FPDNPq6Dp21NlPXjL0MrAzRrGIiBw0qp58MjUvvDDvTsHBIDUvvVTJjJR6ficFPwd8A9wL+JsOX0iGaaUCfYGLXMde4DWP9/a6GQwUtCPRw8BCYF0B/UREJB/1h9+rEgcFqF+vbrGMzkjh+U1oGgODXccuYKOCA9LZi+fHXO1zgROinWiY1knAFcCRwFtxjFFERERKIb8JzRygvVf6oEgM00oGqkbpUtf7mXtt3EagfpTrVvYeNd3qOvY/hmn5imfzhjRCmf42V/IrGAywMU0DRJKX7g2JJN73xp6MAIFARtyuL3EUDh/Q392e3bvy3FvleS6f34RmAPCuYVqfAau8VU7ZXMee6uMapwJulON9IrQnFDCB92FggevYeUvERpFaJ2KOVGSa+CmR6N6QSOJ9b2zatInMzBAVK+aZ/iil3IFMCt6zZw+Vq1SlVq1aPnqXD34Tmnu9ybqt85lDEwYKTGhcx/482uxqw7RO817WAdbkOFQXSItwzknA5UBHn99DROSgkpqayubNm9mxY0dJhyKFtGf3bipWqlSkcxMTE0nNZ/l7eeY3oekHnOI6dtF3CirYz0CGlzi9m6O9K/BxhHOu8pZ3/5HjUVMN4DjDtM5zHbtzHOMVESn1EhISDqr/Si9PNqato7aPJfeSxW9Csx34IZ6BuI69zTCtF4Exhmkt8JZtDwWaecu5IWtUZgzQ1HXsPsAQIHfp13eB74Cx8YxXRERESg+/Cc0I4CHDtO5zHXtPHOO5DXgUmAlUA+YBZ7qOvTJHnwZekoPr2FuALTkvYJjWXmC769j5PqYSERGR8sfXTsGGaf0AtAGqePWbck8KbhrPIONEOwVLsdG9IZHo3pBI4nRvHNw7BXurk5w4xyIiIiJSJH6LUw6Pfygi5czmZTBnMsyfRq2MnXBIVejYG7reCKktSzo6EZFyJWJCY5jWCNexR3mvR0a5Rth17PvjEp1IWbXEhWn9IDMAoUDWGG/GDvhlKvz2FvSeCm2Mko5SRKTciDZC0wcY5b3uF2XOSRhQQiOyz+ZlWclMIJ+yZ6GsBIdp/eC6bzVSIyISIxETGtex2+d43bzYIhIp6+ZMzhqZiSYzAN89BeeML66oRETKtcSCOhimlWyY1rLiCUekHJg/LWsUJppQAOa/U1wRiYiUewUmNF6F7U2GaUWteC0inoydse0nIiIF8rts+2PgLcO0fgSWeSUKsrmOfV98whMpgw6pmjUB2E8/ERGJicJU2wY41vuTUxhQQiOyT8feWauZoj12SkyBjpcUZ1QiIuWa331oWsQ/FJFyouuNWUuzoyU0SSnQ5YbijEpEpFwrcA7NPoZpJRqmdaphWgNytFWOW2QiZVVqy6x9ZlIqZ43E5JSYktXee6qWbIuIxJCvhMYwrWbAH8DnwLNeW3NguWFaR8Q9SpGypo2Rtc/M0f2hQjXCJECFalnvr/tWm+qJiMSY3zk0E4AfgK7AP2Q9hlphmNZz3rEz4xumSBmU2jJrn5lzxrNJBQhFROLK7yOnLsCtrmNvzbVj8BjguDjFJiIiIuKL34SmGrA7n/ZDgKQYxyQiIiJSKH4Tmh+AoTkbDNOqmuNRlIiIiEiJ8TuH5nbgU8O0rgUqGKY1D2gFpAM94hyjiIiISFS+Rmhcx54HtAYeBZ4AvvCSnDbeMREREZES43eEBtexdxqm9SxQF9jtOva2+IYmIiIi4o+vhMYwrUOBZ4BzgQpe2w7gDWCY69iqsiciIiIlxu8IzdPAUcBdwHIgwXsEdZ23AqpfnOMUERERichvQnMGcKzr2MtzNhqm9REwJz6hiYiIiPjjd9l2CFiZT/vqGMcjIiIiUmh+E5rXgEH5tF8JvB7jmEREREQKxe8jpyrAI4ZpXQ/86SVC7b29aGYYpvXSvo6uY18Zv3BFRERE8vKb0FQF3s/V9qv3B2+SsIiIiEiJ8JXQuI7dN9Ixw7QOcR07I6ZRiYiIiBSCrzk0hmm9b5hW7Xza/wP8EpfIRERERHzyOym4KvCHYVrnkpXIJBimdS/wPTAzviGKiIiIROe3ltMZ3qZ6Lxmm9TLwDXAFcLrr2DfFP0wRERGRyPyO0OA69ivAVd6uwIcDvVzH/ja+4YmIiIgUzO8cmmqGaU3x9qO5CXgZ+N4wrVviH6KIiIhIdH5HaP7yajkd7Tr2FNexb/MKVd5imJZGaURERKRE+U1onga6uY79974G17FneUnOgviFJyIiIlKwhHA47LuzYVrJQJPcRSrLKP9f3KeNaeuoXb9hrC8r5YDuDYlE94ZEEqd7o9xuhOtrYz3DtCoBjwMDvUKVFQzTOhR4A7jcdeyt8Q9VREREJH9+HzmNBjoDvbyEBu9nCJgYx/hERERECuQ3oTkP6O069kf7HtW4jr0NuBow4xuiiIiISHR+i1M2BPKbN7MFqBbjmEREyrXV21fz6oJX+XjZx+wK7KJySmV6tuxJ/w79aVK9SUmHJ1Im+R2h+Rs4M5/2gd4xERHxYfaa2fT6qBfTF08nPZBOmDDpgXSmL55Or496MXvN7JIOUaRM8jtC8xAwwzCt94Bkw7QmAZ2AE4HL4xyjiEi5sHr7aobMGsKe4J48x4LhIMFgkCGzhjDj3BkaqREpJL+1nKYBpwMVgD+BbsA64CTvmIiIFODVBa8SzAxG7RPMDDJ1wdRii0mkvCjUPjTljPahkWKje0MATnjzBNID6QX2q5pSle8u/65YYpLSS/vQFI7fR07FwtvvZhxwMVDdGw2603XsLws470pgGNDMGzl60nVsLScXkVJlV2CXr35+kh4R2Z/vatvFZApwBtAdqA28BXximFabSCcYpnUJcJ9XBbyGVzxzsGFaxxZv6CIi0VVOqeyrX5WUKnGPRaS8KTUjNIZppQJ9gYtcx95XH2q8YVp9gMHA0Ain3g/c4Tr2D977T7w/IiKlSs+WPZm+eDrBcOR5NMkJyfRs2bNY4xIpD0pNQuPtRJwM/JirfS5wQn4nGKbVADgMSDJM6yegHbAMGK3JyiJS2vTv0J8Pln5AMBgloUlKpl+HfsUal0h5EDGhMUzL7/+iUlzHfrGgTl5hy6pRutT1fm7K1b4RqB/hnKbez8HAZd78mauBdwzT+terCJ6vzRvSCGWGIh0ukmAwwMa0dTG9ppQPujcEoBJJPNBxOA/MG0UgHCQznJl9LCkhiZSEZB7oOJxKu5LYuEv3y8EuHv+/UZ4XJ0QboXkl1/twPrOjQ8AuoMCEBjgVcKMc7xOhPSHKiqR98T/oOvYS7/Xj3mOqgUDEhCa1TqQcqei0kkUi0b0h+5xT/3w6NuvM1AVT+XjZx6QH0qmSUoWeLXvSr0M/7T8j2fT/G4UTLaFJyfG6B3AV8DCwCEgCOngri57x80GuY38ebbmYYVqneS/rAGtyHKoLpEU4baP3c0uu9mVAAz9xiYgUtybVm3DvCfdy7wn36h8tkRiJmNC4jp09FmqY1jjgFNexN+ToMscwrcHATOC/MYjlZyAD6AK8m6O9K/BxhHP+9pKa44F5OdpbAz/FICYREREpA/xOCm7iPVrKbQfQOBaBuI69zTCtF4ExhmktAFZ6K5uaecu5ISu5GgM0dR27j+vYmYZpTQDuN0zrV2A+MMgryzAoFnGJiIhI6ec3ofkNeMkwrVHACm9OS3PgXuCPGMZzG/CoN+pTzRt1OdN17JU5+jTwkpx9HvH203kPqAUsBM51HfvXGMYlIiIipZiv0geGaXUAbO9RTk7rgbNdx54X4dTSTKUPpNjo3pBIdG9IJCp9UDi+Rmi8je7aebvvNvGKVK4GfnAdOxD/MEVEREQiK9TGeq5j/5jPxnciIiIiJcpXQmOY1jHAU8DhQKXcx13HTopLdCIiIiI++B2heQH4F7gL2B3nmEREREQKxW9C0wY43nXsvXGOR0RERKTQEn32Wwr4q3svIiIiUsz8jtDcCEw2TGukl9zsV9XRdezYVnkUERERKQS/Cc00oCZwaYTjmhQsIiIiJcZvQjPCq7MkIiIiUur43Vjv+fiHIiIiIlI0BSY0hmmdC5wOrAWecx17W67jf7mOfVhcoxQRERGJIuoqJ8O0BgMzgFOA24H5hmm1ydWteXxDFBEREYmuoGXbNwMXuo7dCWgKfAG4hmnVztEn5kUeRURERAqjoISmCfARWfNo9rqOfSUwF7AN09LKJhERESkVCkpoNgAdcrX186ptv2KYVkJ5LkUuIiIiZUNBCc1U4CPDtM7f1+A69h7A9BKdLwqx27CIiIhIXBSUjIwC3gU65Wx0HXujN1H4dyU0IiIiUtISwuGDdk5vzL/4xrR11K7fMNaXlXJA94ZEontDIonTvVFup4lodEVERETKPCU0IiIiUuYpoREREZEyTwmNiIiIlHm+ExrDtBIN0zrVMK0BOdoqxy0yEREREZ98JTSGaTUD/gA+B5712poDyw3TOiLuUYqIiIhE4XeEZgLwA1AbCJG1F80K4DnvmIiIiEiJ8ZvQdAFudR17a679W8YAx8UpNhERERFf/CY01YDd+bQfAqhIpYiIiJQovwnND8DQnA2GaVXN8ShKREREpMQk++x3O/CpYVrXAhUM05oHtALSgR5xjlFEREQkKl8jNK5jzwNaA48CT3hVtm8H2njHREREREqM3xEaXMfeCTwd33BERERECs9XQmOYVh3gDqADkGczPdexT4tLdCIiIiI++B2heQ3oDMwCtsQ5JhEREZFC8ZvQnAgc4Tr2yjjHIyIiIlJofpdtbwLS4hyLiIiISJH4TWgeAu6JcywiIiIiRRLxkZNhWv/L8TYMdDRM6ypgxb56Tvu4jn1yXKMUERERiSLaHJq1ud6vi3MsIiIiIkUSMaFxHXvgvteGadVxHXtD7j6GaR3iLeUWERERKTF+59BEWt1UGfhfhGMiIiIixSLqsm3DtCygF3CIYVpT8+nSvBBJkYiIiEhcFLQPzWJgPZAANMnn+HbgqjjFJiIiIuJL1ITGdew/gaGGadV3HbtP8YUlIiIi4p/fattKZkRERKTU8l1tuzgYplUJGAdcDFQH/gTudB37yyjntAfGAl2BFGAhMNJ17E+KN3oREREpKaVtQu8U4AygO1AbeAv4xDCtNvl1NkwrAfgM2AG08s55A3jfS3RERETkIFBqEhrDtFKBvsAw17EXuI6d7jr2eOAvYHCE0+oCTYE3Xcfe5jp2AHjRG3k6qpi/goiIiJSQUpPQAJ29ROTHXO1zgRPyO8F17H+BWcCVhmnVNkyrAnCtV0zzq+IJW0REREqarzk0hmkdAzwFHA5Uyn3cdewkH9dIBqpG6VLX+7kpV/tGoH6U83oD/wU2eDWnNgIXeclORJs3pBHKDEXrUmjBYICNaaoQIXnp3pBIdG9IJPG4N2rXbxjT65UmficFvwD8C9wF7C7iZ50KuFGOR1pJleAlKnl4pRc+8yYCnw3sBPoDHxmm1cV17D8ifVhqnWg5UtFsTFtXrm8WKTrdGxKJ7g2JRPdG4fhNaNoAx7uOvbeoH+Q69udecpIvw7RO817WAdbkOFQXSItw2hnAf4CzXcde77U9bZjWdcCVwJCixisiIiJlh985NEu9uk3x9DOQAXTJ1d4V+LaAc3MnSsmRRnVERESk/PE7QnMjMNkwrZFecrPf5BPXsQ94Morr2NsM03oRGGOY1gKvIOZQoJm3nBuyRnLGAE29zf7meKM3jximdSuQ7q2UaudNDhYREZGDgN8RmmnAhcACYC8QyPUnVm4DPgZmepN8ewBnuo6ds9p3Ay/JwXXsrcBZQC2v7tQG4DrgYtexZ8cwLhERESnFEsLhgp/MGKY1yHsclC/XsV+NdWDFIOaPpDSBSyLRvSGR6N6QSOJ0b0Scy1rW+Xrk5Dr28/EPRURERKRoIiY0hmm94Dr21d7rqVGuEXYdu39cohMRERHxIdoITZMIr0VERERKFV9zaMopzaGRYqN7QyLRvSGRaA5N4ZSmWk4iIiIiRaKERkRERMo8JTQiIiJS5imhERERkTIv2rLtpj6vkeI69tLYhSQiIiJSONGWba8oxEqgpBjFIyIiIlJo0RIaI8frVsCtwEvAIi+B6eAVghxZDHGKiIiIRBQxoXEd+4t9rw3TGg5c6jr2/Bxd3jdM61NgEvB23CMVERERicDvpOBjgL/yaf8d6BzjmEREREQKxW9Csxq40TCt3DsMDgbWxiEuEREREd98VdsG7gPeAu42TGuVN1m4KVAL6BfnGEVERESi8jVC4zr2e0AbYBwwB/gFeBI42nXsN+MfpoiIiEhkfkdocB17BTDOMK1k17GD8Q1LRERExD9fCY1hWsnAncC1QB2gsmFaVbwRm1tdx86If6giIiIi+fM7KfguYJCXwOybGFzZW/30SBzjExERESmQ34SmD3C+69iT9+0e7Dr2BuBSoHd8QxQRERGJzm9C09Tbcya3Vd5KJxEREZES4zehWQccm0/7ed4eNSIiIiIlxu8qp0nAh4ZpPQskGaZ1i7dDcG/gjjjHKCIiIhKV331ongJuAc4Cdnkb7bUFBnjzakRERERKjN9l2y1dx34HeCf+IYmIiIgUjt9HTn8bpvUN8AowzXXsnXGOS0RERMQ3vwnN6cAlwKPAk4Zpve8lN5+7jh2Oc4wiIiIiUfmdQzPTdezBQH3gYiAIvAusNkxLG+uJiIhIifJdy4msxCYTcADHMK3/eDsH3+HtJCwiIiJSIgqV0BimdZi3VLu3t8ppJjAgfuGJiIiIFMzvKqfh3hyaDt6OwS8Bb7qO/U/8QxQRERGJzu8IzTXAW8BlrmP/EeeYRERERArFb+mDZq5jDwMWGqbVIs4xiYiIiBSK3xGaioZpPQ4MBEJABcO0DgXeAC53HXtrnOMUERERicjvCM1or3ZTLy+hwfsZAibGMT4RERGRAvlNaM4DeruO/REQJmsJ9zbgasCMb4giIiIi0flNaBoCy/Np3wJUi3FMIiIiIoXiN6H5Gzgzn/aB3jERERGREuN3UvBDwAzDtN4Dkg3TmgR0Ak4ELo9zjCIiIiJR+a3lNM0rUFkB+BPoBqwDTvKOiYiIiJQY36UPXMf+Hrg0vuGIiIiIFF7EhMYwrRGuY4/yXo+MdhHXse+LR3AiIiIifkQboekDjPJeXxGlXxhQQiMiIiIlJmJC4zp2+xyvi63cgVda4WXgFKCF69grCuhfCRgHXAxU9+b43Ok69pfFFbOIiIiULN9zaMhKHmoDlXO3u469KhbBGKZlAc8AnxbitClAF6A7sBIYDHximFZH17GXxCIuERERKd18JTSGafUEXgRq5zqU4D1ySopRPKnAyUAToJ+PuFKBvsBFrmMv8JrHG6bVx0tshsYoLhERESnF/I7QTAC+8IpR7olXMK5jv0hWotLE5ymdve/wY672ucAJsY9QRERESiO/CU1DoJ/r2MGifpBhWslA1UjHi1ixu673c1Ou9o1A/Wgnbt6QRigzFK1LoQWDATamrYvpNaV80L0hkejekEjicW/Urt8wptcrTfwmNL8BDYDVB/BZpwJupIOGaVVyHTtWoz/7HoVFlFonar5TJBvT1pXrm0WKTveGRKJ7QyLRvVE40fahyflbHAFMMUzrSWAZsN/QhuvYywr6INexP/cSjVhK837WAdbkaK+b45iIiIiUc9FGaNbkGuVIAM7Jpy2Wk4IL62cgw1vl9G6O9q7AxyUUk4iIiBSzaAlN92KMwzfDtMYATV3H7uM69jbDtF4ExhimtcBbtj0UaOYt5xYREZGDQLSN9WblfG+YVlUgxXXsLd77ZsBW17G3xSoYw7QWecnIvqKZiwzTCgOvuY49yGtr4PXZ5zbgUWAmUA2YB5zpOvbKWMUlIiIipVtCOBx17ixkJRrHeJvd3eA69jte2xDgHqCH69g/FUewMVbwFy8kTeCSSHRvSCS6NySSON0bsZ7LWmr4XeU0HngO+DBH25PersETgW5xik9ERESkQIk++gB0Aka4jr17X4Pr2AHgEeCo+IUnIiIiUjC/CU060Dyf9vbArhjHJCIiIlIofh85vQ44hmlNBpZ7z+DaAzd4x0RERERKjN+E5m5gh7fB3r4ClRuBp4DRcYxPREREpEC+EhqvhtNIYKRhWtWBhH3LtQ3T6gbMjnukIiIiIhH4HaGBrOSlLlDRe10DaAp8AKTGLUIRERGRAvhKaAzT6gRMz7Wh3T7fxj4sEREREf/8rnKaBHwNnAsEgR7Avd6jpnPiHKOIiIhIVH4Tmo7Ata5jO0Cm69iu69iPeJvrTYhzjCIiIiJR+U1oQjn67vbqOgHYQK84xSYiIiLii9+E5gfgFcO0KgKLgPsM06riPYLKjHOMIiIiIlH5TWhuAw7zNtQbDdwMbAdmAM/EOUYRERGRqPzuQ7PIm0cD8IlhWu2Bo4GVZbTStoiIiJQjhdqHZh/XsVcAK2IfjoiIiEjh+X3kJCIiIlJqKaERERGRMk8JjYiIiJR5vhIaw7TeNkzrjPiHIyIiIlJ4ficFV/NWN/0DvAy84jr2yjjHJiIiIuKLrxEa17HPAeoDDwOnAH8bpuUapnWpYVqHxD9MERERkcgSwuFwoU8yTKsBcDlwj9f0IvCY69jrYx5h/BT+ixdgY9o6atdvGOvLSjmge0Mi0b0hkcTp3kiI9QVLi0JPCjZM63BgCHALkAK8B7QHFhmmdWp8whQRERGJzNccGq8Y5WXAVcBxwE/ASOAt17HTvT6DgeeBNnGPWkRERCQHv5OC04AA8CZwrevYv+XT51lgfIzjExERESmQ34RmJPCk69i7czZ6E4I7uI49z3XssGFa7eITpoiIiEhkfufQPJA7mfFUBv63743r2GtiF5qIiIiIP1FHaAzTsoBeQIphWlPz6dJcuw2LiIhISSvokdNiYL2XtDTJ5/h2b6KwiIiISImJmtC4jv0nMNQwrfquY/cpvrBERERE/IuY0Bim1dx17BXe2xGGabWM1Nd17GVxiU5ERETEh2gjNAu8Sb8Af0fYWTfBa0+KU3wiIiIiBYqW0JyV4/Vp8SgVICIiIhILRarlVE6olpMUG90bEonuDYlEtZwKJ9ocmq/9XsR17JNjFpGIiIhIIUV75LRMj5lERESkLIiY0LiOPaB4QxEREREpmmiPnPq5jj3Ve31llGuEXcd+OS7RiYiIiPgQ7ZHTs8C+cgcvROkXBpTQiIiISImJ9sipUo7XqtckIiIipZavRMUwrfcjtNc0TOurmEclIiIiUggFVdtuDrQEehim1T2f9evtgWPjG6KIiIhIdAVV2z4RmAikAF9E6PN6HOISERER8S3qIyfXsd8A6gEBoEU+f+q6jt2v+MIVERERyaugERpcxw4bppXqOvau4gjIMK0W3qqpU4AWOSp+R+pfD3iU/2vv3uOtnPIHjn+60U1FNC4VYqpBbjMumRExa4aFxpqhkVFqKAx+TKNBg3HJbZohDLnLjGeGcgAAGIhJREFU/W6pWGJlhMa4DxGFUboQKqTTier0+6Pvo8du7332qXPaZ5/9fb9e57X3fq7r2c9znuf7fNdaz4aDgBbAVGB4DF7b9iillFJloro2NHek3qdHVQCvAnfH4JfWVmGMdQ64HphQg9nGAl8AuwJfAn8FHjPWdY3Bf1xbZVNKKaVU/VVdL6dOOf72BK4G/mOsa1OL5dkE6AXcWcjEsu6pwB9j8PMkuLocaAXsXYvlUkoppVQ9ljdDE4PvnWucsa4D8DBwLjCsNgoTg79Flt2pwOkXAcdlDO4ir5qdUUoppcpEtW1oconBf2asOxV4qJCAxljXFGidZ3lfrm1ZUutoI+1vHo/Bv5hv2oWfz6NqRdW6rvJ7li9fxvx5GkepNemxoXLRY0PlUhfHxqabb1mry6tP1jqgEW8BWxQ47f5AzDXSWNdiXdrjGOu2Bh4DPgP6VTf9Jpttvrarymn+vI8b9MGi1p4eGyoXPTZULnps1My6BjSbAAX1forBT8zyYL5aYazbQ4IZD5wag19WF+tRSimlVP20rgHNUOD5WirLWjHW7SS9oi6MwV9VzLIopZRS6+LbWbNYcNttLBo3nqolS1jQsiVt+hxG+0GD2KBz52IXr16rrtv2hTlGtQT2AnYD9qmbouUs06VA5xj874x1TYDbges0mFFKKVXKFj/3HHNOO52Vy5bB8uUAVFVU8OWDD/HVo2PpeNUoWvfqVexi1lvVZWj65xi+VNrPnBqDn1JbhTHWTQe2TnUnn26sWwncGYMfLMO2kGkAegK7AzsZ6zIbJqfnUUoppeqtb2fNWhXMVFauOXL5clYuX86c006ny9hHNVOTQ6OVK1cWuwzFUusbrg24VC56bKhc9NhQAJ9ccAFfPvjQd5mZrJo2pV3fvmxx3rnrsqo6actaH1T3YD2llFJK1bFF48bnD2ZYlalZNG7c+ipSydGARimllCqyqiWF/VxiVUVFnZelVGlAo5RSShVZ45YtC5uuVas6L0up0oBGKaWUKrI2fQ6DptX002nalDZ9+qyvIpUcDWiUUkqpIms/aBCNmjXLO02jZs1oP/DY9VamUqMBjVJKKVVkG3TuTMerRtGoRYs1MzVNm9KoRQs6XjVKu2znoQGNUkopVQ+07tWLLmMfpV3fvjRu3RoaNaJx69a069uXLmMf1YfqVUOfQ1OL9HkSKhc9NlQuemyoXOro2NDn0CillFJK1Vca0CillFKq5GlAo5RSSqmSpwGNUkoppUqeBjRKKaWUKnka0CillFKq5GlAo5RSSqmSpwGNUkoppUpeOT9YTymllFINhGZolFJKKVXyNKBRSimlVMnTgEYppZRSJU8DGqWUUkqVPA1olFJKKVXyNKCpJ4x10411f5X35xvr5sj7rY11S411vYtdRqVU7TPWjTDWzSzCek821i1MzjVqlWLtj/oqfW2q75oWuwDrwlh3E9BfPjYCNgCWAVUy7KMYfLf1WJ5JwJwY/DFZxo0Bto/B/0w+Hwp8HIN/HSBXOWPwHwHNU8vpCPwiBn9r3W6NUuVD/nf3lfNH4lvgPeCKGPw9RSxeXbkAGAP8qdgFSSvHfSEBVEdgeZbRX8bgNy9CsSDPtWl9MtYdA7wQg/8w33QlHdDE4AcDg1m1wdsAMwAbg5+Yax5jXdMYfLaDZn27ABgNvF7D+RzwW0ADmgIZ664ETs8x+ugY/L3GuueBihj8QVnmnw08HoM/McfyvgE+BC6Pwd+eMW9T4GRgANBNgu3/AOfF4F+q7W1ldfB8bJZRk2Pw+9bFOhuIe9M3I8a6FsCRwB3Gum9i8A8Xt3i1rj3wTgy+Pj6MrNz2BcBlMfhzil2IhLGuWQx+WQGT1nU5GgFXAv3kPJtTSQc0hZKI/22gK7C/sa4lMDEzm2Ksmwx8EIMfKJ8PAC4FegALgKeBM2Lw89exPHOArYDRxrpTY/C7SIR+V+YBnQrUDHAg8GegkbFuKXAecDnQNQb/fmqea4E9YvB7rks5G5AewGRgWJZxb6emuTFzpLFuY7lzeivP8jYGzgJuNda9HIN/V+ZtCzwJbA9cBbwoF5E/As8Z60wM/rk62N6/AdfL+2OBE4DPgGvqYF0NVgy+Ui6gRwN9gYeNdT3l++0BrJTg9JTkztFYNxcYCXSXeVYC98k0K411jeVmZhCwEfAo8L3zibFuazmB95Ss8xTgzzH4V2T8v2W9zSVQrgSGA9Nlv28rN0r9YvBrVCcZ67YC/icfRxvrRhQzA1CIbPuCVdtS8vujUMa6c4CTgB1i8F/JsInAkhh8H2Pd3cBioEJqLpoAETgpBr9Qpt8V+Aewl0z7AjA0Bj+T1ZmiMcChwKbANulrk7HuYrkW3QBcBLQB7gRGyHz7AHOBITH4SbLM9sAo4BBp5jIVGB6Df1bG3y2xyPPAmXI+nSzfZQWwUL73YKybEIPvk+s7Kqc2NEdKRqRFIRkaOYgfkwOyHbAnsDlw77oWJAbfUd6eFIPfpQbznS0Hzwsx+Obyj/o+8PtUuZsARwC3rGs5G5AewMsx+Bez/C2Wfd0WeDPLvDvL65SM5aWX8YQENI2BnVh9V+GBLSW4vCgGH2Pw9wH7AZ8CV9TFxsbg35GT6TnAccBlwHYx+AfqYn1lYENgpbFuA2C8XJx+AGwDNANuS027DDgDeBzYTLKpfwCsjP+djO8v48fKPoLVGb2JspwewNYSCD9rrOucWscAuQC0l0D1Kska9gY6yYXmjGwbE4OfK+cP5BxUr4OZDBtKUEJD2R81cCkwS/6fMdYNlPPT4FQ5jgI+ALYA9gB2leADY91GcoP1jGzrj4CvgSdkOxODgNOALlnKsAz4oczbRYKUE4GHZPs2lu9hVGqeuyRY7C776W7gKWNdl9Qye0uZusp0uwLDYvAVktlGal9yBjOUS4ZGzI7B+xpM/wfgtRh88s/xibFuGDDFWNelurq89UHuMG4GTjfWnSuB2oFy8Kxz4NUQGOs6AB3kriCXbEFL1nF5lreVvCaZsuPln/QXMfgZ6Qlj8EuNdXcBZxvrOsTgP1urjcvBWLep3Jm1A/aJwb9am8svF8a61nKh6gUcEoP/1li3LfBNDP5b4Btjnc8SmL4Qgx8v7yca6xYCO8pF9ShgQgz+GRn/iLHuOBkPcJBk9HolmWBpkHmSXIxHynQfxODvl/GPyN3ytTH4z2XYk3IBbhAy9wWr/o8a2v44y1iXLegZEYMfEYNfYawbALxurJsA/B04Pgb/aWraWTH46+T9/4x11wGXS8ByjHxXI2R8pbHuNKl96AX8S4a/EoP/d55ytpYq86US2H0OPBWDf1O29WHgaHn/o+Q7TJ3nrpPveKDUMgCsAC6IwVcBcyTrtWPOEuRQTgFNTQOQbsA+UrWTtkJSiEUPaMQYSfcdLHcr/YCHYvCLil2weiIJSKZn3IUArJD2AztLo8NpOeaflaR4U8ubJsvbUNK3fwPuicG/IePPAF6Pwccc5Zotr5tLdVCtkBT6eKAFsHfGyU7l189Yd0Tq84bAa8CvY/ATZNhvgNPk7nJDSetnHlcfZHyuBFrK+84SbKZNT528t5dGoJ8kI+XCPQPYLjVPuhfOEnn9KGNYi8I3vd4pZF/QwPZHtW1oYvDvG+vOkuzvnTH4RzMmybzRmiHfSwe5pnXMck2rkuxWorpr2+cx+CWpz0uybGuSAUyyK1ONdellNE5V9wPMkGAmUSnZrhopp4Dm2wKmSVfBVUlD0LwprgxLU/8omdpIfWCtisF/ZqwbCww01j0ljYZ/VdvrKWFJADI5y7jewCSZ5t0cDeB2zsjcJMv7T8Z0N0tbFYx13SR1mq/3yKby+nXhm1KQ06Xaa1cNZmrsu4aoEhg+D3wRgx8rw34q1RlDgetj8JXGuiFJSj+lKuvSV/muyiSlScbnRlnma5wxX7Z1ZF1vRm9QUtVN9VnefUEJ749asL20f+lqrGsSg1+RUa60pOyVUp63Y/A7k19118qabGsyfMukHU8Nlllj5RTQZKqUhkZpnaRrIPJ6lLGucRI5GuuaA5vE4D/Oscy3gCMzW4dLC/09gTvqaFtuBMZJdmY+UBcNTUtVD7lD65dl3JTUNGtUy0g7mB2lDj3X8ppLdmy4BE23p+7u3slTru4SzMzKst62UgeeVww+W0bpNOna+r8s41SBYvBVxrpBwBvGuhNi8DdIo9CFMfgrU5PuXsNFz864G0baIySmA22NdVvF4Oey+ryzjWRj12ZbBqfaWZScHPuCUt0f68JYt5/sy72lYfTZkqFPdM+YZTvg6xj8F8a694ATjHVtkgy+nOO2yawWr0XJ9XQ36VSTbMe2wMza7mFXzgHNuxJ8tI3Bf2WsO1EahiZGy93uRca6S6Wx2d+Bnsa6nTLSY4mrpVfJzca6c6W193ZSHZGMTyyRCLt9DH5BDcpdAWwlLccrJfU3EfhYWuKPrKfdMIulB/BmrnYkxrpmkk3JFmx2A1oB/61meZPluUIDJKBpLcOz9oYz1rUC+gAh4+4qcSRwUwHb9r07R2PdjyWFfl8B86pqxODfM9b9BbjCWPcvSau3M9b9RBqQDwF2YdV33zkGv0ZwmsU44FJj3b7AS8Dh0ngzqdJ8Si6iV8o5aQVwvowr2/2auS+kV2dZ7Q9p1DtG2q+8Le1QnjbWheR5ZsB2xrpTpFNIR2kLmjy35x7gQuBqY90f5XETZwMnGuu2jcEvru0yx+CnSfuhkca6vlIF1kfKckCWTHc2Sc1Gd2PdazH4L3JNWM4BzUi5OE031s2XRrRPJt9JDP4juUhdLCnNpcCzwME5ghli8LONdXtJg7CXpVHmfGACsFcMfl5q8qvlbrpvljuEfO4Cfi3dLgcA46Rx8C1ysN5ewDLKgqSqd5DGf7lsJinmbOlQKyewpHthvuVVpuqNk/r2TtkyP3KSaZWrl1MM/mapwqqppL567lrMq7K7Sv7f7pKGk7fJneY3cnE5TI6P/8r/fnX+KReaB+QYGC89Qoawat+vMNb1kWGz5LzzKvDTdDuOMvXdvpDqpkca2P7I1SgY4Bdyvv806UEUg58s1Yl3GeuSzNQj0gtpttzwTJBHfRCDX2SsO0huzOfIue1l4Od1Ecyk9Jeb7ZflHPk+MCAGX0gwQwz+c+naPVKul71yTdto5Uq9mW8IjHXXSD3lb4pdlvpC2rJMA36bq8uydHOvAMYkD86T4ZvIXd9LMfgj8i1Pum9OB0bH4IdKBmYu8HwM/rCM9e0nJ5kbYvC5Hva3ttt7uDQW3LuuHtqnlKqf5IGaJM9RK0flnKFpEKQOtI88O2HvYpennkm6SW5orMv8bhbG4N+TO7BbgcHGusWSdu4s2bNmkp3LtbymkhU5SzJxf2PVCaVCeiKMNtbdL3f3VXKXdYLcDQ6l9j0j5XhAHoA1FXhLe7wppcpBOT1Yr6H6Wtr7HB+Dz/YclXKWBCB3SF1t+u/E1HRD5aFVh0vwMVS6cv4kox4+c3nPyHMUojw877sqxRj89dIWZhsJYO6WHlL9Y/ADclVbrgvpWn6ANHa+THqGzEw9wEoppRosrXJSqoEy1rWTuvKTM39jSimlGhrN0CjVAMlD/w6UarF8T/1USqkGQQMapRqmnlKNdnQMPvNJqUop1eBolZNSSimlSp5maJRSSilV8jSgUUoppVTJ04BGKaWUUiVPAxqllFJKlTwNaJRSSilV8vSnD5Qqcca6p4A5MfjfF7ssa8tY119+YbxVjl8gV0qpvLTbtlIFMNZNAvYFluWY5Afy0wNlSX6Z/uMY/OsFTt8aGBKDz/qL43XBWLeR/PLwEcBWMng2cC9waRJI1XRbcqxrvW+fUuVOMzRKFe7eGPwxxS5EwljXNAa/vNjlEBfIb4oVGgT0lt/MWp8X/Hvkt7X6AW8BTYBfArcDLYHhMl3ObTHWNYvB5wpq04qxfUqVNc3QKFUAydDMyRfQGOuOAa4HdorBz5RhtwK7yC+hnw/sDkwC/g/YSH7kcnDyI5jGum2BK+WCuFwuqmfE4N9MleNtoCuwv1yIJyZlM9YNBi4Gfg9cDWwOBOAk4FrAAguBYTH4+2WZLeSXwo8EWgHvAxfH4B+W8RcDPwf+DlwCbAm8AQyMwb9vrJsjGY/lwDsx+F2MdZsD18h2bAi8B5wZg59orDsR+KcEFN8A/WW9twHNYvDLjXXtZX0HAm2A6cB5MfgnpUx3yw3Z88CZwMbAZGBADP6zHPunEjg7Bj8qY/h+QKMY/KQc2zITGAMcCmwag9+mptsXg3/QWHeAPL25B7AAeFr27Xwpxw7AjXK8zAROkX13OrBC1rdF+tfTjXWPAxUx+L61dawrVaq0UbBStSQGfxfwBHAdqy42+wNHyQVtmVRX7QO0BbYDfigX8iRwaAKMAz4BOgGdgVeBp411bVOrOlIyCC2yZGiWyfKdXBh3Aw6RIOpaoB1wKzDaWNdI5rkC+LEEXRsDI4D7jHU/Sy2zqwQXuwMdJci4RLa7o0x3Ugx+F3l/kwQ+XYFNgAnAI8a6NvJL5COAuTH45jH4B7N8nQ8D2wI/laDsDuAJY91eqTL1BjaTdXQHdgWG5dlFbwJDjHV7Zuy3Z2Pwk/JsC8Ag4DQg+eXyGm2fsW5r4DEJeNsBe8p23cvq3956UoLNTrLPzpOAdRlwnwRZ/ZICGes2AQxwS55tVqpsaJWTUoXrZ6w7IsvwO2Pwg+X9icDbxrqBwNmSEXgnNe0KyTQsB5Ya60YCjxrrOsqde3fgJzH4b1h10RoOHA/8RgIRgNkxeJ+nnBsAl8fgvwamG+veAt6NwT8ry3wA+CvQwVi3BBgM/DLJKsmFeRwwRLIeSAAzTJaZNEQ+OE8ZjgSaxOArWJ1RGQ7sALyY70s21u0E7Af0jMHPlsHXGutOBgYAL6W+ywti8FXAHGPdv4Ed8yy6vwRGLxnr5kl27FngwRj8x/nKBLwSg0//yGdNt+8PwGsx+Nvk8yfGumHAFGNdFwluOgK/isF/CXxprLsMOIBVgdYSWcdxwA2yjCOAeUCspuxKlQUNaJQqXLVtaGLwC4x1xwPj5WJ5dcYk72VkVWbIa2egm/xPfmWsS8/TRNp+JD4soKwzU++XAB9lfAZoAWwhyw/GunT9c2O54Cc+TYIZUSnZg1x2By4y1vWQjFGieQFl315e380YPl0yW4kZEsyky9Q+10Jj8O8DPSWA2A/4mVRXjTTWnRKDvzFPmTK/85puXzdgH2Pd0ozhKyQT1UE+p39I9KWMaW8ETjLW9YjBvyXZmjEZ34FSZUsDGqVq3/bAYglSWsn7RGY1b1LtUwlUAV/H4NtUs/xvCyhD5kUu10UvGd6zml49BV80pYfPY1KF8iMJ8rpKQFITjTI+NwbSQddaXchj8B9KgHKbsa6xVB9dY6y7MwZfmWO2777ztdy+KuDxGHyfbCONdb+Tt+nt+14Dxxj8G8a6V4GBxrp/SK+7ku2qr1Rt0zY0StUiY103aZR7iHQJHpUxyXbGumbpz/I6SxqWbmSsS2chkIxCXflQsgS7Zayzs7TrWBvdpS3OJTH4BTJs9xrMnwQGmdVH3eU7qjFj3S7GuuslGPmOZDcel2q6trmXsEY5arp97wE7SwCVlKm5sW5L+ZhUeW2dmmePLMu5EegLHA08G4OfkWUapcqSZmiUqiXSqPcO4NYY/PNS9TTFWDc2Bj9eJmsuVRUXA63luShPyl1+BKYC10kbnAVyBz7KWNctBv9RNUWosRj8YmPdzcA5xrrXgSnSENcDJ0tj1EIsAbpK76S5EiQdaKybKpmEATJdZ3mtADY21m0FLEovKAb/rrFuInCJse5o4AvppdUl1Y6opuZJO6QtjXVnA9Pkhm53aXz7rxj8vMxtSQUsaWuzfaOlt9JFxrpLgWbSi6untBl6UbZzuPSSagv8Kcu675VG3H+R/aOUEpqhUapw/Yx1S3P89ZdGwB3klRj8B3KxvNlYt5ks4xXga8lCTAPmSw8a5MFufYClMn4BcCxwcF0EMylDJUsxQS7EN0nD5UKDGaSt0CnS8PUT6ZZ+JvCVXMiPBe6Xxr1HA49Ib65p0lg3U38JQqZK9uJwoHfSfb2mYvCfSs+iT2VbFwGfScbjAfne19iWHMuq8fbJ/jtUur9/Lpmx9rJvq6Sqq480Kv5E5h8hq1yRWvfipGeUTKOUEvocGqXWE2Pd+cD+Mfj9i10WVf9IdVST5MF90tV7pgRyk1LTjZfG5dkyOEqVLa1yUkqp+uG/wDSpqgS4UKq3XmF1wDME6CVd7ZVSKVrlpJRS9cNR8pC+OZKZ2RI4JAZfYazrJL3lhgG/TrX3UUoJrXJSSimlVMnTDI1SSimlSp4GNEoppZQqeRrQKKWUUqrkaUCjlFJKqZKnAY1SSimlSp4GNEoppZQqef8PrfXA26KOZfwAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "bento_obj_id": "140626190719344",
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}