gh_rumor_contiuous.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install numpy==1.25.2\n",
    "!pip install networkx==3.1\n",
    "!pip install scipy==1.11.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import math\n",
    "\n",
    "import copy\n",
    "import random\n",
    "\n",
    "import pickle\n",
    "\n",
    "import datetime\n",
    "\n",
    "import networkx as nx\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "\n",
    "import scipy.integrate as integrate\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABv4klEQVR4nO3dd1RU1/r/8TdNmljBghV7wTpgbLFgN2qMxmiMFXuJXs2NGjWWxBhzLTGJQbBh1xhjFLEralQ0yiCKYgcb3YaUGcrM/P7wB9/rVSMOAwPD81or6y6ZOXs/J/FyPmefffY20+l0OoQQQghRaJkbuwAhhBBCGJeEASGEEKKQkzAghBBCFHISBoQQQohCTsKAEEIIUchJGBBCCCEKOQkDQgghRCEnYUAIIYQo5CQMCCGEEIWchAEhhBCikJMwIIQQQhRyEgaEEEKIQk7CgBBCCFHISRgQQgghCjkJA0IIIUQhJ2FACCGEKOQkDAghhBCFnIQBIYQQopCTMCCEEEIUchIGhBBCiELO0tgFCCGEEPmRTqfj4cOHKJVKgoKCCA4OJjIyEpVKhZmZGTY2NlSuXBk3NzcUCgUKhYLy5csbu2y9mOl0Op2xixBCCCHyi5SUFLZt24aXlxfBwcEAlCtXDoVCgYuLCzY2NgCoVCpu3bqFUqnk8ePHALRq1YoJEybQp08frK2tjXYO70rCgBBCCAEkJiby7bffsnr1ahISEujevTvDhw+nefPmODs7Y2Zm9trjdDod9+/f58yZM6xZs4bjx49TpkwZxo8fz/Tp07PCQ34mYUAIIUShd+zYMUaMGMGjR48YP348Y8eOpVq1anq1de3aNby8vFi1ahXVq1dn/fr1NGvWzMAVG5ZMIBRCCFFoqdVqxo0bR8eOHXFxceHy5cv85z//0TsIANStW5dffvkFpVKJvb09LVq04KuvviIjI8OAlRuWjAwIIYQolBITE/nwww85e/YsS5YsYdy4cZibG/YeOSMjg8WLFzNnzhx69uzJtm3b8uVcAgkDQgghCp3k5GS6dOlCaGgo/v7+vP/++7nan7+/P/369aNDhw78+eefWFlZ5Wp/70oeEwghhChUtFot/fr1IyQkhMOHD+d6EADo0aMHe/bs4fDhw4wYMYL8dh8uYUAIIUShsmLFCg4cOMAff/zBe++9l2f9du7cGV9fXzZt2sRvv/2WZ/1mhzwmEEIIUWjcvn2bhg0b4unpyYoVK4xSwyeffEJAQABXr16lbNmyRqnhf0kYEEIIUShotVratWvHw4cPuXz5MkWLFjVKHfHx8dSvX582bdqwc+dOo9Twv+QxgRBCiELh2LFjnDp1Cm9vb6MFAQAnJyd+/PFH/vjjD0JCQoxWx3+TkQEhhBCFwkcffcSdO3e4dOnSG1cTzCsZGRlUqVKFHj164OPjY9RaQEYGhBBCFAIPHjzAz8+P8ePHGz0IAFhaWjJmzBg2b95MQkKCscuRMCCEEML0+fr6Ym9vz2efffbW7yYmJjJt2jQ6d+6Mk5MTZmZmzJs377XfDQ4OpmPHjhQtWpQSJUrQp08fwsPDs1XTqFGjSEtLY9u2be9yKrlCwoAQQgiTd+bMGdq1a4eDg8Nbv/v48WNWrVpFamoqvXv3fuP3rl+/Trt27UhLS2PHjh2sW7eOmzdv8v777xMfH//WfsqXL49CoeDMmTPvciq5wtLYBQghhBC5SafTERQUxKRJk7L1/SpVqvD06VPMzMx49OgRa9asee335syZg7W1Nf7+/hQrVgwAhUJBzZo1WbJkCT/88MNb+1IoFAQEBGT/ZHKJjAwIIYQwaffu3ePJkycoFIpsfd/MzOyt8woyMjLw9/enb9++WUEAXgSJ9u3b8+eff2arLzc3N27cuEFiYmK2vp9bJAwIIYQwaVeuXAGgcePGBmvzzp07qFQqGjZs+MpnDRs25Pbt26jV6re207hxY3Q6HWFhYQarTR8SBoQQQpi0zLvukiVLGqzNx48fA1CqVKlXPitVqhQ6nY6nT5++tZ0SJUoAkJSUZLDa9CFhQAghhElLS0sDoEiRIgZv+58eJ2TnFcbMmlJTUw1Wkz4kDAghhDBpuXHBLV26NPB/IwT/7cmTJ5iZmWXd9f+TzJqsra0NVps+JAwIIYQwaZkT/J48eWKwNqtXr46trS2hoaGvfBYaGkqNGjWwsbF5azuZjxKy88pjbpIwIIQQwqRlTvIz5D4AlpaW9OzZk127dr30JsD9+/c5fvw4ffr0yVY7Fy9exNzcnPr16xusNn3IOgNCCCFMWsWKFXFyciIoKIhevXpl65gDBw6QnJycdaEPCwvL2mGwe/fu2NnZMX/+fNzd3enRowczZsxArVYzZ84cHB0d+eKLL7LVj1KppG7dutjb2+t3cgYiGxUJIYQwed26dcPc3Jx9+/Zl6/tVq1bl3r17r/0sIiKCqlWrAi8u5tOnT+fs2bNYWlri4eHBkiVLqF69erb6cXd3p169emzYsCFb388tMjIghBDC5LVp04YFCxaQkJBA8eLF3/r9u3fvZqtdhULB0aNH9arpwYMHBAcHM2bMGL2ONySZMyCEEMLkDRs2jLS0NDZu3GjsUrKsWrUKe3t7BgwYYOxS5DGBEEKIwqF///5cvnyZsLAwo29jnJaWRuXKlenXrx+//PKLUWsBGRkQQghRSIwfP57r16+zd+9eY5fCpk2biI2NZezYscYuBZCRASGEEIWETqeja9euXLlyhbCwsGzNHcgNUVFR1K9fnw8++IDNmzcbpYb/JSMDQgghCgWVSoWjoyOxsbFMmTLFKDXodDrGjBmDjY0NP//8s1FqeB0JA0IIIUxeeno6Hh4ebN26FY1Gg6+vb7a3GTak1atX4+/vj4+Pz2s3OTIWCQNCCCFMnpmZGV9++SUAtra2KBQKPv30U44fP55nNfz555+MGzeOcePGZXvxo7wicwaEEEIUGt9++y39+vXDxcWFnj17cvr0aXbt2kXXrl1ztd/t27czePBg+vbty5YtW7CwsMjV/t6VhAEhhBAF2uPHj3n27NlbV/3LvNxlvlaoUqn45JNPOHToEPPnz+fLL7/E0tKwa/Gp1WrmzZvHf/7zHwYPHszatWsN3ochyGMCIYQQBdaOHTtwcnJi1qxZxMfH/+N3zczMXlpfwNbWll27djF16lRmz55Ny5YtCQsLM1htFy5cQKFQ8OOPP/Ldd9/h6+ubL4MAyMiAEEIIA9PpdNy5cwelUsnly5d5/vw5qampFClSBAcHB1xdXVEoFNSqVQtzc/3vSXfv3s2cOXNo1KgRO3bsYMmSJYwePRpra+t3buvvv/9m2LBhhIeH4+npyfjx42nQoME7t6PT6bhw4QJeXl5s2rSJpk2b4uvri6ur6zu3lZckDAghhMgxjUbD/v378fHx4dSpUzx//hyAEiVKYGdnh4WFBRqNBrVazZMnTwCwt7enZcuWjBo1it69e2NlZZXt/nQ6HXv27OH8+fMsXLiQuXPnsnz5cvz8/Gjbtq1e56BWq1myZAleXl5ER0fTunVrhg8fTosWLahVq9Ybn/NnZGQQFhZGYGAga9asQalUUrVqVSZPnszEiRPz7WjAf5MwIIQQQm8JCQmsXLkSLy8vHjx4QMWKFalVqxbOzs6UL1/+tVvzqlQqoqOjiYqK4vbt29y9e5eyZcsyZswYJk6ciJOTU7b6VqlUqFSqrFf0WrZsiU6nY+vWrbi4uOh9Tunp6ezZs4dff/2VEydOAC+CS5MmTXBxccHW1hadTodKpeL27duEhISgVqsxMzOjW7duTJgwgS5duuS7SYL/RMKAEEIIvRw8eJARI0YQHx9P/fr1cXd3p0KFCu/cTmxsLEFBQYSGhmJnZ4e3tzf9+vXL9vHp6elYWVkRHx+Pi4sLI0aM4Ntvv6VYsWLvXMv/evbsGRcvXiQoKAilUklUVBQqlQozMzNsbGyoXLkybm5uKBQKGjdujIODQ477NAYJA0IIId5JQkICU6ZMwdfXlxo1atCjRw9KlCiR43aTkpLYv38/YWFhfPzxx3h5eWV7lCAjIwNLS0t27NjBgAED2Lx5M/379+fChQtERUXRp0+fHNdnyiQMCCGEyLbIyEg6duzI3bt36dSpE02bNjXoDoA6nY6rV69y4MABSpUqRUBAADVq1Hjp8zf1l/nZqFGjOHLkCO3atWPjxo0sX76cSZMmGaxGUyRhQAghRLY8fPiQ1q1b8/z5cz777DMcHR1zra+EhISsTXxOnTpF7dq1OX78OG5ubtjb27/2LQStVou5uTnh4eHUqFGD8uXLs3r1arp3755rdZoKWWdACCHEWz169IgOHTrw/Plzhg4dmqtBAKB48eIMGzYMc3NzPDw8GD16NB4eHgwfPvyNryOam5tz9OhRatSoQZcuXbhz544EgWySkQEhhBD/SKfT0bdvXw4fPoynpyelS5fOs76fP3/O6tWrSUpKylpB8MCBA3Tp0uW1jwvOnTtHSEgIY8eOzbMaTYGEASGEEP/ot99+Y8CAAfTr14/69evnef/h4eFs3LgRCwsLli1bxueff27QeQpCwoAQQoh/EBsbS926dXF2dn6n1/0Mzd/fn9DQUMLCwqhWrZrR6jBVMmdACCHEG3377bekpaUZ/dl7p06dsLOzY8aMGUatw1TJyIAQQojXSkxMpHz58igUCjw8PIxdDufOnePo0aPcv3+f8uXLG7sckyIjA0IIIV5r8+bNqFQqFAqFsUsBoFGjRpibm7NmzRpjl2JyZGRACCHEa7m6uqLVaunfv7/ebdy7d49Tp07x8OFDMjIyKFasGI0aNdJ7MyE/Pz+io6N58OBBgVr7P7+TkQEhhBCviI2N5erVqzl6e+Dy5cusX78eGxsbPvroIz777DNatWpFTu5BGzRoQHR0NNevX9e7DfGq/L+vohBCiDynVCoB9Np4CF6sD7B3714UCgU9evTI+nlOdhMEsuYKKJVKo7zmaKpkZEAIIcQrgoKCsLOz03sDouDgYNLT02ndurVB67KxscHJyYmgoCCDtlvYyciAEEKIV1y8eJHy5cvrvbjPvXv3sLW15dGjR2zbto24uDhsbW2pW7cunTp1wsbGRu/aypYtK2HAwCQMCCGEeEV8fDz29vZ6H//8+XPS09PZsWMH77//PhUrViQqKorjx48TFxeHp6en3kGjaNGiPH78WO/axKskDAghhHiFWq3G0lL/S4ROpyMjI4MOHTrw/vvvAy/mC1hYWHDw4EHCw8OpXr26Xm1bWlqiUqn0rk28SuYMCCGEeIWlpSVarVbv4+3s7ACoUaPGSz/P/HN0dLTebWu1WqysrPQ+XrxKwoAQQohX2Nvbk5aWpvfxZcuW/cfPc7LRUFpaWlbYEIYhYUAIIcQrateunaPn8nXr1gXg1q1bL/08888VK1bUu+1Hjx5ltS8MQ+YMCJHPpaenc+3aNeLj41GpVFhYWGBra0uNGjWoUKGCbOUqcoWbmxve3t6kpqZibW39zsfXqFGDWrVqcfLkSXQ6XdYEwpMnT1KrVi2qVKmiV11arZaYmBjc3Nz0Ol68noQBIfIZjUbDgQMHOHDgAEFBQVy6dInU1NTXfrdMmTIoFArc3d0ZOHAgtWvXzuNqhalSKBTodDpiYmL0vnD369ePEydOoFQqOXnyJA4ODjRv3px27drpXdfjx49Rq9X5Zr8EUyF7EwiRT8TFxbFu3Tq8vb25d+8eNWvWpFmzZri5uaFQKKhYsSI2NjZoNBqSk5O5du0aSqUSpVLJuXPnePr0KR07dmT8+PH07NkzRzPBhUhPT6dEiRI0a9YsRxdvQzt//jwHDx7k0aNHlCxZ0tjlmAz5bSGEkWk0GpYtW8acOXMAGDBgAOPHj8fd3f0fj6tduza9e/cGXrwGtnPnTry8vOjTpw+1atXC19eXli1b5nb5wkRZWVkxcOBAdu7cyfvvv58vNgXS6XQEBwfTq1cvCQIGJhMIhTCi69ev06pVK6ZPn8748eN5+PAhvr6+bw0C/8vGxoZBgwYRGBhIUFAQJUuWpHXr1nzxxRfyPrbQ24QJE3j27Bk3b940dikA3L9/n5iYGCZMmGDsUkyOPCYQwki2bt2Kp6cnVapUMfhdfOZow9dff021atU4ePAglStXNlj7ovBo3rw5cXFxDBkyxOiTVXfs2EFaWho3btzA3FzuZQ1J/m0KYQQ+Pj4MGjSI/v37ExISYvDhfAsLC7788kuCg4NRq9W0atXqlVe8hMiOWbNmERERQWhoqFHruHXrFmFhYcycOVOCQC6Qf6NC5LGNGzcyduxYJk6ciK+vL7a2trnWV7169Th9+jRFixalQ4cO3L9/P9f6EqapZ8+eDBgwgAMHDpCYmGiUGtRqNfv27aNTp04MGzbMKDWYOgkDQuSh8+fP4+npyYgRI/jpp5/y5A7H2dmZo0ePYmFhwYcffpijVeVE4ZOWloaNjQ1qtRo/P78cLVGsD51Ox8GDB8nIyGDNmjVGf1RhqiQMCJFH1Go1w4YNo3Hjxnh7e+fpL7UKFSrwxx9/EBoayvfff59n/YqCLTIykrZt27J+/Xp0Oh23bt3i8OHD5OVUs1OnThESEsLPP/8s815ykYQBIfLI/PnzuXPnDuvXrzfKGgBNmzblq6++YsGCBYSEhOR5/6JgOXXqFAqFgnPnzgFgbW3NZ599xrlz5zhy5EieBILTp08TEBDA/PnzGT58eK73V5jJ2wRC5IGrV6/SsGFDvv32W2bOnGm0OtLS0nBzc8Pa2prz58/LkKt4hU6n45dffuGLL74gIyMDgMqVK7Nr1y4UCgU///wzkydPpmHDhnTv3h0bGxuD15CWlsaRI0e4cOECc+bMYd68efJ3NZdJGBAiD4wdO5a9e/dy9+5do2+9eujQIbp27cqZM2dkUSLxkpSUFEaPHs2WLVuyftahQwe2b9+Oo6Nj1s+2bNnCmDFjsLKyokePHq9sU5wT9+/fx8/Pj+fPn/Pjjz8yfvx4g7Ut3kzCgBC5LCEhgQoVKvDll18yd+5cY5eDVqulVq1aNG/enM2bNxu7HJFPhIeH06dPHy5dupT1s+nTp7NgwYLXPta6e/cuI0aMICAggEaNGtGqVSvKlCmjd/9Pnjzh7NmzBAUF4e7uzoYNG6hTp47e7Yl3I3MGhMhlmzZtQq1WM2rUqLd+NzExkWnTptG5c2ecnJwwMzNj3rx5r3zv9OnTjBw5EoVCgbW1NWZmZty9ezdb9ZibmzNu3Dh+//134uLi3vFshCk6ePAgbm5uWUHA3t6e33//nUWLFr1xfkvVqlU5evQoK1euJDIyEi8vLzZs2MDVq1dJT0/PVr8ZGRncuHGDLVu28PPPP3Pz5k1++OEHAgMDJQjkMdmbQIhctnPnTrp3746zs/Nbv/v48WNWrVpFo0aN6N27N2vWrHnt944dO8bRo0dp0qQJxYoV48SJE+9U07Bhw5g2bRp79+5lxIgR73SsMC06nY6goCCePn0KQK1atfjzzz+pV6/eW481MzNj7NixeHp6smvXLlasWMHvv/+Oubk5ZcqUoWzZspQvXx5bW1ssLCzQaDSo1WpiYmKIjY0lNjYWjUaDQqHA19eX/v375+q6G+LN5DGBELlIq9VSokQJZs2axfTp09/6/cz/O5qZmfHo0SOcnJyYO3fuK6MDWq02a42CJUuW8OWXXxIREUHVqlWzXVv9+vVp27YtXl5e2T5GmK7MTa82bNhA8eLF9W7n2rVrnDp1CqVSyYULF7hy5cpLIwWWlpbUrVsXd3d3FAoFrVq1olGjRjktX+SQjAwIkYtu3bpFYmJitvdez+6MaUMsVqRQKFAqlTluR+RfUVFRlChRAjs7u3/8nlarZceOHVhaWub471bdunWpW7du1p91Oh2pqamkpqZSpEgRrK2tZTnhfEj+iwiRi4KCgoAX7/jnNwqFgkuXLmX7+a4oWObNm4dCoeDEiRNvXTXQ3NycIkWK5MpF2szMDBsbG4oXL46tra0EgXxK/qsIkYvu379PqVKlKFWqlLFLeUXNmjVJTU2VSYQm6Ntvv+W3337Dzs6OmTNnEhYWZuySRD4nYUCIXKRWq986RGssmRO11Gq1kSsRhvT06VOSk5OZOHEiFy9e5MmTJ8yaNYuoqChjlybyMQkDQuSigjA/tyDUKLKvZMmSDB06lAEDBlCsWDH27dvHvn37WLFihdF2HRT5n4QBIXKRra0tKpXK2GW8VmZd8iqX6albty6lS5cmPT2dBg0asHbtWhYtWsSuXbtkjoh4LXmbQIhcVKFCBR4/fkxCQkKOXtfKDeHh4VhZWb20zKwwLZlLXw8dOpQLFy4wdepUqlWrRuPGjVm7di0uLi58+OGHRq5S5AcSBoTIRZmvFAYHB9O+fftsHXPgwAGSk5OzhnTDwsLYuXMnAN27d8fOzo74+HhOnjwJQGhoaNZxTk5OODk50bZt27f2o1QqadCgAdbW1u98XqLg0Gg0WFhYsGLFCi5dusTEiROxtrbm9u3bWX+HhJBFh4TIRRqNhmLFijF//nz+/e9/Z+uYqlWrcu/evdd+lrmw0IkTJ94YLtq2bZutFQkbNmxIixYt8PHxyVZdouDKDASHDh2iW7dutG/fnl27duW70SphPDIyIEQusrCwoEmTJpw9ezbbx2Rnj4F27drlaOJfQkICYWFhTJw4Ue82xNulpaURFhZGbGwsarUac3NzbG1tqVatGi4uLgbbllen03H+/HmaNWv22jYtLCzYuXMnn3zyCePGjePXX381SL/CdEgYECKXffTRR8ycOZO4uLgc7epmSJs2bQKgR48eRq7EtGg0Gg4cOMC+ffs4f/48oaGhb5ywV7x4cRQKBc2aNePTTz+lYcOGevWZkpLCmDFj2LJlC3v37qVLly6v3VyoZMmSbN68mYEDB+rVjzBt8phAiFz2+PFjKlasyNy5c5kxY4axy0Gn01G/fn3q16/P77//buxyTEJ8fDxr167Fy8uLBw8eUKZMGcqVK4ezszPOzs4UL14cCwsL4MVowaNHj4iOjiY6OprIyEgSExNp0aIFn3/+OX369Mn2PI7/3Xa4ePHihIeHU7JkSYONOojCQcKAEHlg+PDhHD9+nDt37mRdFIwlc75BQEBAtic1itfTaDQsX76cWbNmodVqqV+/Pu7u7lSoUOGd2rh+/TpKpZLw8HAqVaqEr68vHTp0+MfjDh48yMCBA7N2G7S3t8fX15d+/frl6JxE4SRhQIg8EBwcjEKhYPny5UyePNlodWRkZNCyZUtUKhWXL1+Wu8ccuHHjBkOHDs16Vt+2bdscrzYZFxfHgQMHiIiIYMyYMSxevBgHB4eXvqPValm0aBGzZ8/OmjfyLtsOC/E6EgaEyCOTJk1izZo1XLp0iZo1axqlhkWLFjFr1izOnDlD8+bNjVKDKfj9998ZPHgwDg4O9OzZkypVqhisba1WS1BQEMeOHaNcuXIcPnyYWrVqAfD8+XOGDh3K7t27s77fq1cvNm7cKG8GiByRMCBEHklOTqZhw4Y4Oztz8uTJPN+9LSwsjCZNmjB58mT+85//5GnfpmTdunWMHDkSV1dXevbsSZEiRXKlnydPnrB9+3a0Wi0BAQFYWFjw0UcfcfPmTeDFboDffPMNM2fOlJ0ARY5JGBAiD508eZL27dszZcoUlixZkmfD9PHx8bRp0waAixcvYmNjkyf9mppt27bx2Wef0bRpUz744INcvwgnJyezZcsWkpOTSU9PJyUlBYASJUqwdetWunXrlqv9i8JD4qQQeaht27b88ssvLFu2jLlz5+bJJkGPHz+ma9euPHnyBD8/PwkCegoJCWHIkCE0bNgwT4IAvJgUOHDgQMzNzbP2kmjYsCFBQUESBIRByToDQuSxCRMmkJSUxIwZM0hISGDJkiVZa8gb2r179+jevTvx8fEcOXLEaHMVCrq0tDSGDBmCk5MTPXv2zNNh+aJFizJw4EBWrlxJnTp1OHv2bL7dFlsUXDIyIIQRTJ8+HS8vL3799VeaN2+etb+Aoeh0OlavXk2DBg1ITk7m1KlTNGrUyKB9FCYLFy4kLCyMXr16vXZBn9zm5OSEh4cH169fz1pTQAhDkjAghJGMGzeOc+fOkZqaikKhYMGCBVnPhHPi9u3bdOnShdGjR/PJJ59w6dIlateubYCKC6dbt27x3Xff0bp1a8qXL2+0Olq2bEnFihXx9PREq9UarQ5hmiQMCGFEbm5uKJVKpk2bxrx586hQoQJTpkzJmjGeXRqNBn9/f7p06UKtWrW4ePEiBw4cYM2aNfLKWQ79+uuv2NjY0Lp1a6PWYW5uTseOHbl+/TpHjx41ai3C9MjbBELkExEREfj4+LB27VoePXpEs2bNaNasGQqFAoVCQcWKFbGxsUGj0ZCSkkJYWBhKpRKlUsmpU6d4+PAhFhYWaDQamjRpglKplEWFcig5ORlnZ2caNmxIx44djV0OOp2OVatW4e7uzp49e4xdjjAhEgaEyGfUajU7d+7kwIEDKJVKbt68+ca3Duzs7GjcuDHu7u4MHDiQsWPHcvHiRQBZbtgA1qxZw+jRo5k0aRIlS5Z85+PDw8O5fPkyDx484Pnz59jY2ODs7Ezbtm1xdnbWq6agoCD2799PREQElStX1qsNIf6XhAEh8rnExERCQkKIi4tDrVZjYWGBjY0NNWvWpE6dOi/tdbBt2zYGDRpEnz59+P7776lRo4YRKy/4unbtyu3btxk8eLBex+/YsYOUlBTq16+Pk5MTycnJnD17lqioKAYNGkS1atXeuc3U1FQWL17M0qVLmTRpkl51CfG/JAwIYUI0Gg0xMTFUqFCBjIwMo8x8NxU6nQ5HR0caNGig9whLUlISRYsWfelnqamp/Pzzz5QpU4ahQ4fq1e7atWtp3749GzZs0Ot4If6XTCAUwoRYWFhkzXiXIJAzDx484MmTJ3oP5wOvBAEAa2trnJyceP78ud7tli1blgsXLuh9vBD/S8KAECYmuwviZGRk5MkKiAVVUFAQgMFfJ1Sr1URHR+Pk5KR3G+XLl+fGjRskJycbsDJRmEkYEKIQunXrFitWrODIkSPGLiXfevDgAVZWVhQrVsyg7e7bt4/09PSsvSL0UapUKbRaLVFRUQasTBRmEgaEKISsra0JDw9n1qxZxi4l31Kr1QbfkTAgIIDQ0FC6dOmSo8cPmctXq9VqQ5UmCjkJA0IUEhqNJmvlusqVK/PJJ5+gVCrx9vY2cmX5k6EfoZw4cYK//voLDw8P3nvvPYO0KY95hKFIGBDCRD179oyEhAQ0Gg3wYnKhubk5N27c4NNPP8XDw4PatWvLpjdvYGtrS3p6ukHaOnHiBCdOnKBdu3Y5ejyQKbMuW1vbHLclBEgYEMJkff/990ycODFrHYJTp07h4eFB3bp1CQ8Px9vbmwMHDtC/f38jV5o/VaxYkbS0NBITE3PUzsmTJzlx4gRt2rShXbt2Bqnt6dOnmJmZGXWvBGFa5N0jIUxUt27d6NSpE82aNWP16tVcvXqVzp0788cff9CiRQvKlCmTp1vxFjQKhQKAqKgovTd6CgwM5Pjx49SoUYOaNWvy4MGDlz6vVKmSXu1GRUVRq1at1766KIQ+JAwIYaLatWtHixYtmDx5MkOHDuXHH3+kcePGlC5d2tilFQhVqlShZMmSREdH6x0Gbty4AbzYSfL27duvfD5v3jy92o2NjTXYKIMQIGFACJM2bdo0zp07x1dffUWtWrWMXU6BYmZmRqNGjV65m38Xw4cPN2BFL6SlpRETE5M1ciGEIcgYoRAmrEePHpQpU4bjx48bu5QCQ6PRcPjwYQYMGMCpU6e4c+cOz549M3ZZWUJDQ8nIyODDDz80dinChMjIgBAmbu3atSQnJ6PT6WRL438QERHB+vXrWb9+Pffv38/6uZmZGUqlkg4dOhixuhd0Oh1KpZLu3btTtWpVY5cjTIiEASFMXJcuXYxdQr6lUqn4888/WbduHceOHXvlc0dHRypWrMjFixdp27at0fd7ePjwIVFRUaxZs8aodQjTI7sWCiEKFZ1OR3BwMOvWrWPr1q2vPAIwNzenW7dueHp60qNHD8LDw3F1daVt27YGWSNAX1qtlg0bNmBlZcWNGzfkTRBhUDIyIEQho9Pp0Gq1mJubF6rHBo8fP2bLli2sXbuWy5cvv/J5jRo18PT0ZMiQIVSoUCHr53Xq1GH69On88MMP1K5dm7Jly+Zl2Vn+/vtv7t+/z8mTJyUICIOTkQEhCpm4uDiWLFlC6dKlmT59urHL0VtQUBDbtm3jww8/fOMdu06nQ6VSMWzYMPbs2UNaWtpLn9vZ2dGvXz88PT15//333xiOUlNTadKkCc+fP8fT0zNrIae88vjxY3x8fBg7diw//fRTnvYtCgcZGRCiEHn06BFVq1ZFpVLh5OTEpEmTSEtL48KFCyiVSoKCgggJCSExMZHU1FSKFClC0aJFadiwIe7u7igUCtzd3SlVqpTRziEuLo7vvvsOPz8/7t27h7m5Oe+99x7W1tavfNfMzAw7OzsePnz4UhBo3rw5np6e9O/fP1u7ElpbW7Nx40aaN2/Ovn376NmzZ56NqqSkpPD7779ToUIFFi5cmCd9isJHwoAQhYijoyMffvgh27dvJz4+nvbt23Px4kXS0tKwsbGhfPnylClThooVK2JpaYlGo0GlUnH58mUOHTqESqXCysqKPn36MGHCBFq3bp3njxo0Gg0WFhasXLmSM2fOsGXLFiZMmPDG2fXp6el4enpy+/ZthgwZgqenJ/Xq1Xvnft3c3Fi7di3Dhg3DysqKrl275vq5q1Qqtm3bRlpaGgEBAdjb2+dqf6LwkscEQhQyK1asYNKkSeh0OooXL06zZs2oXbs2pUqV+sdn0VqtlqdPn3Lz5k2Cg4OJj4+nbt26LFy4kN69e+dZ/VqtlqioKCpWrEhSUhLFihVj69atDBgw4I3HZGRkoNPpsrb+zQkvLy8mTJhAkyZN+OCDD3LtDYOEhAS2bdtGamoqR48epWnTprnSjxAgYUCIQiMhIYEpU6bg6+tLlSpVaN26NdWrV9drMppOpyMiIoKzZ89y69YtPv30U3755Zc8Xeo4cxKkh4cHDg4ObNq0KVtD/oawefNmPD09KVWqFL169XppwmFO6XQ6Ll68yMGDB3FycuLw4cN6jWQI8S4kDAhRCJw4cYLPPvuMJ0+e0KlTJ5o2bWqQIW6dTkdoaCgHDx7E3t6eDRs20K1bNwNU/HaZjwv8/PyyVgvMyyV6r1y5wpAhQ7h06RItW7akdevW2NjY5KjNJ0+esG/fPu7cucOQIUNYtmyZ7CUh8oSEASFM3K5duxgwYAAVK1bkww8/pESJEgbvIzExkb1793Lnzh3WrVvHkCFDDNZ2dlZOLFmyJF9++SXTp0/P05n+6enpLF68mHnz5mFubk6DBg1wc3OjXLly2W5Dq9Vy69YtlEolt27doly5cqxevZoPPvggFysX4mUSBoQwYX/++Scff/wx9erVo3fv3rm6gp5Wq8Xf35/g4GA2btzI4MGD9W4rJSWFnTt3Ehsby7///e83hoGMjAwsLS2ZOHEiZ86cYf/+/eh0OiIjI3F3d9e7/3cVGRnJ6tWr8fb2JjY2lvLly+Ps7Jz1v8WLF8fS0hKdTkd6ejrx8fFER0cTFRVFZGQkz549o0mTJnz++ef0798fOzu7t/aZ+ajm+fPnNG7cOPdPUpg0CQNCmKgzZ87Qvn17atWqRd++ffNkoRqdToefnx+XL19m//79dO7c+Z2OPX/+POvWrWPbtm0kJibi4OBAbGwstra2bzzGzMyMixcvolAoaNiwIWFhYQwZMoQVK1bkeNj+XaWnp7Nnzx727dvHhQsXuH79OhqN5rXftbOzo3HjxjRr1oyBAwe+c3hJTk7mxx9/5PDhwyxcuJDWrVsb4hREISVhQAgTlJycjKurKzqdjsGDB+fpmvparZatW7eSlJREWFgYJUuW/Mfvx8XFsXnzZtatW8fVq1df+fyPP/7gww8/fO3wf2pqKgsXLmT16tUkJyfzySefMHLkSN577z2DnU9OqFQqLl26RGxsLGq1GgsLC2xsbKhevTq1atXS+5FG5uTJ6OhofvjhB7Zv3050dHShWlFSGJasMyCECfrqq6+IiopizJgxeb65jrm5OT179sTb25spU6awfv36V76TkZHBoUOHWLduHX5+fmRkZLz0ub29Pf3798fT05OWLVu+8SKn1WpRq9XMnDmTiRMn5sbp5IitrS3Nmzc3aJuZj0bgxYTDAwcOoFarCQwMpFWrVgbtSxQeMjIghIk5deoUbdq0oWvXrga/EL2LixcvZg2Zd+/eHYBbt27h6+vLhg0biIqKeuWYVq1aMWLECPr160fRokXzuuR8LXNPiczRhLlz5/Ltt9/ywQcfMGvWLBo1avTGxylCvI2EASFMTMeOHbl+/TojRoww6oY2Op2OjRs3UrJkSSZNmsTatWs5derUK98rW7YsQ4cOxdPTk9q1axuh0vwtJCQEtVqdFexu3LhB//79uXfvHnPmzGHgwIFG2zxJmA7Z+koIE3Lz5k2OHTtGs2bNjL6znZmZGe+99x7BwcEMGzbspSBgaWlJ79698fPz48GDB1k7AopXHT9+nM6dO5OUlMT3339PvXr1KFOmDP7+/owfP16CgDAImTMghAnx9vamaNGi+WbFulq1auHg4EBiYiLwYjvgESNGMHjwYLmIZdOUKVPYuHEjxYsXp3jx4nz//fcMGjQIZ2dnY5cmTIg8JhDCRGg0GkqXLo2rqyudOnXSq43U1FQCAgK4evUqKpUKR0dHWrduTYMGDfSu66+//uKvv/7i8OHDtGvXTma86yEiIoJatWoxffp05s2bl+eTQoXpk79RQpiI69evk5CQQI0aNfRu47fffiMqKoqOHTtSunRpQkND+eOPP9DpdDRs2FCvNmvUqEFAQAA2NjYSBPTk4uLCnDlz+Omnn/j888+zPaqi0+l4+PAhN27cICUlhYyMDGxsbChVqhQNGzbM1uJGonCQMCCEiVAqlQCUL19er+Nv3rxJeHg4ffv2zRoJcHFx4dmzZxw5cgRXV1e95iGUKVMGS0tLlEolLVq00Ks2AV9//TXh4eFcunTpHxdzunPnDps3b+bvv/8mKCiI+Pj4137P3NycevXqoVAo6NSpE3379s3zRZpE/iETCIUwEUFBQTg5Oen9C/369esUKVLklfkGTZo0ITExkYcPH+rVrqWlJeXKlSMoKEiv48X/8fHxeW0Q0Gg07N27l27dulGjRg1+/PFHzMzMGDt2LLt37+b27dvExsby6NEjIiMjCQoKwtvbm1atWhEaGsqgQYOoVKkSM2bMICIiwghnJoxNRgaEMBFXr17F0dFR7+Pj4uJwdHR8ZVW8zCHpuLg4KleurFfbTk5OhIaG6l2beKFIkSKv/CwoKAhPT09CQ0Nxd3fH19eX/v37/+OaA87OzigUCkaNGgW8eF3R29sbb29vFi9ezNSpU/nmm29k3YJCREYGhDARiYmJORrmTUlJee0v/8yfqVQqvdu2trYmKSlJ7+PFq9RqNXPnzqV58+bodDoCAwM5f/48w4YNe+eLeO3atfnxxx+JjIzku+++45dffqFJkyacPXs2l6oX+Y2EASFMRHp6eo7XFsitCX4WFhakpaXlStuFUWxsLK1bt+a7775j9uzZBpuPYW9vz4wZM7h48SLFixenVatWLF682AAVi/xOHhMIYSKsra1JTU3V+3g7OztSUlJe+XnmiEBOhowzZ7GLnIuMjMTDw4PExETOnz9P06ZNDd5H3bp1OXPmDHPmzGHatGkkJCTw7bffytsgJkzCgBAmokSJEjma/FWmTBmuXLmCRqN5ad5AbGxs1uf6SklJoUSJEnofL16Ij4+nY8eOqNVqTp06RfXq1XOtL0tLSxYuXEipUqX48ssvsbe356uvvsq1/oRxyWMCIUxE48aNiYuL0/v4unXrkpaWxrVr1176+aVLl3BwcKBixYp6tx0XF0eTJk30Pl682KFxwIABPHnyhKNHj+ZqEPhv//73v5k3bx4zZ85kz549edKnyHsSBoQwEW5ubjx79kzviXo1a9akWrVq+Pv7o1QqiYiIwM/Pj9u3b9OpUye95yOkpqYSFxeHm5ubXseLF7y9vQkICGDbtm3UrFkzT/ueM2cOPXr0YOzYsTx58iRP+xZ5Q8KAECZCoVAAvHZr4Ozq378/jRo14vjx42zevJnIyEj69u2r9+qDADExMeh0uqz6xLuLiIhg2rRpjB07Fg8Pjzzv38zMDB8fH9RqNZMmTcrz/kXuk70JhDAROp2OypUr4+TkxIcffmjscrIcPHiQGzduEBsbi5WVlbHLKZB69OjBlStXCA0NxcHBwWh1bNy4kaFDh3LkyBE6duxotDqE4cnIgBAmwszMjHHjxmVtMpQfpKWlcfnyZUaPHi1BQE83b95k3759fPvtt0YNAgCDBw+mSZMm/PTTT0atQxiehAEhTMiIESPQ6XSEhIQYuxQArly5gkqlYsyYMcYupcDy9vamdOnS9OvXz9ilYGZmxvjx49m3bx937941djnCgCQMCGFCypYtS9++fblw4YLRF/nJyMjg77//pmvXrri4uBi1loIqJSUFX19fRowYodc6DSdOnMDMzOy1/5w7d06vmj799FOKFSuGj4+PXseL/EnCgBAmZv78+SQnJ3Ps2DGj1vHXX3/x+PFjFi5caNQ6CrLjx4/z7NkzPD09c9TOwoULOXv27Ev/uLq66tWWvb09n376KTt37sxRTSJ/kTAghImpVasWCxcu5Pz589y7d88oNURFRXH69Glmz55N48aNjVKDKQgKCqJ06dLUqlUrR+3UrFmT5s2bv/RP0aJF9W6vRYsW3L59m4SEhBzVJfIPCQNCmKDJkyfz3nvv4efnR3Jycp72rVar2bNnD/Xr15cV63JIqVSiUCjy3TLAma+JBgcHG7kSYSgSBoQwQRYWFmzevBkzMzO2bt2KWq3Ok37T0tLYvn07arWabdu2vXbLXZF9mWEgpyZMmIClpSXFihWjS5cunD59Okft1alTBzs7O5RKZY5rE/mDhAEhTFT16tU5cuQIiYmJrF+/PtdHCFQqFVu2bCEuLo4DBw5Qv379XO3P1Gk0GqKionK07HDx4sWZPHkyPj4+HD9+nJ9++okHDx7Qrl07Dh06pHe7FhYWuLi48ODBA73bEPmLLDokhAlLT0+nZcuWKJVKihYtykcffUS1atUM3s/9+/fZu3cv6enpHDhwgObNmxu8j8ImJSUFe3t7tm7dyqeffmqwdp89e0aDBg0oVaoUly5d0rsdd3d3mjZtKm8VmAgZGRDCROl0Oj7//HOCgoLQ6XSkpqayceNG/P39c7TV8X9LT0/n0KFD+Pr6UrVqVc6dOydBwEBy6z6tRIkS9OjRg8uXL+d4cSq5lzQdsoWxECbKy8sr667N2tqagIAAgoODmTZtGrdu3UKhUNC0aVO9ZpUnJydz8eJFlEolycnJ/PDDD0ydOvWlrY9FzmSuK5Abq0lmXsRzMjFRpVJha2trqJKEkUkYEMIEHTt2jMmTJ2f9efXq1bRs2ZKWLVvSvXt3vvvuO7Zu3crJkyepW7cutWvXxtnZmZIlS752d0KdTsfTp0+Jiori1q1bhIWFYWZmRv/+/Zk5cyZ16tTJy9MrFCwsLChfvjx37twxaLtPnz7F39+fxo0b67WQEbyYzxAREZGjba1F/iJzBoQwMbdu3eK9997j6dOnAEybNo0ffvjhle89ffqUjRs3snLlSm7cuAGAra0tZcuWxdraGktLSzQaDampqcTGxpKSkgJAtWrVGDt2LMOHD8fR0THvTqwQ6tmzJ+np6Rw8eFCv4wcOHEjlypVxc3PD0dGRW7dusXTpUu7cucOBAwf03mwoLCyM+vXrc+zYMaPsoigMT8KAECbk2bNnNG/ePOvi3qNHD3bv3v3W4ftHjx4RHBxMUFAQly9fJjExEbVajbW1NQ4ODri6uuLm5oZCoaBMmTJ5cSoCmDdvHr/++itxcXF6DekvWrSI3377jYiICJKSkihVqhStW7fmq6++wt3dXe+6Nm3axJAhQ3j69CklSpTQux2Rf0gYEMJEZGRk0KNHj6xXxurXr09gYCDFihUzcmVCX/7+/vTs2ZObN29Ss2ZNY5eTZfz48Rw+fJjbt28buxRhIPI2gRAmYtq0aVlBoHTp0vj5+UkQKODat29P8eLFWbdunbFLyZKSksK2bdvo27evsUsRBiRhQAgTsG7dOn788UcALC0t+eOPP3JlPQGRt+zt7Rk2bBhr16412OugObV9+3YSEhJkW2oTI48JhCjgTp8+jYeHB+np6QD4+PgwevRoI1clDOXGjRvUqVOHzZs389lnnxm1Fp1Oh7u7O2XLlmXfvn1GrUUYloQBIQqwu3fv0qxZM+Lj4wH4/PPP+fnnn41clTC0bt26cePGDS5fvpyj3QZzasuWLQwaNIhDhw7RuXNno9UhDE/CgBAFVFJSEq1ateLy5csAdOzYkQMHDmBpKcuHmJo7d+7QoEEDRowYwS+//GKUGmJiYqhXrx5dunRh27ZtRqlB5B6ZMyBEAaTVahk8eHBWEKhZsyY7duyQIGCiqlevzqJFi1ixYgUnTpzI8/51Oh1jx47FysrKaGFE5C4JA0IUQHPmzGH37t3Ai53p/Pz8KFmypHGLErlq4sSJtGnThk8//dTgqxK+zffff8+ePXtYuXKlLDRlouQxgRAFzMGDB+nWrRsA5ubm7N+/ny5duhi5KpEX4uLieP/990lLS+P48eNUrVo11/tcvnw5U6ZMYf78+cyZMyfX+xPGISMDQhQgOp2Odu3a0a9fPwCWLVsmQaAQKVOmDEeOHMHCwoLWrVvnaAvit9FoNMyZM4cpU6Ywbdo0vv7661zrSxifjAwIUcBotVrMzc3x8/OjZ8+eOdp5ThRM0dHRdOvWjbCwMObOncu0adOwsrIyWPs3b97E09OTwMBAvvvuO2bMmCF/z0ychAEhhCiAUlNTmT9/Pj/88AONGzfGx8cHNze3HLWpUqnw8vJi9uzZVKhQAV9fX95//30DVSzyM3lMIIQQBZC1tTULFy7k3LlzqNVq3N3dadmyJZs3b0atVr9TW3fu3OHLL7+kYsWKfPnll4wZM4bLly9LEChEZGRAiHzk5s2bVK5cWe995kXhlJGRwd69e/Hy8uLo0aNZuxMqFAoUCgWurq44ODhgaWmJWq0mJiYGpVKJUqkkKCiIv//+m5IlS+Lp6cnYsWOpUaOGsU9J5DEJA0LkE4sXL2bZsmX8+OOP9OzZE3t7e2OXJAqgGzdusGnTJs6fP09QUBBPnz597ffMzMyoXbs2CoWCjh070r9/f2xtbfO4WpFfSBgQIh8IDAykf//+ODk5cf36debMmcOoUaMoXbo08OItApnAJd6VTqfj7t273Lhxg5SUFNLT07G1taVUqVI0atQIBwcHY5co8glZrkwII8vIyCAwMJC2bduybt06vLy8mDp1KhEREcycOZMqVapIEBB6MTMzw8XFBRcXF2OXIvI5GRkQIh+4fv069+/fz9r85eDBg/Tt25dWrVqxePFiGjZsiJmZGceOHaNWrVpUqlTJyBULIUyJhAEh8pmMjAwsLS2JiIigQ4cOFClSBG9vb6Kiopg8eTL79+/H3d3d2GUKIUyIhAEh8iGNRoOFhQU6nY6uXbsSGBhIcnIyX3/9NfPnzzd2eUIIEyNhQIh8KnOEIDExkVKlSjFmzBhWrFhh7LKEECZIwoAQ+VhycjI9evQgKiqKGzduGLscIYSJkhUIhTAyrVZLRkbGGz/v2rUrQUFBeViREKKwkZEBIYwoPT2d4cOHM3v2bGrUqIGl5atv+8oaA0KI3CYjA0IY0ZQpU9iyZQvNmjXj+PHjvC6bSxAQQuQ2CQNCGIm3tze//vorAGq1Gjs7O7nwCyGMQh4TCGEEx48fp3PnzllzBXx9fRk2bJhxixJCFFoyMiBEHrtz5w4ff/xxVhD44osvJAgIIYxKRgaEyEPPnz+nefPmXLt2DYBu3bqxd+9eLCwsjFyZEKIwk5EBIfKIRqNh4MCBWUGgbt26bNu2TYKAEMLoJAwIkUe++uor9u3bB0DJkiXx8/OjePHiRq5KCCHkMYEQeWLDhg1Z8wIsLCw4fPgwHh4exi1KCCH+PxkZECKXBQYGMnr06Kw///LLLxIEhBD5iowMCPEGWq0WlUpFamoqVlZW2NravnaFwH9y//593N3diYuLA2DcuHF4eXnlRrlCCKE3CQNC/H83b97kxIkTKJVKLly4wJUrV0hPT8/63MzMjBo1auDu7o5CoaBly5a89957b1woKDk5mdatWxMSEgJA+/btOXToEFZWVnlxOkIIkW0SBkShlp6ezp49e/j11185ceIEZmZmlC1blrJly1K+fHns7e2xsLBAq9WiVquJjY0lNjaW6Oho0tPTqV27NhMnTmTw4MEvTQbUarV88skn/PHHHwBUr16dv//+m9KlSxvrVIUQ4o0KfBiIjY1FqVSiVCq5d+8earUanU6Hra0tFSpUQKFQ4ObmhrOzs7FLFfmITqdj06ZNTJ8+nZiYGKpWrYpCoaB27doUKVLkrcdrNBru3buHUqnk2rVr2NjYMHXqVGbPno21tTXz5s1j/vz5ABQrVoxz585Rt27d3D4tIYTQS4EMAzdv3sTb25udO3fy4MED4MWrWjVq1MDOzg4AlUpFREQE8fHxAJQrV47evXszfvx4GjRoYLTahfFFRUUxatQo9u/fj6urK61bt6ZcuXJ6t/f8+XPOnz/P2bNnqV27NoMGDWLmzJnAi0cL/v7+dO/e3VDlCyGEwRWoMHDgwAF+/PFHjhw5QunSpRk0aBCtWrVCoVDg4uLyyrNbnU7Hw4cPCQoK4ty5c2zatIno6Ghat27NpEmT+Pjjj2VjmEJm9+7dDBs2DJ1OR/fu3alTp47B2o6JiWHPnj1ER0dn/WzJkiV88cUXButDCCFyQ4EIA/Hx8UycOJEdO3bw3nvvMWHCBPr164eNjc07tfO/z4e7devGqlWrqFixYi5VLvKT9evXM2LECGrXrk3Pnj2zRpEMSaPR8Ndff3Hy5Elq167N1atXZYVBIUS+l+/DwB9//MG4cePQarWsWLGC/v37G+Ruft++fYwePZqkpCR+/PFHhg8fLqMEJmzz5s0MHjwYhULBBx98gLl57i6xERwczN69exk3bhwrVqyQv1tCiHwt3y46pNPp+Pbbb/n4449p3bo1V69eZcCAAQb7pfrBBx9w5coVPvroI0aMGMGUKVPQarUGaVvkLydOnGDYsGE0adKEHj165HoQAGjatCk9evTAy8uLxYsX53p/QgiRE/l2ZGDmzJl8//33LFiwgJkzZ+bqndXKlSuZMGECI0eOxMfHR+7iTEhSUhL169fH3NycwYMH5/mQ/eHDh7lw4QLBwcG4urrmad9CCJFd+XJkYPHixXz//fcsWbKEWbNm5frFedy4caxbt47Vq1czffr0XO1L5K1p06YRExNDr169jPLsvn379pQsWZKhQ4eSkZGR5/0LIUR25LswcPbsWWbMmMFXX32Vp7Owhw0bxtKlS1m8eHHWznKiYDt16hQrV66kQ4cOlCpVyig1WFlZ0atXL0JCQli2bJlRahBCiLfJV48JVCoVTZo0oXjx4pw5c+ad14HPKZ1OR7du3QgNDeXq1auUKFEiT/sXhvXBBx8QEhLCyJEj82SewD/x9/fn7t27REZGZmtRIyGEyEv5amRg7ty5RERE4Ovrm+dBAF4sELN69WqSkpKYMmVKnvcvDCciIoIDBw7g5uZm9CAA0KxZMx49esSuXbuMXYoQQrwi76+4b3D//n2WLl3KggULqFevntHqqFSpEkuWLGH06NH861//olGjRkarRejPx8cHGxsbvSftpaamcvLkSWJiYoiJiSElJYW2bdvSvn17vdorU6YMLi4urFixggEDBujVhhBC5Bbj3zL9f6tWrcLe3p7PP//c2KUwbNgwnJ2dWblypbFLEXrQ6XSsX7+ehg0b6j0kn5KSglKpRKPRGGyVQoVCwZkzZ4iIiDBIe0IIYSj5IgykpaWxevVqhg4dStGiRY1dDlZWVowePZrNmzeTkJBg7HLEO4qMjCQ2NhYXFxe92yhRogQzZsxg+PDhdOjQwSB1ZdZz4cIFg7QnhBCGki/CwO7du4mLi2PcuHF6t3Hx4kV69+6Ns7MzdnZ21KlTh2+++YaUlBS92hs1ahRqtZrNmzfrXZMwjqCgIADKly+vdxtmZmYGf6XV3t6ekiVLZtUnhBD5Rb4IA0ePHsXV1VXvuQJhYWG0bNmSu3fvsnz5cvz9/RkwYADffPMNn376qV5tOjs706ZNG44dO6bX8cJ4lEolDg4OFCtWzNilvKJcuXISBoQQ+U6+mECoVCpxc3PT+/itW7eiVqv5448/qF69OgAeHh5ER0ezatUqnj59SsmSJd+5XTc3N3777Te96xLGcfPmTRwdHfPlSpJOTk5cv37d2GUIIcRLjD4ykJqaSmhoaI7CgJWVFQDFixd/6eclSpTA3Nxc70lkCoWC+/fvEx8fr3dtIu+lpKTk23f5ixQpgkqlMnYZQgjxEqOHgbCwMNLT02natKnebQwdOpQSJUowbtw4wsPDSUxMxN/fHx8fHyZMmIC9vb1e7WbWdPHiRb1rE3kvPT09X44KAJibm8uyxEKIfMfojwmePHkCQNmyZfVuo2rVqpw9e5aPPvoo6zEBwKRJk1i+fLne7WbW9PTpU73bEHnP1tYWjUZj7DJeKyMjAxsbG2OXIYQQLzF6GEhNTQXA2tpa7zbu3r1Lz549KVu2LDt37sTJyYm///6bBQsWkJSUxNq1a/VqN/OXtlqt1ru23PD06VOCg4MJCgoiMjISlUqFmZkZNjY2VK5cGYVCQdOmTV95bFJYlC5dmuTkZGOX8VqJiYmULl3a2GUIIcRLjB4GMpcdzsnQ6YwZM3j+/DkhISFZjwTatGmDo6Mjnp6eDBkyhLZt275zu+np6cD/zUkwpjt37uDt7c0ff/yRtWiNjY0NJUuWzPp3mJ6ezpMnT0hLSwOgRo0a9OvXjzFjxlClShWj1Z7X6tevz/r160lPT8/Rf7tbt26RlpaW9e8zPj6eq1evAlCzZk295iXExsby/vvv612TEELkBqOHgcyLd2Jiot5thISEUK9evVfmBri7uwNw5coVvcJAZk12dnZ615ZTBw8eZPny5Rw6dAg7Ozvq169P48aNcXZ2pnTp0q+su6/Vann06BFRUVE8ePCA5cuX88MPP9C9e3emTJmCh4eHkc4k96jVas6ePcvx48cJCAjg3LlzaDQa4uLiqFChgt7t+vv7v7ToVFhYGGFhYQBMnjz5ncOARqMhOjoahUKhd01CCJEbjB4GMpd6DQ0N1XsdeWdnZ65cuUJSUtJLKxiePXsWgIoVK+rVbmhoKAB169bV6/iciIuLY/z48fzxxx9UrFiRDz/8EFdX17fe6Zqbm1OmTBnKlClD48aN6dy5M1euXCEoKIgOHTowaNAgfv75Z71etcwv0tPTuXDhAgEBAQQEBBAYGJj1uOm/RUZG5igMGHqzqvj4eNLT0yUMCCHynXyxhXHVqlX5+OOPWbJkiV7H+/n50bt3b9577z2mTJmCo6Mj586d4/vvv6dy5cpcvHhRryHdRYsWsXDhQp49e5atne8yMjJIS0vL8UjC77//ztixY0lNTaVbt27Ur18/x7PjdTodISEhHD58mGLFirF69Wp69uyZozbflVKpxM/PD1dXV3r37p3tIXyNRsPFixcJCAjg+PHjnDp16h/nBNSqVYukpCSsrKwYPny4ocrPsSNHjhAaGkpMTAy2trbGLkcIIbIYfWQAXizuo1Qq9T6+V69eHDt2jEWLFjF58mQSEhKoVKkSY8aM4auvvtL7nfOgoCAqVKjA06dPszXpKzg4mJ9++olHjx7h4eHB+PHjcXBwyHZ/Op2OOXPmZO3c2L17d4Pt1WBmZkaTJk2oXr06/v7+9OrVi0WLFjF9+nSDtP9PEhIS+P7779m7dy/Xrl2jc+fOdOrUiRIlSrz2+zqdjocPH7Jr1y4CAgI4efLkP+4RUaVKFTw8PPDw8KB9+/ZUqFCB33//nU8++YTY2NgcvaliKOnp6Vy6dImRI0dKEBBC5Dv5YmRgyZIlzJkzh+jo6HwzAz4tLY1y5crx9OlTLCws6NChA7t37/7HX+SnT5/m9OnTPHz4EC8vL7Zt20b//v2z1Z9Op+PLL79k6dKldOzYkVatWuXau/I6nY7jx4/z119/MXfuXObNm5cr/WRKTk7G29sbV1dXwsPD+eabbzh9+vRLr4H+t/T0dLZs2fLGu/ry5ctnXfg9PDxeuyFReno6FStWpHLlyvTo0cOg56OPS5cu8eeff3L9+nVq165t7HKEEOIlRl90CGDgwIGkpaWxadMmY5eSZdeuXVnrC2g0GpKSkt56R9e6dWtmzJhB3bp1qVy58jstpLRgwQKWLl1Kt27daN26da4ummNmZoaHhwcdOnRg/vz5OVqLITvs7e2ZOHEiXbp0YeDAgcTGxnLr1q03ft/KyoouXbpk/dnR0ZGPP/4YLy8vrl+/TmRkJJs3b2bEiBFv3JnQysqKcePGcfnyZaOvE5GRkUFgYCAdOnSQICCEyJfyxcgAQL9+/bh69SpXr17NF6vHtWnThpSUFDw8PPj999+ZNGkSEydO/Mfn3JmvsrVo0YIaNWrg4+OTrfkDx48fx8PDg3bt2tGuXTsDnsXbHT58mHPnznH27FmaNWuWq31pNBosLCyoUKECo0ePZtasWVmvRb7O+vXradq0Ka6urtmas/G/EhMTqVevHkWKFGHQoEF6tWEIx44d4+zZswQHB9OgQQOj1CCEEP8k34SBzAvioUOH6Ny5s1FrCQ4ORqFQsGPHDvr164dOpyMjIyNbE96Sk5NxcHDI9iOCpKQk6tevj7m5OUOGDMnzC5ZGo2HdunUULVqUkJCQXF0dLyMjA0tLSwYNGkRUVBS7du1647wBQzl69CidOnWie/fuuR52XicyMpK1a9cyf/58Zs+enef9CyFEduSLxwQA7dq1o2XLlkyYMIGUlBSj1ZGens7o0aOpW7cuvXv3Bl4Mq78tCGQumrRt2zYcHR2z/Yhg+vTpxMTE0KtXL6PcuVpYWNCrVy/u3LnD/Pnz9W7n2bNn7Nmzh4CAgDcuIJU54tOrVy8uXrxIXFyc3v1lV8eOHRk9ejTHjh0jKioq1/v7b8nJyezevZuGDRvmyURNIYTQV74JA2ZmZqxbt46HDx8a9Q5q8eLFXLx4kfXr17/T6nWZFzpfX186dOiAs7PzW4+5ceMGXl5etG/fnlKlSuldc06VLVuWNm3asHjxYh48eJCtY5KSkjh48CDTpk3Dzc2N0qVL07t3b5YuXfrGoX8LCwsAunbtSkJCAjdv3jTYOfyTpUuX0qBBA7Zu3ZonAQRApVKxbds2tFotv/32W75YxVIIId4k34QBgNq1a7NgwQKWL1/OyZMn87z/S5cuMW/ePL788st3GlLWarVYWFigVqs5d+4cPXv2fO1OiRkZGZw+fZqFCxdy8+ZNvLy8KFq0aNZKicb03nvvYWVlhY+Pz2s/V6lUBAQEMHv2bFq1akXJkiXp1q0bixcvRqlUotVqATh16tRbNwkqVqwY1apVY8+ePfz8889Mnz79HycU5lTRokU5dOgQVatWZcOGDURGRuZaX/AiKG3atImkpCSOHj1KrVq1crU/IYTIqXwzZyCTRqOhY8eOXLp0iZMnT+bZhKvw8HBat25NmTJlOHfuXLafnaelpfHdd99RtGhR0tLS+OWXXzhz5sxrX5vT6XQMHz6cDRs2AC/ulFu0aEHHjh0Nei762r9/P+Hh4VkXy/Pnz2ct8Xv27NnXrvKXqWHDhlmv+nXv3v21owM6nY79+/ezZcsWtm/fDoCTkxOffvop06ZNy9ZoSk48efKEbt26cfHiRdq1a0eLFi0M/mjm+vXr7N+/HxsbG44dO6b3qppCCJGX8sWiQ//NwsKCP//8k/bt29OhQwcOHz5M48aNc7XPW7du0alTJ+zt7Tl48OA7TaKzsLDA0dGRRYsWER0dDcCqVasYNWoU1apVe+lio9Vq8fPzy/qzRqPBzc1Nr5qjo6MJCAggNjaWlJQULC0tcXR0xN3dnUaNGunVppubG+fPn8fd3Z3bt2//49yN2rVrZ73r365dO5ycnN7avlar5dKlSzx58oTffvuNLl26UKxYMb1q1UepUqU4ceIEX3/9NcuWLeP69ev06tUrW7W/TUpKCgcOHCA0NJS2bduydevWXA83QghhKPluZCDTo0eP6Nq1K7dv38bX15ePPvooV/o5cuQIgwcPpkSJEhw5coRKlSrp3dajR4/YuHEjPj4+uLi4sHnzZhwdHV/6zt27d9m1axcLFy7E1taWkSNH6tVXREQEV65coXLlyhQrVoy0tDRCQ0O5cuUK7du312tjJoBff/2V+Pj4V37u4uKSdeffvn37An+hCwwMZOjQoURERFCnTh3c3d2pUqXKO7/WGh8fT1BQECEhIaSlpaHT6ejQoQNHjhzJF6/ICiFEduTbMADw/Plzhg4dyu7duxkwYAC//PLLKxfXnLT95ZdfsmrVKjw8PNi+fbtB7hAzJScnv3beQKZq1apRtmxZunbtarA+AVavXk1iYiJTp07V6/g9e/Zw6dIlypUr99ISv1WrVjVonfmBSqVizZo1rFixgps3b1K2bFlq166Ns7Mz5cuXp1ixYq9c0FUqFdHR0URFRREeHk54eDilS5fG09OTrVu3Zj1i2b59e7ZXnxRCCGPL12EAXjxn3rZtG59//jmWlpbMmTOHwYMH6z28nJKSwvbt25k/fz5Pnjxh8eLFjB49Ok9f63v27BklS5bko48+0ntI/022bNlCfHw8//rXv/Q6/sKFCxw8eJDExMRCs4a+TqfjxIkTrFy5kuPHj/Po0SMAHBwcsLe3x8LCAq1Wi1qtzlrN0N7enmbNmjFq1Cj69OmDtbU1fn5+fPjhh8CLJZOvX7+ep49BhBBCX/k+DGSKiYlh6tSp7NixA1tbWwYNGsTIkSNp1KjRP65iBy+eVV+9ehVfX198fX1JSEigZ8+e/PTTT0a54z1x4gTt27dn/PjxlClTJkdtabVadDodarWaq1evcvDgQbp37673XISHDx+yZs0agoKCCuVWuzqdjsjISJRKJSEhITx79ozU1FSKFCmCnZ0d9evXR6FQUKtWrdcGyF69erF3717gxRbIy5Yty+tTEEKId1ZgwkCmyMhIVq9ezapVq4iOjsbW1pbGjRvj5uZGzZo1s+5mVSoVERERKJVKgoODSUpKonTp0owYMYIxY8ZQrVo1o53Drl276Nu3L9OnT8/x3ffevXuzdny0sLCga9euOXpV8dmzZyxfvpzDhw/TqVOnHNVWGEVERFC/fn1UKhUWFhYolUqDj/4IIYSh5bu3Cd6mQoUKzJs3j1mzZhEYGIhSqSQoKIiDBw+yatWqrNffrK2tcXZ2xs3NjdmzZ6NQKGjdunWuLrebXWq1Gvi/RXhy4v3336dp06YkJydz8+ZN9u/fT1paGq1atdKrvcxRFpVKlePaCiMXFxdmz57NrFmz0Gg0jB8/nlOnThltXwQhhMiOAhcGMllZWdG2bdtXZs1nLn6Tn3/5Zl5wM2vNiRIlSmSt75+5uM2xY8do3LjxP05gfJPMmmTFPP198cUXbNiwgZs3bxIYGMj69evx9PQ0dllCCPFG+feKqSdzc/N8HQSArJ0M09LSDN52hQoV0Gq1em/bm1lTdnZbFK9nbW3Nr7/+mvXnGTNmkJSUZMSKhBDin+Xvq6aJytzTPjfWyY+IiMDMzIySJUvqdXxmTbKEbs507NiRAQMG0LRpUw4cOEDRokWNXZIQQrxRgX1MUJBVr14dBwcHoqOjqVGjhl5t+Pn5YW1tTYUKFShatCgpKSlcvXqVq1ev0rJlS70eEQBERUVRrlw5ypcvr9fx4v+sWbMGW1vbt+7VIIQQxiZhwAjMzc1p2rRp1vLF+qhUqRIXL17k0qVLqNVqihQpQtmyZXO8dkFMTIzeryWKl2UGsuw8ttJqtSQnJ+Pg4JDbZQkhxCskDBhJ8+bN8fLyIiMj463rJLxOkyZNaNKkiUFrSktL4+HDhwwdOtSg7Yp/ptFo2L17N+fPn2fChAlUrlzZ2CUJIQoZmTNgJEOGDCExMZFr164Zu5QsoaGhpKamMnjwYGOXUqhYWFjg4ODAnTt3GDt2rLHLEUIUQhIGjKRevXq0bds2a8EgY9PpdCiVSj744AOqVKli7HIKBZ1OR3p6OgCdO3dGoVBw8OBBDh06ZOTKhBCFjYQBI5owYQJ3797N0dwBQ7l//z5RUVFMmDDB2KUUChkZGZiZmWFlZUVkZCTdunVj/vz5jBgxQiZvCiHynIQBI+rduze1atVi3759Rp1xnpGRwYEDB2jcuDGdO3c2Wh2m7tatW1mPhTLnicyfP5+qVavy5MkTdu7cyZIlS2jYsKExyxRCFEISBozIysqKDRs2EBUVRWBgoNHqOHnyJI8ePWLDhg35fsGmguy3336jR48eABw9ehQXFxd++eUXvvvuO3bu3MkHH3xA8eLFjVylEKIwkt/8Rta8eXO++OILTp48SWxsbJ73//DhQ86cOcOcOXPkjjSXzZ49m+fPn1OtWjW6d+9Oq1atOHjwIP/617+oVKkSZmZmxi5RCFFIFbhdC02RWq3Gzc2Nhw8fMnz48Ky9BnLb48ePWb9+PbVr1yYwMFD2I8gD/v7+9OrVi+XLlzN06FAZCRBC5AsyMpAP2NjY8O9//5vExER8fX313lfgXcTHx7Np0ybKly/PgQMHJAjkkR49etCiRQuOHj0qQUAIkW9IGMgHDh06xJgxY9BqtSQmJrJ27Vru3r2ba/3dvn2bDRs2UL58eY4fP46jo2Ou9SVetXnzZmJiYrhx44axSxFCCEAeExjdzZs3adSoEWq1GnjxhkFcXByBgYG89957dOjQgSJFihikL7VazeHDhwkODsbDw4MdO3ZQunRpg7Qt3k1ERAQuLi7GLkMIIQAJA/nClClTWL58OX369GH79u2Ym5uzYsUKZsyYgb29PW3btqVevXp6LVsMkJ6ezpUrV/jrr79IS0tj6dKljB49Wias5TM6nU7+mwghjELCQD6xYcMGPv3005dGAW7dusWECRM4cuQIRYsWpXHjxjRp0oRSpUq99aKh0+l49OhR1mZGycnJ9OjRgxUrVsgKg/mQVqslLi6OsmXLSiAQQuQ5CQMFwLVr1/D29sbX15fExESKFi2atc1wyZIls0YMMjIyePLkCdHR0cTExJCcnEzx4sUZOXIkY8eO1Xu7ZJF7dDodGRkZLFiwgB9++IGNGzfyySefGLssIUQhI2EgF2m1WoMu4pOUlMTx48dRKpUEBQVx4cIF4uLiXvpO+fLlcXNzw93dHYVCQfv27bG1tTVYDcLwjh49SqdOnQBwdnbm+vXrspWxECJPSRjIJZcuXSIsLIyePXtStGjRXOtHo9GgVqsxMzPD2toaCwuLXOtL5A6dTkevXr3w9/cHYOrUqSxdutTIVQkhChMJA7ng0qVLKBQKtFota9eupX///tjZ2Rm7LJGPRUREUK9ePdRqNRYWFgQHB8uKkEKIPCPrDBjYs2fPmDt3LmPGjGHChAmMHj2aDRs2kJSUZOzSRD7m4uLCrFmzgBejPePGjUOr1Rq5KiFEYaHfu2rijTIyMmjatClNmzalR48elCpViokTJ5KWloanp6c8CxZv9OWXX7Jx40Zu3bpFYGAgGzZsYPjw4S99R6fTERUVhVKpRKlUcv/+fdRqNTqdDltbWypUqIBCocDNzY2KFSvKmwlCiGyRxwS5ID4+Hicnp6w/f/fdd3z99df88MMPjBkzhmLFiqFSqYiMjJQZ/uIlR44cydpG2tHRkRs3blCqVCmuXr3KypUr+f3337MmjTo4OLzyNsmzZ894/vw5AKVLl6Zv376MHz+eRo0aGeeEhBAFgoSBXJSRkZH1i3rJkiVMmzaNBQsWMHjwYKZPn46NjQ1r1qyRbYPFSwYMGMBvv/0GQJcuXVCr1Zw8eZJixYrh6upKpUqVcHZ2plixYq/c+et0OhITE4mKiuLhw4eEhoaSkJBAixYtmDJlCh9//LGMFgghXlHow4BWq+XOnTvcuHGD5ORkMjIysLa2pnTp0jRu3JiSJUvmuP3Mi/2vv/7KlClTqFixIs+ePeP69euUKVPGEKchTEhkZCS1atUiJSUFgCpVquDm5kbdunXfeRVKjUbDjRs3CAoKIjw8nK5du7J69WoqVqyYG6ULIQqoQhkGrl+/zsaNGzl37hzBwcEkJCS88bvVqlVDoVDQoUMHBg4cqNcz//9eZtbNzY1Hjx4RGBiIs7Oz3ucgTNe2bdsYOXIkWq2WXr16Ua9ePYO0e/PmTfbt24dWq2X58uUMHz5cRgmEEEAhCgPp6en4+fnh5eVFQEAApUuXpk2bNri5uaFQKHB1dcXBwQFLS0tSU1OJiYkhODg4a4GfM2fOYG9vz5AhQxg3bhz169d/pQ+tVotOp3vtu/7p6elMmjQJHx8f7ty5I5vUiFfodDpmz57NwoULcXV1pVu3btjb2xu0D5VKxaFDhwgJCeFf//oXS5culcdUQojCEQYuXLjAsGHDCAsLo1WrVowfP56+fftibW2d7TYePHjAqlWrWL16NbGxsYwaNYolS5ZQrFgxAFJTUxk0aBCzZs3C1dX1leHcjIwM1q5dS5s2bahbt65Bz08UfDqdjn//+98sW7aMTp060apVq1zt78KFC+zfv5+RI0fi4+MjIwRCFHImHQZSU1OZP38+//nPf2jUqBE+Pj64ubnlqM20tDTWrFnDtGnTKF26NGvWrKFdu3b069ePPXv2ULx4cY4dO0bTpk1fO7lLfumK11mwYAFff/013bt3p1mzZnnS58WLF9mzZw/Tp09n0aJFedKnECJ/MtkwEBMTQ7du3bh69Spz585l2rRpWFlZGaz9u3fvMmLECAICAqhbty7Xrl0DwM7OjiNHjtCyZUuD9SVM219//UXbtm1p164d7dq1y9O+AwMDOXz4MAcOHKBr16552rcQIv8wyTDw4MEDPDw8SElJYd++fTRu3DhX+tFqtfznP//hq6++AqBIkSLs37+fDh065Ep/wvQkJyfToEEDtFotQ4cOzfPn9zqdji1btpCSkkJYWBjFixfP0/6FEPmDyc0cio+Pp1OnTqSnp3P69OlcCwIA5ubmzJgxAx8fHwB69eolQUC8k5kzZ/Lw4UN69epllIl8ZmZm9OjRgydPnjB16tQ8718IkT+Y1MiAVqulU6dOXL16ldOnT+fp6n7Lly9nypQpbNq0iUGDBuVZv6LgCg8Pp0aNGnTs2DHXJwy+TVBQEP7+/ly+fJkGDRoYtRYhRN4zqZEBHx8fAgIC2LJlS54v8/uvf/2LTz/9lEmTJhEdHZ2nfYuCydvbG1tbW9zd3Y1dCk2aNKFYsWKsXLnS2KUIIYzAZEYGIiIiaNCgAYMGDcLb29soNTx69Ij69evTvHlzdu/eLW8OiDdSqVQ4OztTt25dunTpYuxyADh+/DhBQUFER0fLhlpCFDImMzIwefJkHB0dWbx4sdFqcHR0xNvbGz8/P/z8/IxWh8j/du7cybNnz3L8qut/UyqVzJs3j++++06v45s2bYpKpWLLli0Gq0kIUTCYRBi4c+cOe/fuZe7cuUa/o/noo49o1aoVP//8s1HrEPlbQEAAFSpUoHTp0gZp7/nz5xw+fDhHf/+LFy9O5cqVCQgIMEhNQoiCwyTCgLe3NyVLlmTAgAHGLgWA8ePHExAQkLX2gBD/68KFC5QtW9Zg7fn7+1OlShWqVauWo3bKlSvHhQsXDFSVEKKgKPBhQKVSsW7dOjw9PbG1tX3n44cNG4aZmdkb/zl37tw7t9m3b1+cnJzw8vJ652OF6UtJSeH69esG26jq0qVL3L17lw8++CDHbTk7O3P37l2ePn1qgMqEEAVFgQ8Dp06d4smTJwwfPlyv47/++mvOnj37yj+Ojo5UqFBBr5ne1tbWDBo0iD///FOvmoRpu3LlChqNhvLly+e4raSkJA4ePEjHjh0NsmBQZk0hISE5bksIUXAU+DAQFBRE8eLF9d78p3r16jRv3vylf1JTU3n06BHDhw9/7Q6E2dGiRQsiIyOJjY3V63hhujLvug2xI+G+fftwdHQ02OuJmTXJyIAQhUuBDwNKpZKmTZsadPW2tWvXYmZmhqenp95tKBQK4EV9Qvy31NRUgFd2tnxXYWFh3Lx5k549exrsNdbMmtRqtUHaE0IUDCYRBjIvvIaQkJDAzp076dChAy4uLnq34+LiQsmSJSUMiFdkXnC1Wq3ebaSmprJv3z6aNWuGg4MDKpUKlUqFRqMBXsylSUtLe+d2M2sy5KZeQoj8L2e3JvnAw4cPczyD+r9t27YNlUrFiBEjctSOmZkZLi4uREZGGqgyYSoyh+IzRwj0kZKSQnJyctYcl//1ww8/ULt2bT799NN3ajezJjs7O71rE0IUPAU6DGRkZKDRaPR6i+BN1q5dS+nSpfnoo49y3JatrS0qlcoAVQlTUqdOHQDi4uJwcnLSq42iRYsydOjQV35++vRp7t27x2effabXBT0uLg5A7zk4QoiCqUCHAUO7fPkyQUFBTJ48GWtra4O0KUsSi/9VtmxZypcvT1RUFPXr19erDSsrq9c+xgoJCckaldJHVFQUxYsXz9EjMiFEwVOg5wxYWlpiaWlJSkqKQdpbu3YtACNHjjRIeyqVChsbG4O0JUyLu7t7vtzQKjo6Gjc3NwmxQhQyBToMAFSuXJnbt2/nuJ3U1FQ2b95Ms2bNcHV1zXF7Wq2W27dvU7ly5Ry3JUxP5qunhp61/9FHHzFr1iy9jk1PT+fBgwc0b97coDUJIfK/Ah8GFAqFQWbs7969mydPnhhsVODOnTs8f/7coG86CNMxaNAgMjIyuHz5srFLyXL16lWSk5NfOxdBCGHaTCIMXLx4MUevacGLRwT29vYG298gM6BIGBCvU7FiRXr27IlSqSS/7CKuVCrp1KkTNWvWNHYpQog8VuDDgJubG4mJiYSGhuaoncOHD5OUlGSwXQ8DAwOpXLkyjo6OBmlPmJ4JEyYQGxtLeHi4sUvh4cOHPHjwgPHjxxu7FCGEERT4MNC6dWucnJxYt26dsUvJkrknfL9+/YxdisjHOnToQLNmzTh48CDp6elGqyMjI4N9+/bh6upKjx49jFaHEMJ4CnwYsLa2ZuTIkaxfv57k5GRjlwPAjh07ePLkCWPHjjV2KSIfMzMzY8OGDSQkJBAQEGC0Ok6dOkV8fDybNm3K8RLJQoiCqcCHAYAxY8aQmJjIli1bjF0KOp0OLy8vunTpQo0aNYxdjsjn6tSpw4IFCzh37hz37t3L8/4jIyM5ffo0s2bNonHjxnnevxAifzDT5ZfZSzn08ccfExgYyNWrVylZsqTR6ti6dSufffYZ+/fvp1u3bkarQxQcGo2Gdu3acfHiRYYMGULZsmXzpN/Hjx+zZs0aqlWrRnBwMEWKFMmTfoUQ+Y9JjAwA/PTTT6SkpDBlyhSj1RATE8Pnn39O//79JQiIbLOwsGDv3r1Ur16dzZs3ExMTk+t9xsfHs27dOtRqNVFRUVy7di3X+xRC5F8mEwYqVKjA8uXL2bBhA/v27cvz/nU6HePGjcPCwoIVK1bkef+iYCtRogTHjh2jRo0abNy4kbCwsFzr6+bNm2zYsAGdTodOp+Pp06csXbo037ziKITIeybzmABeXJB79OjBuXPnOHnypEFWEsyuBQsW8PXXX7Nz50769u2bZ/0K0/L8+XOGDBnCnj17aNCgAV27ds3a5TCnVCoVhw4dIiQkhC5duuDt7c3AgQMpXbo0u3btwsLCAnPzN98fJCQkYGZmRrFixQxSjxAi/zCpMADw7Nkz2rVrR1xcHMeOHcuT3deWLVvGF198wTfffMPXX3+d6/0J06bT6di2bRsTJkxAo9HQunVrGjVqpPc+F6mpqYSGhnL69Gk0Gg0//fQTw4YNw8zMjJSUFIoUKYK5ufk/BoFnz56xevVqgoKCmDt3LvXq1dP39IQQ+ZDJhQGA2NhYOnbsSExMDHv27KFly5a50o9Go2HOnDksXLiQr776iu+++042eBEGExMTw9SpU/n999+xsLDA1dWVpk2bUq5cOSwsLP7xWI1GQ1xcHBcvXuTy5cukpaXx0UcfsXz5cipWrPjSd3U6Xbb+3u7atYtDhw6xadMmLly4oPeOi0KI/MckwwDAkydP6NWrF2fPnuXf//438+fPN+gOgteuXWP48OGcP3+eRYsWMW3aNIO1LcR/i4qKYvXq1Xh7exMTE4OVlRXlypWjXLlylCpVCisrK+DFRkNPnz4lNjaW6Oho0tLScHR0ZMyYMYwZM4ZKlSrp1X9GRkbW+gNz587l22+/xcfHhxEjRvzjaIIQouAw2TAAL36JLVmyhLlz51KtWjW8vLxo165dju7ek5OT+eWXX5g3bx5VqlRh/fr1tGjRwoBVC/F66enpnDt3DqVSiVKp5Pz58zx48IDU1FR0Oh02NjY4OzvTrFkzFAoFCoWCli1b5uiVwf8eNfj555/517/+xdKlSxk2bJhRX+EVQhiWSYeBTGFhYVl38Q0aNGD8+PF89tln77QPwfXr11m5ciXr168nKSmJqVOn8s0332Bra5uLlQuRPdkd6n/XNuHFSoleXl5MnDiRhQsXMn78eJlEKISJKRRhAECr1XLs2DG8vLzw8/PDzs6O5s2bZ91BNWjQgKJFi2JlZYVarSY2NjbrDiwoKIhLly7h5OTEyJEjGT16NFWrVjX2KQmRKzIyMgCyHg34+Pgwbtw4vv32WyZOnEjx4sWNWZ4QIhcUmjDw3x48eMDmzZv5+++/USqVPHz48LXfs7S0xNXVFYVCQYcOHejTpw/W1tZ5XK0QeUen07FmzRouXbrEihUrWLt2LaNGjWLu3LlMnjyZEiVKGLtEIUQuKJRh4H/FxsZy/fp1UlJSSE9Px8bGhlKlSuHq6mrQSYdCFARXrlyhYcOGtGjRggsXLjBjxgymTp2a4yCQkpJCSEgI4eHhqNVqtFotNjY2lCtXjqZNm8p230IYkYQBIcQrrl+/joeHB/b29pw4cYIKFSq8cxtarZajR4+yfft2Lly4QFhYGFqtNutzMzOzl1Y9rFKlCm5ubvTo0YP+/fvLfBwh8pCEASHEa4WHh9OwYUMGDBiAl5dXtt9KePLkCb6+vqxcuZI7d+5Qt25d2rRpkzU/p3bt2tja2mJmZkZaWhr379/Pmp/z999/c/r0aUqUKMHw4cMZN26c7P4pRB6QMCCEeKPw8HC+/vprvvnmG6pXr/7SZ1qt9qV1BnQ6HZs3b2bSpEmkpKTQr18/xo8fT4sWLd7pTYc7d+7g4+PD2rVrSUhIYNq0acydO1fm6wiRiyQMCCH+UVpa2iujAunp6cTFxREYGEi/fv2Ijo5mzJgx7N27l4EDB7Js2bIcb8WsUqlYunQp33zzDTVr1mT9+vW4u7vnqE0hxOtJGBBCvBONRkN8fDytWrUiPDycGTNmsHr1aiwtLfH29qZ3794G7e/y5csMHz6cS5cusXLlSkaNGmXQ9oUQJrSFsRAib5ibm7N27VrCw8MB+M9//kPt2rW5cuWKwYMAQMOGDTl37hxjxoxh9OjRLFu2zOB9CFHYWRq7ACFEwWJmZsbMmTO5fv0627Zt4/3338ff399gWy2/jpWVFStWrMDBwYEvvvgCe3t7xowZk2v9CVHYyGMCIcQ7e/r0KfXr16dSpUocO3aMokWL5km/Op2OSZMm4eXlxZkzZ2jevHme9CuEqZMwIIR4Z0OHDmXPnj1cvXpVrzUIciIjI4OWLVvy/PlzLl68KOsRCGEAMmdACPFO/P392bhxIz/++GOeBwF4sUz4+vXriYiIYO7cuXnevxCmSEYGhBDZlp6eTrVq1WjQoAH79u0z+E6J72LRokXMmjWL0NBQ6tWrZ7Q6hDAFMjIghMi23bt38/DhQ3744QejBgGAqVOn4ujoyMqVK41ahxCmQEYGhBDZ1r59ezQaDX/99ZexSwFg9uzZ/Pzzz0RFReXZJEYhTJGMDAghsiUsLIwTJ04wfvx4vds4f/48Xbp0wcHBgaJFi9K+fXvOnDmjd3ujR48mOTmZzZs3692GEELCgBAim/z8/HBwcKBPnz56HX/hwgXatGmDSqVi06ZNbNq0CbVaTYcOHTh79qxebVauXJkOHTrg5+en1/FCiBfkMYEQIlv69etHfHw8J06c0Ov4rl27EhISQnh4OHZ2dgAkJiZSrVo1atWqpfcIwZw5c/Dx8SEmJsbo8xiEKKhkZEAIkS1BQUEoFAq9jz9z5gzt2rXLCgIADg4OtGnThsDAQKKjo/VqV6FQEBcXx8OHD/WuTYjCTsKAEOKtnjx5wt27d3MUBtLS0l67DXHmz0JDQ/VqN7MmpVKpd21CFHYSBoQQbxUVFQWAi4uL3m3Uq1ePc+fOodVqs36WkZHB33//DcDjx4/1ardChQpYWlpm1SiEeHcSBoQQb6VWqwGwsbHRu43PP/+cmzdvMnHiRCIjI3nw4AFjx47l3r17wIvdEPVhZmaGra0tKpVK79qEKOwkDAgh3ipzYl5O5ht7enqyaNEiNm3aRMWKFalcuTJhYWH8+9//BsjR0sZarVbvMCGEkDAghMiGzM2AUlJSctTO9OnTefToEaGhody9e5fAwECePn2Kvb293vMRdDodarVaNiwSIgckDAgh3qpSpUqYmZlx69atHLdlbW2Nq6srVapU4f79+/z222+MGjVK74t5eHg4Go2GKlWq5Lg2IQorS2MXIITI/xwcHKhduzZKpZLhw4fr1caVK1f4448/cHNzw9ramkuXLrFo0SJq1qzJt99+q3dtmW8R5ORNByEKOwkDQohsUSgUBAUF6X18kSJFCAgI4OeffyYpKYnKlSszduxYZsyYgb29vd7tKpVKKlWqRJkyZfRuQ4jCTsKAECJb3Nzc2LlzJ4mJiTg4OLzz8bVq1eLkyZMGr+v06dO4ubkZvF0hChOZMyCEyJa+ffuSnp7O1q1bjV1KlrCwMAIDA/nkk0+MXYoQBZrsTSCEyLbevXsTERFBSEhIvtgH4PPPP2fHjh08ePCAIkWKGLscIQosGRkQQmTb+PHjuXz5co62HTaUxMRENmzYwKhRoyQICJFDMjIghMg2rVZLo0aNsLGx4ezZs1haGm/a0eTJk1m1ahU3b96kUqVKRqtDCFMgIwNCiGwzNzdn7dq1BAcHs3jxYqPV8ddff/Hzzz+zcOFCCQJCGICMDAgh3tlXX33FsmXLUCqVuLq65mnfycnJNGrUiHLlynHy5EksLCzytH8hTJGEASHEO1Or1bi5uaFWqzl16hTly5fPk37T09Pp27cvR48e5dKlS9SsWTNP+hXC1MljAiHEO7OxscHf3x+1Wk2nTp2Ijo7O9T7T09MZNGgQBw8eZNeuXRIEhDAgCQNCCL1UrVqVo0eP8vTpU95//32uXbuWa309ffqU3r178+eff7J9+3a6du2aa30JURhJGBBC6K1OnTqcOXMGKysrmjRpwuLFi9FoNAbtw9/fn/r163PmzBn8/f3p06ePQdsXQkgYEELkUNWqVQkODubzzz9n+vTptGrVigsXLuS43fv37zN06FB69uxJkyZNuHr1Kp07dzZAxUKI/yVhQAiRY7a2tixevJgzZ86QkJBAs2bNaNasGb6+vqhUqmy3o9VqOXToEB9++CEuLi74+fnh6+uLv78/FSpUyMUzEKJwk7cJhBAGpdFo2L9/P15eXhw6dIiiRYvi5uaGQqFAoVBQp04d7OzsMDc3R6VScf/+fZRKJUqlkvPnzxMTE0PDhg2ZMGECAwcOpGjRosY+JSFMnoQBIUSuuXPnDjt27CAoKAilUsm9e/de+71SpUplhYUePXrQsmXLfLH3gRCFhYQBIUSeefToEeHh4ajVajQaDba2tpQrV44qVarIxV8II5IwIIQQQhRyMoFQCCGEKOQkDAghhBCFnIQBIYQQopCTMCCEEEIUchIGhBBCiEJOwoAQQghRyEkYEEIIIQo5CQNCCCFEISdhQAghhCjkJAwIIYQQhZyEASGEEKKQkzAghBBCFHISBoQQQohCTsKAEEIIUchJGBBCCCEKOQkDQgghRCEnYUAIIYQo5CQMCCGEEIWchAEhhBCikJMwIIQQQhRy/w9g4cNVBk3XxgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# An example of the rumor graph, where infected nodes are in grey.\n",
    "\n",
    "# seed is used in \"nx.spring_layout(G, seed=pos_SEED)\"\n",
    "pos_SEED=0\n",
    "\n",
    "G = nx.Graph()\n",
    "\n",
    "G.add_nodes_from(range(11))\n",
    "\n",
    "G.add_edges_from([(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6), (3, 7), (3, 8), (4, 9),(6,10),(0,11)])\n",
    "\n",
    "for e in G.edges(data=True):\n",
    "    G[e[0]][e[1]][\"weight\"]=1\n",
    "\n",
    "edge_labels = nx.get_edge_attributes(G,'weight')\n",
    "    \n",
    "nodes_infected={0,1,2,3,4,6}\n",
    "\n",
    "# Set the colors for infected nodes and uninfected nodes in the graph\n",
    "node_colors = ['gray' if i in nodes_infected else 'white' for i in range(G.number_of_nodes())]\n",
    "\n",
    "# Draw the graph\n",
    "pos = nx.spring_layout(G, seed=pos_SEED)\n",
    "nx.draw_networkx_nodes(G, pos, node_color=node_colors, node_size=800, edgecolors= 'black')\n",
    "nx.draw_networkx_labels(G, pos, labels={i: str(i) for i in range(G.number_of_nodes())}, font_size=12)\n",
    "nx.draw_networkx_edges(G, pos, width=2)\n",
    "nx.draw_networkx_edge_labels(G, pos, edge_labels)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Construct the parent and child relation between nodes after selecting a node as source.\n",
    "\"\"\"\n",
    "# source=0\n",
    "# source = list(nodes_infected)[0]\n",
    "def parent_child_relation(G, nodes_infected, source):\n",
    "    parent={} # 'key:value' pair where 'value' is the parent node for node 'key'\n",
    "    child={} #'key:value' pair where 'value' is the set of child nodes for node 'key'\n",
    "    depth={} # \n",
    "    nodes_waiting_child=set() # nodes haven't assigned child\n",
    "    b_uninfected=set() #susceptible nodes at final observation; uninfected nodes which have infected neighbors\n",
    "    b_infected=set() #infected nodes which have uninfected neighbors\n",
    "    leaf_infected=set() # the leaf infected nodes\n",
    "\n",
    "    leaf_uninfected=set() # the uninfected nodes whoes parent is in leaf_infected\n",
    "    pseudo_leaf_uninfected=set() # the uninfected nodes whoes parent is infected but not in leaf_infected\n",
    "\n",
    "    parent[source]=None\n",
    "    depth[source]=0\n",
    "    nodes_waiting_child.add(source)\n",
    "    while len(nodes_waiting_child)!=0:\n",
    "        i=nodes_waiting_child.pop()\n",
    "        child[i]= set(j for j in G.neighbors(i) if j not in parent.keys())\n",
    "        if i!=source:\n",
    "            i_is_leaf_infected = True \n",
    "        else:\n",
    "            i_is_leaf_infected = False\n",
    "        i_has_infected_child = False\n",
    "        i_uninfected_child=set()\n",
    "        for j in child[i]:\n",
    "            parent[j]=i\n",
    "            if j in nodes_infected:\n",
    "                depth[j]=depth[i]+1\n",
    "                nodes_waiting_child.add(j)\n",
    "                i_is_leaf_infected = False\n",
    "                i_has_infected_child = True\n",
    "            else:\n",
    "                b_uninfected.add(j)\n",
    "                i_uninfected_child.add(j)\n",
    "        if i_has_infected_child==True:\n",
    "            b_infected.add(i)\n",
    "        if i_is_leaf_infected==True:\n",
    "            leaf_infected.add(i)\n",
    "            leaf_uninfected = leaf_uninfected.union(i_uninfected_child)\n",
    "        # print(i, child[i])\n",
    "        \n",
    "    #### pay attention to the uninfected neighbors of the source.\n",
    "    root_uninfected_child = child[source].intersection(b_uninfected)\n",
    "    pseudo_leaf_uninfected = b_uninfected - leaf_uninfected -root_uninfected_child \n",
    "    return parent,child,b_uninfected,b_infected,depth,leaf_infected, root_uninfected_child, pseudo_leaf_uninfected\n",
    "\n",
    "\n",
    "# parent,child,b_uninfected,b_infected,depth,leaf_infected, root_uninfected_child, pseudo_leaf_uninfected = parent_child_relation(G=G.subgraph([0]), nodes_infected=nodes_infected, source=source)\n",
    "    \n",
    "# print(parent,child,b_uninfected,b_infected,depth,leaf_infected, root_uninfected_child, pseudo_leaf_uninfected,sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_gr_main(gnp, gr_nodes_infected, gr_nodes_susceptible):\n",
    "    ## gr_main is the subgraph of infected and susceptible nodes, with edges between susceptible nodes removed\n",
    "    gr_main=gnp.subgraph(list(gr_nodes_infected) + list(gr_nodes_susceptible)).copy()\n",
    "    # remove the edges between susceptible nodes\n",
    "    for u in gr_nodes_susceptible:\n",
    "        for v in set(gr_main.neighbors(u)).intersection(gr_nodes_susceptible):\n",
    "            gr_main.remove_edge(u,v)\n",
    "    return gr_main\n",
    "\n",
    "def extract_bfs(gr_main, gr_nodes_infected, gr_nodes_susceptible, s_selected):\n",
    "    gr_bfs=nx.bfs_tree(gr_main.subgraph(gr_nodes_infected), s_selected).to_undirected()\n",
    "    for i in gr_nodes_susceptible:\n",
    "        if gr_main.degree[i]==1:\n",
    "            gr_bfs.add_edges_from(gr_main.edges(i))\n",
    "        else:\n",
    "            v_cand=sorted([v for (_,v) in gr_main.edges(i)],reverse=True)\n",
    "            # print(gr_main.edges(i),v_cand)\n",
    "            v_dist_min=np.inf\n",
    "            v_arg_min=v_cand[0]  # the infected neighbors of i that will be selected by bfs w.r.t s_selected\n",
    "            for v in v_cand:\n",
    "                v_dist=nx.shortest_path_length(gr_bfs, s_selected, v)\n",
    "                if v_dist<=v_dist_min:\n",
    "                    v_arg_min=v\n",
    "                    v_dist_min=v_dist\n",
    "            gr_bfs.add_edge(i, v_arg_min)\n",
    "    return gr_bfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fhat(t,k,d,T2):\n",
    "    return (t**(k-1)*np.exp(-t)/math.factorial(k-1))*np.exp(-(T2-t)*(d-1))\n",
    "\n",
    "def fhat_integral(T1, T2, k, d):\n",
    "    # print(\"T1, T2, k, d\",T1, T2, k, d)\n",
    "    return integrate.quad(fhat, T1, T2, args=(k,d,T2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# tmax=4\n",
    "# gr_main=G \n",
    "# gr_nodes_infected=nodes_infected\n",
    "# gr_nodes_susceptible=b_uninfected\n",
    "\n",
    "\n",
    "def compute_likelihood(tmax, gr_main, gr_nodes_infected, gr_nodes_susceptible, tcount=21, dynamic_scale=False):\n",
    "    '''return the likelihood for each node to be the source;\n",
    "    tmax: the maximum time to maximize over;\n",
    "    The return is a list, the i-th element is a dict storing node-likelihood for i-th critical time \n",
    "    '''\n",
    "\n",
    "    t_list = np.linspace(0, tmax, tcount)\n",
    "    t_positions=[i for i in range(len(t_list))]\n",
    "\n",
    "    \n",
    "    result=[{} for i in t_positions]\n",
    "    scale_num=[{} for i in t_positions]\n",
    "    for source in gr_nodes_infected:\n",
    "        message=[{} for i in t_positions]\n",
    "        \n",
    "        G=extract_bfs(gr_main, gr_nodes_infected, gr_nodes_susceptible, s_selected=source)\n",
    "        \n",
    "        parent,child,b_uninfected,b_infected,depth,leaf_infected, root_uninfected_child, pseudo_leaf_uninfected = parent_child_relation(G=G, nodes_infected=gr_nodes_infected, source=source)\n",
    "\n",
    "        for t_pos in t_positions:\n",
    "            for i in leaf_infected:\n",
    "                if depth[i]==0:\n",
    "                    print(gr_nodes_infected, gr_nodes_susceptible, gr_main.edges(),'\\n', 'i', i, 't_list[t_pos], depth[i], G.degree[i]', t_list[t_pos], depth[i], G.degree[i])\n",
    "                message[t_pos][i]=fhat_integral(0, t_list[t_pos], depth[i], G.degree[i])[0]\n",
    "                \n",
    "            for i in pseudo_leaf_uninfected:\n",
    "                message[t_pos][i]=fhat_integral(0, t_list[t_pos], depth[parent[i]], 2)[0]\n",
    "\n",
    "            for i in root_uninfected_child:\n",
    "                message[t_pos][i]=math.exp(-t_list[t_pos])\n",
    "            \n",
    "            if dynamic_scale==True:\n",
    "                scale_num[t_pos][source]=0\n",
    "                result[t_pos][source]=1\n",
    "                for m in message[t_pos].values():\n",
    "                    if result[t_pos][source]<10**(-6):\n",
    "                        result[t_pos][source]=result[t_pos][source]*10**20\n",
    "                        scale_num[t_pos][source]+=1\n",
    "                    result[t_pos][source]=result[t_pos][source]*m\n",
    "            else:\n",
    "                result[t_pos][source]=np.prod(list(message[t_pos].values()))\n",
    "                # result[t_pos][source]=np.prod([10**300]+list(message[t_pos].values()))\n",
    "\n",
    "                \n",
    "            \n",
    "            ## to save memory\n",
    "            # print(max(message[t_pos].values()))\n",
    "            message[t_pos]={}\n",
    "            \n",
    "    if dynamic_scale==True:\n",
    "        scale_num_min=min([min(scale_num[t_pos].values()) for t_pos in t_positions])\n",
    "        for t_pos in t_positions:\n",
    "            for k,v in result[t_pos].items():\n",
    "                result[t_pos][k]=v*10**(-20*(scale_num[t_pos][k]-scale_num_min))\n",
    "        # print(scale_num)\n",
    "        \n",
    "            \n",
    "    return result, t_positions\n",
    "\n",
    "# result, t_positions = compute_likelihood(tmax=tmax, gr_main=G, \n",
    "#                                          gr_nodes_infected=gr_nodes_infected,gr_nodes_susceptible=gr_nodes_susceptible)\n",
    "# # result, t_positions = compute_likelihood(tmax=tmax, gr_main=G, gr_nodes_infected=gr_nodes_infected,gr_nodes_susceptible=gr_nodes_susceptible,dynamic_scale=True)\n",
    "\n",
    "\n",
    "# print(result)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_max_nodes(result, nodes_infected):\n",
    "    result_by_node={}\n",
    "    for i in nodes_infected:\n",
    "        result_by_node[i]=[]\n",
    "        for t_pos in t_positions:\n",
    "            result_by_node[i].append(result[t_pos][i])\n",
    "            \n",
    "    max_nodes_t_pos={}\n",
    "    max_value=0\n",
    "    max_nodes=set()\n",
    "\n",
    "    for k,v in result_by_node.items():\n",
    "        max_index=np.argmax(v)\n",
    "        max_nodes_t_pos[k]=max_index\n",
    "        if np.isclose(v[max_index],max_value):\n",
    "            max_nodes.add(k)\n",
    "        elif v[max_index]>max_value:               \n",
    "            max_value=v[max_index]\n",
    "            max_nodes={k}\n",
    "    return max_nodes,max_value\n",
    "    \n",
    "# max_nodes,max_value=extract_max_nodes(result,nodes_infected=gr_nodes_infected)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### https://github.com/networkx/networkx/pull/6903/files\n",
    "def rumor_centrality(G):\n",
    "    \"\"\"Compute the rumor centrality for nodes.\n",
    "    Parameters\n",
    "    ----------\n",
    "    G : graph\n",
    "      A networkx graph\n",
    "    Returns\n",
    "    -------\n",
    "    nodes : dictionary\n",
    "       Dictionary of nodes with degree centrality as the value.\n",
    "    Raises\n",
    "    ------\n",
    "    NetworkXPointlessConcept\n",
    "        If the graph G is the null graph.\n",
    "    Notes\n",
    "    -----\n",
    "    Rumor centrality was introduced by Shah & Zaman [1]_ for rumor source detection.\n",
    "    .. [1] Shah, Devavrat, and Tauhid Zaman. \"Rumor centrality: a universal source detector.\" In Proceedings of the\n",
    "    12th ACM SIGMETRICS/PERFORMANCE joint international conference on Measurement and Modeling of Computer Systems,\n",
    "    pp. 199-210. 2012.\n",
    "    \"\"\"\n",
    "\n",
    "    if len(G) == 0:\n",
    "        raise nx.NetworkXPointlessConcept(\n",
    "            \"cannot compute centrality for the null graph\"\n",
    "        )\n",
    "\n",
    "    # Create copy to be able to use node properties\n",
    "    H = G.copy()\n",
    "    set_visited_to_false(H)\n",
    "\n",
    "    # Calculate rumor centrality for a single vertex\n",
    "    arbitrary_start_vertex = list(H)[0]\n",
    "    calculate_rumor_centrality_for_single_vertex(\n",
    "        H, arbitrary_start_vertex, arbitrary_start_vertex\n",
    "    )\n",
    "\n",
    "    # Calculate rumor centrality for remaining vertices\n",
    "    set_visited_to_false(H)\n",
    "    H.nodes[arbitrary_start_vertex][\"visited\"] = True\n",
    "    for neighbor in H.neighbors(arbitrary_start_vertex):\n",
    "        calculate_for_remaining(\n",
    "            H, neighbor, H.nodes[arbitrary_start_vertex][\"rumor_centrality\"]\n",
    "        )\n",
    "\n",
    "    print({v:{ H.nodes[v][\"subtree_size\"], H.nodes[v][\"cumulative_prod\"]} for v in H.nodes} )\n",
    "    return {v: H.nodes[v][\"rumor_centrality\"] for v in H.nodes}\n",
    "\n",
    "\n",
    "def calculate_rumor_centrality_for_single_vertex(G, v, start_vertex):\n",
    "    # Mark v as visited\n",
    "    G.nodes[v][\"visited\"] = True\n",
    "\n",
    "    # Collect all unvisited neighbors\n",
    "    unvisited_neighbors = []\n",
    "    for neighbor in G.neighbors(v):\n",
    "        if not G.nodes[neighbor][\"visited\"]:\n",
    "            unvisited_neighbors.append(neighbor)\n",
    "\n",
    "    # If v does not have unvisited neighbors, initialize v with default values\n",
    "    if len(unvisited_neighbors) == 0:\n",
    "        G.nodes[v][\"subtree_size\"] = 1\n",
    "        G.nodes[v][\"cumulative_prod\"] = 1\n",
    "        return 1, 1\n",
    "\n",
    "    # If v has unvisited neighbors, invoke recursive call for each of them\n",
    "    # and calculate cumulative sum and product\n",
    "    cum_sum, cum_prod = 0, 1\n",
    "    for neighbor in unvisited_neighbors:\n",
    "        a, b = calculate_rumor_centrality_for_single_vertex(G, neighbor, start_vertex)\n",
    "        cum_sum += a\n",
    "        cum_prod *= b\n",
    "\n",
    "    # Calculate rumor centrality for chosen root\n",
    "    if v == start_vertex:\n",
    "        G.nodes[v][\"rumor_centrality\"] = math.factorial(len(G) - 1) // cum_prod\n",
    "\n",
    "    # Calculate v's values\n",
    "    G.nodes[v][\"subtree_size\"] = cum_sum + 1\n",
    "    G.nodes[v][\"cumulative_prod\"] = cum_prod * G.nodes[v][\"subtree_size\"]\n",
    "\n",
    "    # Return v's values\n",
    "    # print('v, G.nodes[v][\"subtree_size\"]', v, G.nodes[v][\"subtree_size\"])\n",
    "    return G.nodes[v][\"subtree_size\"], G.nodes[v][\"cumulative_prod\"]\n",
    "\n",
    "\n",
    "def set_visited_to_false(G):\n",
    "    for node in G.nodes:\n",
    "        G.nodes[node][\"visited\"] = False\n",
    "\n",
    "\n",
    "def calculate_for_remaining(G, vertex, parent_rumor_centrality):\n",
    "    G.nodes[vertex][\"visited\"] = True\n",
    "    # print(len(G),vertex,G.nodes[vertex][\"subtree_size\"])\n",
    "    G.nodes[vertex][\"rumor_centrality\"] = int(\n",
    "        parent_rumor_centrality\n",
    "        * G.nodes[vertex][\"subtree_size\"]\n",
    "        / (len(G) - G.nodes[vertex][\"subtree_size\"])\n",
    "    )\n",
    "\n",
    "    for neighbor in G.neighbors(vertex):\n",
    "        if not G.nodes[neighbor][\"visited\"]:\n",
    "            calculate_for_remaining(G, neighbor, G.nodes[vertex][\"rumor_centrality\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_ml_by_rumor_centrality(gr_main, gr_nodes_infected):\n",
    "    reciprocal_ml_set={}\n",
    "    ## scale the numerator denominator when necessary\n",
    "    rc_dynamic_scale=1\n",
    "    for s in gr_nodes_infected:\n",
    "        gr_nodes_infected_bfs_tree=nx.bfs_tree(gr_main.subgraph(gr_nodes_infected), s).to_undirected()\n",
    "        psigmas_numerator=1\n",
    "        s_set={s}\n",
    "        for e in gr_nodes_infected_bfs_tree.edges():\n",
    "            psigmas_numerator*=len(list(nx.edge_boundary(gr_main, s_set)))\n",
    "            s_set.add(e[1])\n",
    "\n",
    "        H = gr_nodes_infected_bfs_tree.copy()\n",
    "        set_visited_to_false(H)\n",
    "        calculate_rumor_centrality_for_single_vertex(H, s, s)\n",
    "        # s_rumor_centrality=math.factorial(H.nodes[s][\"subtree_size\"]) // H.nodes[s][\"cumulative_prod\"]\n",
    "        reciprocal_s_ml_by_rumor_centrality = (H.nodes[s][\"cumulative_prod\"] * psigmas_numerator) // math.factorial(H.nodes[s][\"subtree_size\"]) \n",
    "        # s_ml_by_rumor_centrality = 1 / reciprocal_s_ml_by_rumor_centrality\n",
    "        reciprocal_ml_set[s]=reciprocal_s_ml_by_rumor_centrality\n",
    "        ## avoid 0 value\n",
    "        if reciprocal_s_ml_by_rumor_centrality==0:\n",
    "            rc_dynamic_scale=max(rc_dynamic_scale, 10**10 * math.factorial(H.nodes[s][\"subtree_size\"])//(H.nodes[s][\"cumulative_prod\"] * psigmas_numerator))\n",
    "\n",
    "    ## if scale the numerator denominator is needed\n",
    "    if rc_dynamic_scale!=1:\n",
    "        for s in gr_nodes_infected:\n",
    "            reciprocal_ml_set[s]=rc_dynamic_scale*(H.nodes[s][\"cumulative_prod\"] * psigmas_numerator) // math.factorial(H.nodes[s][\"subtree_size\"]) \n",
    "\n",
    "    return reciprocal_ml_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# s_real=None\n",
    "# final_infected_num=None\n",
    "# final_t=np.inf\n",
    "\n",
    "\n",
    "# gnp_pass=False\n",
    "# gnp=nx.gnp_random_graph(n, p, seed=gnp_SEED, directed=False)\n",
    "# gnp_pos = nx.spring_layout(gnp, seed=pos_SEED)\n",
    "\n",
    "def continuous_time_simulation(gnp, final_t=np.inf, t_unit=0.01,s_real=None, final_infected_num=None):\n",
    "    # print(\"continuous_time_simulation called\")\n",
    "\n",
    "    t_unit=0.1\n",
    "\n",
    "    t=0\n",
    "\n",
    "    gnp=nx.Graph(gnp)\n",
    "\n",
    "    # print(list(gnp.nodes()))\n",
    "\n",
    "\n",
    "    for e in gnp.edges():\n",
    "        gnp.edges[*e][\"spreading_time\"]=np.inf\n",
    "\n",
    "    for n in gnp.nodes():\n",
    "        gnp.nodes[n][\"when_infected\"]=np.inf\n",
    "\n",
    "    if s_real==None:\n",
    "        s_real=random.choice(list(gnp.nodes()))\n",
    "\n",
    "\n",
    "    if final_infected_num==None:\n",
    "        final_infected_num=len(nx.node_connected_component(gnp, s_real))\n",
    "\n",
    "    gnp_pass=True\n",
    "    if final_infected_num>len(nx.node_connected_component(gnp, s_real)):\n",
    "        gnp_pass=False\n",
    "        gr_infection_order_list=[]\n",
    "        gr_infection_time_list=[]\n",
    "    else:\n",
    "\n",
    "        gnp.nodes[s_real][\"when_infected\"]=0\n",
    "\n",
    "        gr_nodes_infected=set()\n",
    "        gr_nodes_susceptible=set()\n",
    "\n",
    "        gr_nodes_infected.add(s_real)\n",
    "\n",
    "        for v in gnp.adj[s_real]:\n",
    "            gr_nodes_susceptible.add(v)\n",
    "            gnp[s_real][v][\"spreading_time\"]=max(np.random.exponential(), t_unit)\n",
    "            gnp.nodes[v][\"when_infected\"]=gnp[s_real][v][\"spreading_time\"]\n",
    "\n",
    "\n",
    "        while len(gr_nodes_infected)<final_infected_num and t<final_t:\n",
    "            # print(len(gr_nodes_infected), final_infected_num, t)\n",
    "            t+=t_unit\n",
    "            for u in gr_nodes_susceptible.copy():\n",
    "                if gnp.nodes[u][\"when_infected\"]<=t:\n",
    "                    gr_nodes_infected.add(u)\n",
    "                    gr_nodes_susceptible.remove(u)\n",
    "                    for v in gnp.adj[u]:\n",
    "                        if gnp.nodes[v][\"when_infected\"]==np.inf:\n",
    "                            gnp[u][v][\"spreading_time\"]=max(np.random.exponential(), t_unit)\n",
    "                            gnp.nodes[v][\"when_infected\"]=min(gnp.nodes[v][\"when_infected\"], gnp.nodes[u][\"when_infected\"]+gnp[u][v][\"spreading_time\"])         \n",
    "                            gr_nodes_susceptible.add(v)\n",
    "\n",
    "        gr_infection_order_list=[]\n",
    "        gr_infection_time_list=[]\n",
    "\n",
    "        for k, v in sorted(dict(gnp.subgraph(gr_nodes_infected).nodes(data=\"when_infected\")).items(), key=lambda item: item[1]):\n",
    "            gr_infection_order_list.append(k)\n",
    "            gr_infection_time_list.append(v)\n",
    "\n",
    "    # print(\"continuous_time_simulation finished\")\n",
    "    \n",
    "    return gnp_pass, s_real, gr_infection_order_list, gr_infection_time_list\n",
    "\n",
    "# gnp_pass, s_real, gr_infection_order_list, gr_infection_time_list = continuous_time_simulation(gnp, final_t=np.inf, t_unit=0.01,s_real=None, final_infected_num=None)\n",
    "# print(gnp_pass,gr_infection_order_list, gr_infection_time_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameters\n",
    "\n",
    "`graph_type_to_test`: the graph types to test. the supported types are [\"random_tree\", \"ER\", \"WS_small_world\"]\n",
    ";\n",
    "\n",
    "`centrality_type_to_test`: the centrality measures to use. The supproted types are ['starlike_approximation', 'rumor_centrality', 'distance_centrality','jordan_center'];\n",
    "\n",
    "`n_list`: list of `n` as the total number of nodes in the underlying graph;\n",
    "\n",
    "`p_list`: list of `p` as one of the parameters for `ER(n,p)` and WS_small_world graph; In WS_small_world graph, the number of infected nodes is `int(n*p_list[p_index])+1`;\n",
    "\n",
    "`target_infected_ratio_list`: the infection ratio at which to detect source;\n",
    "\n",
    "`repeat_num`: the number of runs to repeat.\n",
    "\n",
    "Remarks: The infection graph is generated by simulating infection until `max(target_infected_ratio_list) * number of nodes` nodes are infected, and the infected nodes at diffent infection ratio is obtained based on the infection order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adjust the parameters for running the experiments\n",
    "\n",
    "graph_type_to_test=[\"random_tree\", \"ER\", \"WS_small_world\"]\n",
    "centrality_type_to_test=['starlike_approximation', 'rumor_centrality', 'distance_centrality','jordan_center']\n",
    "\n",
    "n_list=[50,100]\n",
    "# n_list=[50,100,150,200,250,300]\n",
    "\n",
    "p_list=[0.04]\n",
    "\n",
    "target_infected_ratio_list=[0.1, 0.3, 0.5]\n",
    "# target_infected_ratio_list=[0.1,0.2,0.3,0.4,0.5,0.6]\n",
    "\n",
    "repeat_num=50\n",
    "# repeat_num=500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following is what we use in the paper\n",
    "\n",
    "# graph_type_to_test=[\"random_tree\", \"ER\", \"WS_small_world\"]\n",
    "# centrality_type_to_test=['starlike_approximation', 'rumor_centrality', 'distance_centrality','jordan_center']\n",
    "# n_list=[50,100,150,200,250,300]\n",
    "# p_list=[0.04]\n",
    "# target_infected_ratio_list=[0.1,0.2,0.3,0.4,0.5,0.6]\n",
    "# repeat_num=500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SIMULATION_TYPE:  continous_time \n",
      " graph_type_to_test:  ['random_tree', 'ER', 'WS_small_world'] \n",
      " centrality_type_to_test:  ['starlike_approximation', 'rumor_centrality', 'distance_centrality', 'jordan_center'] \n",
      " n_list:  [50, 100] \n",
      " p_list:  [0.04] \n",
      " target_infected_ratio_list:  [0.1, 0.3, 0.5]\n",
      "current n: 50 \n",
      " current time: 231217 01:37:34\n",
      " n:  50 p:  0 GRAPH_TYPE:  random_tree\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " n:  50 p:  0.04 GRAPH_TYPE:  ER\n",
      " n:  50 p:  3 GRAPH_TYPE:  WS_small_world\n",
      "current n: 100 \n",
      " current time: 231217 01:40:09\n",
      " n:  100 p:  0 GRAPH_TYPE:  random_tree\n",
      " n:  100 p:  0.04 GRAPH_TYPE:  ER\n",
      " n:  100 p:  5 GRAPH_TYPE:  WS_small_world\n",
      "end time: 231217 01:56:30\n"
     ]
    }
   ],
   "source": [
    "SIMULATION_TYPE=None\n",
    "SIMULATION_TYPE='continous_time'\n",
    "\n",
    "ALLOW_MULTIPLE_SOURCE=True #randomly choose one as the source if multiple sources are reported\n",
    "\n",
    "gnp_SEED=0\n",
    "\n",
    "tmax=25\n",
    "\n",
    "all_results={}\n",
    "\n",
    "print('SIMULATION_TYPE: ',SIMULATION_TYPE,'\\n','graph_type_to_test: ',graph_type_to_test,'\\n', 'centrality_type_to_test: ', centrality_type_to_test, '\\n','n_list: ', n_list,'\\n','p_list: ',p_list,'\\n','target_infected_ratio_list: ',target_infected_ratio_list)\n",
    "\n",
    "\n",
    "if SIMULATION_TYPE=='continous_time':\n",
    "    for GRAPH_TYPE in graph_type_to_test:\n",
    "        all_results[GRAPH_TYPE]={}\n",
    "        for CENTRALITY_TYPE in centrality_type_to_test: \n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE]={}\n",
    "\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"]=np.full([len(n_list), len(p_list), len(target_infected_ratio_list), repeat_num], np.nan)\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"pairwise_average_dist_list\"]=np.full([len(n_list), len(p_list), len(target_infected_ratio_list), repeat_num], np.nan)\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"gnp_pass_count\"]=np.zeros([len(n_list), len(p_list), len(target_infected_ratio_list)])\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"gnp_fail_count\"]=np.zeros([len(n_list), len(p_list)])\n",
    "            # recorded_count=np.zeros([len(n_list), len(p_list), len(target_infected_ratio_list)])\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"recorded_count\"]=np.zeros([len(n_list), len(p_list)])\n",
    "            # gnp_fail_count=np.zeros([len(n_list), len(p_list), len(target_infected_ratio_list)])\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"max_nodes_multiple_count\"]=np.zeros([len(n_list), len(p_list), len(target_infected_ratio_list)])       \n",
    "\n",
    "\n",
    "\n",
    "for n_index in range(len(n_list)):\n",
    "    n=n_list[n_index]\n",
    "    final_infected_num=n*target_infected_ratio_list[-1]\n",
    "    print(\"current n:\",n, '\\n', \"current time:\", datetime.datetime.strftime(datetime.datetime.now(),'%y%m%d %H:%M:%S'))\n",
    "    for p_index in range(len(p_list)):\n",
    "        if SIMULATION_TYPE=='continous_time':\n",
    "            for GRAPH_TYPE in graph_type_to_test:\n",
    "                if GRAPH_TYPE=='ER':\n",
    "                    p=p_list[p_index]\n",
    "                elif GRAPH_TYPE==\"WS_small_world\":\n",
    "                    # p indeed is the argument for k\n",
    "                    p=int(n*p_list[p_index])+1\n",
    "                elif GRAPH_TYPE==\"random_tree\":\n",
    "                    p=0\n",
    "                else:\n",
    "                    print(\"wrong GRAPH_TYPE\")      \n",
    "                      \n",
    "                print(' n: ', n, 'p: ',p, 'GRAPH_TYPE: ', GRAPH_TYPE)\n",
    "                repeat_index=0\n",
    "                while all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"recorded_count\"][n_index][p_index]<repeat_num:\n",
    "                    # print('repeat_index', repeat_index)\n",
    "                    gnp_pass=False  \n",
    "                    # Only try to generating gnp with a certain number of tries\n",
    "                    while gnp_pass==False and all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"gnp_fail_count\"][n_index][p_index]<2*repeat_num:\n",
    "                        if GRAPH_TYPE=='ER':\n",
    "                            # gnp=nx.gnp_random_graph(n=er_n, p=er_p, seed=gnp_SEED, directed=False)\n",
    "                            gnp=nx.gnp_random_graph(n=n, p=p, seed=gnp_SEED, directed=False)\n",
    "                            # print('new gnp generated')\n",
    "                        elif GRAPH_TYPE==\"WS_small_world\":\n",
    "                            # p indeed is the argument for k\n",
    "                            p=int(n*p_list[p_index])+1\n",
    "                            gnp=nx.watts_strogatz_graph(n,p, 0.1, seed=gnp_SEED)\n",
    "                        elif GRAPH_TYPE==\"random_tree\":\n",
    "                            if p_index==0:\n",
    "                                # random tree do not need p, only run for one time when \\abs{p_list}>=2\n",
    "                                gnp=nx.random_tree(n, seed=gnp_SEED)\n",
    "                            else:\n",
    "                                pass\n",
    "                        else:\n",
    "                            print(\"wrong GRAPH_TYPE\")                                  \n",
    "                        gnp_pos = nx.spring_layout(gnp, seed=pos_SEED)\n",
    "                        gnp_pass, s_real, gr_infection_order_list, gr_infection_time_list = continuous_time_simulation(gnp, final_t=np.inf, t_unit=0.01,s_real=None, final_infected_num=final_infected_num)\n",
    "\n",
    "                        if gnp_pass==False:\n",
    "                            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"gnp_fail_count\"][n_index][p_index]+=1\n",
    "                    if gnp_pass==False:\n",
    "                        print('generation failed with ', 'n:', n, 'p', p)\n",
    "                        all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"recorded_count\"][n_index][p_index]+=1\n",
    "                    else: \n",
    "                        for t_i_r_index in range(len(target_infected_ratio_list)): \n",
    "                            target_infected_num=math.ceil(n_list[n_index]*target_infected_ratio_list[t_i_r_index])\n",
    "                            gr_nodes_infected=gr_infection_order_list[0:target_infected_num]\n",
    "                            gr_nodes_susceptible=nx.node_boundary(gnp, gr_nodes_infected)\n",
    "\n",
    "                            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"gnp_pass_count\"][n_index][p_index][t_i_r_index]+=1\n",
    "                            gr_main=extract_gr_main(gnp, gr_nodes_infected, gr_nodes_susceptible)\n",
    "\n",
    "                            for CENTRALITY_TYPE in centrality_type_to_test:\n",
    "                                if CENTRALITY_TYPE=='starlike_approximation':\n",
    "                                    result, t_positions=compute_likelihood(tmax=tmax, gr_main=gr_main, gr_nodes_infected=gr_nodes_infected, \n",
    "                                    gr_nodes_susceptible=gr_nodes_susceptible,tcount=51, dynamic_scale=True)\n",
    "                                    max_nodes, max_value=extract_max_nodes(result=result, nodes_infected=gr_nodes_infected)\n",
    "                                elif CENTRALITY_TYPE=='jordan_center':\n",
    "                                    result_jordan=dict(nx.eccentricity(gnp.subgraph(gr_nodes_infected)))\n",
    "                                    result={k:1/v for k,v in result_jordan.items()}\n",
    "                                    max_value=max(result.values())\n",
    "                                    max_nodes=[i for i in gr_nodes_infected if result[i]==max_value]\n",
    "                                elif CENTRALITY_TYPE=='distance_centrality':\n",
    "                                    result=dict(nx.closeness_centrality(gnp.subgraph(gr_nodes_infected)))\n",
    "                                    max_value=max(result.values())\n",
    "                                    max_nodes=[i for i in gr_nodes_infected if result[i]==max_value]\n",
    "                                elif CENTRALITY_TYPE=='rumor_centrality':\n",
    "                                    reciprocal_ml_set=compute_ml_by_rumor_centrality(gr_main=gr_main, gr_nodes_infected=gr_nodes_infected)\n",
    "                                    min_value=min(reciprocal_ml_set.values())\n",
    "                                    max_nodes=[i for i in gr_nodes_infected if reciprocal_ml_set[i]==min_value]\n",
    "                                    max_value=1/min_value\n",
    "                                    result=reciprocal_ml_set                   \n",
    "                                \n",
    "                                pred_s=random.choice(list(max_nodes))\n",
    "                                error_hops=nx.shortest_path_length(gr_main, s_real, pred_s)\n",
    "                                \n",
    "                                if ALLOW_MULTIPLE_SOURCE==True or len(max_nodes)==1:\n",
    "                                    all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"][n_index][p_index][t_i_r_index][repeat_index]=error_hops\n",
    "                                    all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"pairwise_average_dist_list\"][n_index][p_index][t_i_r_index][repeat_index]=nx.average_shortest_path_length(gr_main.subgraph(gr_nodes_infected))\n",
    "                                else:\n",
    "                                    all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"max_nodes_multiple_count\"][n_index][p_index][t_i_r_index]+=1\n",
    "\n",
    "                    all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"recorded_count\"][n_index][p_index]+=1\n",
    "                    repeat_index+=1\n",
    "\n",
    "\n",
    "# print(all_results)\n",
    "\n",
    "if SIMULATION_TYPE=='continous_time':\n",
    "    for GRAPH_TYPE in graph_type_to_test:\n",
    "        for CENTRALITY_TYPE in centrality_type_to_test: \n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"zero_error_rate\"]=1-(np.count_nonzero(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"],axis=3)-np.count_nonzero(np.isnan(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"]), axis=3))/(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"].shape[3]-np.count_nonzero(np.isnan(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"]), axis=3))\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"ave_error_hops_list\"]=np.nanmean(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"], axis=3)\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"ave_pairwise_average_dist_list\"]=np.nanmean(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"pairwise_average_dist_list\"], axis=3)\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"one_hop_error_rate\"]= all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"zero_error_rate\"] + 1-(np.count_nonzero(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"]-1,axis=3)-np.count_nonzero(np.isnan(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"]), axis=3))/(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"].shape[3]-np.count_nonzero(np.isnan(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"]), axis=3))\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"std_error_hops_list\"]=np.round(np.sqrt(np.nanvar(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"error_hops_list\"], axis=3, ddof=1)),3)\n",
    "            all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"std_pairwise_average_dist_list\"]=np.round(np.sqrt(np.nanvar(all_results[GRAPH_TYPE][CENTRALITY_TYPE][\"pairwise_average_dist_list\"], axis=3, ddof=1)),3)\n",
    "\n",
    "# write the results to file\n",
    "if repeat_num>20:\n",
    "    time_str=datetime.datetime.strftime(datetime.datetime.now(),'%y%m%d%H%M%S')\n",
    "    file_name='rumor_vars_'+time_str+'.pkl'\n",
    "    with open(file_name, 'wb') as f:\n",
    "        pickle.dump([all_results, graph_type_to_test, centrality_type_to_test, tmax, \n",
    "                    n_list,p_list,target_infected_ratio_list,repeat_num], f)\n",
    "\n",
    "\n",
    "print(\"end time:\", datetime.datetime.strftime(datetime.datetime.now(),'%y%m%d %H:%M:%S'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the accuracy of rumor detection methods against the number of nodes `n` with different infection proportions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def customize_legend(c):\n",
    "    if c=='pseudo_leaf':\n",
    "        idx_legend='Starlike tree approximation'\n",
    "    elif c=='rumor_centrality':\n",
    "        idx_legend='Rumor centrality with BFS'\n",
    "    elif c=='closeness_centrality':\n",
    "        idx_legend='Distance centrality'\n",
    "    elif c=='jordan_center':\n",
    "        idx_legend='Jordan Center'\n",
    "    else:\n",
    "        idx_legend=c\n",
    "    return idx_legend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GRAPH_TYPE:  random_tree\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x300 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Current code only considers \\abs{p_list}=1\n",
    "# Select the index of graph types in `graph_type_to_test` for plotting\n",
    "graph_type_index = 0\n",
    "\n",
    "color_list=['r','g','b','c']\n",
    "\n",
    "graph_type_to_test=[\"random_tree\", \"ER\", \"WS_small_world\"]\n",
    "GRAPH_TYPE=graph_type_to_test[graph_type_index]\n",
    "print(\"GRAPH_TYPE: \", GRAPH_TYPE)\n",
    "\n",
    "centrality_type_to_test=['starlike_approximation', 'rumor_centrality', 'distance_centrality','jordan_center']\n",
    "\n",
    "\n",
    "statistic_list=[\"zero_error_rate\", \"one_hop_error_rate\"]\n",
    "STATISTIC=\"zero_error_rate\"\n",
    "\n",
    "\n",
    "\n",
    "USE_SAME_YLIM=True\n",
    "max_value=0\n",
    "for centrality in centrality_type_to_test:\n",
    "    max_value=max(max_value, np.nanmax(all_results[GRAPH_TYPE][centrality][STATISTIC][:,0,:]))\n",
    "\n",
    "width=10\n",
    "bar_pos_list=[i*width - (len(centrality_type_to_test)-1)/2*width for i in range(0,len(centrality_type_to_test))]\n",
    "error_params=dict(elinewidth=4,ecolor='gray',capsize=5)\n",
    "\n",
    "n_subfig=all_results[GRAPH_TYPE][centrality_type_to_test[0]][STATISTIC].shape[2]\n",
    "\n",
    "fig, axs = plt.subplots((n_subfig)//3,3,figsize=(12, 1.7*n_subfig//2),dpi=150)\n",
    "\n",
    "for j in range(0,n_subfig):\n",
    "    axs_tmp = axs[j//3,j%3] if len(axs.shape)>=2 else axs[j%3]\n",
    "    for idx in range(0,len(centrality_type_to_test)):\n",
    "        axs_tmp.bar(np.array(n_list)+bar_pos_list[idx], all_results[GRAPH_TYPE][centrality_type_to_test[idx]][STATISTIC][:,0,j],alpha=0.7, width=width, color=color_list[idx],label=customize_legend(centrality_type_to_test[idx]))\n",
    "  \n",
    "    ADD_LEGEND=True\n",
    "    if j==0 and ADD_LEGEND==True:\n",
    "        axs_with_legend = axs[0,0] if len(axs.shape)>=2 else axs[0]\n",
    "        axs_with_legend.legend(bbox_to_anchor=(0.1,1,0.74,0.6), borderaxespad=0)\n",
    "\n",
    "    axs_tmp.set_title('Infection proportion: '+str(target_infected_ratio_list[j]),y=0.85)\n",
    "    axs_tmp.set_xlabel('n')\n",
    "    axs_tmp.xaxis.set_major_locator(plt.MultipleLocator(50))\n",
    "    axs_tmp.set_ylabel('Accuracy')\n",
    "    if USE_SAME_YLIM==True:\n",
    "        axs_tmp.set_ylim(0, max_value * 1.1)\n",
    "    else:\n",
    "        axs_tmp.set_ylim()\n",
    "\n",
    "# adjust the y-axis of the second row of subplots\n",
    "for j in range(3,n_subfig):\n",
    "    axs_tmp=axs[j//3,j%3] if len(axs.shape)>=2 else axs[j//3]\n",
    "    axs_tmp.set_ylim(0, 0.2*1.1)\n",
    "\n",
    "fig.subplots_adjust(wspace=0.25, hspace=0.3)\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the accuracy of the rumor detection methods against the infection proportion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GRAPH_TYPE:  random_tree\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Select the index of graph types in `graph_type_to_test` for plotting\n",
    "graph_type_index = 0\n",
    "\n",
    "graph_type_to_test=[\"random_tree\", \"ER\", \"WS_small_world\"]\n",
    "GRAPH_TYPE=graph_type_to_test[graph_type_index]\n",
    "print(\"GRAPH_TYPE: \", GRAPH_TYPE)\n",
    "\n",
    "statistic_list=[\"zero_error_rate\", \"one_hop_error_rate\"]\n",
    "\n",
    "STATISTIC=\"zero_error_rate\"\n",
    "\n",
    "USE_SAME_YLIM=True\n",
    "max_value=0\n",
    "for centrality in centrality_type_to_test:\n",
    "    max_value=max(max_value, np.nanmax(all_results[GRAPH_TYPE][centrality][STATISTIC][:,0,:]))\n",
    "\n",
    "fmt_list=['r-','g-','b-','c-.','m-.','y-.']\n",
    "marker_list=['o','+','^','o','+','^']\n",
    "# point_fmt_list=['ro-','g+-','b^-', 'co-','m+-','y^-']\n",
    "\n",
    "\n",
    "n_subfig=len(centrality_type_to_test)\n",
    "\n",
    "fig, axs = plt.subplots(n_subfig//4,4,figsize=(16, 2*n_subfig//2),dpi=150)\n",
    "\n",
    "\n",
    "fig=plt.figure()\n",
    "for c in range(len(centrality_type_to_test)):\n",
    "    for i in range(len(n_list)):\n",
    "        axs[c%4].plot(target_infected_ratio_list,all_results[GRAPH_TYPE][centrality_type_to_test[c]][STATISTIC][i,0,:],fmt_list[i],marker=marker_list[i],label='n='+str(n_list[i]))\n",
    "        # axs[c%4].plot(target_infected_ratio_list,all_results[GRAPH_TYPE][centrality_type_to_test[c]][STATISTIC][i,0,:],point_fmt_list[i])\n",
    "    # axs[c%4].set_title(centrality_type_to_test[c]+ ': '+ STATISTIC+' - infection proportion in ' + GRAPH_TYPE+' graph')\n",
    "    axs[c%4].set_title(customize_legend(centrality_type_to_test[c]),y=0.9)\n",
    "    # plt.text(0.02,0.3,'')\n",
    "    axs[c%4].set_xlabel('Infection proportion')\n",
    "    axs[c%4].xaxis.set_major_locator(plt.MultipleLocator(0.1))\n",
    "    # axs[c%4].set_ylabel(STATISTIC)\n",
    "    axs[c%4].set_ylabel('Accuracy')\n",
    "    axs[c%4].yaxis.set_major_locator(plt.MultipleLocator(0.1))\n",
    "    if c==0:\n",
    "        axs[c%4].legend(bbox_to_anchor=(0,0.48,0.98,0.2), borderaxespad=0)\n",
    "    if USE_SAME_YLIM==True:\n",
    "        axs[c%4].set_ylim(0, max_value * 1.1)\n",
    "    else:\n",
    "        axs[c%4].set_ylim()\n",
    "\n",
    "fig.subplots_adjust(hspace=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python311",
   "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}