examples/quickstart/synthetic_slate.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quickstart Example with Synthetic Slate Bandit Data\n",
    "---\n",
    "This notebook provides an example of conducting OPE of several different evaluation policies with synthetic slate bandit data.\n",
    "\n",
    "Our example with synthetic bandit data contains the following four major steps:\n",
    "- (1) Synthetic Slate Data Generation\n",
    "- (2) Defining Evaluation Policies\n",
    "- (3) Off-Policy Evaluation\n",
    "- (4) Evaluation of OPE Estimators\n",
    "\n",
    "The second step could be replaced by some Off-Policy Learning (OPL) method, but obp still does not implement any OPL module for slate bandit data. Implementing OPL for slate bandits is our future work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# needed when using Google Colab\n",
    "# !pip install obp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "# import open bandit pipeline (obp)\n",
    "import obp\n",
    "\n",
    "from obp.ope import SlateStandardIPS, SlateIndependentIPS, SlateRewardInteractionIPS, SlateOffPolicyEvaluation\n",
    "from obp.dataset import (\n",
    "    logistic_reward_function,\n",
    "    SyntheticSlateBanditDataset,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5.2\n"
     ]
    }
   ],
   "source": [
    "# obp version\n",
    "print(obp.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (1) Synthetic Slate Data Generation\n",
    "We prepare easy-to-use synthetic slate data generator: `SyntheticSlateBanditDataset` class in the dataset module.\n",
    "\n",
    "It takes the following arguments as inputs and generates a synthetic bandit dataset that can be used to evaluate the performance of decision making policies (obtained by `off-policy learning`) and OPE estimators.\n",
    "- length of a list of actions recommended in each slate. (`len_list`)\n",
    "- number of unique actions (`n_unique_actions`)\n",
    "- dimension of context vectors (`dim_context`)\n",
    "- reward type (`reward_type`)\n",
    "- reward structure (`reward_structure`)\n",
    "- click model (`click_model`)\n",
    "- base reward function (`base_reward_function`)\n",
    "- behavior policy (`behavior_policy_function`)\n",
    "\n",
    "We use a uniform random policy as a behavior policy here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# generate a synthetic bandit dataset with 10 actions\n",
    "# we use `logistic_reward_function` as the reward function and `linear_behavior_policy_logit` as the behavior policy.\n",
    "# one can define their own reward function and behavior policy such as nonlinear ones. \n",
    "\n",
    "n_unique_action=10\n",
    "len_list = 3\n",
    "dim_context = 2\n",
    "reward_type = \"binary\"\n",
    "reward_structure=\"cascade_additive\"\n",
    "click_model=None\n",
    "random_state=12345\n",
    "base_reward_function=logistic_reward_function\n",
    "\n",
    "# obtain  test sets of synthetic logged bandit data\n",
    "n_rounds_test = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[sample_action_and_obtain_pscore]: 100%|██████████| 10000/10000 [00:03<00:00, 2821.57it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6461\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# define Uniform Random Policy as a baseline behavior policy\n",
    "dataset_with_random_behavior = SyntheticSlateBanditDataset(\n",
    "    n_unique_action=n_unique_action,\n",
    "    len_list=len_list,\n",
    "    dim_context=dim_context,\n",
    "    reward_type=reward_type,\n",
    "    reward_structure=reward_structure,\n",
    "    click_model=click_model,\n",
    "    random_state=random_state,\n",
    "    behavior_policy_function=None,  # set to uniform random\n",
    "    base_reward_function=base_reward_function,\n",
    ")\n",
    "\n",
    "# compute the factual action choice probabililties for the test set of the synthetic logged bandit data\n",
    "bandit_feedback_with_random_behavior = dataset_with_random_behavior.obtain_batch_bandit_feedback(\n",
    "    n_rounds=n_rounds_test,\n",
    "    return_pscore_item_position=True,\n",
    ")\n",
    "\n",
    "# print policy value\n",
    "random_policy_value = dataset_with_random_behavior.calc_on_policy_policy_value(\n",
    "    reward=bandit_feedback_with_random_behavior[\"reward\"],\n",
    "    slate_id=bandit_feedback_with_random_behavior[\"slate_id\"],\n",
    ")\n",
    "print(random_policy_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (2) Evaluation Policy Definition (Off-Policy Learning)\n",
    "After generating synthetic slate bandit data, we now define some evaluation policies in the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_policy_logit_ = np.zeros((n_rounds_test, n_unique_action))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_expected_reward = dataset_with_random_behavior.base_reward_function(\n",
    "    context=bandit_feedback_with_random_behavior[\"context\"],\n",
    "    action_context=dataset_with_random_behavior.action_context,\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimal_policy_logit_ = base_expected_reward * 3\n",
    "anti_optimal_policy_logit_ = -3 * base_expected_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[obtain_pscore_given_evaluation_policy_logit]: 100%|██████████| 10000/10000 [00:12<00:00, 782.75it/s]\n"
     ]
    }
   ],
   "source": [
    "random_policy_pscores = dataset_with_random_behavior.obtain_pscore_given_evaluation_policy_logit(\n",
    "    action=bandit_feedback_with_random_behavior[\"action\"],\n",
    "    evaluation_policy_logit_=random_policy_logit_\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[obtain_pscore_given_evaluation_policy_logit]: 100%|██████████| 10000/10000 [00:14<00:00, 707.16it/s]\n"
     ]
    }
   ],
   "source": [
    "optimal_policy_pscores = dataset_with_random_behavior.obtain_pscore_given_evaluation_policy_logit(\n",
    "    action=bandit_feedback_with_random_behavior[\"action\"],\n",
    "    evaluation_policy_logit_=optimal_policy_logit_\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[obtain_pscore_given_evaluation_policy_logit]: 100%|██████████| 10000/10000 [00:14<00:00, 706.80it/s]\n"
     ]
    }
   ],
   "source": [
    "anti_optimal_policy_pscores = dataset_with_random_behavior.obtain_pscore_given_evaluation_policy_logit(\n",
    "    action=bandit_feedback_with_random_behavior[\"action\"],\n",
    "    evaluation_policy_logit_=anti_optimal_policy_logit_\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (3) Off-Policy Evaluation (OPE)\n",
    "Our next step is OPE, which aims to estimate the performance of evaluation policies using logged bandit data and OPE estimators.\n",
    "\n",
    "Here, we use \n",
    "- `SlateStandardIPS` (SIPS)\n",
    "- `SlateIndependentIPS` (IIPS)\n",
    "- `SlateRewardInteractionIPS` (RIPS)\n",
    "\n",
    "and visualize the OPE results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# estimate the policy value of the evaluation policies based on their action choice probabilities\n",
    "# it is possible to set multiple OPE estimators to the `ope_estimators` argument\n",
    "\n",
    "sips = SlateStandardIPS(len_list=len_list)\n",
    "iips = SlateIndependentIPS(len_list=len_list)\n",
    "rips = SlateRewardInteractionIPS(len_list=len_list)\n",
    "\n",
    "ope = SlateOffPolicyEvaluation(\n",
    "    bandit_feedback=bandit_feedback_with_random_behavior,\n",
    "    ope_estimators=[sips, iips, rips]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          mean  95.0% CI (lower)  95.0% CI (upper) policy_name\n",
      "sips  1.646317          1.631293          1.662105      random\n",
      "iips  1.646317          1.631293          1.662105      random\n",
      "rips  1.646317          1.631293          1.662105      random \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, estimated_interval_random = ope.summarize_off_policy_estimates(\n",
    "    evaluation_policy_pscore=random_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=random_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=random_policy_pscores[2],\n",
    "    alpha=0.05,\n",
    "    n_bootstrap_samples=1000,\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")\n",
    "estimated_interval_random[\"policy_name\"] = \"random\"\n",
    "\n",
    "print(estimated_interval_random, '\\n')\n",
    "# visualize estimated policy values of Uniform Random by the three OPE estimators\n",
    "# and their 95% confidence intervals (estimated by nonparametric bootstrap method)\n",
    "ope.visualize_off_policy_estimates(\n",
    "    evaluation_policy_pscore=random_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=random_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=random_policy_pscores[2],\n",
    "    alpha=0.05,\n",
    "    n_bootstrap_samples=1000, # number of resampling performed in bootstrap sampling\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          mean  95.0% CI (lower)  95.0% CI (upper) policy_name\n",
      "sips  1.629474          1.585960          1.675414     optimal\n",
      "iips  1.674750          1.655507          1.692978     optimal\n",
      "rips  1.626834          1.594925          1.658154     optimal \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, estimated_interval_optimal = ope.summarize_off_policy_estimates(\n",
    "    evaluation_policy_pscore=optimal_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=optimal_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=optimal_policy_pscores[2],\n",
    "    alpha=0.05,\n",
    "    n_bootstrap_samples=1000,\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")\n",
    "\n",
    "estimated_interval_optimal[\"policy_name\"] = \"optimal\"\n",
    "\n",
    "print(estimated_interval_optimal, '\\n')\n",
    "# visualize estimated policy values of Optimal by the three OPE estimators\n",
    "# and their 95% confidence intervals (estimated by nonparametric bootstrap method)\n",
    "ope.visualize_off_policy_estimates(\n",
    "    evaluation_policy_pscore=optimal_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=optimal_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=optimal_policy_pscores[2],\n",
    "    alpha=0.05,\n",
    "    n_bootstrap_samples=1000, # number of resampling performed in bootstrap sampling\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          mean  95.0% CI (lower)  95.0% CI (upper)   policy_name\n",
      "sips  1.691671          1.647720          1.737568  anti-optimal\n",
      "iips  1.602862          1.584707          1.623184  anti-optimal\n",
      "rips  1.687415          1.654940          1.722200  anti-optimal \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgwAAAGSCAYAAACPApmhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABSqUlEQVR4nO3deVhTV/4/8HdYwhJkCQgiaFEWEagg7uBWxWWsdV9qp45VO2Nd6Lej1uloW3Wc/oq1aB231lartnZk0Vaxm6KCFQRRUSqIuIECBUTZdyG/P3zIGCHJjQQT4f16nj6P99xzTz6x1+STc88ikslkMhARERGpYKDrAIiIiEj/MWEgIiIitZgwEBERkVpMGIiIiEgtJgxERESkFhMGIiIiUosJAxEREanFhIGIiIjUYsJAREREahkJrZibm4vff/8dV69eRWFhIcrKyiAWi2FpaQkXFxd4e3vDx8cHYrG4NeMlIiIiHRCpWxo6Li4Ox44dQ3p6utrGJBIJhg8fjrFjx8Le3l5rQRIREZFuKU0Yrly5gn379iErKwvm5ubo168fPD094erqCmtra1hYWKC2thZlZWXIzc1FRkYGUlJScP36dRgZGeFPf/oTpkyZAnNz82f9noiIiEjLlCYMM2fORLdu3TBx4kT07dsXxsbGghr8448/cPz4cRw/fhwTJ07EtGnTtBowERERPXtKE4Zz586hf//+T91wcXExCgoK4OHh8dRtEBERkX5QO4aBiIiISPAsifYqNzdX1yEQERE9E507d1Z6juswEBERkVoqexiWLFmicYMikQhbtmx56oCIiIhI/6hMGO7du/es4iAiIiI9pnLQ49MmDB07dnzqgPQNxzAQEVF7oWoMg8oehrb0xU9ERERPj4MeiYiISC2VPQwNDQ347LPPIBKJEBwcDCOj5qs/fPgQW7ZsgUgkwjvvvNMacRIREZEOqexhSExMRGJiIvr27as0WQAAIyMj9OvXD2fPnkVCQoLWgyQiIiLdUpkwnD17FlKpFIMHD1bbUGBgIKRSKc6cOaO14IiIiEg/qEwYbt68CW9vb4hEIrUNiUQi+Pj44NatW1oLjoiIiPSDyoShuLgYtra2ghuTSqUoKSlpcVBERESkX1QmDEZGRqirqxPcWF1dncqxDkRERPR8Upkw2NjYICsrS3BjWVlZsLGxaXFQREREpF9Udgf06NEDp0+fRl5eHjp16qSyoby8PKSlpWHYsGEaBZCXl4cjR44gIyMDd+/eRc+ePbFmzRqV14SHhyMyMrLZc7NmzcLkyZMBANu2bUNsbGyTOps2bYKTk5NGcZIw06ZNAwCl/3+IiOj5pDJhGDVqFGJiYrBx40asWrUKVlZWzdYrLS3Fpk2b0NDQgKCgII0CuHv3LpKTk+Hu7o76+npB14wcORJ+fn4KZUlJSTh8+DB69+6tUO7k5ISFCxcqlHEFSyIiIs2oTBjc3NwQFBSE6OhoLF26FKNGjYKPjw+kUikA4MGDB7hy5Qqio6NRVlaGUaNGwc3NTaMA+vTpg379+gEAQkNDUVZWpvYaW1vbJoMxDx48CCcnJ7i4uCiUm5iYwMPDQ6OYiIiISJHaEYrz5s1DQ0MDTp48ie+//x7ff/99s/VGjhyJefPmaRyAgUHLV6cuKytDSkoKpk6d2uK2iIiIqCm1CYOhoSEWLFiA4cOH4/jx47h27RqKi4sBANbW1vD09ERQUBB69OjR2rEqlZiYiPr6egQGBjY5l52djTlz5qCurg6urq6YNWsWvLy8dBAlERHR80vwHMgePXroNClQJS4uDt26dYOjo6NCebdu3eDu7g5nZ2eUlpYiKioK69atw7p16zR+dEJERM8HDr5uHc/9oglFRUVIS0vDn//85ybnxo0bp3Dcu3dvLF26FIcOHcKKFSuabS86OhrR0dEAgJCQENjZ2Wk/6DbM2NgYAPj3RkQ6w8+h1vHcJwxnz54FAAQEBKita2Jigt69e+PChQtK6wQFBSnM9CgsLGx5kO1I40Jf/HsjIl3h59DT69y5s9JzLR9xqGNxcXHw9PQUnEmKRCJBe2MQERHR/zzXCUNBQQGuX7/e7GDH5tTW1uLixYvo3r17K0dGRETUtuj8kURNTQ2Sk5MBPFrXoaqqCgkJCQAejTkwMTFBcHAwvLy8mizAFB8fD0NDQwwcOLBJu5WVlQgJCcGQIUPQqVMnlJWV4ccff0RRURGWLl3a+m+MiIioDdF5wlBSUoKNGzcqlDUeb926Ffb29mhoaEBDQ0OTa+Pi4uDj4wNLS8sm54yMjGBpaYlDhw6hpKQExsbG8PDwwJo1a+Dq6to6b4aIiKiNEslkMpmug9Bnubm5ug7hucLpTESka/wcenqtNuixoKAAFy9exMWLF1FQUNCSpqgNOHToEC5cuICzZ8+if//+OHTokK5DIiIiLXmqRxJVVVX4/PPP5WMNGg0aNAhvvfUWTE1NtRIcPT8a17aora0FAOTk5MjXupgyZYouQyOidqTxh0ttbS369++P9957j59BWvJUjyS2bt2KCxcuYPz48ejevTvq6upw/vx5xMbGYvjw4U0GJz7P+EhCmP79+yMnJ6dJuZOTE86dO6eDiIiovWn84VJVVSUvMzMzwyeffMKkQSBVjyRUJgw1NTUwMTFpUj5nzhy8+eabGDJkiEL5pk2bkJKSgq+//roF4eoXbSYMf7z7ptba0jf9vvsZzd1IIgBJr/3pWYfzTDhu+ErXIRDRY/jDpeVUJQwqH0ksX74cCxYsgI+Pj0J5fX09zMzMmtQ3MzNrdjYDtX0O5qbIq6xutpyI9MevR/7QdQitJien+R94OTm5bfZ9j5ngqL6Slqgc9Oju7o5169Zh586dCl08Pj4+2LVrF86cOYOcnBxkZmbi4MGDiI2NxYsvvtjqQZP+WezrAVNDxdvJ1NAAi309dBQREbU3tlIHjcpJMyp7GN5++20MHjwYX375JZKTk/G3v/0NvXv3xptvvokNGzZgy5YtCvW7d++OefPmtWrApJ/+1M0JAPCvxCuoa2hAJ3NTLPb1kJcTEbW2KRMXY+/+j1Bb+7/eTrHYFFMmLtZhVG2HoEGPlZWV2LdvH06dOoUhQ4bgjTfegIWFBVJSUuTPi5ydndtk7wLHMGjmb9GJAICdQQN0HEnr4xgGeh611a75RmfP/Yyvv/kXHj6sg620E6ZMXIxB/dvmOCpA+48knnoMQyNzc3O89dZbCAgIwM6dO7Fs2TLMnz8f/fv3R69evbQWKBERUUsM6v8nnD7zPQDgH0t36jiatkWjhZt69eqFTz/9FP3790doaCg2bdqE0tLS1oqNiIiI9ISghKG0tBS3bt1CaWkpTE1NMX/+fKxZswaZmZn4+9//jjNnzrR2nERERKRDKh9JVFdXY8eOHQorOg4YMACLFi1Cz549sWHDBhw4cADbtm1DfHw8/va3v8Ha2rq1YyYiIqJnTGUPw3fffYeEhAQMGzYM8+fPx/Dhw5GYmIj9+/cDAMRiMf7yl79g3bp1yMvLw9///necOnXqmQRORG3TtGnT5JsHEZH+UNnDkJSUJO9RaFRVVYXz589j/vz58jI3Nzd88skniIyMxJdffomXXnqp9SImIiKiZ05lwlBTUwNbW1uFMltbW1y5cqVpQ0ZGePXVVzFw4EDtRkhEREQ6p3alx9OnTyM9PR0PHz5ERkYGfvvtN7i7uyu9xsXFRdsxElE7wS3SSRv+sXQnp1S2ApU9DHPnzsXatWuxevVqeZlUKsUbb7zR2nERUTvDLdKJ9JvKhKFTp0747LPPcOHCBRQWFsLOzg7+/v4wNeWGQkSkXSEhIQp71gCPxkyFhIQwYSDSA2pXejQxMUFAQMCziIWI1Hhj71ldh9BqVO002Fbf9545g3QdApFggpaGJhKqPewhQa3D1NoW1cWFzZYTke49dcJw/vx5XL16FTU1NbC3t0dAQADs7Oy0GRsRtSNuo15D2g+fo6GuVl5mYCyG26jXdBgVETVSmTB899136NWrF3x8fORlFRUV+OSTT5Cenq5QNywsDAsWLMDQoUNbJ1IiatMcez/67Eg7tB0N9Q9ham0Ht1GvycuJSLdUJgyHDx+GWCxWSBi++OILpKenw97eHoGBgbC0tERGRgbOnj2Lzz//HC4uLujatWurB05EbY9j76HIOR8NAOj713/pOBoiepxGjyTy8vKQmJiIbt26YfXq1TAzMwMAjBs3Dv7+/ti2bRt++uknvPXWW60SLBEREemGRttbX716FQAwa9YsebLQaOjQoXBzc0NaWpr2oiMiIiK9oFEPQ3FxMQDA1dW12fOurq44efJki4MiovaLjyKI9JNGPQyNvQrGxsbNnjc2NoZIJGp5VERERKRX1PYwpKamyv+cl5cHALh37x6cnZ2b1L1//z46dOigxfCIiIhIH6hNGNLS0pqMS7h48WKzCcOtW7fg5OSkveiIiIhIL6hMGB7fdOpxlpaWTcpu3bqF+vp6vPjii9qJjIiIiPSGyoTBy8tLcEPdu3fHtm3bWhwQERER6R+d7yWRl5eHI0eOICMjA3fv3kXPnj2xZs0aldcUFBRgyZIlTcoDAgLwzjvvKJQlJSXhwIEDyMvLg729PaZPn87NtIiIiDSkUcJQX1+P/Px8VFRUQCQSwcrKCh07dmxRAHfv3kVycjLc3d1RX1+v0bWzZ89Gjx495MdPPipJT09HaGgoRo8ejblz5yI5ORmbN2+GRCKBr69vi+ImIiJqTwQlDOfOncOvv/6Kq1evNvlSt7S0RGBgICZNmgRra2uNA+jTpw/69esHAAgNDUVZWZngazt37gwPDw+l5w8ePIiePXti3rx5AAAfHx9kZ2cjMjKSCQMREZEGVK7DIJPJsG3bNoSGhuLKlSsKyYKdnR2cnZ1RWVmJn3/+GcuWLWuyIZWgAAw0WgpCsLq6Oly5cgWDBinuNx8QEICMjAxUVla2yusSERG1RSp7GKKjo3H69Gn4+/tj5syZcHBwQH5+PsLDw3Ht2jWsWrUKHTt2RFxcHL755husX78eoaGhkEqlzyT47du3o7y8HFZWVggMDMSsWbMgFosBAPn5+aivr28yzdPJyQkymQy5ublwc3N7JnESERE971QmDCdPnoSzszOWL18OQ0NDAICLiwuWLVuGFStW4LvvvsPy5csxfPhwuLi44J///Cd++OEH+SOA1mJsbIwxY8bA19cXZmZmSE1NxeHDh5Gfn48VK1YAAMrLywEAEolE4VoLCwsAj7bpbk50dDSiox/tlhcSEgI7Ozutxf2H1loifaDNe4PaJ93cQ/wkakue5T2kMmHIzs7GyJEj5clCI0NDQ7z44ouIjY2Vl7m4uMDf3x/JycmtE+ljbGxsMH/+fPmxt7c3rK2t8dVXXyEzMxMuLi5P3XZQUBCCgoLkx4WFhS0Jldow3hvUUryHqKW0fQ917txZ6TmVAwhEIhFqa2ubPVdbW4u6ujqFMicnJzx48OApQmy5gQMHAni0gBTwv56EJ8cqKOt5ICIiIuVUJgxdunTB+fPn5V+yjcrLy3H+/Hk4OjoqlFdXV8vHEOhK4+ZXDg4OMDQ0RE5OjsL53NxciEQilVkUERERKVKZMLz00ksoKSnBypUrcezYMVy6dAnHjh3DqlWrUFJSgiFDhijUv3v3Ljp16tSqASuTkJAA4NGKk8CjcQ4+Pj7y8kbx8fHw8PCAubn5M4+RiIjoeaVyDENQUBDS0tIQFxeHXbt2KZzz8/PD+PHj5cdVVVWora3VeBXFmpoa+biHBw8eoKqqSv4l37t3b5iYmCA4OBheXl5YuHAhACA8PBzV1dXo0aMHzMzMcPXqVRw5cgT9+/fHCy+8IG976tSpWLNmDfbs2YN+/fohOTkZycnJWLlypUYxEhERtXdqF256++23MXDgQJw7dw4lJSXo0KED/P39ERAQoLCGgpmZGT766CONAygpKcHGjRsVyhqPt27dCnt7ezQ0NKChoUF+3snJCVFRUThx4gRqa2thZ2eHCRMmYMqUKQrteHp6YunSpQgLC8OxY8dgb2+Pt99+m4s2ERERaUgkk8lkug5Cn+Xm5mqtrT/efVNrbZHuOW746pm/5ht7zz7z16TWs2fOIPWVtOzXI5xW2ZaMmeCovpIGnnqWBBERERHAhIGIiIgEYMJAREREajFhICIiIrWYMBAREZFaTBiIiIhILSYMREREpBYTBiIiIlJL44QhLS0NkZGRGp8jIiKi55fGCUNqaioiIiI0PkdERETPLz6SICIiIrWYMBAREZFaTBiIiIhILbXbWwNAYWGh/M8VFRVNygDAzs5Oi2ERERGRPhGUMCxevFhlmUgkwoEDB7QXFREREekVQQnD1KlTIRKJADyaOpmWloZp06a1amBERESkPwQlDDNmzJD/OSIiAmlpaZg+fXqrBUVERET6hYMeiYiISC0mDERERKQWEwYiIiJSS+OEQSaTPdU5IiIien4JGvT4uBkzZigMghR6joiIiJ5ffCRBREREajFhICIiIrWUJgy1tbUtblwbbRAREZHuKU0YFi9ejJ9++gl1dXUaN5qZmYlPPvkER44caVFwREREpB+UDnr09fXF3r17ERERgYCAAAwaNAgeHh4Qi8XN1s/Pz8fly5cRGxuLGzduwM7ODhMmTGi1wImIiOjZUZowLFmyBGPHjsWBAwcQHR2N6OhoGBgYwNnZGdbW1pBIJKirq0N5eTlyc3NRWloKALC0tMSsWbPw8ssvw9jY+Jm9ESIiImo9KqdVurm54f3338cff/yBkydP4sqVK8jMzMSdO3cU6llaWmLAgAHy/4yMNJ6tSURERHpM0De7o6Mj/vznPwMAampq8ODBA5SVlUEsFsPKygo2NjatGiQRERHplsZdASYmJnB0dISjo2NrxENERER6SOfPDvLy8nDkyBFkZGTg7t276NmzJ9asWaPymhs3buDYsWO4evUqioqKYGtri8GDB2PixIkKgzLDw8MRGRnZ5PqVK1fCz89Py++EiIio7dJ5wnD37l0kJyfD3d0d9fX1gq6Jj49Hfn4+Jk6cCEdHR2RlZSEsLAxZWVlYvny5Ql1zc3OsXLlSoczZ2Vlr8RMREbUHOk8Y+vTpg379+gEAQkNDUVZWpvaaSZMmwdLSUn7s7e0NsViMnTt34t69e+jYsaP8nKGhITw8PLQfOBERUTui86WhDQw0D+HxZKGRi4sLAKCoqKilIREREdETdN7DoC0ZGRkQiURwcHBQKK+oqMD8+fNRWVmJLl26YOrUqRgwYICOoiQiIno+tYmEobi4GIcOHcLQoUNhZWUlL+/UqRNef/11uLi4oLq6GsePH0doaCiWLVumNGloXKQKAEJCQmBnZ6e1OP/QWkukD7R5b1D7pJt7iJ9EbcmzvIee+4Th4cOH2LRpE0xNTTFnzhyFc0OHDlU47tOnD95//31ERkYqTRiCgoIQFBQkPy4sLNR+0NQm8N6gluI9RC2l7Xuoc+fOSs9pPIDg4cOHuHTpEo4ePaowZbG2thYlJSVoaGh4uiifgkwmw9atW3H37l3885//hIWFhcr6IpEIAwYMwJ07d55pnERERM87jXoYLl26hB07dqC4uFheNm3aNACPdqj84IMPEBwcjMGDB2s1SGX27NmDpKQkfPDBB3Bycnomr0lERNQeCe5huHnzJjZs2ACRSIQ5c+YgMDBQ4byHhwfs7e1x7tw5rQfZnO+//x6//PILgoOD4enpKegamUyGxMREuLi4PNXsDCIiovZKcA/DwYMHIRaLERISAmtra0RERDSp4+rqitu3b2sUQE1NDZKTkwEADx48QFVVFRISEgAAvXv3homJCYKDg+Hl5YWFCxcCAM6cOYP//ve/GD58OKRSKTIyMuTtderUST7tcvXq1RgwYACcnJxQU1ODEydO4MaNG3j33Xc1ipGIiKi9E5wwXLt2Df369YO1tbXSOnZ2dvIvf6FKSkqwceNGhbLG461bt8Le3h4NDQ0KYw4uX74MAIiJiUFMTIzCtYsWLcLw4cMBPEoefvrpJxQVFcHAwADdunXDe++9h969e2sUIxERUXsnOGGorq5udsGkx9XU1Gg8mNDe3h7h4eEq62zbtk3hePHixVi8eLHatht7JIiIiKhlBD/Il0qluHv3rso6mZmZTRZOIiIiouef4ITBz88Ply9fRnp6erPnk5OTkZGRAX9/f60FR0RERPpB8COJyZMnIz4+Hv/+978xduxY3Lt3DwBw8eJFpKWl4ddff4W1tTXGjx/fasESERGRbghOGKRSKVatWoVNmzYhKipKXr5+/XoAgIODA5YvX652nAMRERE9fzRauKl79+7YvHkzLl68iIyMDJSVlcHc3Bzu7u7o168fDA0NWytOIiIi0iGN95IwMDBA37590bdv39aIh4iIiPQQlzskIiIitQT3MMTGxgpudNiwYU8VDBEREeknwQnD9u3bBTfKhIGIiKhtEZwwKFs1sbKyEjdu3EB8fDz69+/PdRiIiIjaIMEJQ+P+DMq89NJLCAkJwbhx41oaExEREekZrQ16fPHFF+Hr64uwsDBtNUlERER6QquzJDp37oxbt25ps0kiIiLSA1pNGLKzs7XZHBEREekJjRduelJDQwPu37+PEydOIDk5Gb1799ZGXERERKRHBCcMM2fOVFvHwsICr7/+eosCIiIiIv0jOGHo2bMnRCJRk3KRSASJRAI3Nze89NJL3HyKiIioDRKcMKxZs6YVwyAiIiJ9xr0kiIiISC0mDERERKSW0kcSmuwd8TiRSKR0GWkiIiJ6PilNGDTZnfJJTBiIiIjaFqUJw9atW59lHERERKTHlCYMHTt2fJZxEBERkR7joEciIiJS66mWhm5oaEBpaSkePnzY7Hk7O7sWBUVERET6RaOE4c6dO9i/fz9SU1NRV1fXbB2RSIQDBw5oJTgiIiLSD4IThuzsbLz//vsAgF69euHChQt44YUXYGVlhdu3b6OsrAze3t7sXSAiImqDBCcMhw4dQn19PT7++GN07doVM2fORP/+/TFt2jRUV1fj66+/RnJyMhYtWtSa8RIREZEOCB70mJqaCn9/f3Tt2lVeJpPJAACmpqb429/+BolEgrCwMO1HSURERDoluIehrKwMjo6O8mMDAwPU1NTIjw0NDeHt7Y2kpCSNAsjLy8ORI0eQkZGBu3fvomfPnoI2uqqsrMSePXuQlJSEhoYG9OnTB3PnzkWHDh0U6iUlJeHAgQPIy8uDvb09pk+fjoCAAI1iJCIiau8E9zBYWFigurpafmxpaYnCwkKFOkZGRqisrNQogLt37yI5ORmdO3dG586dBV+3adMmpKamYsGCBVi8eDFu3ryJDRs2KNRJT09HaGgovL298c9//hP+/v7YvHkzLl++rFGMRERE7Z3gHgYHBwcUFBTIj7t164bff/8dJSUlsLKyQnV1Nc6fPw97e3uNAujTpw/69esHAAgNDUVZWZnaazIyMnD58mWsWbMGXl5eAACpVIqVK1ciJSUFvXr1AgAcPHgQPXv2xLx58wAAPj4+yM7ORmRkJHx9fTWKk4iIqD0T3MPg6+uL1NRUeS/D6NGjUV5ejhUrVmDjxo1Yvnw57t27hxEjRmgWgIHma0clJyfDyspKniwAgJubG+zt7XHp0iUAQF1dHa5cuYJBgwYpXBsQEICMjAyNe0KIiIjaM8Hf1iNHjsTChQtRW1sLAPD398ecOXNQW1uLxMRElJSUYOLEifjTn/7UasE2ysnJgZOTU5NyJycn5OTkAADy8/NRX1/fpJ6TkxNkMhlyc3NbPU4iIqK2QuUjiRUrViAoKAhDhgyBjY1Nk8GC48aNw9ixY1FaWgorKyuIRKJWDbZRRUUFzM3Nm5RLJBL5Y5Py8nJ52eMsLCzkbTQnOjoa0dHRAICQkBCtrivxh9ZaIn3ANUeopXRzD/GTqC15lveQyoQhKysLu3btwrfffouAgACMHDkS7u7uCnUMDAxgbW3dmjE+U0FBQQgKCpIfPzmwk6gR7w1qKd5D1FLavodUTT5QmTCsW7cO0dHRSEhIwKlTp3Dq1Cl07doVI0eOxNChQ5v9lf8sSCSSZgdHVlRUyHsUGnsSnhyroKzngYiIiJRTOYbBw8MDixYtwhdffIH58+ejW7duuHPnDr7++mssWLAA27ZtQ3p6+rOKVe7xsQqPy83NlY9ZcHBwgKGhYZN6ubm5EIlEGk3hJCIiau8ETas0MzPD6NGjMXr0aGRmZiI6OhpxcXE4ffo0Tp8+DWdnZ3mvQ+Mv+9bUu3dvHDx4EOnp6fD09AQA3Lx5E/n5+fDz8wMAGBsbw8fHBwkJCRg1apT82vj4eHh4eOisd4SIiOh5pPGcRhcXF7z55pv44osvsGjRIvTo0QPZ2dnYu3cv3nrrLWzZskWj9mpqapCQkICEhAQ8ePAApaWl8uPGlSSDg4OxY8cO+TUeHh7w9fXF1q1bkZiYiHPnzuE///kPPD095WswAMDUqVORmpqKPXv2IDU1Fd9++y2Sk5Mxbdo0Td82ERFRu6bR9taPE4vFGDZsGIYNG4bc3Fx88cUXSE9Px5kzZxAcHCy4nZKSEmzcuFGhrPF469atsLe3R0NDAxoaGhTqvPPOO9i7dy927NgBmUwGf39/zJ07V6GOp6cnli5dirCwMBw7dgz29vZ4++23uWgTERGRhp46YQAeDSCMjY3FyZMnkZ2dDQAad/Xb29sjPDxcZZ1t27Y1KZNIJFi0aJHa3TH79++P/v37axQTERERKXqqhOHKlSuIjo5GUlISHj58CABwd3dHUFAQN3YiIiJqgwQnDMXFxTh16hROnjwpXxxJIpHI1y3o0qVLqwVJREREuqUyYZDJZLh48SJOnDiB5ORk+TgCT09PjBw5EgMHDoRYLH4mgRIREZHuqEwYFi1ahAcPHgB4tBDS0KFDERQU1Ow+DkRERNR2qUwYHjx4AC8vL3lvgpFRi8ZIEhER0XNKZQbw2WefwdHR8VnFQkRERHpK5cJNTBaIiIgIeIqVHomIiKj9YcJAREREajFhICIiIrWYMBAREZFaTBiIiIhILcEJQ2JiYpMdI4mIiKh9ELwS08aNG2FjY4OXXnoJI0eOhJ2dXWvGRURERHpEcA/DmDFjUFNTg0OHDiE4OBghISG4cOECZDJZa8ZHREREekBwD8O8efPw+uuvIz4+HsePH0dycjKSk5MhlUoxcuRIjBgxAlKptDVjJSIiIh3RaHMIsViM4cOHY/jw4bhz5w6io6Px22+/ISIiAgcPHoS/vz9GjRoFPz+/VgqXiIiIdOGpd5Pq2rWrQq9DWFgYzp8/j/Pnz8POzg5jxozB6NGjYWpqqs14iYiISAdaNK2yuroap0+fxi+//CLfBtvFxQXl5eXYv38//v73vyMzM1MbcRIREZEOPVUPw+3bt3H8+HHExcWhuroaYrEYI0aMwJgxY+Di4oLq6mr8+uuvCA8Px9dff421a9dqO24iIiJ6hgQnDDU1NYiLi8Px48dx69YtAICTkxNGjRqFYcOGwdzcXF7X1NQUEydOxP3793Hy5EntR01ERETPlOCEYcGCBaiqqoKBgQEGDBiAMWPGwNvbW+U1UqkUdXV1LQ6SiIiIdEtwwmBmZobx48cjKCgI1tbWgq4ZPXo0AgMDnzY2IiIi0hOCE4Zt27bBwECzMZLm5uYKjyqIiIjo+SQ4A9A0WSAiIqK2Q3AWcPDgQcyaNUs+ffJJDx48wKxZs/DDDz9oKzYiIiLSE4IThgsXLsDLy0vp8s9SqRQ+Pj5ISkrSWnBERESkHwQnDHl5eXB2dlZZx8nJCXl5eS0OioiIiPSL4IShtrYWJiYmKuuIxWJUV1e3OCgiIiLSL4ITBltbW1y/fl1lnevXr3PHSiIiojZIcMLg6+uLtLQ0xMfHN3s+Li4OaWlp3KmSiIioDRK8DsOkSZNw5swZbN68GfHx8fDz84NUKsWDBw+QnJyM8+fPw8LCApMmTdIogOzsbOzevRsZGRmQSCQYMWIEpk+frnIaZ3h4OCIjI5s9N2vWLEyePBnAo7UjYmNjm9TZtGkTnJycNIqTiIioPROcMEilUqxatQobN25EUlJSk9kQHTt2xNKlS2Frayv4xcvLy7Fu3To4OztjxYoVyMvLwzfffAOZTIZXX31V6XUjR45s0pORlJSEw4cPo3fv3grlTk5OWLhwYZNYiYiISDiNdqt0dXXF5s2bceHCBVy/fh0VFRWQSCRwd3dHnz59YGSk2eaXx48fR21tLZYtWwZzc3P06tULVVVViIiIwIQJE5SuEmlra9skMTl48CCcnJzg4uKiUG5iYgIPDw+N4iIiIiJFGm9vbWRkhAEDBmDAgAEtfvFLly7B19dXITEIDAzE/v37kZaWhr59+wpqp6ysDCkpKZg6dWqLYyIiIqKmNE4YtCknJ6fJjpd2dnYwMTFBbm6u4HYSExNRX1/f7EZX2dnZmDNnDurq6uDq6opZs2bBy8urxbETERG1J0oThsbBgv3794eZmVmzgweVGTZsmKB6jY80niSRSFBeXi749eLi4tCtWzc4OjoqlHfr1g3u7u5wdnZGaWkpoqKisG7dOqxbtw5ubm7NthUdHY3o6GgAQEhICOzs7ATHoc4fWmuJ9IE27w1qn3RzD/GTqC15lveQ0oRh+/btAAB3d3eYmZnJj4UQmjBoQ1FREdLS0vDnP/+5yblx48YpHPfu3RtLly7FoUOHsGLFimbbCwoKQlBQkPy4sLBQuwFTm8F7g1qK9xC1lLbvoc6dOys9pzRhaJxZYGNjo3CsTRKJBJWVlU3KKyoqYGFhIaiNs2fPAgACAgLU1jUxMUHv3r1x4cIFzQIlIiJq55QmDMOHD1d5rA1OTk7IyclRKCssLERNTY3KLOdxcXFx8PT0FNwtIxKJIBKJNI6ViIioPRO80mNr8PPzw+XLl1FVVSUvi4+Ph1gsFjQwsaCgANevX292sGNzamtrcfHiRXTv3v2pYyYiImqPdDpLYtSoUfj555/x6aefYuLEiSgoKEBERATGjx+vMNUyODgYXl5eTR6LxMfHw9DQEAMHDmzSdmVlJUJCQjBkyBB06tQJZWVl+PHHH1FUVISlS5e2+nsjIiJqS5QmDEuWLHmqBkUiEbZs2SKoroWFBT788EPs2rUL69evh0Qiwcsvv4wZM2Yo1GtoaEBDQ0OT6+Pi4uDj4wNLS8sm54yMjGBpaYlDhw6hpKQExsbG8PDwwJo1a+Dq6vpU742IiKi9UpowyGSyp2pQ0+ucnZ2xevVqlXW2bdvWbPmGDRuUXiMWi7F8+XKNYiEiIqLmKU0YlH1JExERUfuj00GPRERE9Hx46oShqqoKhYWFza6jQERERG2LRrMk6uvrERUVhRMnTqCgoEBebm9vj5EjR+KVV16BoaGh1oMkIiIi3RKcMDx8+BAfffQR0tLSIBKJYGdnB2traxQXF+PevXv473//i0uXLuH999/XeJtrIiIi0m+Cv9mPHj2KtLQ0+Pv74y9/+YvCRk95eXnYt28fLly4gKNHj2LSpEmtESsRERHpiOAxDGfOnEGXLl3w7rvvNtkVslOnTli+fDm6dOmC3377TetBEhERkW4JThjy8vLg5+cHA4PmLzEwMICfnx/y8/O1FhwRERHpB8EJg5GREaqrq1XWqamp4aBHIiKiNkhwwvDCCy8gMTERpaWlzZ4vLS1FQkICXFxctBUbERER6QnBCcOYMWNQWlqKf/7znzh58iTy8/NRW1uLgoICnDp1CqtWrUJpaSnGjBnTmvESERGRDgieJREQEIDMzEwcPnwYX3zxRbN1JkyYgICAAK0FR0RERPpBowUTXnvtNfTt2xcnT55EZmYmKisrYW5uDhcXF4wYMQIeHh6tFScRERHpkOCEoaysDCKRCB4eHkwMiIiI2hm1CUNSUhL27dsnXwq6U6dOmD17Nvr27dvqwREREZF+UDnoMSMjA6GhoQr7RuTl5SE0NBQZGRmtHhwRERHpB5UJw9GjRyGTyTB16lR8+eWX2LlzJ6ZMmYKGhgYcPXr0WcVIREREOqbykcT169fh6emJGTNmyMtmzpyJtLQ09jAQERG1Iyp7GEpKSuDu7t6k3N3dXekCTkRERNT2qEwY6uvrYWpq2qTcxMQE9fX1rRYUERER6RfBKz0SERFR+6V2WmVMTAxSU1MVyu7duwcAWLt2bZP6IpEIH374oZbCIyIiIn2gNmG4d++ePEF4UlpamtYDIiIiIv2jMmFYvXr1s4qDiIiI9JjKhMHLy+tZxUFERER6jIMeiYiISC0mDERERKQWEwYiIiJSiwkDERERqcWEgYiIiNRSuw5Da8vOzsbu3buRkZEBiUSCESNGYPr06TAwUJ7LFBQUYMmSJU3KAwIC8M477yiUJSUl4cCBA8jLy4O9vT2mT5+OgIAAbb8NIiKiNk2nCUN5eTnWrVsHZ2dnrFixAnl5efjmm28gk8nw6quvqr1+9uzZ6NGjh/zY0tJS4Xx6ejpCQ0MxevRozJ07F8nJydi8eTMkEgl8fX21/n6IiIjaKp0mDMePH0dtbS2WLVsGc3Nz9OrVC1VVVYiIiMCECRNgbm6u8vrOnTvDw8ND6fmDBw+iZ8+emDdvHgDAx8cH2dnZiIyMZMJARESkAaUJQ2Rk5FM3Om3aNEH1Ll26BF9fX4XEIDAwEPv370daWhr69u371DHU1dXhypUrmDt3rkJ5QEAAtm/fjsrKSrUJCRERET2iNGGIiIh46kaFJgw5OTnw9vZWKLOzs4OJiQlyc3PVXr99+3aUl5fDysoKgYGBmDVrFsRiMQAgPz8f9fX1cHJyUrjGyckJMpkMubm5cHNzE/iOiIiI2jelCUNz+0gcPXoUycnJGDJkCLy8vGBtbY3i4mKkpqbizJkz8Pf3x8svvyz4xSsqKiCRSJqUSyQSlJeXK73O2NgYY8aMga+vL8zMzJCamorDhw8jPz8fK1asAAD59U+2b2FhIX9tIiIiEkZpwvDkPhKxsbH4/fff8dFHH6F79+4K54YPH46xY8di9erVGDBgQOtE+hgbGxvMnz9ffuzt7Q1ra2t89dVXyMzMhIuLy1O3HR0djejoaABASEgI7OzsWhqu3B9aa4n0gTbvDWqfdHMP8ZOoLXmW95DgQY8//vgjBg0a1CRZaOTq6opBgwbhxx9/xNChQwW1KZFIUFlZ2aS8oqJC3hMg1MCBA/HVV1/h1q1bcHFxkV//ZPvKeh4aBQUFISgoSH5cWFioURzUfvDeoJbiPUQtpe17qHPnzkrPCV64KTc3FzY2Nirr2NjYCBp70MjJyQk5OTkKZYWFhaipqVEZtCoikQgA4ODgAENDwybt5+bmQiQSPXX7RERE7ZHghMHMzAzXrl1TWefatWswNTUV/OJ+fn64fPkyqqqq5GXx8fEQi8Uab62dkJAAAPIeEGNjY/j4+MjLH2/fw8ODMySIiIg0IDhh8Pf3x9WrV7Fv3z6FL3gAqKqqwr59+5Ceno4+ffoIfvFRo0bB2NgYn376KVJSUhAdHY2IiAiMHz9e4Qs9ODgYO3bskB+Hh4dj3759SExMREpKCsLCwrB37170798fL7zwgrze1KlTkZqaij179iA1NRXffvstkpOTBc/iICIiokcEj2F47bXXkJaWhh9//BEnT56Ei4sLrKysUFJSgszMTFRVVcHe3h6zZs0S/OIWFhb48MMPsWvXLqxfvx4SiQQvv/wyZsyYoVCvoaEBDQ0N8mMnJydERUXhxIkTqK2thZ2dHSZMmIApU6YoXOfp6YmlS5ciLCwMx44dg729Pd5++20u2kRERKQhkUwmkwmtXFZWhu+++w5nzpxBbW2tvFwsFmPIkCGYNWsWOnTo0CqB6oomYzLU+ePdN7XWFume44avnvlrvrH37DN/TWo9e+YMeuav+esRzpJoS8ZMcNRqe6rG92m0NHSHDh2wYMECvPnmm8jJyZGvlujk5ARDQ8MWB0pERET66an2kjA0NETXrl21HQsRERHpKY0ThocPH+LKlSvIzs5GdXW1fABhbW0tqqqq0KFDB5VbUxMREdHzR6OE4dKlS9ixYweKi4vlZY0JQ2ZmJj744AMEBwdj8ODBWg2SiIiIdEtwV8DNmzexYcMGiEQizJkzB4GBgQrnPTw8YG9vj3Pnzmk9SCIiItItwQnDwYMHIRaLERISgnHjxsHRsenITFdXV2RlZWk1QCIiItI9wQnDtWvX0K9fP1hbWyutY2dnp/C4goiIiNoGwQlDdXU1LC0tVdapqalRWGCJiIiI2gbBCYNUKsXdu3dV1snMzISDg0OLgyIiIiL9IjhhaNwoKj09vdnzycnJyMjIgL+/v9aCIyIiIv0geFrl5MmTER8fj3//+98YO3Ys7t27BwC4ePEi0tLS8Ouvv8La2hrjx49vtWCJiIhINwQnDFKpFKtWrcKmTZsQFRUlL1+/fj0AwMHBAcuXL1c7zoGIiIiePxot3NS9e3ds3rwZFy9eREZGBsrKymBubg53d3f069eP+0kQERG1URovDW1gYIC+ffuib9++rREPERER6SHBgx7Xrl2L2NhYlXVOnz6NtWvXtjgoIiIi0i+CE4a0tDT5QEdlCgsLkZaW1uKgiIiISL9odVvJ2tpajmMgIiJqgzQew9AcmUyGwsJCJCcnw9bWVhtNEhERkR5RmTDMnDlT4TgiIgIREREqG5w8eXLLoyIiIiK9ojJh6NmzJ0QiEYBHYxjs7Oxgb2/fpJ6BgQEsLCzw4osvYsSIEa0TKREREemMyoRhzZo18j/PnDkTL730EqZNm9baMREREZGeETyGYevWrZBIJK0ZCxEREekpwQlDx44dWzMOIiIi0mMaz5IoKirC77//jgcPHuDhw4fN1uFjCyIiorZFo4QhPDwcP/zwA+rr61XWY8JARETUtghOGH777TccPHgQPj4+GDNmDEJDQzFs2DD4+voiNTUVp06dwsCBAzFq1KjWjJeIiIh0QHDCcOzYMUilUqxcuVK+mqO9vT0CAwMRGBiI/v37IyQkBIGBga0WLBEREemG4KWh79y5g969eyss/dzQ0CD/s5+fH3x9fREVFaXdCImIiEjnBCcM9fX16NChg/xYLBajsrJSoU6XLl2QmZmpteCIiIhIPwhOGGxsbFBUVCQ/trOzQ1ZWlkKdoqIibj5FRETUBglOGFxcXHD37l35sbe3N9LT03H69GlUV1fj4sWLSEhIQLdu3VolUCIiItIdwYMe+/Tpg6+++goFBQWwt7fHpEmTcPbsWWzbtg3btm171JiRUZMNq9TJzs7G7t27kZGRAYlEghEjRmD69OkwMFCey9y4cQPHjh3D1atXUVRUBFtbWwwePBgTJ06EWCyW1wsPD0dkZGST61euXAk/Pz+N4iQiImrPBCcMw4cPx/Dhw+XHdnZ2+PjjjxEVFYX8/Hx07NgRY8aMQdeuXQW/eHl5OdatWwdnZ2esWLECeXl5+OabbyCTyfDqq68qvS4+Ph75+fmYOHEiHB0dkZWVhbCwMGRlZWH58uUKdc3NzbFy5UqFMmdnZ8ExEhER0VOs9Pg4e3t7zJ8//6mvP378OGpra7Fs2TKYm5ujV69eqKqqQkREBCZMmABzc/Nmr5s0aRIsLS3lx97e3hCLxdi5cyfu3bunsIy1oaEhPDw8njpGIiIi0mAMQ2u4dOkSfH19FRKDwMBA1NbWIi0tTel1jycLjVxcXABAYWAmERERaYfGPQwNDQ148OCByr0kvLy8BLWVk5MDb29vhTI7OzuYmJggNzdXo7gyMjIgEong4OCgUF5RUYH58+ejsrISXbp0wdSpUzFgwACN2iYiImrvNEoYjhw5gqioKJSWlqqsFxYWJqi9ioqKZrfMlkgkKC8vFxxXcXExDh06hKFDh8LKykpe3qlTJ7z++utwcXFBdXU1jh8/jtDQUCxbtkxp0hAdHY3o6GgAQEhICOzs7ATHoc4fWmuJ9IE27w1qn3RzD/GTqC15lveQ4IQhPDwcBw8ehIWFBYYNGwapVKoXay48fPgQmzZtgqmpKebMmaNwbujQoQrHffr0wfvvv4/IyEilCUNQUBCCgoLkx4WFhdoPmtoE3hvUUryHqKW0fQ917txZ6TnBCcOpU6dgb2+P9evXKx2MqCmJRNJktUjgUc+DhYWF2utlMhm2bt2Ku3fvYt26dWqvEYlEGDBgAPbv34+GhgaVUzeJiIjofwR/Y5aVlaFv375aSxYAwMnJCTk5OQplhYWFqKmpUZnlNNqzZw+SkpKwYsUKODk5aS0uIiIiUiQ4YejUqRMqKiq0+uJ+fn64fPkyqqqq5GXx8fEQi8VqB05+//33+OWXXxAcHAxPT09BryeTyZCYmAgXFxf2LhAREWlA8COJ0aNHIywsDMXFxbC2ttbKi48aNQo///wzPv30U0ycOBEFBQWIiIjA+PHjFXoygoOD4eXlhYULFwIAzpw5g//+978YPnw4pFIpMjIy5HU7deokn3a5evVqDBgwAE5OTqipqcGJEydw48YNvPvuu1qJn4iIqL3QKGH4448/8MEHH2Dq1Kno3r270scTQkdtWlhY4MMPP8SuXbuwfv16SCQSvPzyy5gxY4ZCvYaGBoWttC9fvgwAiImJQUxMjELdRYsWyVek7NSpE3766ScUFRXBwMAA3bp1w3vvvYfevXsLfNdEREQEACKZTCYTWjkmJgZ79+5tdqCivEGRCAcOHNBKcPpA0/UgVPnj3Te11hbpnuOGr575a76x9+wzf01qPXvmDHrmr/nrEU6rbEvGTHDUantamSVx4sQJ7Ny5E4aGhvD29oaNjY1eTKskIiKi1ic4YYiKioKVlRX+/e9/w97evjVjIiIiIj0jeKrAvXv3MHDgQCYLRERE7ZDghEEqlSrdO4KIiIjaNsEJw7Bhw5CcnKywZgIRERG1D4IThsmTJ8PNzQ3r1q1DamoqEwciIqJ2RPCgx9dee03+53/9619K67W1aZVERESkQcLQs2dPiESi1oyFiIiI9JTghGHNmjWtGAYRERHpM+7ARERERGoxYSAiIiK1lD6SiIyMBACMHTsWFhYW8mMhpk2b1vLIiIiISG8oTRgiIiIAAAEBAbCwsJAfC8GEgYiIqG1RmjCsXr0awP+2qm48JiIiovZHacLg5eWl8piIiIjaD8GDHmNjY5GVlaWyzp07dxAbG9vioIiIiEi/CE4Ytm/fjqSkJJV1zp8/j+3bt7c4KCIiItIvWp1W2dDQwNUgiYiI2iCtJgy5ubmQSCTabJKIiIj0gMqloZ98vJCUlISCgoIm9RoaGnD//n1cvXoV/v7+2o2QiIiIdE5lwvDkAMbMzExkZmYqre/u7o45c+ZoJTAiIiLSHyoThq1btwIAZDIZgoODMW7cOIwbN65JPQMDA0gkEpiamrZOlERERKRTKhOGjh07yv88bdo0eHt7K5QRERFR+yB4e+vp06e3ZhxERESkxwQnDLdv30ZGRgaGDBkCc3NzAEB1dTW++uornD9/HiYmJpg4cWKzjyyIiIjo+SZ4WuXhw4dx6NAhebIAAN999x1+++03yGQylJWVYe/evbh8+XKrBEpERES6IzhhuHnzJry9veXHDx8+RGxsLNzc3PDll19i69atsLS0xM8//9wqgRIREZHuCE4YSktLYWtrKz++desWqqurERQUBLFYDKlUir59+6rdb4KIiIiePxqt9FhfXy//c3p6OgDFXSwtLS1RWlqqpdCIiIhIXwhOGOzs7HD9+nX5cVJSEmxtbeHg4CAvKyoqgoWFhXYjJCIiIp0TPEti0KBBiIiIQGhoKIyNjZGRkYGXX35ZoU5OTo5CAkFERERtg+CEYfz48bh8+TLOnTsHAHBxccG0adPk5wsKCnDjxg1MnjxZowCys7Oxe/duZGRkQCKRYMSIEZg+fToMDFR3flRWVmLPnj1ISkpCQ0MD+vTpg7lz56JDhw4K9ZKSknDgwAHk5eXB3t4e06dPR0BAgEYxEhERtXeCEwZTU1OsW7cOd+7cAQA4Ozs3+VJfvnw5XF1dBb94eXk51q1bB2dnZ6xYsQJ5eXn45ptvIJPJ8Oqrr6q8dtOmTcjNzcWCBQtgYGCA/fv3Y8OGDfjXv/4lr5Oeno7Q0FCMHj0ac+fORXJyMjZv3gyJRAJfX1/BcRIREbV3ghOGRl27dm223N7eHvb29hq1dfz4cdTW1mLZsmUwNzdHr169UFVVhYiICEyYMEFhzYfHZWRk4PLly1izZo180KVUKsXKlSuRkpKCXr16AQAOHjyInj17Yt68eQAAHx8fZGdnIzIykgkDERGRBlT2+6elpaGwsFBwY1lZWU12uFTl0qVL8PX1VUgMAgMDUVtbi7S0NKXXJScnw8rKSmGGhpubG+zt7XHp0iUAQF1dHa5cuYJBgwYpXBsQEICMjAxUVlYKjpOIiKi9U5kwrF27FjExMQplP/zwg/wX+5POnTuH7du3C37xnJwcdO7cWaHMzs4OJiYmyM3NVXmdk5NTk3InJyfk5OQAAPLz81FfX9+knpOTE2Qymcr2iYiISJHGjyTq6upQUVGhlRevqKiARCJpUi6RSFBeXq7yuuYeV0gkEhQUFACA/Pon22+c9qnsPURHRyM6OhoAEBIS0iShaYnO+3/SWlvUPh3751Rdh0DPublvae8zjdoXjRZuag+CgoIQEhKCkJAQXYfy3Hrvvfd0HQI953gPUUvxHtI+nSYMEomk2bEEFRUVKheAkkgkqKqqava6xh6FxuufbF9ZzwMREREpp9OE4fExB40KCwtRU1Oj8lFAc9cBQG5urnzMgoODAwwNDZvUy83NhUgk0uqjBiIiorZOpwmDn58fLl++rNBbEB8fD7FYrDAD4km9e/dGcXGxfD8L4NFumvn5+fDz8wMAGBsbw8fHBwkJCQrXxsfHw8PDQ+mUTWq5oKAgXYdAzzneQ9RSvIe0T6cJw6hRo2BsbIxPP/0UKSkpiI6ORkREBMaPH6/whR4cHIwdO3bIjz08PODr64utW7ciMTER586dw3/+8x94enrK12AAgKlTpyI1NRV79uxBamoqvv32WyQnJyusUEnax3+o1FK8h6ileA9pn0gmk8mUnZw5c+ZTNRoWFia4bnZ2Nnbt2qWwNPSMGTMUVpFcvHgxvLy8sHjxYnlZRUUF9u7di3PnzkEmk8Hf3x9z586FpaWlQvvnzp1DWFgY/vjjD/nS0IGBgU/1voiIiNornScMREREpP9UJgxET4qJicH27duxaNEiDB8+XNfhkB5LTU3F2rVrMW3aNMyYMQMAMGPGDHh5eWHNmjW6DY6ea/wc0g2uw0BERERqsYeBNFJZWYmioiLY2NhwpgmpVFNTg8LCQnTo0EE+tignJwcmJiaws7PTcXT0POPnkG4wYSAiIiK1NN5Lgtq2uLg4/Pzzz/jjjz9QXV0NS0tLdO/eHVOnTkX37t2bfXZYUFCAJUuWYNiwYRg3bhy+/fZbXL9+HYaGhvDz88Ps2bMhlUoVXufGjRs4dOgQbt68ibKyMkgkEnTu3BmjRo3C4MGDdfDOSduEjmFYs2YN0tLS8M033+C7775DQkICysvL0bVrV0ybNg19+vRRaLe8vByHDx/GuXPncP/+fRgZGUEqlcLHxwd/+ctfYGTEj7W24PH7x8vLCxEREbh9+zYcHBzw8ssv83NIBziGgeR+/vlnbN68GSUlJQgMDMS4cePg5eWFmzdvIiMjQ+31+fn5WLNmDYyMjDB27Fh4eHggLi4OH3zwgcJmYrdu3cIHH3yAq1evwtfXF+PHj0efPn1QVVWFc+fOteZbJD22ceNGXLx4EYGBgRg2bBhyc3PxySefKCy+JpPJ8NFHH+HIkSNwcHDA2LFjMWzYMHTs2BEnTpzAw4cPdfgOqDVcu3YNH330EczNzTF69Gi8+OKLKuvzc6j1MBUnuZiYGNjY2ODTTz+FiYmJvLyhoaHZPT+elJ6ejhkzZigsjBUZGYnw8HBERkbijTfeAAD89ttvqK+vx+rVq+Hi4qLQRllZmVbeCz1/7t+/jw0bNsDU1BQAMH78eKxYsQK7du1C3759YWRkhDt37uDmzZsYN26c/H5qVFFRAbFYrIPIqTX9/vvvePvttxV+8cfExCitz8+h1sMeBlJgbGwMQ0NDhTIDAwOVm4E1srCwwCuvvKJQ9sorr0AikeDMmTNN6jd+MTyuQ4cOGkZMbcXkyZMV7onOnTtj6NChKCkpQUpKikLd5u4diUSisOAbtQ2urq4aPR7g51Dr4b8ukhs0aBAKCgqwbNkyhIeHIzU1FbW1tYKv79atm0LPBACYmJigW7duKC0tRVFRkfx1RCIRVq5cid27dyMpKUmhq5DaJ09PT6VlWVlZAABnZ2d06dIF33//PUJCQnDs2LFmN6KjtqN79+4a1efnUOvhIwmSmzhxIiQSCY4dO4bIyEhERkbCxMQEQ4YMwezZs2FmZqbyemVZeeOUuqqqKtjY2MDDwwMffvghDh06hOPHj+OXX36BSCSCr68v3njjDe4k2k49uaz742WNG9QZGhpi9erVCAsLQ2JiIi5evAjg0e6006ZNw7Bhw55dwPRMWFlZaVSfn0OthwkDyYlEIowaNQqjRo1CcXExrly5ghMnTiA6Ohq1tbVYsmSJyuuVPfcrLS0FAIWEw9vbG97e3qiurkZ6ejrOnj2LmJgYfPzxx9i0aRNHurdDpaWlsLW1bVIGKN47lpaW+Otf/4r58+fjzp07uHTpEn766Sds27YNUqlU7aA4atv4OdR6+EiCmmVtbY3Bgwfj/fffh1QqxYULF9Rec/v2bdTU1CiU1dTU4Pbt27C0tISNjU2Ta0xNTeHn54eFCxdi0KBByM/PR3Z2ttbeBz0/Ht+u/smyF154ock5AwMDuLi4YNKkSVi0aBEACLpPqW3j51DrYcJAcmlpaU3KqqurUVNTIyjTLi8vR1RUlEJZVFQUKioqFAYtZWRkoK6uTqGeTCZDSUkJgEcDL6n9+f7771FdXS0/zs3NxenTp2FlZSXftr6goAD37t1rcm1xcTEA3jvEz6HWxP4Wkvvkk08gkUjg7u4OOzs71NTU4Pz586ioqMBrr72m9npPT09ERUXh+vXreOGFF5CVlYXk5GR07NhRYYrTDz/8gKtXr6Jnz56wt7eHgYEBrl69ips3b6J3795wcnJqzbdJesrW1hbvvvsu+vXrh+rqasTHx6Ourg5LliyRJ6yZmZkIDQ2Fh4cHnJycYGlpiby8PJw/fx5mZmYYMWKEjt8F6Ro/h1oPEwaSe+2113Dx4kVcu3YNSUlJMDc3h7OzM+bOnYv+/furvd7BwQFvvPEG9u/fj19++QUGBgYICAjA7NmzFaZljh49Gubm5rh+/Tp+//13GBoawt7eHn/5y18wevTo1nyLpMeWLl2K7777DmfOnEFFRQWcnZ0xffp09O3bV17H1dUVEyZMwJUrV5CUlITq6mpIpVIMHToUkyZNQqdOnXT4Dkgf8HOo9XAvCWqxx5dkXbx4sa7DoedM49LQ4eHhug6FnmP8HGp9HMNAREREajFhICIiIrWYMBAREZFaHMNAREREarGHgYiIiNRiwkBERERqMWEgIiIitZgwEJFeS01NxYwZMzBjxgxdh0LUrnGlRyKBamtrERsbiwsXLiArKwulpaUwMjKCVCqFp6cnAgMD4ePjo7KNxYsXN7sXgqmpKTp27IiePXti7NixcHZ2blKncYEjIby8vLBmzRpBddXF1hxtLI5TUVGBH3/8EQDw8ssvQyKRtKg9fRQTE4OCggL5rohEzzMmDEQCpKSkYMeOHbh//768zMzMDA8fPkROTg5ycnJw4sQJ9O7dG0uWLEGHDh1UtmdsbAxzc3MAjza8KSsrw927d3H37l2cOHECf/3rX5Xui2BoaKiwxG1z1J0XGpsy6s4LUVFRgcjISADA8OHDlSYMJiYm6Ny5c4tfTxdiYmLkSR4TBnreMWEgUiM+Ph5btmxBfX09pFIpZsyYgf79+8u/lHNycnD8+HH8+uuvSE5OxqpVq7Bu3TpYWVkpbTMgIEDhF3ptbS0uXLiA3bt3o6SkBDt37oSrq2uz2zr36NFD494DTTwZm665ubnhs88+03UYRO0exzAQqZCdnY0dO3agvr4eXbt2xSeffIIRI0Yo/IJ3cnLCG2+8gXfffRdGRkbIy8vDf/7zH41eRywWY9CgQQgODgYANDQ04NixY1p9L0RELcEeBiIVDhw4gJqaGhgbG2Pp0qWwtLRUWtff3x9TpkxBeHg4fv/9d1y8eBH+/v4avV6vXr1gY2ODoqIi3Lx5s6XhP1P3799HVFQUUlJScO/ePdTX16NDhw6wtrZGz549MXjwYLi5uQFoOh5jyZIlCm09PgYjNTUVa9euBYAmG1TFxMRg+/bt6NixI7Zt24arV6/i8OHDuHHjBmpqauDo6IixY8cqPN65ePEifvzxR2RmZqKmpgZdunTBK6+8goCAgGbfV0FBAeLj45GamoqCggI8ePAAAGBnZwdfX1+MHz8ednZ2zcbVKDIyUv74pdHWrVthb28vP25oaEBMTAx+++033LlzB1VVVejQoQN69OiBMWPGKH2k0fh3OW3aNEyZMgU///wz4uLikJeXh8rKSqxevVp+bU5ODo4ePYq0tDTcv38fMpkMlpaWkEql8Pb2xrBhw7itMynFhIFIiaKiIiQlJQEAAgMDBT1HHz9+PKKiolBVVYVff/1V44QBAKRSKYqKilBVVaXxtbqSmZmJtWvXoqKiAgBgYGAAMzMzFBcXo6ioCLdv30ZFRYU8YbCwsECHDh1QVlYGAOjQoQMMDP7X4fk0YzBOnDiBnTt3Ang0vqSmpgaZmZn4/PPPkZeXh9deew3h4eGIjIyESCSCmZkZamtrcfPmTXz22WcoLy9vdlvj7du3y5MbIyMjmJmZoby8XD52JSYmBu+99x48PT3l14jFYlhZWaG8vBz19fUwMTGBqampQruPv9/Kykps2LABqampTf7+EhISkJCQgFdeeQWzZ89W+v7r6uqwdu1aXLt2DYaGhjA1NYVIJJKfT0lJwfr161FXVwcA8jr379/H/fv3cf36dRgZGXE2CinFhIFIidTUVDSunD5gwABB15iamqJXr15ITEzE1atXUV9fD0NDQ41et3GmQksGLj5r33zzDSoqKtCtWzfMnz8f7u7uEIlEePjwIe7du4fz58/j8VXoly9fLt+OGAA+/vhjhV/bmiotLcWuXbswduxYTJ06FZaWligvL8fevXsRGxuLw4cPQyKR4NChQ3j11VcxduxYmJubo6ioCDt27MClS5fwzTffYPDgwU0GdLq4uGDQoEHo1asXHBwcYGBggPr6ety+fRvh4eG4dOkSNm3ahC1btkAsFgN4NA4kICBA/uv/lVdeUflFvGPHDqSmpsLIyAizZ8/GiBEjYGJiguLiYvz3v//FqVOnEBUVBQcHh2aTGgD49ddfAQCLFi1CQEAAxGIxysrK5EnDl19+ibq6Ovj6+mL27Nno2rUrgEfjZ/Lz85GYmNikp4TocUwYiJTIzs6W/7lbt26Cr3NxcUFiYiKqq6tx7949dOrUSfC1CQkJKC0tBQC4u7s3W+fatWv461//qrKduXPnKu1iVyc+Ph6XLl1SWWf58uXo0aOHQkwAMH/+fHh4eMjLjYyM4OjoiFdeeeWpYhGqpqYGI0aMwNy5c+VlFhYWWLhwIa5evYqCggLs378fr776KqZMmSKvY2Njg3feeQcLFixATU0Nzp8/j6FDhyq0/cYbbzR5PUNDQ7i5ueG9997DP/7xD2RlZSEhIaHJtUJcv34diYmJAIB58+YhKChIfs7a2hoLFy5EZWUlEhMTERYWhuHDh8sTk8dVV1djxYoV6Nu3r7yscbZOSUkJ8vPzATxKKGxsbOR1xGIxunTpgi5dumgcO7UvHPRIpERjdzmg2a/9x6dUlpeXq60vk8lw7949/Pzzz9ixYweAR1+0Y8aMabZ+fX09SkpKVP5XW1srON4n1dXVqW3/4cOHCtc0ToksKip66tdtqUmTJjUpMzAwkK+NYWxsjHHjxjWpY25uLk9y7ty5o9FrGhgYwNfXFwCQnp6uYcSPxMfHAwBsbW2VTqWdOXMmgEf3ZEpKSrN1unTpopAsPM7MzEze06DL/0f0fGMPA5EOxMbGIjY2ttlzpqamWLx4MRwdHZs9/zSLMmniaRZl8vf3x4kTJ7Bt2zZcu3YNffv2haurK0xMTFopSkUWFhZKe3Ksra0BAM7Ozk3GETRqnAKrLMG7evUqTp48ievXr+P+/fuoqalpUqdxMKSmbt26BeDROg2Pj2t4nLOzM6RSKR48eIBbt241mxg83uPzJLFYjBdffBEpKSn4f//v/2HUqFHw9/dHt27dYGTErwEShncKkRJP9hRIpVJB1wnpmXh8cSSRSAQTExPY2dmhZ8+eGDlyJGxtbVsQ+bP3+uuvIy8vD6mpqTh69CiOHj0KAwMDuLi4wN/fH0FBQYL//p6GmZmZ0nONX8Kq6jSOM6mvr29y7ttvv8WRI0cU2pNIJPIv2urqatTU1DSbRAhRUlICAGr/fmxtbfHgwQN5/SepmsEDAG+99RbWr1+PrKwsHDx4EAcPHoSRkRFcXV3Rr1+/JtOFiZ7EhIFIiceXZ75165bgL7zbt28D+N9yz83Rt8WRWkoikWD16tVIT0/H+fPnce3aNdy6dUv+35EjR/DWW29h8ODBug5VIykpKfJkYfTo0Rg9ejScnZ0VegIOHDiAQ4cOKQzq1AVlvRON7OzssH79eqSkpCA5ORnXrl1DVlYWrl27hmvXruH777/HsmXL1C5vTu0XEwYiJby9vSESiSCTyZCYmKj0+fDjqqur8fvvvwMAevbsqfEMieedp6enfHphbW0tUlJScODAAdy5cwc7duyAj4+P/BHB8yAuLg4A4OvrizfffLPZOsXFxS16DSsrK+Tm5iosO96cxvOqVhBVx8DAAH5+fvDz8wMAVFVV4cKFC/juu+9QWFiIzZs3Y8eOHXxMQc3ioEciJWxsbNCvXz8Ajwam5ebmqr3m6NGj8vUTlE1/ay/EYjH69u2L5cuXA3g0mPLxgYHqfhHrg8YvaWWzZGQymXzthOY8vg6CMt27dwfwaBpvQ0NDs3VycnLkYyRcXV3VtimUmZkZBg8ejLfeegvAo8cjmg78pPZD///FEunQzJkzIRaLUVdXh40bN8qnPDYnOTkZhw4dAvCod+JpFm16HtXX1yv9ogOgMAXw8STh8TEFjQs+6ZvGcSZZWVnNnj9+/Lh8umJzGt+jqvcXGBgI4NGgyZMnTzZbJywsDMCjcTUvvvii+sCf8OSslic9/v9ISJJD7RMTBiIVunTpgrfeegsGBga4c+cO/vGPf+DkyZMKXwC5ubnYu3cvPvnkEzx8+BAODg74v//7v3bzwXv//n383//9Hw4ePIjbt28rDBzMysrCli1bADzaddLLy0t+TiKRyMeFnDp1qtkBh7rW2HWfnJyMyMhIVFdXA3iUABw6dAi7d+9WuTNp4+JIycnJSmdRuLm5yRcG2717N3755Rf5AMri4mJ8/vnnSEhIAPC/BFZT165dw/Lly3H06FFkZ2fLEzyZTIZr167hq6++AvBoYGVzG54RARzDQKTW4MGDYWFhId/e+vPPP8fnn38Oc3Nz1NXVyZfaBR496w4ODlY7Yr0lhCzcBDxa2e9pCFm4yc7ODh9//LH8OD8/H2FhYQgLC4OBgQHMzc1RXV0t/2VrZGSExYsXNxmFP2rUKISFheGXX37BiRMnYGlpCQMDA7i7u+Odd955qvi1aejQoYiNjcXVq1cRHh6OiIgImJubo7KyEjKZDP7+/nBxcZH3LD1p2LBhiIqKQl5eHhYuXAhLS0v5F/6//vUv+WyYhQsXoqysDGlpadi9ezf27t0LU1NT+esAwCuvvNKix1x37tzBvn37sG/fPhgaGsrfR2OiZmZmhrfffvu5eFREusGEgUgAPz8/bNmyBTExMbhw4QKysrJQVlYGIyMj+XTIwMDAp+ou1lTjwk2tpXHhJlUe/5UrlUqxYsUKpKamIiMjQz71z9DQEJ06dYK3tzfGjRvX7LoSkydPhpmZGX777Tf5c3qZTKZ0dsmzZmRkhFWrVuGHH35AXFycfNluNzc3DBs2DEFBQU02lXqco6MjVq9ejR9++AHXr1+X7y0BKE7hNDc3x4cffijffCozMxPV1dWwtraGh4cHxo4dq3TzKSFcXV3x97//Hampqbhx4waKiopQWloKY2NjdOnSBb169cK4ceNadeorPf9EMl3PBSIiIiK9x74nIiIiUosJAxEREanFhIGIiIjUYsJAREREajFhICIiIrWYMBAREZFaTBiIiIhILSYMREREpBYTBiIiIlKLCQMRERGp9f8BKhH4vBQ2geEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, estimated_interval_anti_optimal = ope.summarize_off_policy_estimates(\n",
    "    evaluation_policy_pscore=anti_optimal_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=anti_optimal_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=anti_optimal_policy_pscores[2],\n",
    "    alpha=0.05,\n",
    "    n_bootstrap_samples=1000,\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")\n",
    "estimated_interval_anti_optimal[\"policy_name\"] = \"anti-optimal\"\n",
    "\n",
    "print(estimated_interval_anti_optimal, '\\n')\n",
    "# visualize estimated policy values of Anti-optimal by the three OPE estimators\n",
    "# and their 95% confidence intervals (estimated by nonparametric bootstrap method)\n",
    "ope.visualize_off_policy_estimates(\n",
    "    evaluation_policy_pscore=anti_optimal_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=anti_optimal_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=anti_optimal_policy_pscores[2],\n",
    "    alpha=0.05,\n",
    "    n_bootstrap_samples=1000, # number of resampling performed in bootstrap sampling\n",
    "    random_state=dataset_with_random_behavior.random_state,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (4) Evaluation of OPE estimators\n",
    "Our final step is **the evaluation of OPE**, which evaluates and compares the estimation accuracy of OPE estimators.\n",
    "\n",
    "With synthetic slate bandit data, we can calculate the policy value of the evaluation policies. \n",
    "Therefore, we can compare the policy values estimated by OPE estimators with the ground-turths to evaluate the accuracy of OPE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[calc_ground_truth_policy_value (pscore)]: 100%|██████████| 10000/10000 [00:05<00:00, 1703.90it/s]\n",
      "[calc_ground_truth_policy_value (expected reward), batch_size=3334]: 100%|██████████| 3/3 [00:02<00:00,  1.13it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.644826072014703"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ground_truth_policy_value_random = dataset_with_random_behavior.calc_ground_truth_policy_value(\n",
    "    context=bandit_feedback_with_random_behavior[\"context\"],\n",
    "    evaluation_policy_logit_=random_policy_logit_\n",
    ")\n",
    "ground_truth_policy_value_random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[calc_ground_truth_policy_value (pscore)]: 100%|██████████| 10000/10000 [00:06<00:00, 1639.37it/s]\n",
      "[calc_ground_truth_policy_value (expected reward), batch_size=3334]: 100%|██████████| 3/3 [00:02<00:00,  1.16it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.6125410474183628"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ground_truth_policy_value_optimal = dataset_with_random_behavior.calc_ground_truth_policy_value(\n",
    "    context=bandit_feedback_with_random_behavior[\"context\"],\n",
    "    evaluation_policy_logit_=optimal_policy_logit_\n",
    ")\n",
    "ground_truth_policy_value_optimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[calc_ground_truth_policy_value (pscore)]: 100%|██████████| 10000/10000 [00:06<00:00, 1637.62it/s]\n",
      "[calc_ground_truth_policy_value (expected reward), batch_size=3334]: 100%|██████████| 3/3 [00:02<00:00,  1.16it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.6893330966600806"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ground_truth_policy_value_anti_optimal = dataset_with_random_behavior.calc_ground_truth_policy_value(\n",
    "    context=bandit_feedback_with_random_behavior[\"context\"],\n",
    "    evaluation_policy_logit_=anti_optimal_policy_logit_\n",
    ")\n",
    "ground_truth_policy_value_anti_optimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimated_interval_random[\"ground_truth\"] = ground_truth_policy_value_random\n",
    "estimated_interval_optimal[\"ground_truth\"] = ground_truth_policy_value_optimal\n",
    "estimated_interval_anti_optimal[\"ground_truth\"] = ground_truth_policy_value_anti_optimal\n",
    "\n",
    "estimated_intervals = pd.concat(\n",
    "    [\n",
    "        estimated_interval_random,\n",
    "        estimated_interval_optimal,\n",
    "        estimated_interval_anti_optimal\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>95.0% CI (lower)</th>\n",
       "      <th>95.0% CI (upper)</th>\n",
       "      <th>policy_name</th>\n",
       "      <th>ground_truth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sips</th>\n",
       "      <td>1.646317</td>\n",
       "      <td>1.631293</td>\n",
       "      <td>1.662105</td>\n",
       "      <td>random</td>\n",
       "      <td>1.644826</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iips</th>\n",
       "      <td>1.646317</td>\n",
       "      <td>1.631293</td>\n",
       "      <td>1.662105</td>\n",
       "      <td>random</td>\n",
       "      <td>1.644826</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rips</th>\n",
       "      <td>1.646317</td>\n",
       "      <td>1.631293</td>\n",
       "      <td>1.662105</td>\n",
       "      <td>random</td>\n",
       "      <td>1.644826</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sips</th>\n",
       "      <td>1.629474</td>\n",
       "      <td>1.585960</td>\n",
       "      <td>1.675414</td>\n",
       "      <td>optimal</td>\n",
       "      <td>1.612541</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iips</th>\n",
       "      <td>1.674750</td>\n",
       "      <td>1.655507</td>\n",
       "      <td>1.692978</td>\n",
       "      <td>optimal</td>\n",
       "      <td>1.612541</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rips</th>\n",
       "      <td>1.626834</td>\n",
       "      <td>1.594925</td>\n",
       "      <td>1.658154</td>\n",
       "      <td>optimal</td>\n",
       "      <td>1.612541</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sips</th>\n",
       "      <td>1.691671</td>\n",
       "      <td>1.647720</td>\n",
       "      <td>1.737568</td>\n",
       "      <td>anti-optimal</td>\n",
       "      <td>1.689333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iips</th>\n",
       "      <td>1.602862</td>\n",
       "      <td>1.584707</td>\n",
       "      <td>1.623184</td>\n",
       "      <td>anti-optimal</td>\n",
       "      <td>1.689333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rips</th>\n",
       "      <td>1.687415</td>\n",
       "      <td>1.654940</td>\n",
       "      <td>1.722200</td>\n",
       "      <td>anti-optimal</td>\n",
       "      <td>1.689333</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          mean  95.0% CI (lower)  95.0% CI (upper)   policy_name  ground_truth\n",
       "sips  1.646317          1.631293          1.662105        random      1.644826\n",
       "iips  1.646317          1.631293          1.662105        random      1.644826\n",
       "rips  1.646317          1.631293          1.662105        random      1.644826\n",
       "sips  1.629474          1.585960          1.675414       optimal      1.612541\n",
       "iips  1.674750          1.655507          1.692978       optimal      1.612541\n",
       "rips  1.626834          1.594925          1.658154       optimal      1.612541\n",
       "sips  1.691671          1.647720          1.737568  anti-optimal      1.689333\n",
       "iips  1.602862          1.584707          1.623184  anti-optimal      1.689333\n",
       "rips  1.687415          1.654940          1.722200  anti-optimal      1.689333"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estimated_intervals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can confirm that the three OPE estimators return the same results when the behavior policy and the evaluation policy is the same, and the estimates are quite similar to the `random_policy_value` calcurated above.\n",
    "\n",
    "We can also observe that the performance of OPE estimators are as follows in this simulation: `IIPS > RIPS > SIPS`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>se</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sips</th>\n",
       "      <td>0.000002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iips</th>\n",
       "      <td>0.000002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rips</th>\n",
       "      <td>0.000002</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            se\n",
       "sips  0.000002\n",
       "iips  0.000002\n",
       "rips  0.000002"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# evaluate the estimation performances of OPE estimators \n",
    "# by comparing the estimated policy values and its ground-truth.\n",
    "# `summarize_estimators_comparison` returns a pandas dataframe containing estimation performances of given estimators \n",
    "\n",
    "relative_ee_for_random_evaluation_policy = ope.summarize_estimators_comparison(\n",
    "    ground_truth_policy_value=ground_truth_policy_value_random,\n",
    "    evaluation_policy_pscore=random_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=random_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=random_policy_pscores[2],\n",
    ")\n",
    "relative_ee_for_random_evaluation_policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>se</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sips</th>\n",
       "      <td>0.000283</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iips</th>\n",
       "      <td>0.003849</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rips</th>\n",
       "      <td>0.000201</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            se\n",
       "sips  0.000283\n",
       "iips  0.003849\n",
       "rips  0.000201"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# evaluate the estimation performances of OPE estimators \n",
    "# by comparing the estimated policy values and its ground-truth.\n",
    "# `summarize_estimators_comparison` returns a pandas dataframe containing estimation performances of given estimators \n",
    "\n",
    "relative_ee_for_optimal_evaluation_policy = ope.summarize_estimators_comparison(\n",
    "    ground_truth_policy_value=ground_truth_policy_value_optimal,\n",
    "    evaluation_policy_pscore=optimal_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=optimal_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=optimal_policy_pscores[2],\n",
    ")\n",
    "relative_ee_for_optimal_evaluation_policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>se</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>sips</th>\n",
       "      <td>0.000006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>iips</th>\n",
       "      <td>0.007534</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rips</th>\n",
       "      <td>0.000005</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            se\n",
       "sips  0.000006\n",
       "iips  0.007534\n",
       "rips  0.000005"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# evaluate the estimation performances of OPE estimators \n",
    "# by comparing the estimated policy values and its ground-truth.\n",
    "# `summarize_estimators_comparison` returns a pandas dataframe containing estimation performances of given estimators \n",
    "\n",
    "relative_ee_for_anti_optimal_evaluation_policy = ope.summarize_estimators_comparison(\n",
    "    ground_truth_policy_value=ground_truth_policy_value_anti_optimal,\n",
    "    evaluation_policy_pscore=anti_optimal_policy_pscores[0],\n",
    "    evaluation_policy_pscore_item_position=anti_optimal_policy_pscores[1],\n",
    "    evaluation_policy_pscore_cascade=anti_optimal_policy_pscores[2],\n",
    ")\n",
    "relative_ee_for_anti_optimal_evaluation_policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variance of OPE estimators is as follows: `SIPS > RIPS > IIPS`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimated_intervals[\"errbar_length\"] = (\n",
    "    estimated_intervals.drop([\"mean\", \"policy_name\", \"ground_truth\"], axis=1).diff(axis=1).iloc[:, -1].abs()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x159a509d0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha = 0.05\n",
    "plt.style.use(\"ggplot\")\n",
    "\n",
    "def errplot(x, y, yerr, **kwargs):\n",
    "    ax = plt.gca()\n",
    "    data = kwargs.pop(\"data\")\n",
    "    data.plot(x=x, y=y, yerr=yerr, kind=\"bar\", ax=ax, **kwargs)\n",
    "    ax.hlines(data[\"ground_truth\"].iloc[0], -1, len(x)+1)\n",
    "    \n",
    "g = sns.FacetGrid(\n",
    "    estimated_intervals.reset_index().rename(columns={\"index\": \"OPE estimator\", \"mean\": \"Policy value\"}),\n",
    "    col=\"policy_name\"\n",
    ")\n",
    "g.map_dataframe(errplot, \"OPE estimator\", \"Policy value\", \"errbar_length\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}