test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "f77fecc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json, os\n",
    "import pandas as pd\n",
    "\n",
    "search_list = [\"IEEE Transactions on Software Engineering\", \"ACM Transactions on Software Engineering and Methodology\", \"ACM Transactions on Software Engineering and Methodology\", \"Automated Software Engineering\", \"Empirical Software Engineering\", \"IEEE Transactions on Neural Networks and Learning Systems\"]\n",
    "search_list = [\"_\".join(item.split(\" \")) for item in search_list]\n",
    "keyword_list = [\"empirical\", \"code\", \"commit\", \"diff\", \"change\", \"generation\", \"experimental\", \"commits\", \"diffs\", \"changes\", \"language\", \"multi\", \"multi-language\", \"multilingual\"]\n",
    "keyword_list.sort()\n",
    "keyword_str = \"_\".join(keyword_list)\n",
    "\n",
    "result = dict()\n",
    "count_total = dict()\n",
    "count_include_ketyword_title = dict()\n",
    "for journal in search_list:\n",
    "    single_result = json.load(open(os.path.join(\"searched_result\", journal,\"{}.json\".format(keyword_str))))\n",
    "    result[journal] = single_result[list(single_result.keys())[0]]\n",
    "    count_total[journal], count_include_ketyword_title[journal] = dict(), dict()\n",
    "    for each in result[journal]:\n",
    "        count_total[journal][each['paper_list_url']] = each['papers_total_n']\n",
    "        count_include_ketyword_title[journal][each['paper_list_url']] = dict()\n",
    "        for keyword in keyword_list:\n",
    "            count_include_ketyword_title[journal][each['paper_list_url']][keyword] = len(each['matched_titles'][keyword])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "3c9e5d37",
   "metadata": {},
   "outputs": [],
   "source": [
    "count = dict()\n",
    "journal_total = dict()\n",
    "for journal in count_include_ketyword_title.keys():\n",
    "    count[journal] = {key:0 for key in keyword_list}\n",
    "    journal_total[journal] = 0\n",
    "    for url in count_include_ketyword_title[journal].keys():\n",
    "        for keyword in keyword_list:\n",
    "            count[journal][keyword] += count_include_ketyword_title[journal][url][keyword]\n",
    "        journal_total[journal] += count_total[journal][url]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "82a0fac8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'IEEE_Transactions_on_Software_Engineering': 3730,\n",
       " 'ACM_Transactions_on_Software_Engineering_and_Methodology': 570,\n",
       " 'Automated_Software_Engineering': 527,\n",
       " 'Empirical_Software_Engineering': 1163,\n",
       " 'IEEE_Transactions_on_Neural_Networks_and_Learning_Systems': 6105}"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "journal_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "9e24b74c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'IEEE_Transactions_on_Software_Engineering': {'change': 22,\n",
       "  'changes': 17,\n",
       "  'code': 97,\n",
       "  'commit': 0,\n",
       "  'commits': 1,\n",
       "  'diff': 1,\n",
       "  'diffs': 0,\n",
       "  'empirical': 107,\n",
       "  'experimental': 22,\n",
       "  'generation': 60,\n",
       "  'language': 122,\n",
       "  'multi': 21,\n",
       "  'multi-language': 0,\n",
       "  'multilingual': 1},\n",
       " 'ACM_Transactions_on_Software_Engineering_and_Methodology': {'change': 1,\n",
       "  'changes': 3,\n",
       "  'code': 29,\n",
       "  'commit': 0,\n",
       "  'commits': 0,\n",
       "  'diff': 0,\n",
       "  'diffs': 0,\n",
       "  'empirical': 22,\n",
       "  'experimental': 5,\n",
       "  'generation': 16,\n",
       "  'language': 11,\n",
       "  'multi': 9,\n",
       "  'multi-language': 0,\n",
       "  'multilingual': 0},\n",
       " 'Automated_Software_Engineering': {'change': 5,\n",
       "  'changes': 0,\n",
       "  'code': 24,\n",
       "  'commit': 0,\n",
       "  'commits': 0,\n",
       "  'diff': 0,\n",
       "  'diffs': 0,\n",
       "  'empirical': 3,\n",
       "  'experimental': 0,\n",
       "  'generation': 17,\n",
       "  'language': 14,\n",
       "  'multi': 12,\n",
       "  'multi-language': 0,\n",
       "  'multilingual': 0},\n",
       " 'Empirical_Software_Engineering': {'change': 27,\n",
       "  'changes': 24,\n",
       "  'code': 92,\n",
       "  'commit': 2,\n",
       "  'commits': 3,\n",
       "  'diff': 1,\n",
       "  'diffs': 0,\n",
       "  'empirical': 200,\n",
       "  'experimental': 19,\n",
       "  'generation': 14,\n",
       "  'language': 10,\n",
       "  'multi': 14,\n",
       "  'multi-language': 0,\n",
       "  'multilingual': 1},\n",
       " 'IEEE_Transactions_on_Neural_Networks_and_Learning_Systems': {'change': 15,\n",
       "  'changes': 5,\n",
       "  'code': 3,\n",
       "  'commit': 0,\n",
       "  'commits': 0,\n",
       "  'diff': 0,\n",
       "  'diffs': 0,\n",
       "  'empirical': 13,\n",
       "  'experimental': 6,\n",
       "  'generation': 19,\n",
       "  'language': 11,\n",
       "  'multi': 48,\n",
       "  'multi-language': 0,\n",
       "  'multilingual': 0}}"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baba8057",
   "metadata": {},
   "source": [
    "## The number of papers with keywords as titles since the records of 5 journals "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "id": "19d61766",
   "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>TSE</th>\n",
       "      <th>TOSEM</th>\n",
       "      <th>ASE</th>\n",
       "      <th>ESE</th>\n",
       "      <th>TNNLS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>change</th>\n",
       "      <td>22</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>27</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>changes</th>\n",
       "      <td>17</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>24</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>code</th>\n",
       "      <td>97</td>\n",
       "      <td>29</td>\n",
       "      <td>24</td>\n",
       "      <td>92</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>commit</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>commits</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>diff</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>diffs</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>empirical</th>\n",
       "      <td>107</td>\n",
       "      <td>22</td>\n",
       "      <td>3</td>\n",
       "      <td>200</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>experimental</th>\n",
       "      <td>22</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>19</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>generation</th>\n",
       "      <td>60</td>\n",
       "      <td>16</td>\n",
       "      <td>17</td>\n",
       "      <td>14</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>language</th>\n",
       "      <td>122</td>\n",
       "      <td>11</td>\n",
       "      <td>14</td>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>multi</th>\n",
       "      <td>21</td>\n",
       "      <td>9</td>\n",
       "      <td>12</td>\n",
       "      <td>14</td>\n",
       "      <td>48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>multi-language</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>multilingual</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                TSE  TOSEM  ASE  ESE  TNNLS\n",
       "change           22      1    5   27     15\n",
       "changes          17      3    0   24      5\n",
       "code             97     29   24   92      3\n",
       "commit            0      0    0    2      0\n",
       "commits           1      0    0    3      0\n",
       "diff              1      0    0    1      0\n",
       "diffs             0      0    0    0      0\n",
       "empirical       107     22    3  200     13\n",
       "experimental     22      5    0   19      6\n",
       "generation       60     16   17   14     19\n",
       "language        122     11   14   10     11\n",
       "multi            21      9   12   14     48\n",
       "multi-language    0      0    0    0      0\n",
       "multilingual      1      0    0    1      0"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(count, columns=count.keys(), index=count['Automated_Software_Engineering'].keys())\n",
    "df.columns=[\"TSE\",\"TOSEM\",\"ASE\",\"ESE\",\"TNNLS\"]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "e3d81987",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot.bar(stacked=True, figsize=(16,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "53b35f79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAIICAYAAACW1EjCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABqwklEQVR4nO3dd3gV1dr38d8y0sMBBKyoCYpA6k4gAYTE0FEUDIiKKCAPYAFBPCJ6LESPngeVI+1VEQtBRARBLNgQBSmCkEBoAUQkisqDEQQJRRKy3j/2zphAEtKH8v1cV67svWZmzb1mZpd7rzUzxlorAAAAAADccI7bAQAAAAAAzl4kpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15zrdgCSVK9ePRsQEOB2GAAAAACAcpCcnPy7tbZ+ftNOiaQ0ICBASUlJbocBAAAAACgHxpgfC5rG8F0AAAAAgGtISgEAAAAAriEpBQAAAAC45pQ4pxQAAKCsZWZm6ueff9aRI0fcDgUAzhpVq1ZVgwYNVKlSpSIvQ1IKAADOSD///LNq1qypgIAAGWPcDgcAznjWWu3Zs0c///yzAgMDi7wcw3cBAMAZ6ciRI6pbty4JKQBUEGOM6tatW+wRKiSlAADgjEVCCgAVqyTvuySlAAAAAADXcE4pAAA4KwQ8/HGZ1pc2putJ5/H391dGRobS0tLUtGlTNW7c2Jn2wAMPqG/fvgoICFDNmjXl5+cnSYqNjdXEiRPVv39/ff3116pVq5YkqXr16vrmm29OWMfUqVM1YcIESVJqaqoaN24sPz8/denSRWPGjCmLppbY4sWLVblyZV199dWSpMmTJ6t69erq27evq3EVxcqVKzV8+HD99ddf+uuvv3TLLbcoISGhwPn/+usvde3aVb///rseeeQRbd++Xf/6178qLuB8xMXFadeuXapWrZok6corr9ScOXNKVNfAgQP1wAMPKCgoqCxDzOPXX3/VsGHDShwjTl8kpQAAABXgiiuuUEpKSr7TFi1apHr16p1Q/vzzz+umm24qtN4777xTd955pyQpICAg37qOHTvmJL0VafHixfL393eS0rvvvrvCYyipfv36afbs2QoPD9exY8e0devWQudfu3atJDn72N/fv8yT0pLsxxkzZqh58+alXvdrr71W6joKk5WVpYsvvpiE9CzF8F0AAIAzkL+/v/75z38qPDxcK1as0FNPPaWoqCiFhIRo8ODBstZK8vamjRo1StHR0brqqqu0dOlSSdKmTZsUHR0tj8ejsLAwbdu2TZJ04403qlmzZgoODtaUKVOc9X322WeKjIxUeHi42rdvr7S0NE2ePFnjxo2Tx+PR0qVLlZCQoLFjx0ryJm8tW7ZUWFiY4uPj9ccff5Qonvy88MILCgkJUUhIiMaPHy9JTm/1oEGDFBwcrE6dOunw4cMF1vHbb7/poosukiT5+fk5PYR79+7VjTfeqLCwMLVs2VLr16/Xb7/9pttvv12rV6+Wx+NRr169dPjwYXk8HvXp00fPP/+8Jk6cKEkaMWKE2rVrJ0n66quv1KdPH0nSPffco+bNmys4OFijR4924ggICNCoUaMUGRmpd999VwsWLFCrVq0UGRmpXr16KSMj46THwvH69++vYcOG6eqrr1bDhg2dRDA7O1v33nuvmjRpoo4dO+q6665zpsXFxSkpKUmS99h69NFHFR4erpYtW2r37t2SpPT0dPXs2VNRUVGKiorS8uXLJUkHDx7UgAEDFB0drYiICH3wwQeSpMTERHXr1k3t2rVzjpmQkBBnWo8ePdSlSxc1atRIDz30kBP/66+/rquuukrR0dEaNGiQhg4dWuxtgFMLSSkAAEAF2L59uzwej/OXk2xJUtu2bZ3ycePGOeUjR450ynOSl6I6ePCgWrRooXXr1qlNmzYaOnSoVq9erY0bN+rw4cOaP3++M29WVpZWrVql8ePH68knn5TkHWo7fPhwpaSkKCkpSQ0aNJAkvfHGG0pOTlZSUpImTpyoPXv2KD09XYMGDdLcuXO1bt06vfvuuwoICNDdd9+tESNGKCUlRTExMXni69u3r5599lmtX79eoaGhznqLG8/xkpOTNXXqVH377bdauXKlXn31VacXc9u2bRoyZIg2bdqk2rVra+7cuQVuvxEjRqhx48aKj4/XK6+84lxNdPTo0YqIiND69ev1n//8R3379tX555+v1157TTExMUpJSdG7776ratWqKSUlRTNmzFBMTIyzv5OSkpSRkaHMzEwtXbpUsbGxkqRnnnlGSUlJWr9+vb7++mutX7/eiaVu3bpas2aNOnTooKeffloLFy7UmjVr1Lx5c73wwguFHgd9+vRxjqGRI0c65bt27dKyZcs0f/58Pfzww5Kk9957T2lpaUpNTdX06dO1YsWKfOs8ePCgWrZsqXXr1ik2NlavvvqqJGn48OEaMWKEVq9erblz52rgwIFO29q1a6dVq1Zp0aJFGjlypA4ePChJWrNmjebMmaOvv/76hPWkpKRo1qxZ2rBhg2bNmqWdO3fq119/1b///W+tXLlSy5cv15YtWwptP04PDN8FAACoAOU1fLcgfn5+6tmzZ551PPfcczp06JD27t2r4OBg3XDDDZKkHj16SJKaNWumtLQ0SVKrVq30zDPP6Oeff1aPHj3UqFEjSdLEiRM1b948SdLOnTu1bds2paenKzY21rkv4XnnnVdobPv379e+fft0zTXXSPIOle3Vq5czvTjxHG/ZsmWKj49XjRo1nLqWLl2qbt26KTAwUB6P54S68/PEE0+oT58+WrBggd5++23NnDlTixcv1rJly5xktl27dtqzZ4/+/PPPQtvbrFkzJScn688//1SVKlUUGRmppKQkLV261OlBnT17tqZMmaKsrCzt2rVLqampCgsLkyTdcsstkrznuaampqp169aSpKNHj6pVq1aFrrug4bs33nijzjnnHAUFBTk9ncuWLVOvXr10zjnn6MILL1Tbtm3zrbNy5cq6/vrrnbZ98cUXkqSFCxcqNTXVme/PP/9URkaGFixYoA8//NDpJT9y5Ih++uknSVLHjh0LPF7at2/vnFMdFBSkH3/8Ub///ruuueYaZ5levXrpu+++K3Qb4NRHUgoAAHAGqlq1qnP+4ZEjR3TvvfcqKSlJl156qRISEvLcR7BKlSqSvIlsVlaWJOm2225TixYt9PHHH+u6667TK6+8onPOOUcLFy7UihUrVL16dcXFxRX7foRFUdR4cobBFrfenLoLG74reX9IuOeeezRo0CDVr19fe/bsKWZLvCpVqqTAwEAlJibq6quvVlhYmBYtWqTvv/9eTZs21Y4dOzR27FitXr1aderUUf/+/fNs15wE21qrjh07aubMmSWKI7fc2yJnKHdx2pNz24/c+yg7O1srV65U1apV88xvrdXcuXPzXOhLkr799lunbSeLMfd6cOZh+C4AAMAZLifBqVevnjIyMop0MZkffvhBDRs21LBhw9S9e3etX79e+/fvV506dVS9enVt2bJFK1eulCS1bNlSS5Ys0Y4dOyR5z7uUpJo1a+rAgQMn1F2rVi3VqVPHGdI6ffp0p9e0OPHkJyYmRu+//74OHTqkgwcPat68eScMHS6Kjz/+2EnWtm3bJj8/P9WuXVsxMTGaMWOGJO+FnOrVq6d//OMfJyxfqVIlZWZm5olr7Nixio2NVUxMjCZPnqyIiAgZY/Tnn3+qRo0aqlWrlnbv3q1PP/0035hatmyp5cuX6/vvv5fkHUZblr2ErVu31ty5c5Wdna3du3dr8eLFxVq+U6dOmjRpkvM8Z2RA586dNWnSJGd75gynLomoqCh9/fXX+uOPP5SVlVXoEGycPugpBQAAZ4Wi3MKlPOWcU5pjwIABGjZsmCTvOaU5vZphYWF68803JXnPKX366aedZVatWqXKlSsXe921a9fWoEGDFBISogsvvFBRUVEnXWb27NmaPn26KlWqpAsvvFD/+te/VKNGDU2ePNm5vU3Lli0lSfXr19eUKVPUo0cPZWdn6/zzz9cXX3yhG264QTfddJM++OCDPMmKJE2bNk133323Dh06pIYNG2rq1KnFjic/kZGR6t+/v6KjoyV5b2USERFR6FDd/EyfPl0jRoxQ9erVde6552rGjBny8/NTQkKCBgwYoLCwMFWvXl3Tpk3Ld/nBgwcrLCxMkZGRznmlzzzzjFq1aqUaNWqoatWqTrIcHh6uiIgINWnSRJdeeqkzPPd49evXV2Jionr37q2//vpLkvT000/rqquuKrAdffr0cW4JU69ePS1cuLDAeXv27Kkvv/xSQUFBuvTSSxUZGekMny2KiRMnasiQIQoLC1NWVpZiY2M1efJkPf7447r//vsVFham7OxsBQYG5jmnuTguueQS/etf/1J0dLTOO+88NWnSpFgx4tRkittdXx6aN29uc67mBQAAUBY2b96spk2buh0GcFrJyMiQv7+/9uzZo+joaC1fvlwXXnih22HlkRNjVlaW4uPjNWDAAMXHx7sdFnLJ7/3XGJNsrc33/kQnHb5rjLnUGLPIGJNqjNlkjBnuKz/PGPOFMWab738dX7kxxkw0xnxvjFlvjIksg3YBAAAAKGfXX3+9PB6PYmJi9Pjjj59yCakkJSQkyOPxKCQkRIGBgbrxxhvdDgmlVJThu1mS/mmtXWOMqSkp2RjzhaT+kr601o4xxjws6WFJoyRdK6mR76+FpJd9/wEAAFAKU6dO1YQJE/KUtW7dWi+++KJLEblnz549at++/QnlX375perWrVvkeoYMGeLcTzPH8OHDdeedd5Y6xooSHx/vnM+b49lnn1Xnzp2LXVdxzyN1Q85VfHHmKPbwXWPMB5L+n+8vzlq7yxhzkaTF1trGxphXfI9n+ubfmjNfQXUyfBcAAJQ1hu8CgDvKfPjucRUFSIqQ9K2kC3Ilmv8n6QLf40sk7cy12M++MgAAAAAA8ijy1XeNMf6S5kq631r7Z869iSTJWmuNMcXqcjXGDJY0WJIuu+yy4iwKAADK0OYm+fcmNt2yuYIjAQCcjYrUU2qMqSRvQjrDWvuer3i3b9iufP9/85X/IunSXIs38JXlYa2dYq1tbq1tXr9+/ZLGDwAAAAA4jZ20p9R4u0Rfl7TZWvtCrkkfSuonaYzv/we5yocaY96R9wJH+ws7nxQAAKBCJJTxvQwT9pdtfQBwlipKT2lrSXdIameMSfH9XSdvMtrRGLNNUgffc0n6RNIPkr6X9Kqke8s+bAAAgNPD+++/L2OMtmzZ4pStWrVKsbGxaty4sSIiIjRw4EAdOnRIiYmJMsZo4cKFJyw/Z86cfOuPj4+Xx+PRlVdeqVq1asnj8cjj8eibb74p97adzPjx43Xo0CHn+XXXXad9+/a5F1AxPPPMMwoODlZYWJg8Ho++/fbbQudfunSpgoOD5fF4tGLFCn3yyScVFGn+0tLSVK1aNed48Hg8evPNN0tU16+//qqbbrqpjCM80eTJk0scY3kJCAjQ77//XuB0Y4xuv/1253lWVpbq16+v66+/vtB6U1JS8hwjCQkJpbqqcFGW79+/f4HvI247aU+ptXaZJFPA5BOuw229l/MdUsq4AAAAzggzZ85UmzZtNHPmTD355JPavXu3evXqpXfeeUetWrWSJM2ZM0cHDhyQJIWGhuqdd95Rhw4dnOXDw8MLrH/evHmSvLfyGDt2rObPn59nelZWls49t8iXESlT48eP1+23367q1atLkuuJWlGtWLFC8+fP15o1a1SlShX9/vvvOnr0aKHLzJgxQ4888ohuv/12JSYmKikpSdddd12ZxVSS/XjFFVcoJSWl1Ou++OKLyz2ZycrK0t13312u6ygPNWrU0MaNG3X48GFVq1ZNX3zxhS655OTXeE1JSSnzY+R0Vqyr7wIAAKDoMjIytGzZMr3++ut65513JEkvvvii+vXr5ySkknTTTTfpggu8NzKIiYnRqlWrlJmZqYyMDH3//ffyeDzFWm9iYqK6deumdu3aqX379srIyFD79u0VGRmp0NBQffCB96yrtLQ0NW3aVIMGDVJwcLA6deqkw4cPS5ImTpyooKAghYWF6dZbb5Xk7eFt1aqVIiIidPXVV2vr1q2SpGPHjunBBx9USEiIwsLCNGnSJE2cOFG//vqr2rZtq7Zt20rK2+v0wgsvKCQkRCEhIRo/fnyJ4snP3r17deONNyosLEwtW7bU+vXrJXl7kgYMGKC4uDg1bNhQEydOLLCOXbt2qV69eqpSpYokqV69err44oslee+DGhERodDQUA0YMEB//fWXXnvtNc2ePVuPP/64evfurSeeeEKzZs2Sx+PRrFmzFBoaqn379slaq7p16zq9gX379tUXX3yhtLQ0xcTEKDIyUpGRkU4v9+LFixUTE6Nu3bopKChIx44d08iRIxUVFaWwsDC98sorxTksHP7+/nr00UcVHh6uli1bavfu3ZKk7du3q2XLlgoNDdVjjz0mf39/Z7+EhIRI8h5bPXr0UJcuXdSoUSM99NBDTr0LFixQq1atFBkZqV69eikjI0OSlJycrGuuuUbNmjVT586dtWuX98y+uLg43X///WrevLkmTJiQp7cvLi5Oo0aNUnR0tK666iotXbpUknTo0CHdfPPNCgoKUnx8vFq0aKHCbi15zz33qHnz5goODtbo0aOd8oCAAI0ePdp5TeSMZNizZ486deqk4OBgDRw4UEW5feZ1112njz/+WJL3R6TevXs70w4ePKgBAwYoOjpaERER+uCDD3T06NETjhFJSk1Nzff4zO+1Inl786+66iq1adPGeS1K3oS3ZcuWCgsLU3x8vP74448TYs7vOJa8Pxw1adJEzZo107Bhw3T99dcrOztbjRo1Unp6uiQpOztbV155pfO8TFhrXf9r1qyZBQAA7kht3CTfv9Ndampq3oLR/yjbvyJ466237IABA6y11rZq1comJSXZ+Ph4+/777+c7/9SpU+2QIUPsiBEj7EcffWTfeustm5CQYPv162fffffdQte1aNEi27VrV6eeSy65xO7Zs8daa21mZqbdv3+/tdba9PR0e8UVV9js7Gy7Y8cO6+fnZ9euXWuttbZXr152+vTp1lprL7roInvkyBFrrbV//PGHtdba/fv328zMTGuttV988YXt0aOHtdbal156yfbs2dOZlrPeyy+/3Kanpzsx5jxPSkqyISEhNiMjwx44cMAGBQXZNWvWFDue/AwdOtQmJCRYa6398ssvbXh4uLXW2tGjR9tWrVrZI0eO2PT0dHveeefZo0eP5lvHgQMHbHh4uG3UqJG955577OLFi6211h4+fNg2aNDAbt261Vpr7R133GHHjRtnrbV59lHOfsxx11132fnz59sNGzbY5s2b24EDB1prrb3yyittRkaGPXjwoD18+LC11trvvvvO5nw3XrRoka1evbr94YcfrLXWvvLKK/bf//63tdbaI0eO2GbNmjnTjrdjxw5btWpVGx4e7vwtWbLEWmutJPvhhx9aa60dOXKkU2fXrl3t22+/ba219uWXX7Y1atRw6goODnbaFhgYaPft22cPHz5sL7vsMvvTTz/Z9PR0GxMTYzMyMqy11o4ZM8Y++eST9ujRo7ZVq1b2t99+s9Za+84779g777zTWmvtNddcY++55x4n5tGjR9vnn3/emfbAAw9Ya639+OOPbfv27a211j7//PN28ODB1lprN2zYYP38/Ozq1avz3QbW/n0sZmVl2WuuucauW7fOWus9FidOnGittfbFF1+0//M//2Ottfa+++6zTz75pLXW2vnz51tJeY7h49WoUcOuW7fO9uzZ0x4+fNiGh4fneS0+8sgjzjH8xx9/2EaNGtmMjIwTjpGCjs+CXis55QcPHrT79++3V1xxhbPtQkNDnWP28ccft8OHD7fW/n2MFnQc55TnHFO33nqr046EhATnWP/888+d135BTnj/tdZKSrIF5IP0lAIAAJSTmTNnOr16t956q2bOnFmk5W699Va98847euedd/L0uhRHx44ddd5550nydkL861//UlhYmDp06KBffvnF6R0LDAx0emKbNWumtLQ0SVJYWJj69Omjt956yxk2un//fvXq1UshISEaMWKENm3aJElauHCh7rrrLme+nPUWZNmyZYqPj1eNGjXk7++vHj16OD1hxYmnoLrvuOMOSVK7du20Z88e/fnnn5Kkrl27qkqVKqpXr57OP/98Zxscz9/fX8nJyZoyZYrq16+vW265RYmJidq6dasCAwN11VVXSZL69eunJUuWFNpWydv7vWTJEi1ZskT33HOPNmzYoF9++UV16tRRjRo1lJmZqUGDBik0NFS9evVSamqqs2x0dLQCAwMleXsi33zzTXk8HrVo0UJ79uzRtm3bClxvzvDdnL+YmBhJUuXKlZ1zHnNv4xUrVqhXr16SpNtuu63Aetu3b69atWqpatWqCgoK0o8//qiVK1cqNTVVrVu3lsfj0bRp0/Tjjz9q69at2rhxozp27CiPx6Onn35aP//8s1PXLbfcUuB6evTocUKMy5Ytc15TOT3zhZk9e7YiIyMVERGhTZs25dm2+dW/ZMkS5xzRrl27qk6dOoXWL3mPzbS0NM2cOfOE4bgLFizQmDFj5PF4FBcXpyNHjuinn37Kt578js+CXitLly5VfHy8qlevrn/84x/q1q2bJO9rdN++fbrmmmsk5X+MFnQcb9myRQ0bNnSOt9zvPQMGDHB6+N944w3deeedJ90uxeHOCQYAAABnuL179+qrr77Shg0bZIzRsWPHZIxRv379lJycrO7duxe4bHR0tDZs2KDq1as7XxyLq0aNGs7jGTNmKD09XcnJyapUqZICAgJ05MgRSXKGqEqSn5+fM1z2448/1pIlS/TRRx/pmWee0YYNG/T444+rbdu2mjdvntLS0hQXF1ei2ApTnHiKe47l8XVnZWUVOK+fn5/i4uIUFxen0NBQTZs2TREREcVsjVdsbKxefPFF/fTTT3rmmWc0b948zZkzx0kSx40bpwsuuEDr1q1Tdna2qlat6iybez9aazVp0iR17ty5RHHkqFSpkrw32Dj5dshPftvRWquOHTue8MPLhg0bFBwcrBUrVuRbV+72FbSeksQoSTt27NDYsWO1evVq1alTR/3793eO+7KoP7du3brpwQcf1OLFi7Vnzx6n3FqruXPnqnHjxnnmz+/CWcU5PivapZdeqgsuuEBfffWVVq1apRkzZpRp/fSUAgCAs0PC/rL9O4k5c+bojjvu0I8//qi0tDTt3LlTgYGB6tChg6ZNm5bnS+l77713Qq/dmDFj9J///KdMmr5//36df/75qlSpkhYtWqQff/yx0Pmzs7O1c+dOtW3bVs8++6z279+vjIwM7d+/37mIS2JiojN/x44d9corrzhfovfu3StJqlmzpnMBp9xiYmL0/vvv69ChQzp48KDmzZvnJGjFiSc/MTExzhfmxYsXq169evrHP/5RaHuPt3Xr1jw9kCkpKbr88svVuHFjpaWl6fvvv5ckTZ8+3emRyu34dl966aX6/ffftW3bNjVs2FBt2rTR2LFjFRsbK8m7fy666CKdc845mj59uo4dO5ZvXJ07d9bLL7+szMxMSdJ3332ngwcPFqtthWnZsqXmzp0rSc450MVZdvny5c62OXjwoL777js1btxY6enpTlKamZnp9LCXROvWrTV79mxJ3nMwN2zYUOC8f/75p2rUqKFatWpp9+7d+vTTT09af2xsrN5++21J0qeffprv+Zj5GTBggEaPHq3Q0NA85Z07d9akSZOcc1PXrl0rqeDXxvEKeq3Exsbq/fff1+HDh3XgwAF99NFHkqRatWqpTp06zsiD/I7Rgo7jxo0b64cffnB6jXPOdc0xcOBA3X777erVq5f8/PyKtF2KiqQUAACgHMycOVPx8fF5ynr27OkMy33wwQfVuHFjNW3aVJ9//rlq1qyZZ95rr73WuUBQafXp00dJSUkKDQ3Vm2++qSZNmhQ6/7Fjx3T77bcrNDRUERERGjZsmGrXrq2HHnpIjzzyiCIiIvL04gwcOFCXXXaZwsLCFB4e7nypHzx4sLp06XJCOyIjI9W/f39FR0erRYsWGjhwYKG9kAXFk5+EhAQlJycrLCxMDz/8sKZNm1bErfS3jIwM9evXz7mwUmpqqhISElS1alVNnTpVvXr1UmhoqM4555x8rxjbtm1bpaam5rmITYsWLZxe75iYGP3yyy9q06aNJOnee+/VtGnTFB4eri1bthTYezhw4EAFBQUpMjJSISEhuuuuuwrtTdu+fXueW8IUdnEnyXu15BdeeEFhYWH6/vvvVatW0e/tW79+fSUmJqp3794KCwtTq1attGXLFlWuXFlz5szRqFGjFB4eXurbFd17771KT09XUFCQHnvsMQUHBxcYZ3h4uCIiItSkSRPddtttat269UnrHz16tJYsWaLg4GC99957uuyyy4oUV4MGDTRs2LATyh9//HFlZmYqLCxMwcHBevzxxyXlf4zkp6DXSmRkpG655RaFh4fr2muvVVRUlLPMtGnTNHLkSIWFhSklJUVPPPFEnjoLOo6rVauml156SV26dFGzZs1Us2bNPNu2W7duysjIKPOhu5JkcrJ2NzVv3twWdtUsAABQfjY3aZpvedMtmys4krK1efNmNW2af9sAnOjQoUOqVq2ajDF65513NHPmTOdKzaeKY8eOKTMzU1WrVtX27dvVoUMHbd26VZUrV3Y7tDNCRkaG/P39Za3VkCFD1KhRI40YMUKSlJSUpBEjRji9sIXJ7/3XGJNsrW2e3/ycUwoAAABAycnJGjp0qKy1ql27tt544w23QzrBoUOH1LZtW2VmZspaq5deeomEtAy9+uqrmjZtmo4ePaqIiAjdddddkrynE7z88stlfi5pDnpKAQA4y9FTevqIj4/Xjh078pQ9++yzpb7wzelo6tSpmjBhQp6y1q1b68UXXyxyHXv27FH79u1PKP/yyy9Vt27dUsdYETZs2OBcbThHlSpV8r2QzpmsRYsWzr02c0yfPv2EczxL4kw4TipacXtKSUoBADjLkZQCAMpScZNSLnQEAAAAAHANSSkAAAAAwDUkpQAAAAAA13D1XQAAcFYInVb6C57ktqHfhjKtDwDOVvSUAgAAlKP3339fxhht2bLlpPOOHz9ehw4dKtd40tLS9Pbbbxd7uf79+2vOnDkFTp8/f74iIiIUHh6uoKAgvfLKK4XWl56erhYtWigiIkJLly7VSy+9VOyYylpAQIBCQ0Pl8Xjk8Xg0bNiwEtd13XXXad++fWUXXD6SkpJKFSNwqiApBQAAKEczZ85UmzZtNHPmzJPOeyonpYXJzMzU4MGD9dFHH2ndunVau3at4uLiCl3myy+/VGhoqNauXatLL720XJLSY8eOFXuZRYsWKSUlRSkpKZo4cWKJ1/3JJ5+odu3aJV7+ZLKystS8efNSxQicKkhKAQAAyklGRoaWLVum119/Xe+8844kafHixbr++uudeYYOHarExERNnDhRv/76q9q2bau2bdtK8ia0oaGhCgkJ0ahRo5xl/P39NXLkSAUHB6tDhw5atWqV4uLi1LBhQ3344YeSvMlnTEyMIiMjFRkZqW+++UaS9PDDD2vp0qXyeDwaN26cjh07ppEjRyoqKkphYWFOD6e1VkOHDlXjxo3VoUMH/fbbbwW288CBA8rKynLu2VilShU1btzYiaNdu3YKCwtT+/bt9dNPPyklJUUPPfSQPvjgA3k8Ho0aNUrbt2+Xx+PRyJEjNWTIEKcd8fHxGjBggCTpjTfe0KOPPipJuvHGG9WsWTMFBwdrypQpebbNP//5T4WHh2vFihV66623FB0dLY/Ho7vuuqtEiWpcXJxGjRql6OhoXXXVVVq6dKkk6dChQ7r55psVFBSk+Ph4tWjRQjm3OQwICNDvv/+utLQ0NW3aVIMGDVJwcLA6deqkw4cPS5K2b9+uLl26qFmzZoqJiXF609PT09WzZ09FRUUpKipKy5cvlyQlJCTojjvuUOvWrXXHHXfkOZYSEhI0YMAA5zjInaz++9//VuPGjdWmTRv17t1bY8eOLfY2AMoTSSkAAEA5+eCDD9SlSxddddVVqlu3rpKTkwucd9iwYbr44ou1aNEiLVq0SL/++qtGjRqlr776SikpKVq9erXef/99SdLBgwfVrl07bdq0STVr1tRjjz2mL774QvPmzdMTTzwhSTr//PP1xRdfaM2aNZo1a5YzzHPMmDGKiYlRSkqKRowYoddff121atXS6tWrtXr1ar366qvasWOH5s2bp61btyo1NVVvvvmmk9Tm57zzzlO3bt10+eWXq3fv3poxY4ays7MlSffdd5/69eun9evXq0+fPho2bJg8Ho+eeuop3XLLLUpJSdGzzz6rK664QikpKXr++ecVExPjJH6//PKLUlNTJUlLly5VbGysJG+CmpycrKSkJE2cOFF79uxxtk2LFi20bt061a1bV7NmzdLy5cuVkpIiPz8/zZgxo9B91rZtW2f47rhx45zyrKwsrVq1SuPHj9eTTz4pSXrppZdUp04dpaam6t///neB+3fbtm0aMmSINm3apNq1a2vu3LmSpMGDB2vSpElKTk7W2LFjde+990qShg8frhEjRmj16tWaO3euBg4c6NSVmpqqhQsX5tvzvmXLFn3++edatWqVnnzySWVmZjp1rFu3Tp9++qmTNAOnEi50BAAAUE5mzpyp4cOHS5JuvfVWzZw5M08vaWFWr16tuLg41a9fX5LUp08fLVmyRDfeeKMqV66sLl26SJJCQ0NVpUoVVapUSaGhoUpLS5PkHVI7dOhQJxn77rvv8l3PggULtH79eud80f3792vbtm1asmSJevfuLT8/P1188cVq165dofG+9tpr2rBhgxYuXKixY8fqiy++UGJiolasWKH33ntPknTHHXfooYceOmnbY2JiNH78eKWmpiooKEh//PGHdu3apRUrVjg9gBMnTtS8efMkSTt37tS2bdtUt25d+fn5qWfPnpK8Q4STk5MVFRUlSTp8+LDOP//8Qte9aNEi1atX74TyHj16SJKaNWvmbONly5Y5+zckJERhYWH51hkYGCiPx5Nn+YyMDH3zzTfq1auXM99ff/0lSVq4cKGTiEvSn3/+qYyMDElSt27dVK1atXzX07VrV1WpUkVVqlTR+eefr927d2v58uXq3r27qlatqqpVq+qGG24otP2AG0hKAQAAysHevXv11VdfacOGDTLG6NixYzLGqHv37k4voiQdOXKk2HVXqlRJxhhJ0jnnnKMqVao4j7OysiRJ48aN0wUXXKB169YpOztbVatWzbcua60mTZqkzp075yn/5JNPih1XaGioQkNDdccddygwMFCJiYnFrkOSLrnkEu3bt0+fffaZYmNjtXfvXs2ePVv+/v6qWbOmFi9erIULF2rFihWqXr264uLinO1YtWpV+fn5OW3r16+f/vd//7dEceSWs439/PycbVzcZXOWP3z4sLKzs1W7dm2lpKScMH92drZWrlyZ7z6rUaNGkddT3DgBtzB8FwAAnBU29NtQpn8nM2fOHN1xxx368ccflZaWpp07dyowMFDZ2dlKTU3VX3/9pX379unLL790lqlZs6YOHDggSYqOjtbXX3+t33//XceOHdPMmTN1zTXXFLm9+/fv10UXXaRzzjlH06dPd86lzL0OSercubNefvllZWZmSpK+++47HTx4ULGxsZo1a5aOHTumXbt2adGiRQWuKyMjQ4sXL3aep6Sk6PLLL5ckXX311c75tDNmzFBMTMwJyx8fkyS1bNlS48ePV2xsrGJiYjR27Fhn2f3796tOnTqqXr26tmzZopUrV+YbV/v27TVnzhznfNi9e/fqxx9/LHS7FUfr1q01e/ZsSd5htRs2FP02Qf/4xz8UGBiod999V5I3gV63bp0kqVOnTpo0aZIzb36Ja3Fi/Oijj3TkyBFlZGRo/vz5Ja4LKC8kpQAAAOVg5syZio+Pz1PWs2dPvfPOO7r55psVEhKim2++WREREc70wYMHq0uXLmrbtq0uuugijRkzRm3btlV4eLiaNWum7t27F3n99957r6ZNm6bw8HBt2bLF6WELCwuTn5+fwsPDNW7cOA0cOFBBQUGKjIxUSEiI7rrrLmVlZSk+Pl6NGjVSUFCQ+vbtq1atWhW4LmutnnvuOTVu3Fgej0ejR492ekknTZqkqVOnKiwsTNOnT9eECRNOWL5u3bpq3bq1QkJCNHLkSEneIbxZWVm68sorFRkZqb179zpJaZcuXZSVlaWmTZvq4YcfVsuWLfONKygoSE8//bQ6deqksLAwdezYUbt27Sp0u+U+p7Rv374n3cbp6ekKCgrSY489puDgYNWqVavQZXKbMWOGXn/9dYWHhys4OFgffPCBJO/Q5KSkJIWFhSkoKEiTJ08ucp3Hi4qKUrdu3RQWFqZrr71WoaGhxYoRqAjGWut2DGrevLnlpGsAANyxuUnTfMubbtlcwZGUrc2bN6tp0/zbBpSFY8eOKTMzU1WrVtX27dvVoUMHbd26VZUrV3Y7tDwyMjLk7++vQ4cOKTY2VlOmTFFkZKTbYeEMlt/7rzEm2VrbPL/5OacUAAAAKIFDhw6pbdu2yszMlLVWL7300imXkEreHvjU1FQdOXJE/fr1IyHFKYekFAAAAEUWHx+vHTt25Cl79tlnT7hQ0qmsRYsWzpVuc0yfPl2hoaHFqqdmzZqnxS1W3n77bbdDAApFUgoAAIAiy7kNy+ns22+/dTsEALlwoSMAAAAAgGtISgEAAAAAriEpBQAAAAC4hnNKAQDAWaGgW9+U1Ol+yxwAOFXQUwoAAFBO/Pz85PF4nL8xY8aUSb3XXXed9u3bV+xphUlMTNTQoUMLnL5161bFxcXJ4/GoadOmGjx48Enr7N27t8LCwjRu3DiNHz9ehw4dKnZcZal///4KDAx09sfVV19d4rqeeOIJLVy4sAyjy19pYgROF/SUAgAAlJNq1aopJSWlzOv95JNPTiiz1spam++0sjBs2DCNGDFC3bt3lyRt2LCh0Pn/7//+T6tXr9b3338vSQoICNDtt9+u6tWrl1lMWVlZOvfc4n2dff7553XTTTeVet1PPfVUqesoTE7bvvnmm3JdD3AqoKcUAACgggUEBOiRRx6Rx+NR8+bNtWbNGnXu3FlXXHGFJk+eLElavHixYmNj1bVrVzVu3Fh33323srOzneV///13paWlqXHjxurbt69CQkK0c+dOZ5okvfnmmwoLC1N4eLjuuOMOSdJHH32kFi1aKCIiQh06dNDu3buLFPOuXbvUoEED53nOPT2PHDmiO++8U6GhoYqIiNCiRYskSZ06ddIvv/wij8ejJ598Ur/++qvatm2rtm3b6t1339UDDzwgSZowYYIaNmwoSfrhhx/UunVrSd6kLyoqSiEhIRo8eLCstZKkuLg43X///WrevLkmTJig5ORkXXPNNWrWrJk6d+6sXbt2FXt/JCQkaMCAAYqLi1PDhg01ceJEZ9q///1vNW7cWG3atFHv3r01duxYSd5e1zlz5jj7Y/To0YqMjFRoaKi2bNkiSTp48KAGDBig6OhoRURE6IMPPpAkHTt2TCNHjlRUVJTCwsL0yiuvSPLu85iYGHXr1k1BQUGSJH9/f2daXFycbrrpJjVp0kR9+vRxtsknn3yiJk2aqFmzZho2bJiuv/76Ym8DwE0kpQAAAOXk8OHDeYbvzpo1y5l22WWXKSUlRTExMU6Cs3LlSo0ePdqZZ9WqVZo0aZJSU1O1fft2vffeeyesY9u2bbr33nu1adMmXX755U75pk2b9PTTT+urr77SunXrNGHCBElSmzZttHLlSq1du1a33nqrnnvuuSK1ZcSIEWrXrp2uvfZajRs3zhki/OKLL8oYow0bNmjmzJnq16+fjhw5og8//FBXXHGFUlJSNHr0aF188cVatGiRFi1apJiYGC1dulSStHTpUtWtW1e//PKLli5dqtjYWEnS0KFDtXr1am3cuFGHDx/W/PnznViOHj2qpKQkDRs2TPfdd5/mzJmj5ORkDRgwQI8++mih7Rg5cqSzP/r06eOUb9myRZ9//rlWrVqlJ598UpmZmVq9erXmzp2rdevW6dNPP1VSUlKB9darV09r1qzRPffc4ySuzzzzjNq1a6dVq1Zp0aJFGjlypA4ePKjXX39dtWrV0urVq7V69Wq9+uqr2rFjhyRpzZo1mjBhgr777rsT1rF27VqNHz9eqamp+uGHH7R8+XIdOXJEd911lz799FMlJycrPT29CHsTOLUwfBcAAKCcFDZ8t1u3bpK8PY4ZGRmqWbOmatasqSpVqjgJX3R0tNOL2Lt3by1btuyEoaeXX365WrZseUL9X331lXr16qV69epJks477zxJ0s8//6xbbrlFu3bt0tGjRxUYGFikttx5553q3LmzPvvsM33wwQd65ZVXtG7dOi1btkz33XefJKlJkya6/PLL9d133+kf//hHgXVdeOGFysjI0IEDB7Rz507ddtttWrJkiZYuXaoePXpIkhYtWqTnnntOhw4d0t69exUcHKwbbrhBknTLLbdI8p7nunHjRnXs2FGStwfyoosuKrQdBQ3f7dq1q6pUqaIqVaro/PPP1+7du7V8+XJ1795dVatWVdWqVZ315ycn7mbNmjk/HixYsEAffvihk6QeOXJEP/30kxYsWKD169c7Pa379+/Xtm3bVLlyZUVHRxe4T6Kjo53eao/Ho7S0NPn7+6thw4bOMr1799aUKVMK3QbAqYakFAAAwAVVqlSRJJ1zzjnO45znWVlZkiRjTJ5ljn8uSTVq1CjWeu+77z498MAD6tatmxYvXqyEhIQiL3vxxRdrwIABGjBggEJCQrRx48ZirTu3q6++WlOnTlXjxo0VExOjN954QytWrNB///tfHTlyRPfee6+SkpJ06aWXKiEhQUeOHHGWzWmztVbBwcFasWJFiePIkXsf+Pn5OfuguMvnXtZaq7lz56px48Z55rXWatKkSercuXOe8sWLFxe6P0sbI3CqYvguAAA4KzTdsrlM/yrCqlWrtGPHDmVnZ2vWrFlq06ZNkZdt166d3n33Xe3Zs0eStHfvXkneXrlLLrlEkjRt2rQi1/fZZ58pMzNTkvciRnv27NEll1yimJgYzZgxQ5L03Xff6aeffjohCZOkmjVr6sCBA87zmJgYjR07VrGxsc65qFWqVFGtWrWcBLRevXrKyMhwehSP17hxY6WnpztJaWZmpjZt2lTkNp1M69at9dFHH+nIkSPKyMjIM4S4KDp37qxJkyY5536uXbvWKX/55Zed7fndd9/p4MGDJYqxcePG+uGHH5SWliZJeYaIA6cLekoBAADKSc45pTm6dOlSrNvCREVFaejQofr+++/Vtm1bxcfHF3nZ4OBgPfroo7rmmmvk5+eniIgIJSYmKiEhQb169VKdOnXUrl0751zGk1mwYIGGDx+uqlWrSvIOg73wwgt177336p577lFoaKjOPfdcJSYm5unRyzF48GB16dLFObc0JiZGO3fuVGxsrPz8/HTppZeqSZMmkqTatWtr0KBBCgkJ0YUXXqioqKh8Y6pcubLmzJmjYcOGaf/+/crKytL999+v4ODgAtsxcuRIPf30087zVatWFThvVFSUunXrprCwMF1wwQUKDQ1VrVq1irS9JOnxxx/X/fffr7CwMGVnZyswMFDz58/XwIEDlZaWpsjISFlrVb9+fb3//vtFrje3atWq6aWXXlKXLl1Uo0aNArcVcCozOb/cuKl58+a2sBPHAQBA+dncpGm+5RXVG1heNm/erKZN82/b6WDx4sUaO3ZssXvnULYyMjLk7++vQ4cOKTY2VlOmTFFkZKTbYeWRE6O1VkOGDFGjRo00YsQIt8PCWSy/919jTLK1tnl+8zN8FwAAACjA4MGD5fF4FBkZqZ49e55yCakkvfrqq/J4PAoODtb+/ft11113uR0SUCz0lAIAcJajpxS5PfPMM3r33XfzlPXq1eukt1o5lQwZMkTLly/PUzZ8+HDdeeedLkUEnF2K21PKOaUAAABwPProo6dVApqfF1980e0QABQDw3cBAAAAAK4hKQUAAAAAuIakFAAAAADgGs4pBQAAZ4UX7/6qTOsbMrldmdYHAGcrekoBAADKib+/vyQpLS1N1apVk8fjcf7efPNNSVJAQIBCQ0Od8mHDhkmS+vfvr8DAQKf86quvzncdU6dOdeapXLmyU9fDDz9cMY0sxOLFi/XNN984zydPnuy0+1TXv39/XXLJJfrrr78kSb///rsCAgLKfb2JiYkaOnRogdMTEhJUvXp1/fbbb05ZznFWmP/85z9lEt/xAgIC9Pvvv5dL3UURFxenwu7iUdHxXXfdddq3b1+Z1Xfo0CH16dNHoaGhCgkJUZs2bZSRkVHsespr/5cVekoBAAAqwBVXXKGUlJR8py1atEj16tU7ofz555/XTTfdVGi9d955p3Ork4CAgHzrOnbsmPz8/EoWeCksXrxY/v7+TkJ99913V3gMpeHn56c33nhD99xzT5nWm5WVpXPPLfnX8Hr16um///2vnn322SIv85///Ef/+te/SrzO/Bw7dqxM6zsdnGzfffLJJ2W6vgkTJuiCCy7Qhg0bJElbt25VpUqVil1Peez/skRPKQAAwBnI399f//znPxUeHq4VK1boqaeeUlRUlEJCQjR48GDl3Ks+Li5Oo0aNUnR0tK666iotXbpUkrRp0yZFR0fL4/EoLCxM27ZtkyTdeOONatasmYKDgzVlyhRnfZ999pkiIyMVHh6u9u3bKy0tTZMnT9a4cePk8Xi0dOlSJSQkaOzYsZKklJQUtWzZUmFhYYqPj9cff/xRonjy88ILLygkJEQhISEaP368JG9vddOmTTVo0CAFBwerU6dOOnz4cKHb8P7779e4ceOUlZV1wrTnn39eUVFRCgsL0+jRo511hISEOPOMHTtWCQkJTrvuv/9+NW/eXBMmTNBHH32kFi1aKCIiQh06dNDu3bsLjSW3AQMGaNasWdq7d+8J09566y1nO9111106duyYHn74YR0+fFgej0d9+vTR888/r4kTJ0qSRowYoXbtvEPRv/rqK/Xp00eSNHPmTKd3btSoUU79xx9XOQ4fPqxrr71Wr776qg4ePKiuXbsqPDxcISEhmjVrVoFtKe5xefjwYd16661q2rSp4uPjT7oP85Oenq6ePXsqKipKUVFRzj1tV61apVatWikiIkJXX321tm7dKsnbe92tWze1a9dO7du3V2Jionr06KEuXbqoUaNGeuihh5y6c3pmCzveVq9erbCwMHk8Ho0cOTLPMXO8Xbt26ZJLLnGeN27cWFWqVNETTzzhHNuS91ZOEyZM0K5duxQbGyuPx6OQkBAtXbr0hP0v5X+cSN79O3LkSAUHB6tDhw5atWqV4uLi1LBhQ3344YeSivdaLCqSUgAAgAqwffv2PMN3c75kS1Lbtm2d8nHjxjnlI0eOdMpzvkwW1cGDB9WiRQutW7dObdq00dChQ7V69Wpt3LhRhw8f1vz58515s7KytGrVKo0fP15PPvmkJO9Q2+HDhyslJUVJSUlq0KCBJOmNN95QcnKykpKSNHHiRO3Zs0fp6ekaNGiQ5s6dq3Xr1undd99VQECA7r77bo0YMUIpKSmKiYnJE1/fvn317LPPav369QoNDXXWW9x4jpecnKypU6fq22+/1cqVK/Xqq69q7dq1kqRt27ZpyJAh2rRpk2rXrq25c+cWug0vu+wytWnTRtOnT89TvmDBAm3btk2rVq1SSkqKkpOTtWTJkpPuk6NHjyopKUn//Oc/1aZNG61cuVJr167Vrbfequeee+6ky+fw9/fXgAEDNGHChDzlmzdv1qxZs7R8+XKlpKTIz89PM2bM0JgxY1StWjWlpKRoxowZiomJcY6/pKQkZWRkKDMzU0uXLlVsbKx+/fVXjRo1Sl999ZVSUlK0evVqvf/++5JOPK4kKSMjQzfccIN69+6tQYMG6bPPPtPFF1+sdevWaePGjerSpUuBbSnucfnyyy+revXq2rx5s5588kklJycXebvlGD58uEaMGKHVq1dr7ty5GjhwoCSpSZMmWrp0qdauXaunnnoqT8/imjVrNGfOHH399deSvD+qzJo1Sxs2bNCsWbO0c+fOE9ZT0PF255136pVXXnH2UWEGDBigZ599Vq1atdJjjz3mJIADBgxwhsJnZ2frnXfe0e233663335bnTt3VkpKitatWyePx3PC/i/oOJG8+7ddu3batGmTatasqccee0xffPGF5s2bpyeeeEJS0V+LxXHScQPGmDckXS/pN2ttiK9slqTGvllqS9pnrfUYYwIkbZa01TdtpbX29BqnAQAAUA7Ka/huQfz8/NSzZ88863juued06NAh7d27V8HBwbrhhhskST169JAkNWvWTGlpaZKkVq1a6ZlnntHPP/+sHj16qFGjRpKkiRMnat68eZKknTt3atu2bUpPT1dsbKwCAwMlSeedd16hse3fv1/79u3TNddcI0nq16+fevXq5UwvTjzHW7ZsmeLj41WjRg2nrqVLl6pbt27OObrH112YRx55RN27d1fXrl2dsgULFmjBggWKiIiQ5E3Ktm3bpssuu6zQum655Rbn8c8//6xbbrlFu3bt0tGjR51tV1TDhg2Tx+PRgw8+6JR9+eWXSk5OVlRUlCRvr+L5559/wrLNmjVTcnKy/vzzT1WpUkWRkZFKSkrS0qVLNXHiRK1evVpxcXGqX7++JKlPnz5asmSJbrzxxhOOK0nq3r27HnroIeeHk9DQUP3zn//UqFGjdP3115/wg0RuxT0ulyxZ4px3HRYWprCwsGJtN0lauHChUlNTned//vmnMjIytH//fvXr10/btm2TMUaZmZnOPB07dsxzXLdv3161atWSJAUFBenHH3/UpZdemmc9+R1v+/bt04EDB9SqVStJ0m233ZYnET+ex+PRDz/8oAULFmjhwoWKiorSihUr1LRpU9WtW1dr167V7t27FRERobp16yoqKkoDBgxQZmambrzxRmf9uRV2nFSuXNn5ESE0NFRVqlRRpUqVFBoaWuzXYnEUpac0UVKenzestbdYaz3WWo+kuZLeyzV5e840ElIAAAB3VK1a1emFOXLkiO69917NmTNHGzZs0KBBg3TkyBFn3ipVqkjyJrI5Q1Vvu+02ffjhh6pWrZquu+46ffXVV1q8eLEWLlyoFStWaN26dYqIiMhTT1kpajwlrff4ugvTqFEjeTwezZ492ymz1uqRRx5RSkqKUlJS9P333+t//ud/dO655yo7O9uZ7/htk5MoS9J9992noUOHasOGDXrllVeKvR1r166t2267TS+++GKeuPr16+fEtXXrVmf4cG6VKlVSYGCgEhMTdfXVVysmJkaLFi3S999/r6ZNmxa63tzHVY7WrVvrs88+c4beXnXVVVqzZo1CQ0P12GOP6amnnsq3rpIcl2UhOztbK1eudLbTL7/8In9/fz3++ONq27atNm7cqI8++ihPLLn3Xe7YCouvJMdbfvz9/dWjRw+99NJLuv32253zVgcOHKjExERNnTpVAwYMkCTFxsZqyZIluuSSS9S/f/98LyxW2HFSqVIlGWMkSeecc47ThnPOOadMX4vHO2lPqbV2ia8H9ATGG/HNkrgmOgAAOKWdzbdwyflyXa9ePWVkZGjOnDkn7YH94Ycf1LBhQw0bNkw//fST1q9fr8DAQNWpU0fVq1fXli1btHLlSklSy5Ytde+992rHjh0KDAzU3r17dd5556lmzZr6888/T6i7Vq1aqlOnjpYuXaqYmBhNnz7d6TUtTjw550LmFhMTo/79++vhhx+WtVbz5s07YfhtcT366KN5eko7d+6sxx9/XH369JG/v79++eUXVapUSRdccIF+++037dmzR/7+/po/f36BQ1f379/vnCs4bdq0EsX1wAMPKCoqykkW2rdvr+7du2vEiBE6//zztXfvXh04cECXX365KlWqpMzMTOciOTExMRo7dqzeeOMNhYaG6oEHHlCzZs1kjFF0dLSGDRum33//XXXq1NHMmTN13333FRjHU089paeeekpDhgzRSy+9pF9//VXnnXeebr/9dtWuXVuvvfZavsuV5LiMjY3V22+/rXbt2mnjxo1av359sbdbp06dNGnSJI0cOVKSdyiux+PJs08SExOLXW9R1K5dWzVr1tS3336rFi1a6J133il0/uXLlysoKEh16tTR0aNHlZqaqri4OElSfHy8nnjiCWVmZurtt9+WJP34449q0KCBBg0apL/++ktr1qxR37598+z/wo6Toijqa7E4SntOaYyk3dba3Ge3Bhpj1hpjvjbGFNhXb4wZbIxJMsYkpaenlzIMAACAU9vx55TmXGhGyntOad++fZ3y3OeUejweHT16tETrrl27tgYNGqSQkBB17tzZGbZXmNmzZyskJEQej0cbN25U37591aVLF2VlZalp06Z6+OGH1bJlS0lS/fr1NWXKFPXo0UPh4eHOMNUbbrhB8+bNO+EcWsmbiI0cOVJhYWFKSUlxzlcrTjz5iYyMVP/+/RUdHa0WLVpo4MCBzjDbkgoODlZkZKTzvFOnTrrtttvUqlUrhYaG6qabbtKBAwdUqVIlPfHEE4qOjlbHjh3VpEmTAutMSEhQr1691KxZs3yHbhdFvXr1FB8f79y2JigoSE8//bQ6deqksLAwdezYUbt27ZIkDR48WGFhYc4Q25iYGO3atUutWrXSBRdcoKpVqzrDbC+66CKNGTNGbdu2VXh4uJo1a6bu3bsXGsuECRN0+PBhPfTQQ9qwYYNzIZwnn3xSjz32WL7LlOS4vOeee5SRkaGmTZvqiSeeULNmzU66TFhYmBo0aKAGDRrogQce0MSJE5WUlKSwsDAFBQVp8uTJkqSHHnpIjzzyiCIiIsq0Z/Z4r7/+ugYNGiSPx6ODBw86w4Dzs337dl1zzTUKDQ1VRESEmjdv7gyfrly5stq2baubb77Z6b1evHixwsPDFRERoVmzZmn48OGS8u7/wo6Toijqa7E4TE43e6EzeXtK5+ecU5qr/GVJ31tr/+t7XkWSv7V2jzGmmaT3JQVba0/8iSyX5s2b28LuLwQAAMrP5ib5D9drumVzBUdStjZv3nzSoYgAUNEyMjKce8uOGTNGu3btOuGiVUWRnZ2tyMhIvfvuu2VyXmdZyu/91xiTbK1tnt/8Je4pNcacK6mHJOcaz9bav6y1e3yPkyVtl3RVSdcBAAAAAGeSjz/+OM8tWwrqSS5MamqqrrzySrVv3/6US0hLouR37ZU6SNpirf05p8AYU1/SXmvtMWNMQ0mNJP1QyhgBAAAgaerUqSf0qLRu3TrPxW7OFnv27FH79u1PKP/yyy9Vt27dItczZMgQ5z6VOYYPH64777yz1DGWxjPPPKN33303T1mvXr306KOPuhRR6cTHx2vHjh15yp599ll17ty5TOpv0aKFM4w5x/Tp0xUaGlom9ZelW265Jc+VmCXp888/z3M/WMl79d6cK10fLygoSD/8cOakWScdvmuMmSkpTlI9SbsljbbWvm6MSZT3li+Tc83bU9JTkjIlZfvm/ehkQTB8FwAA95zJw3ebNGniXEkSAFD+rLXasmVLsYbvFuXqu70LKO+fT9lceW8RAwAA4KqqVatqz549qlu3LokpAFQAa6327NmjqlWrFmu50gzfBQAAOGU1aNBAP//8s7jKPwBUnKpVq6pBgwbFWoakFAAAnJEqVaqkwMBAt8MAAJxEae9TCgAAAABAiZGUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHDNSZNSY8wbxpjfjDEbc5UlGGN+Mcak+P6uyzXtEWPM98aYrcaYzuUVOAAAAADg9FeUntJESV3yKR9nrfX4/j6RJGNMkKRbJQX7lnnJGONXVsECAAAAAM4sJ01KrbVLJO0tYn3dJb1jrf3LWrtD0veSoksRHwAAAADgDFaac0qHGmPW+4b31vGVXSJpZ655fvaVncAYM9gYk2SMSUpPTy9FGAAAAACA01VJk9KXJV0hySNpl6T/FrcCa+0Ua21za23z+vXrlzAMAAAAAMDprERJqbV2t7X2mLU2W9Kr+nuI7i+SLs01awNfGQAAAAAAJyhRUmqMuSjX03hJOVfm/VDSrcaYKsaYQEmNJK0qXYgAAAAAgDPVuSebwRgzU1KcpHrGmJ8ljZYUZ4zxSLKS0iTdJUnW2k3GmNmSUiVlSRpirT1WLpEDAAAAAE57J01KrbW98yl+vZD5n5H0TGmCAgAAAACcHUpz9V0AAAAAAEqFpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuISkFAAAAALjmpEmpMeYNY8xvxpiNucqeN8ZsMcasN8bMM8bU9pUHGGMOG2NSfH+TyzF2AAAAAMBprig9pYmSuhxX9oWkEGttmKTvJD2Sa9p2a63H93d32YQJAAAAADgTnTQptdYukbT3uLIF1tos39OVkhqUQ2wAAAAAgDNcWZxTOkDSp7meBxpj1hpjvjbGxJRB/QAAAACAM9S5pVnYGPOopCxJM3xFuyRdZq3dY4xpJul9Y0ywtfbPfJYdLGmwJF122WWlCQMAAAAAcJoqcU+pMaa/pOsl9bHWWkmy1v5lrd3je5wsabukq/Jb3lo7xVrb3FrbvH79+iUNAwAAAABwGitRUmqM6SLpIUndrLWHcpXXN8b4+R43lNRI0g9lESgAAAAA4Mxz0uG7xpiZkuIk1TPG/CxptLxX260i6QtjjCSt9F1pN1bSU8aYTEnZku621u7Nt2IAAAAAwFnvpEmptbZ3PsWvFzDvXElzSxsUAAAAAODsUBZX3wUAAAAAoERISgEAAAAArinVLWEAAACAihTw8Mf5lqeN6VrBkQAoK/SUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHANSSkAAAAAwDUkpQAAAAAA15CUAgAAAABcQ1IKAAAAAHDNuW4HAAAAii/g4Y/zLU8b07WCIwEAoHToKQUAAAAAuIakFAAAAADgGpJSAAAAAIBrSEoBAAAAAK4hKQUAAAAAuIakFAAAAADgGpJSAAAAAIBrSEoBAAAAAK4hKQUAAAAAuIakFAAAAADgGpJSAAAAAIBripSUGmPeMMb8ZozZmKvsPGPMF8aYbb7/dXzlxhgz0RjzvTFmvTEmsryCBwAAAACc3oraU5ooqctxZQ9L+tJa20jSl77nknStpEa+v8GSXi59mAAAAACAM1GRklJr7RJJe48r7i5pmu/xNEk35ip/03qtlFTbGHNRGcQKAAAAADjDlOac0gustbt8j/9P0gW+x5dI2plrvp99ZQAAAAAA5FEmFzqy1lpJtjjLGGMGG2OSjDFJ6enpZREGAAAAAOA0U5qkdHfOsFzf/9985b9IujTXfA18ZXlYa6dYa5tba5vXr1+/FGEAAAAAAE5XpUlKP5TUz/e4n6QPcpX39V2Ft6Wk/bmG+QIAAAAA4Di3KDMZY2ZKipNUzxjzs6TRksZImm2M+R9JP0q62Tf7J5Kuk/S9pEOS7izjmAEAAAAAZ4giJaXW2t4FTGqfz7xW0pDSBAUAAAAAODuUyYWOAAAAAAAoCZJSAAAAAIBrijR8FziVBTz8cb7laWO6VnAkAAAAAIqLnlIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAArjnX7QCAU8nmJk3zLW+6ZXMFRwIAAACcHegpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAArjm3pAsaYxpLmpWrqKGkJyTVljRIUrqv/F/W2k9Kuh4AAAAAwJmrxEmptXarJI8kGWP8JP0iaZ6kOyWNs9aOLYsAAQAAAABnrrIavtte0nZr7Y9lVB8AAAAA4CxQVknprZJm5no+1Biz3hjzhjGmTn4LGGMGG2OSjDFJ6enp+c0CAAAAADjDlTopNcZUltRN0ru+opclXSHv0N5dkv6b33LW2inW2ubW2ub169cvbRgAAAAAgNNQWfSUXitpjbV2tyRZa3dba49Za7MlvSopugzWAQAAAAA4A5VFUtpbuYbuGmMuyjUtXtLGMlgHAAAAAOAMVOKr70qSMaaGpI6S7spV/JwxxiPJSko7bhoAAAAAAI5SJaXW2oOS6h5XdkepIgIAAAAAnDXK6uq7AAAAAAAUG0kpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANeQlAIAAAAAXENSCgAAAABwzbluBwAAAICiC3j44wKnpY3pWoGRAEDZoKcUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGtISgEAAAAArjm3tBUYY9IkHZB0TFKWtba5MeY8SbMkBUhKk3SztfaP0q4LAAAAAHBmKaue0rbWWo+1trnv+cOSvrTWNpL0pe85AAAAAAB5lNfw3e6SpvkeT5N0YzmtBwAAAABwGiuLpNRKWmCMSTbGDPaVXWCt3eV7/H+SLjh+IWPMYGNMkjEmKT09vQzCAAAAAACcbkp9TqmkNtbaX4wx50v6whizJfdEa601xtjjF7LWTpE0RZKaN29+wnQAAAAAwJmv1D2l1tpffP9/kzRPUrSk3caYiyTJ9/+30q4HAAAAAHDmKVVSaoypYYypmfNYUidJGyV9KKmfb7Z+kj4ozXoAAAAAAGem0g7fvUDSPGNMTl1vW2s/M8asljTbGPM/kn6UdHMp1wMAAAAAOAOVKim11v4gKTyf8j2S2pembgAAAAAV78W7vypw2pDJ7SowEpwtyuuWMAAAAAAAnBRJKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFxDUgoAAAAAcA1JKQAAAADANSSlAAAAAADXnOt2AEC5SahVyLT9FRcHAAAAgALRUwoAAAAAcA1JKQAAAADANSSlAAAAAADXkJQCAAAAAFzDhY6Os7lJ0wKnNd2yuQIjAQAAAIAzX4l7So0xlxpjFhljUo0xm4wxw33lCcaYX4wxKb6/68ouXAAAAADAmaQ0PaVZkv5prV1jjKkpKdkY84Vv2jhr7djShwcAAAAAOJOVOCm11u6StMv3+IAxZrOkS8oqMAAAAADAma9MLnRkjAmQFCHpW1/RUGPMemPMG8aYOmWxDgAAAADAmafUSakxxl/SXEn3W2v/lPSypCskeeTtSf1vAcsNNsYkGWOS0tPTSxsGAAAAAOA0VKqk1BhTSd6EdIa19j1JstbuttYes9ZmS3pVUnR+y1prp1hrm1trm9evX780YQAAAAAATlMlPqfUGGMkvS5ps7X2hVzlF/nON5WkeEkbSxciKtLZckuc0Gmh+ZbPruA4AAAAgLNdaa6+21rSHZI2GGNSfGX/ktTbGOORZCWlSbqrFOsAAAAAAJzBSnP13WWSTD6TPil5OAAAAACAs0mZXH0XAAAAAICSICkFAAAAALimNOeUnjICHv64wGlpY7pWYCQAALgsoVYB5fsrNo5yxOc+AJxZ6CkFAAAAALjmjOgpBQAAAM4GBY0UYJQATmf0lAIAAAAAXENSCgAAAABwDUkpAAAAAMA1JKUAAAAAANdwoSMAAHBW29ykab7lTbdsruBITi0v3v1VvuVDJrer4EgAnOnoKQUAAAAAuIakFAAAAADgGpJSAAAAAIBrOKf0DMBNlAEAQGFCp4XmW76h34YKjgQATkRPKQAAAADANSSlAAAAAADXMHwXAADgTJFQK//ywMsqNg4AKAZ6SgEAAAAArqGntBi4iTQAAAAAlC16SgEAAAAArqGnFAAA4Cy1uUnTgifGvVhxgZQzbomTvwL3/xm073F6oKcUAAAAAOAaklIAAAAAgGsYvgsAAPJV0AX+JC7yBwAoO/SUAgAAAABcQ08pAAAAcAYr6EJPsys4DqAg9JQCAAAAAFxDTykAAABOfwm1Cp4WeFmxquJ8aqBi0VMKAAAAAHANSSkAAAAAwDUM3wUAAMBZaXOTpvlPiHuxYgMBznL0lAIAAAAAXENPKQAAAHC6K8MLPQEVjZ5SAAAAAIBrSEoBAAAAAK4hKQUAAAAAuIakFAAAAADgGpJSAAAAAIBrSEoBAAAAAK7hljAAAAD5ePHur/ItHzK5XQVHAgBnNnpKAQAAAACuOWt7SkOnheZbPruC4zid8IsxAOCUl1CrgPL9FRsHAKDI6CkFAAAAALiGpBQAAAAA4BqSUgAAAACAa0hKAQAAAACuOWsvdHRWKOhiDxIXfCimgi7yJHGhpzPF5iZNC5zWdMvmCowEKB8FXeBP4iJ/AAB30VMKAAAAAHANPaUAHAX1FtJTCAAAgPJSbj2lxpguxpitxpjvjTEPl9d6AAAAAACnr3LpKTXG+El6UVJHST9LWm2M+dBam1oe6ytUQedVBl5WsXEAKHMBD39c4LS0MV0rMBJ3lGX7OacWAIBT25n8uV9ePaXRkr631v5grT0q6R1J3ctpXQAAAACA01R5JaWXSNqZ6/nPvjIAAAAAABzGWlv2lRpzk6Qu1tqBvud3SGphrR2aa57Bkgb7njaWtLXMAym6epJ+d3H9bqP9tP9sbf/Z3HaJ9tP+s7f9Z3PbJdpP+8/e9p/NbZfcb//l1tr6+U0or6vv/iLp0lzPG/jKHNbaKZKmlNP6i8UYk2Stbe52HG6h/bT/bG3/2dx2ifbT/rO3/Wdz2yXaT/vP3vafzW2XTu32l9fw3dWSGhljAo0xlSXdKunDcloXAAAAAOA0VS49pdbaLGPMUEmfS/KT9Ia1dlN5rAsAAAAAcPoqr+G7stZ+IumT8qq/jJ0Sw4hdRPvPbmdz+8/mtku0n/afvc7mtku0n/afvc7mtkuncPvL5UJHAAAAAAAURXmdUwoAAAAAwEmdcUmpMSbRd0uas8bZ2ObyYozJcDuGU5kxprkxZqLvcZwx5mq3YypvZ1KbjTEJxpgHjTFPGWM6+MpijDGbjDEpxphqxpjnfc+fdzvesnA2trkojDHflGTaSepMMMY8WPKoyk/u/V+O6+hvjLm4CPOd8p/Zxpj7jTHVcz3/xBhT24U4+EyuADnb2RgTYIy5LVe58/l3usRljFlsjDklry5b1oqyfXzvS//P9/huY0zfCozPWXdRlNs5pQDOPNbaJElJvqdxkjIklegL7OniTGyztfaJXE/7SPpfa+1bknMP6fOstcdcCa6cnI1tLoy19oQfV4wx51prs/Kbdjozxvgdt//LS39JGyX9WgHrKhVjjJH3FK7sAma5X9Jbkg5JkrX2ugoKDe4KkHSbpLelEz7/3BSgUzOuU0WAirB9rLWTKzas4jnte0qNMX2NMeuNMeuMMdN9xbHGmG+MMT/k/BppjPE3xnxpjFljjNlgjOnuKw8wxmw2xrzq+6V8gTGmmm9alK/uFN8v6Rt95X6+56t90+86W9tsjLnIGLPEN/9GY0xMRW6Lghy/jXxt/spX9qUx5jLffIHGmBW+7fP0cXWMzNXeJ91pScGK0cZEY8zLxpiVvuMjzhjzhu8YSMxVX4b5u8dooTEm2veL4w/GmG6+eeKMMfONMQGS7pY0wrfvK2S/n2ptNsb08h3364wxSypiGxSXMeZRY8x3xphlkhr7yhKNMTcZYwZKulnSv40xM4wxH0ryl5RsjLnFxbBLpTRtPhX3qTHmdmPMKt9x94rv/bgox25/Y8wHvvJtxpjRuerM+YU9zhiz1LcdUnNP8z0e5Xt/XGeMGeMrG+R7b1xnjJlrcvWolbJdLXyv5arGmBq+toX4YlxijPnYGLPVGDPZGHOOr45OxvsevsYY864xxt9XnmaMedYYs0ZSL5Ord9I37X99600yxkQaYz43xmw3xtydK74TPgNMAZ+fvrqbS5ph/u6Bf8K3/EZjzBRjjCnCNnnc18ZlxpiZxtvLf4Ux5jNjTLJvXzXxzZtojJlojvvsP0nsW40xb8qbPF9qvO+TSb625Mw3TNLFkhYZYxbl2mb1fI8f8LVpozHm/sK2S0mOiwK2S1l+n8nTe2O87+9xvscnbA9f+XXGmC2+fTDRGDPfV17DeD9bVhlj1ubEVdF822GL75j4znjf2zoYY5Yb72s/2hw3ksG3/wKOq2qMpBjfNhthfJ9/p2tchezPNGPMk7mOp5zXVH1jzBe++V8zxvxojKnna8fGXMs/aIxJ8D3O9/3QeF+3K331P23yvq/mvD43G2N+r6jtk7su4/1ceNZ37H5nfN/jjDHVjTGzjTGpxph5xphvja/n+bg23GR836eMMTf45ltrvJ9HF5xs3+TLWnva/kkKlvSdpHq+5+dJSpT0rrwJd5Ck733TzpX0D9/jepK+l2Tk/XUhS5LHN222pNt9jzdKauV7PEbSRt/jwZIe8z2uIu+vEYFnY5sl/VPSo75yP0k1T9Hj4iNJ/XzPB0h63/f4Q0l9fY+HSMrwPe4k7xXKjG+7zpcU63bbStjGREnv+NrSXdKfkkJ97UrOdRxYSdf6Hs+TtEBSJUnhklJ85XGS5vseJ0h68Gxus6QNki7xPa7t9nGRzzZr5ouxuqR/yPse8KBv+9yUa1vdlGuZDLfjdrPNp9o+ldTUd5xX8j1/SVLfIh67/SXtklRXUjV539+b526z7/g+qFyfYbmmXSvvqIDqvufn+f7XzTXv05Lu8z0u8ntCIe16WtJYSS9KeiRXjEckNZT3c+YLSTfJ+7m2RFIN33yjJD3he5wm6aFc68u9/9Mk3eN7PE7Sekk1JdWXtNtXnu9ngAr//Fycs31zby/f4+mSbsjv+Ms1T5SkFElVffFsk/fY/VJSI988LSR9laue/D77C4s9W1LL42P0bdfFksJybaN6ueZL823vnNdXDXl/zNkkKaKw7VLK4z/nWCzL7zP9Jf2/XOuYLymuoO3h2x875XuNSJqpvz8T/pNrfbXl/Yyq4cL7RM52yP0594b+/gx8Xyd+fm2UFJDP+8H8XPPkeX46xKVcr8P89meu4znnfeteSa/5Hv8//f2+00Xe99l6vnZszLWOByUl+B4X9H44X1Jv3+O7lf/3y0B5X5P9y2v7KNfxnrsu3/b4r+/xdZIW5mrbK77HIb79l+dzw/f4JkmJvsd1JOfiuQNz1eusuyh/p/vw3XaS3rXW/i5J1tq9xvtD5PvWOyQlNVe2biT9xxgTK+8BcImknGk7rLUpvsfJkgKM99yJmtbaFb7ytyVd73vcSVKY+ftXyVqSGknaUfZNPMGp1ubVkt4wxlTyxZBTp5vy20atJPXwTZ8u6Tnf49aSeuYqf9b3uJPvb63vub+87T0lek5UvDZK0kfWWmuM2SDvl64NkmSM2STvm22KpKOSPvPNv0HSX9baTN8yAeXbnCI5Fdu8XFKiMWa2pPdK0bbyEiNpnrX2kCQZb2/Yma60bT7V9ml7eROB1b73+mqSflPRj90vrLV7JMkY856kNjpxWNcqa21+n18dJE3N2ZbW2r2+8hDjHVlSW973xs/LsF1Pyfu5ckTSsONi/MHXjpm+dhyRNxlb7qujsqQVuZaZVcj6c46LDZL8rbUHJB0wxvzl+yws6DPgJ+Xz+VnAOtoaYx6S9weS8+RN4D4qJKbWkj6w1h6RdMQY85G8CdHVkt41f3e0Vsm1TH6f/YXF/qO1dmWu5W823uHr50q6SN7tub6QGNvI+/o6KDnHVIy827Oo26UkyvL7TGHy2x7nSPoh12tkprw/1Eve7dwtV09WVUmXSdpc7BaW3o7jPue+zPUZGCDvZ54b3IyrsOM75/09WX9/j2gjKV6SrLWfGWP+KMI6Cno/bCXpRt/jt+X9sU3K+/qsLG/S52etzXZh++TeBgG+x20kTZAka+1GY0xh7wc5GkiaZYy5SN42lSgfOt2T0oL8letxzrt4H3l/BW3m++BOk/fN4/j5j8n74VgYI+8vISX5IC4vrrXZ9yHRVd4vci9Ya98sQfxusvmUGXnPOXulooMpJzn7O1t59322/n4fyLS+n7Zyz+d7ozwd3yvKvc3W2ruNMS3kPf6TjTHNchIAnJ5OwX1qJE2z1j6Sp9CYB4t47B7//pbf+93BYsaUKOlGa+06Y0x/eX+VL66C2nWRvF/sKsn7eZUTW37tMPIm3b0LWEdh7TrZ+0O+nwG+YXMn/fw0xlSVt/e3ubV2p2+oX9Xj5yuCcyTts9Z6Cpie32d/YbEfzPU8UN5ekShr7R++oXgliTG/WIryvaI4yvL7TJbynr5WVSrx9jCSelprtxalEeXs+OM49zF+rgpo9+kelzHmc3l/oEiy1g7MVX6y/ZkTxzGdPB8qLMZEFe/90Hl9+l6T8621r/umVfR+K842kPK+D+eOY5KkF6y1HxrvUPiEkgRzup9T+pW854rUlSRjzHmFzFtL0m++N7O2ki4vrGJr7T55fzVt4Su6NdfkzyXd4+sdlDHmKmNMjRK2obhOqTYbYy6XtxfqVUmvSYosSaPKWH7b6Bv93Z4+kpb6Hi8/rjzH55IGmL/PT7rEGHN+eQdeDMVpY3k5IO8Qs4pyyrXZGHOFtfZb672ISrqkS8t5/cW1RNKNxnt+W01JN7gdUAUoVZtPwX36paSbct5/jDHn+d53i6qjb5lq8v5qv7wYy34h6U7z9zlSOZ83NSXt8n0e9Clo4ZMoqF2vSHpc0gz9PXJFkqKN9xoA50i6RdIySSsltTbGXOmro4Yx5qoSxnO8knwG5H5/yPnC9ruvjqJcbXe5pBuM95xaf3l79g5J2mGM6eWLwxhjwsso9n/Im6Tu9/WyXltAW3JbKu/rq7rve0+8yv99Vyrb7zNpkjzGmHOMMZdKivaVF7Q9tkpqaP4+jy/3+fafS7rP+LqxjTERJWhbRUmT7zuaMSZS3qGjx6voz3WplHFZaztbaz25E1Kfwo7vgiyX95oDMsZ0kndYqiTtlnS+MaauMaaK8va6F/R+uFJ/j8Q7/vu08/qUdO5J3lvSVLH7Lfc2CJJ36HWO3caYpr734fhc5bUk/eJ73K+kKz4dez8c1tpNxphnJH1tjDmmv4eq5GeGpI983eFJkrYUYRX/I+lVY0y2pK8l7feVvyZvN/ca3xtRuv7uoi9Xp2Cb4ySNNMZkyntV0gq71HRBCthG90maaowZKW/sd/pmHy7pbWPMKEkf5KpjgTGmqaQVvs+aDEm3yzu8zHXFbGN5+UjSHOO9sMN91tpy/WJyKrZZ3oseNZL3l88vJa0r5/UXi7V2jTFmlrxx/SbvsMgzWhm0+flTaZ9aa1ONMY9JWuD7IpAp7/nvRbVK0lx5h1e9Zb1XZSzquj8zxngkJRljjkr6RNK/5E0av5X3NfetSvBlqIB2fSDv6IW3jTF+kr4xxrSTt8dgtbzne10paZG8Q0izjbdnYqbvi6IkPSbveX2lUshnQGFXaE6UNNkYc1jeoXuvynv+1/+pCMehtXa18Q43Xy/vl+AN8n4G95H0sm97VZL3fPkCj8uixu7r2Vkr73eDncr7g8UUSZ8ZY3611rbNtcwa4+1xWuUres1au9aceOGVslaW32eWyzu8MFXeYbZrpIK3h7X2sDHmXnm3x0Hl3Zf/ljRe0nrfcbxDRRsm7Ia5kvoa7xDRb5X/62S9pGPGmHXyHs+Ffcc8peM6yfFdkCflfT+5Q95TAf5P0gHfjyFPyXvc/6K8x19B74f3S3rLGPOovKda7PfF5bw+5X09X+ZbpqDvlxW9316SNM0YkypvOzfp79fOw/KeK5su7+swJ7FOkPcUgz/k7UDIL3E+qZyTUpEPY4y/tTbnCoUPS7rIWjvc5bDK1dnYZgA4E/kStubW2qFux1Iaxjsc7EFr7an6Zb/M5HwGG2/v9BJJg621a9yO63RUlt9ncu0XI+9FuLZZa8eVYbg4Bfh+3Dpmrc0y3mtWvFzI0PmT1VVd0mHf+aG3ynvRo+5lGG658P0gWMlae8QYc4WkhZIaW2uPlve6T+ue0grQ1RjziLzb6Ud5ryJ1pjsb2wwAwKlgim/IXFV5z7klIS25svw+M8gY00/ei7islXeYOc48l0ma7ev1PippUCnqaibp//l+yNgn7x0CTgfV5b0dVCV5RwzdWxEJqURPKQAAAADARaf7hY4AAAAAAKcxklIAAAAAgGtISgEAAAAAriEpBQAAAAC4hqQUAAAAAOAaklIAAAAAgGv+P3LK6CQYZmdvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot.bar(rot=0, figsize=(16,9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a25861",
   "metadata": {},
   "source": [
    "## Titles of the papers with `commit` or `comits`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aef4b80",
   "metadata": {},
   "source": [
    "### `commit`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "id": "99c9aaee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empirical_Software_Engineering : Code and commit metrics of developer productivity: a study on team leaders perceptions.\n",
      "Empirical_Software_Engineering : Correlations between bugginess and time-based commit characteristics.\n"
     ]
    }
   ],
   "source": [
    "for journal in result.keys():\n",
    "    for item in result[journal]:\n",
    "        if len(item['matched_titles']['commit']) != 0:\n",
    "            for i in item['matched_titles']['commit']:\n",
    "                print(journal, \":\", i['title'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48fd8e6d",
   "metadata": {},
   "source": [
    "### `commits` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "id": "ba62a7e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IEEE_Transactions_on_Software_Engineering : Which Commits Can Be CI Skipped?\n",
      "Empirical_Software_Engineering : Revisiting the VCCFinder approach for the identification of vulnerability-contributing commits.\n",
      "Empirical_Software_Engineering : An approach and benchmark to detect behavioral changes of commits in continuous integration.\n",
      "Empirical_Software_Engineering : Characterizing and identifying reverted commits.\n"
     ]
    }
   ],
   "source": [
    "for journal in result.keys():\n",
    "    for item in result[journal]:\n",
    "        if len(item['matched_titles']['commits']) != 0:\n",
    "            for i in item['matched_titles']['commits']:\n",
    "                print(journal, \":\", i['title'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78159d26",
   "metadata": {},
   "source": [
    "## Titles of the papers with  `change`,  `code`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "725c3089",
   "metadata": {},
   "source": [
    "### both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "id": "6bbc3b88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 IEEE_Transactions_on_Software_Engineering : Reducing Features to Improve Code Change-Based Bug Prediction.\n",
      "1 IEEE_Transactions_on_Software_Engineering : Change Distilling: Tree Differencing for Fine-Grained Source Code Change Extraction.\n",
      "2 IEEE_Transactions_on_Software_Engineering : Predicting Source Code Changes by Mining Change History.\n",
      "3 IEEE_Transactions_on_Software_Engineering : Does Code Decay? Assessing the Evidence from Change Management Data.\n",
      "4 Empirical_Software_Engineering : Improving change prediction models with code smell-related information.\n",
      "5 Empirical_Software_Engineering : How does code readability change during software evolution?\n",
      "6 Empirical_Software_Engineering : Associating working memory capacity and code change ordering with code review performance.\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for journal in result.keys():\n",
    "    for item in result[journal]:\n",
    "        if len(item['matched_titles']['change']) != 0 and len(item['matched_titles']['code']) != 0:\n",
    "            for each in [i['title'] for i in item['matched_titles']['change']]:\n",
    "                if each in [i['title'] for i in item['matched_titles']['code']]:\n",
    "                    print(count, journal, \":\", each)\n",
    "                    count+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2f8ed5a",
   "metadata": {},
   "source": [
    "###  `change`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "id": "756c9dcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 IEEE_Transactions_on_Software_Engineering : How Well Do Change Sequences Predict Defects? Sequence Learning from Software Changes.\n",
      "1 IEEE_Transactions_on_Software_Engineering : Automating Change-Level Self-Admitted Technical Debt Determination.\n",
      "2 IEEE_Transactions_on_Software_Engineering : Supporting Change Impact Analysis Using a Recommendation System: An Industrial Case Study in a Safety-Critical Context.\n",
      "3 IEEE_Transactions_on_Software_Engineering : An Industrial Survey of Safety Evidence Change Impact Analysis Practice.\n",
      "4 IEEE_Transactions_on_Software_Engineering : The Impact of API Change- and Fault-Proneness on the User Ratings of Android Apps.\n",
      "5 IEEE_Transactions_on_Software_Engineering : Reducing Features to Improve Code Change-Based Bug Prediction.\n",
      "6 IEEE_Transactions_on_Software_Engineering : Examining the Potentially Confounding Effect of Class Size on the Associations between Object-Oriented Metrics and Change-Proneness.\n",
      "7 IEEE_Transactions_on_Software_Engineering : Visualizing Co-Change Information with the Evolution Radar.\n",
      "8 IEEE_Transactions_on_Software_Engineering : Asking and Answering Questions during a Programming Change Task.\n",
      "9 IEEE_Transactions_on_Software_Engineering : An Empirical Study on Views of Importance of Change Impact Analysis Issues.\n",
      "10 IEEE_Transactions_on_Software_Engineering : Change Distilling: Tree Differencing for Fine-Grained Source Code Change Extraction.\n",
      "11 IEEE_Transactions_on_Software_Engineering : Identifying Failure Causes in Java Programs: An Application of Change Impact Analysis.\n",
      "12 IEEE_Transactions_on_Software_Engineering : Predicting the Probability of Change in Object-Oriented Systems.\n",
      "13 IEEE_Transactions_on_Software_Engineering : Comparing High-Change Modules and Modules with the Highest Measurement Values in Two Large-Scale Open-Source Products.\n",
      "14 IEEE_Transactions_on_Software_Engineering : Predicting Source Code Changes by Mining Change History.\n",
      "15 IEEE_Transactions_on_Software_Engineering : SubCM: A Tool for Improved Visibility of Software Change in an Industrial Setting.\n",
      "16 IEEE_Transactions_on_Software_Engineering : Event-Based Traceability for Managing Evolutionary Change.\n",
      "17 IEEE_Transactions_on_Software_Engineering : Does Code Decay? Assessing the Evidence from Change Management Data.\n",
      "18 IEEE_Transactions_on_Software_Engineering : Predicting Fault Incidence Using Software Change History.\n",
      "19 IEEE_Transactions_on_Software_Engineering : A Formal Framework for On-line Software Version Change.\n",
      "20 IEEE_Transactions_on_Software_Engineering : Evaluating Software Design Processes by Analyzing Change Data Over Time.\n",
      "21 IEEE_Transactions_on_Software_Engineering : The Evolving Philosophers Problem: Dynamic Change Management.\n",
      "22 ACM_Transactions_on_Software_Engineering_and_Methodology : Software Change Contracts.\n",
      "23 Automated_Software_Engineering : Change impact analysis for maintenance and evolution of variable software systems.\n",
      "24 Automated_Software_Engineering : An effective change recommendation approach for supplementary bug fixes.\n",
      "25 Automated_Software_Engineering : An exploratory study for software change prediction in object-oriented systems using hybridized techniques.\n",
      "26 Automated_Software_Engineering : Editorial: Controlling change.\n",
      "27 Automated_Software_Engineering : Logic of Change: Semantics of Object Systems with Active Relations.\n",
      "28 Empirical_Software_Engineering : Investigating design anti-pattern and design pattern mutations and their change- and fault-proneness.\n",
      "29 Empirical_Software_Engineering : Improving change prediction models with code smell-related information.\n",
      "30 Empirical_Software_Engineering : The effectiveness of context-based change application on automatic program repair.\n",
      "31 Empirical_Software_Engineering : Boosting crash-inducing change localization with rank-performance-based feature subset selection.\n",
      "32 Empirical_Software_Engineering : How does code readability change during software evolution?\n",
      "33 Empirical_Software_Engineering : Associating working memory capacity and code change ordering with code review performance.\n",
      "34 Empirical_Software_Engineering : Automatic patch generation with context-based change application.\n",
      "35 Empirical_Software_Engineering : Aggregating Association Rules to Improve Change Recommendation.\n",
      "36 Empirical_Software_Engineering : An empirical study on the interplay between semantic coupling and co-change of software classes.\n",
      "37 Empirical_Software_Engineering : What are the effects of history length and age on mining software change impact?\n",
      "38 Empirical_Software_Engineering : Do Programmers do Change Impact Analysis in Debugging?\n",
      "39 Empirical_Software_Engineering : An initial analysis of software engineers' attitudes towards organizational change.\n",
      "40 Empirical_Software_Engineering : An empirical study for software change prediction using imbalanced data.\n",
      "41 Empirical_Software_Engineering : Change-based test selection: an empirical evaluation.\n",
      "42 Empirical_Software_Engineering : Green mining: a methodology of relating software change and configuration to power consumption.\n",
      "43 Empirical_Software_Engineering : The impact of imperfect change rules on framework API evolution identification: an empirical study.\n",
      "44 Empirical_Software_Engineering : Examination of the software architecture change characterization scheme using three empirical studies.\n",
      "45 Empirical_Software_Engineering : Integrating conceptual and logical couplings for change impact analysis in software.\n",
      "46 Empirical_Software_Engineering : The ability of object-oriented metrics to predict change-proneness: a meta-analysis.\n",
      "47 Empirical_Software_Engineering : An exploratory study of the impact of antipatterns on class change- and fault-proneness.\n",
      "48 Empirical_Software_Engineering : Time variance and defect prediction in software projects - Towards an exploitation of periods of stability and change as well as a notion of concept drift in software projects.\n",
      "49 Empirical_Software_Engineering : An empirical study on the influence of pattern roles on change-proneness.\n",
      "50 Empirical_Software_Engineering : Understanding cost drivers of software evolution: a quantitative and qualitative investigation of change effort in two evolving software systems.\n",
      "51 Empirical_Software_Engineering : Replaying development history to assess the effectiveness of change propagation tools.\n",
      "52 Empirical_Software_Engineering : Open-Source Change Logs.\n",
      "53 Empirical_Software_Engineering : Requirements-Based Estimation of Change Costs.\n",
      "54 Empirical_Software_Engineering : Qualitative Analysis of a Requirements Change Process.\n",
      "55 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Dynamical Channel Pruning by Conditional Accuracy Change for Deep Neural Networks.\n",
      "56 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Bipartite Differential Neural Network for Unsupervised Image Change Detection.\n",
      "57 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Change Detection in Graph Streams by Learning Graph Embeddings on Constant-Curvature Manifolds.\n",
      "58 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Local Restricted Convolutional Neural Network for Change Detection in Polarimetric SAR Images.\n",
      "59 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : A pdf-Free Change Detection Test Based on Density Difference Estimation.\n",
      "60 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : A Deep Convolutional Coupling Network for Change Detection Based on Heterogeneous Optical and Radar Images.\n",
      "61 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Hierarchical Change-Detection Tests.\n",
      "62 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Batch Mode Active Learning for Regression With Expected Model Change.\n",
      "63 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Change Detection in Synthetic Aperture Radar Images Based on Deep Neural Networks.\n",
      "64 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : PCA Feature Extraction for Change Detection in Multidimensional Unlabeled Data.\n",
      "65 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Editorial A Successful Change From TNN to TNNLS and a Very Successful Year.\n",
      "66 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Feature Extraction for Change-Point Detection Using Stationary Subspace Analysis.\n",
      "67 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : A Hopfield Neural Network for Image Change Detection.\n",
      "68 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Nonlinear dynamical factor analysis for state change detection.\n",
      "69 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Automatic change detection of driving environments in a vision-based driver assistance system.\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for journal in result.keys():\n",
    "    for item in result[journal]:\n",
    "        if len(item['matched_titles']['change']) != 0:\n",
    "            for each in [i['title'] for i in item['matched_titles']['change']]:\n",
    "                print(count, journal, \":\", each)\n",
    "                count+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2f07bdf",
   "metadata": {},
   "source": [
    "### `code`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "id": "041c6492",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 IEEE_Transactions_on_Software_Engineering : Beyond Technical Aspects: How Do Community Smells Influence the Intensity of Code Smells?\n",
      "1 IEEE_Transactions_on_Software_Engineering : Toxic Code Snippets on Stack Overflow.\n",
      "2 IEEE_Transactions_on_Software_Engineering : Automatically Assessing Code Understandability.\n",
      "3 IEEE_Transactions_on_Software_Engineering : Lightweight Assessment of Test-Case Effectiveness Using Source-Code-Quality Indicators.\n",
      "4 IEEE_Transactions_on_Software_Engineering : The Impact of Code Review on Architectural Changes.\n",
      "5 IEEE_Transactions_on_Software_Engineering : Erratum to \"Accurate and Scalable Cross-Architecture Cross-OS Binary Code Search With Emulation\".\n",
      "6 IEEE_Transactions_on_Software_Engineering : A Semantics-Based Hybrid Approach on Binary Code Similarity Comparison.\n",
      "7 IEEE_Transactions_on_Software_Engineering : Enriching API Documentation with Code Samples and Usage Scenarios from Crowd Knowledge.\n",
      "8 IEEE_Transactions_on_Software_Engineering : A Multi-Study Investigation into Dead Code.\n",
      "9 IEEE_Transactions_on_Software_Engineering : Leveraging Historical Associations between Requirements and Source Code to Identify Impacted Classes.\n",
      "10 IEEE_Transactions_on_Software_Engineering : Combining Code and Requirements Coverage with Execution Cost for Test Suite Reduction.\n",
      "11 IEEE_Transactions_on_Software_Engineering : Accurate and Scalable Cross-Architecture Cross-OS Binary Code Search with Emulation.\n",
      "12 IEEE_Transactions_on_Software_Engineering : Empirical Evaluation of the Impact of Object-Oriented Code Refactoring on Quality Attributes: A Systematic Literature Review.\n",
      "13 IEEE_Transactions_on_Software_Engineering : Measuring the Impact of Code Dependencies on Software Architecture Recovery Techniques.\n",
      "14 IEEE_Transactions_on_Software_Engineering : Specialising Software for Different Downstream Applications Using Genetic Improvement and Code Transplantation.\n",
      "15 IEEE_Transactions_on_Software_Engineering : On Accelerating Source Code Analysis at Massive Scale.\n",
      "16 IEEE_Transactions_on_Software_Engineering : Expanding Queries for Code Search Using Semantically Related API Class-names.\n",
      "17 IEEE_Transactions_on_Software_Engineering : Process Aspects and Social Dynamics of Contemporary Code Review: Insights from Open Source Development and Industrial Practice at Microsoft.\n",
      "18 IEEE_Transactions_on_Software_Engineering : When and Why Your Code Starts to Smell Bad (and Whether the Smells Go Away).\n",
      "19 IEEE_Transactions_on_Software_Engineering : Autofolding for Source Code Summarization.\n",
      "20 IEEE_Transactions_on_Software_Engineering : Semantics-Based Obfuscation-Resilient Binary Code Similarity Comparison with Applications to Software and Algorithm Plagiarism Detection.\n",
      "21 IEEE_Transactions_on_Software_Engineering : Automatic Source Code Summarization of Context for Java Methods.\n",
      "22 IEEE_Transactions_on_Software_Engineering : Using Reduced Execution Flow Graph to Identify Library Functions in Binary Code.\n",
      "23 IEEE_Transactions_on_Software_Engineering : Detecting, Tracing, and Monitoring Architectural Tactics in Code.\n",
      "24 IEEE_Transactions_on_Software_Engineering : Automatically Recommending Peer Reviewers in Modern Code Review.\n",
      "25 IEEE_Transactions_on_Software_Engineering : Dynamic and Automatic Feedback-Based Threshold Adaptation for Code Smell Detection.\n",
      "26 IEEE_Transactions_on_Software_Engineering : Enhanced Code Conversion Approach for the Integrated Cross-Platform Mobile Development (ICPMD).\n",
      "27 IEEE_Transactions_on_Software_Engineering : Instance Generator and Problem Representation to Improve Object Oriented Code Coverage.\n",
      "28 IEEE_Transactions_on_Software_Engineering : Mining Version Histories for Detecting Code Smells.\n",
      "29 IEEE_Transactions_on_Software_Engineering : An Eye-Tracking Study of Java Programmers and Application to Source Code Summarization.\n",
      "30 IEEE_Transactions_on_Software_Engineering : Synthesizing Multithreaded Code from Real-Time Object-Oriented Models via Schedulability-Aware Thread Derivation.\n",
      "31 IEEE_Transactions_on_Software_Engineering : Symbolic Crosschecking of Data-Parallel Floating-Point Code.\n",
      "32 IEEE_Transactions_on_Software_Engineering : Predicting Consistency-Maintenance Requirement of Code Clonesat Copy-and-Paste Time.\n",
      "33 IEEE_Transactions_on_Software_Engineering : A Cooperative Parallel Search-Based Software Engineering Approach for Code-Smells Detection.\n",
      "34 IEEE_Transactions_on_Software_Engineering : Test Code Quality and Its Relation to Issue Handling Performance.\n",
      "35 IEEE_Transactions_on_Software_Engineering : Identifying and Summarizing Systematic Code Changes via Rule Inference.\n",
      "36 IEEE_Transactions_on_Software_Engineering : Reducing Features to Improve Code Change-Based Bug Prediction.\n",
      "37 IEEE_Transactions_on_Software_Engineering : Quantifying the Effect of Code Smells on Maintenance Effort.\n",
      "38 IEEE_Transactions_on_Software_Engineering : Identifying Code of Individual Features in Client-Side Web Applications.\n",
      "39 IEEE_Transactions_on_Software_Engineering : Measuring Code Quality to Improve Specification Mining.\n",
      "40 IEEE_Transactions_on_Software_Engineering : Comparing the Defect Reduction Benefits of Code Inspection and Test-Driven Development.\n",
      "41 IEEE_Transactions_on_Software_Engineering : Palantír: Early Detection of Development Conflicts Arising from Parallel Code Changes.\n",
      "42 IEEE_Transactions_on_Software_Engineering : Exemplar: A Source Code Search Engine for Finding Highly Relevant Applications.\n",
      "43 IEEE_Transactions_on_Software_Engineering : Improving Source Code Lexicon via Traceability and Information Retrieval.\n",
      "44 IEEE_Transactions_on_Software_Engineering : Evaluating Complexity, Code Churn, and Developer Activity Metrics as Indicators of Software Vulnerabilities.\n",
      "45 IEEE_Transactions_on_Software_Engineering : DECOR: A Method for the Specification and Detection of Code and Design Smells.\n",
      "46 IEEE_Transactions_on_Software_Engineering : Learning a Metric for Code Readability.\n",
      "47 IEEE_Transactions_on_Software_Engineering : What Types of Defects Are Really Discovered in Code Reviews?\n",
      "48 IEEE_Transactions_on_Software_Engineering : The Impact of Design and Code Reviews on Software Quality: An Empirical Study Based on PSP Data.\n",
      "49 IEEE_Transactions_on_Software_Engineering : Data Mining Static Code Attributes to Learn Defect Predictors.\n",
      "50 IEEE_Transactions_on_Software_Engineering : Systematic Testing of Model-Based Code Generators.\n",
      "51 IEEE_Transactions_on_Software_Engineering : Comments on \"Data Mining Static Code Attributes to Learn Defect Predictors\".\n",
      "52 IEEE_Transactions_on_Software_Engineering : Problems with Precision: A Response to \"Comments on 'Data Mining Static Code Attributes to Learn Defect Predictors'\".\n",
      "53 IEEE_Transactions_on_Software_Engineering : Change Distilling: Tree Differencing for Fine-Grained Source Code Change Extraction.\n",
      "54 IEEE_Transactions_on_Software_Engineering : CP-Miner: Finding Copy-Paste and Related Bugs in Large-Scale Software Code.\n",
      "55 IEEE_Transactions_on_Software_Engineering : Using SCL to Specify and Check Design Intent in Source Code.\n",
      "56 IEEE_Transactions_on_Software_Engineering : Tool-Supported Refactoring of Existing Object-Oriented Code into Aspects.\n",
      "57 IEEE_Transactions_on_Software_Engineering : Using Origin Analysis to Detect Merging and Splitting of Source Code Entities.\n",
      "58 IEEE_Transactions_on_Software_Engineering : Automatic Mining of Source Code Repositories to Improve Bug Finding Techniques.\n",
      "59 IEEE_Transactions_on_Software_Engineering : Toward Understanding the Rhetoric of Small Source Code Changes.\n",
      "60 IEEE_Transactions_on_Software_Engineering : On the Use of Clone Detection for Identifying Crosscutting Concern Code.\n",
      "61 IEEE_Transactions_on_Software_Engineering : Using Software Architecture for Code Testing.\n",
      "62 IEEE_Transactions_on_Software_Engineering : Predicting Source Code Changes by Mining Change History.\n",
      "63 IEEE_Transactions_on_Software_Engineering : How Effective Developers Investigate Source Code: An Exploratory Study.\n",
      "64 IEEE_Transactions_on_Software_Engineering : Defect Frequency and Design Patterns: An Empirical Study of Industrial Code.\n",
      "65 IEEE_Transactions_on_Software_Engineering : Locating Features in Source Code.\n",
      "66 IEEE_Transactions_on_Software_Engineering : The Development and Evaluation of Three Diverse Techniques for Object-Oriented Code Inspection.\n",
      "67 IEEE_Transactions_on_Software_Engineering : Automatic Detection and Diagnosis of Faults in Generated Code for Procedure Calls.\n",
      "68 IEEE_Transactions_on_Software_Engineering : The Effectiveness of Control Structure Diagrams in Source Code Comprehension Activities.\n",
      "69 IEEE_Transactions_on_Software_Engineering : Corrections to \"The Effectiveness of Control Structure Diagrams in Source Code Comprehension Activities\".\n",
      "70 IEEE_Transactions_on_Software_Engineering : CCFinder: A Multilinguistic Token-Based Code Clone Detection System for Large Scale Source Code.\n",
      "71 IEEE_Transactions_on_Software_Engineering : Recovering Traceability Links between Code and Documentation.\n",
      "72 IEEE_Transactions_on_Software_Engineering : Does Code Decay? Assessing the Evidence from Change Management Data.\n",
      "73 IEEE_Transactions_on_Software_Engineering : An Internally Replicated Quasi-Experimental Comparison of Checklist and Perspective-Based Reading of Code Documents.\n",
      "74 IEEE_Transactions_on_Software_Engineering : Understanding Code Mobility.\n",
      "75 IEEE_Transactions_on_Software_Engineering : AC++ Data Model Supporting Reachability Analysis and Dead Code Detection.\n",
      "76 IEEE_Transactions_on_Software_Engineering : An Extensible System for Source Code Analysis.\n",
      "77 IEEE_Transactions_on_Software_Engineering : Representation Inheritance: A Safe Form of \"White Box'' Code Inheritance.\n",
      "78 IEEE_Transactions_on_Software_Engineering : An Experiment ot Assess the Cost-Benefits of Code Inspections in Large Scale Software Development.\n",
      "79 IEEE_Transactions_on_Software_Engineering : Compiling Real-Time Programs With Timing Constraint Refinement and Structural Code Motion.\n",
      "80 IEEE_Transactions_on_Software_Engineering : A Model of Code Sharing for Estimating Software Failure on Demand Probabilities.\n",
      "81 IEEE_Transactions_on_Software_Engineering : On \"A Framework for Source Code Search Using Program Patterns\".\n",
      "82 IEEE_Transactions_on_Software_Engineering : When to Stop Testing for Large Software Systems with Changing Code.\n",
      "83 IEEE_Transactions_on_Software_Engineering : A Framework for Source Code Search Using Program Patterns.\n",
      "84 IEEE_Transactions_on_Software_Engineering : Comments on \"Estimating the Number of Faults in Code\" and Two Corrections to Published Data.\n",
      "85 IEEE_Transactions_on_Software_Engineering : Comments on \"Number of Faults per Line of Code\".\n",
      "86 IEEE_Transactions_on_Software_Engineering : Synthesizing Code for Resource Controllers.\n",
      "87 IEEE_Transactions_on_Software_Engineering : Estimating the Number of Faults in Code.\n",
      "88 IEEE_Transactions_on_Software_Engineering : Software Engineering with Reusable Designs and Code.\n",
      "89 IEEE_Transactions_on_Software_Engineering : Software Function, Source Lines of Code, and Development Effort Prediction: A Software Science Validation.\n",
      "90 IEEE_Transactions_on_Software_Engineering : Code Optimization Considerations in List Processing Systems.\n",
      "91 IEEE_Transactions_on_Software_Engineering : Symbolic Gray Code as a Perfect Multiattribute Hashing Scheme for Partial Match Queries.\n",
      "92 IEEE_Transactions_on_Software_Engineering : Number of Faults per Line of Code.\n",
      "93 IEEE_Transactions_on_Software_Engineering : Correction to \"Information Flow Certification Using an Intermediate Code Programm Representation\".\n",
      "94 IEEE_Transactions_on_Software_Engineering : Information Flow Certification Using an Intermediate Code Program Representation.\n",
      "95 IEEE_Transactions_on_Software_Engineering : A New Strategy for Code Generation - the General-Purpose Optimizing Compiler.\n",
      "96 IEEE_Transactions_on_Software_Engineering : The Source Code Control System.\n",
      "97 ACM_Transactions_on_Software_Engineering_and_Methodology : Why My Code Summarization Model Does Not Work: Code Comment Improvement with Category Prediction.\n",
      "98 ACM_Transactions_on_Software_Engineering_and_Methodology : Automatically Generating SystemC Code from HCSP Formal Models.\n",
      "99 ACM_Transactions_on_Software_Engineering_and_Methodology : Is Static Analysis Able to Identify Unnecessary Source Code?\n",
      "100 ACM_Transactions_on_Software_Engineering_and_Methodology : A Defect Estimator for Source Code: Linking Defect Reports with Programming Constructs Usage Metrics.\n",
      "101 ACM_Transactions_on_Software_Engineering_and_Methodology : psc2code: Denoising Code Extraction from Programming Screencasts.\n",
      "102 ACM_Transactions_on_Software_Engineering_and_Methodology : Fine-grained Code Coverage Measurement in Automated Black-box Android Testing.\n",
      "103 ACM_Transactions_on_Software_Engineering_and_Methodology : Generating Question Titles for Stack Overflow from Mined Code Snippets.\n",
      "104 ACM_Transactions_on_Software_Engineering_and_Methodology : Using Relative Lines of Code to Guide Automated Test Generation for Python.\n",
      "105 ACM_Transactions_on_Software_Engineering_and_Methodology : Why Developers Refactor Source Code: A Mining-based Study.\n",
      "106 ACM_Transactions_on_Software_Engineering_and_Methodology : Modular Tree Network for Source Code Representation Learning.\n",
      "107 ACM_Transactions_on_Software_Engineering_and_Methodology : The Virtual Developer: Integrating Code Generation and Manual Development with Conflict Resolution.\n",
      "108 ACM_Transactions_on_Software_Engineering_and_Methodology : Fixing Faults in C and Java Source Code: Abbreviated vs. Full-Word Identifier Names.\n",
      "109 ACM_Transactions_on_Software_Engineering_and_Methodology : Intelligent Code Completion with Bayesian Networks.\n",
      "110 ACM_Transactions_on_Software_Engineering_and_Methodology : Boa: Ultra-Large-Scale Software Repository and Source-Code Mining.\n",
      "111 ACM_Transactions_on_Software_Engineering_and_Methodology : Estimating Semantic Relatedness in Source Code.\n",
      "112 ACM_Transactions_on_Software_Engineering_and_Methodology : Multi-Criteria Code Refactoring Using Search-Based Software Engineering: An Industrial Case Study.\n",
      "113 ACM_Transactions_on_Software_Engineering_and_Methodology : Code-Smell Detection as a Bilevel Problem.\n",
      "114 ACM_Transactions_on_Software_Engineering_and_Methodology : Documenting Design-Pattern Instances: A Family of Experiments on Source-Code Comprehensibility.\n",
      "115 ACM_Transactions_on_Software_Engineering_and_Methodology : On the impact of UML analysis models on source-code comprehensibility and modifiability.\n",
      "116 ACM_Transactions_on_Software_Engineering_and_Methodology : Degree-of-knowledge: Modeling a developer's knowledge of code.\n",
      "117 ACM_Transactions_on_Software_Engineering_and_Methodology : Solving the Search for Source Code.\n",
      "118 ACM_Transactions_on_Software_Engineering_and_Methodology : Amplifying Tests to Validate Exception Handling Code: An Extended Study in the Mobile Application Domain.\n",
      "119 ACM_Transactions_on_Software_Engineering_and_Methodology : Some Code Smells Have a Significant but Small Effect on Faults.\n",
      "120 ACM_Transactions_on_Software_Engineering_and_Methodology : Portfolio: Searching for relevant functions and their usages in millions of lines of code.\n",
      "121 ACM_Transactions_on_Software_Engineering_and_Methodology : How Well Do Search Engines Support Code Retrieval on the Web?\n",
      "122 ACM_Transactions_on_Software_Engineering_and_Methodology : Clone region descriptors: Representing and tracking duplication in source code.\n",
      "123 ACM_Transactions_on_Software_Engineering_and_Methodology : Representing concerns in source code.\n",
      "124 ACM_Transactions_on_Software_Engineering_and_Methodology : Reasoning about code mobility with mobile UNITY.\n",
      "125 ACM_Transactions_on_Software_Engineering_and_Methodology : GENOA - A Customizable, Front-end-Retargetable Source Code Analysis Framework.\n",
      "126 Automated_Software_Engineering : Prioritizing refactorings for security-critical code.\n",
      "127 Automated_Software_Engineering : Multi-objective code reviewer recommendations: balancing expertise, availability and collaborations.\n",
      "128 Automated_Software_Engineering : Enhance code search via reformulating queries with evolving contexts.\n",
      "129 Automated_Software_Engineering : DCTracVis: a system retrieving and visualizing traceability links between source code and documentation.\n",
      "130 Automated_Software_Engineering : How verified (or tested) is my code? Falsification-driven verification and testing.\n",
      "131 Automated_Software_Engineering : From requirements to source code: a Model-Driven Engineering approach for RESTful web services.\n",
      "132 Automated_Software_Engineering : AutoQuery: automatic construction of dependency queries for code search.\n",
      "133 Automated_Software_Engineering : An approach to prioritize code smells for refactoring.\n",
      "134 Automated_Software_Engineering : Monitoring energy hotspots in software - Energy profiling of software code.\n",
      "135 Automated_Software_Engineering : Automated verification of code automatically generated from Simulink®.\n",
      "136 Automated_Software_Engineering : Code completion of multiple keywords from abbreviated input.\n",
      "137 Automated_Software_Engineering : Improving code completion with program history.\n",
      "138 Automated_Software_Engineering : Defect prediction from static code features: current results, limitations, new approaches.\n",
      "139 Automated_Software_Engineering : Fast extraction of high-quality framework-specific models from application code.\n",
      "140 Automated_Software_Engineering : Editorial for Special Issue of JASE on Source Code Analysis and Manipulation.\n",
      "141 Automated_Software_Engineering : Model driven code checking.\n",
      "142 Automated_Software_Engineering : Inferring specifications to detect errors in code.\n",
      "143 Automated_Software_Engineering : Interactive and Probabilistic Proof of Mobile Code Safety.\n",
      "144 Automated_Software_Engineering : Web Application Slicing in Presence of Dynamic Code Generation.\n",
      "145 Automated_Software_Engineering : CODEWEAVE: Exploring Fine-Grained Mobility of Code.\n",
      "146 Automated_Software_Engineering : XMILE: An XML Based Approach for Incremental Code Mobility and Update.\n",
      "147 Automated_Software_Engineering : A Concept Formation Based Approach to Object Identification in Procedural Code.\n",
      "148 Automated_Software_Engineering : Understanding Interleaved Code.\n",
      "149 Automated_Software_Engineering : Extracting Architectural Features from Source Code.\n",
      "150 Empirical_Software_Engineering : An exploratory study on confusion in code reviews.\n",
      "151 Empirical_Software_Engineering : World of code: enabling a research workflow for mining and analyzing the universe of open source VCS data.\n",
      "152 Empirical_Software_Engineering : Learning to recognize actionable static code warnings (is intrinsically easy).\n",
      "153 Empirical_Software_Engineering : Embedding API dependency graph for neural code generation.\n",
      "154 Empirical_Software_Engineering : On using Stack Overflow comment-edit pairs to recommend code maintenance changes.\n",
      "155 Empirical_Software_Engineering : Evaluating the robustness of source code plagiarism detection tools to pervasive plagiarism-hiding modifications.\n",
      "156 Empirical_Software_Engineering : Empirical assessment of the effort needed to attack programs protected with client/server code splitting.\n",
      "157 Empirical_Software_Engineering : Improving change prediction models with code smell-related information.\n",
      "158 Empirical_Software_Engineering : Recognizing lines of code violating company-specific coding guidelines using machine learning.\n",
      "159 Empirical_Software_Engineering : You broke my code: understanding the motivations for breaking changes in APIs.\n",
      "160 Empirical_Software_Engineering : Code Localization in Programming Screencasts.\n",
      "161 Empirical_Software_Engineering : Deep code comment generation with hybrid lexical and syntactical information.\n",
      "162 Empirical_Software_Engineering : Code and commit metrics of developer productivity: a study on team leaders perceptions.\n",
      "163 Empirical_Software_Engineering : Software provenance tracking at the scale of public source code.\n",
      "164 Empirical_Software_Engineering : Do code review measures explain the incidence of post-release defects?\n",
      "165 Empirical_Software_Engineering : The 'as code' activities: development anti-patterns for infrastructure as code.\n",
      "166 Empirical_Software_Engineering : Interaction-based creation and maintenance of continuously usable trace links between requirements and source code.\n",
      "167 Empirical_Software_Engineering : Code cloning in smart contracts: a case study on verified contracts from the Ethereum blockchain platform.\n",
      "168 Empirical_Software_Engineering : Mining understandable state machine models from embedded code.\n",
      "169 Empirical_Software_Engineering : An Empirical Investigation of Relevant Changes and Automation Needs in Modern Code Review.\n",
      "170 Empirical_Software_Engineering : A feature location approach for mapping application features extracted from crowd-based screencasts to source code.\n",
      "171 Empirical_Software_Engineering : How does code readability change during software evolution?\n",
      "172 Empirical_Software_Engineering : Programmers do not favor lambda expressions for concurrent object-oriented code.\n",
      "173 Empirical_Software_Engineering : Syntax, predicates, idioms - what really affects code complexity?\n",
      "174 Empirical_Software_Engineering : Querying distilled code changes to extract executable transformations.\n",
      "175 Empirical_Software_Engineering : How do developers utilize source code from stack overflow?\n",
      "176 Empirical_Software_Engineering : The impact of human factors on the participation decision of reviewers in modern code review.\n",
      "177 Empirical_Software_Engineering : Usage and attribution of Stack Overflow code snippets in GitHub projects.\n",
      "178 Empirical_Software_Engineering : Experimenting with information retrieval methods in the recovery of feature-code SPL traces.\n",
      "179 Empirical_Software_Engineering : Commenting source code: is it worth it for small programming tasks?\n",
      "180 Empirical_Software_Engineering : Classifying code comments in Java software systems.\n",
      "181 Empirical_Software_Engineering : Cross-project code clones in GitHub.\n",
      "182 Empirical_Software_Engineering : An investigation of misunderstanding code patterns in C open-source software projects.\n",
      "183 Empirical_Software_Engineering : Associating working memory capacity and code change ordering with code review performance.\n",
      "184 Empirical_Software_Engineering : Automatic query reformulation for code search using crowdsourced knowledge.\n",
      "185 Empirical_Software_Engineering : Siamese: scalable and incremental code clone search via multiple code representations.\n",
      "186 Empirical_Software_Engineering : Extracting and studying the Logging-Code-Issue- Introducing changes in Java-based large-scale open source software systems.\n",
      "187 Empirical_Software_Engineering : Effects of measurements on correlations of software code metrics.\n",
      "188 Empirical_Software_Engineering : Editor's Note: Special Section on Source Code Analysis and Manipulation.\n",
      "189 Empirical_Software_Engineering : Security code smells in Android ICC.\n",
      "190 Empirical_Software_Engineering : Scripted GUI testing of Android open-source apps: evolution of test code and fragility causes.\n",
      "191 Empirical_Software_Engineering : An empirical catalog of code smells for the presentation layer of Android apps.\n",
      "192 Empirical_Software_Engineering : How does code style inconsistency affect pull request integration? An exploratory study on 117 GitHub projects.\n",
      "193 Empirical_Software_Engineering : Is cloned code really stable?\n",
      "194 Empirical_Software_Engineering : On the diffuseness and the impact on maintainability of code smells: a large scale empirical investigation.\n",
      "195 Empirical_Software_Engineering : A multi-view context-aware approach to Android malware detection and malicious code localization.\n",
      "196 Empirical_Software_Engineering : Persistent code contribution: a ranking algorithm for code contribution in crowdsourced software.\n",
      "197 Empirical_Software_Engineering : Code smells for Model-View-Controller architectures.\n",
      "198 Empirical_Software_Engineering : Evolving software trace links between requirements and source code.\n",
      "199 Empirical_Software_Engineering : Introduction to the special issue on source code analysis and manipulation.\n",
      "200 Empirical_Software_Engineering : A comparison of code similarity analysers.\n",
      "201 Empirical_Software_Engineering : Augmenting and structuring user queries to support efficient free-form code search.\n",
      "202 Empirical_Software_Engineering : Do software models based on the UML aid in source-code comprehensibility? Aggregating evidence from 12 controlled experiments.\n",
      "203 Empirical_Software_Engineering : Early prediction of merged code changes to prioritize reviewing tasks.\n",
      "204 Empirical_Software_Engineering : Learning to rank code examples for code search engines.\n",
      "205 Empirical_Software_Engineering : Review participation in modern code review - An empirical study of the android, Qt, and OpenStack projects.\n",
      "206 Empirical_Software_Engineering : How programmers read regular code: a controlled experiment using eye tracking.\n",
      "207 Empirical_Software_Engineering : Multi-objective reverse engineering of variability-safe feature models based on code dependencies of system variants.\n",
      "208 Empirical_Software_Engineering : Semantic topic models for source code analysis.\n",
      "209 Empirical_Software_Engineering : Empirical evaluation of the effects of experience on code quality and programmer productivity: an exploratory study.\n",
      "210 Empirical_Software_Engineering : Evaluating code complexity triggers, use of complexity measures and the influence of code complexity on maintenance time.\n",
      "211 Empirical_Software_Engineering : An empirical study of the textual similarity between source code and source code summaries.\n",
      "212 Empirical_Software_Engineering : Does the level of detail of UML diagrams affect the maintainability of source code?: a family of experiments.\n",
      "213 Empirical_Software_Engineering : The impact of tangled code changes on defect prediction models.\n",
      "214 Empirical_Software_Engineering : Development nature matters: An empirical study of code clones in JavaScript applications.\n",
      "215 Empirical_Software_Engineering : Automatic identifier inconsistency detection using code dictionary.\n",
      "216 Empirical_Software_Engineering : A field study of how developers locate features in source code.\n",
      "217 Empirical_Software_Engineering : Investigating technical and non-technical factors influencing modern code review.\n",
      "218 Empirical_Software_Engineering : Comparing and experimenting machine learning techniques for code smell detection.\n",
      "219 Empirical_Software_Engineering : Code clones and developer behavior: results of two surveys of the clone research community.\n",
      "220 Empirical_Software_Engineering : An empirical study of the impact of modern code review practices on software quality.\n",
      "221 Empirical_Software_Engineering : Studying the relationship between logging characteristics and the code quality of platform software.\n",
      "222 Empirical_Software_Engineering : An empirical study on the importance of source code entities for requirements traceability.\n",
      "223 Empirical_Software_Engineering : Detecting and refactoring code smells in spreadsheet formulas.\n",
      "224 Empirical_Software_Engineering : Classification model for code clones based on machine learning.\n",
      "225 Empirical_Software_Engineering : A large study on the effect of code obfuscation on the quality of java code.\n",
      "226 Empirical_Software_Engineering : A family of experiments to assess the effectiveness and efficiency of source code obfuscation techniques.\n",
      "227 Empirical_Software_Engineering : Assessing the capability of code smells to explain maintenance problems: an empirical study combining quantitative and qualitative data.\n",
      "228 Empirical_Software_Engineering : Labeling source code with information retrieval methods: an empirical study.\n",
      "229 Empirical_Software_Engineering : An experimental investigation on the effects of context on source code identifiers splitting and expansion.\n",
      "230 Empirical_Software_Engineering : Empirical study on the maintainability of Web applications: Model-driven Engineering vs Code-centric.\n",
      "231 Empirical_Software_Engineering : Analyzing and mining a code search engine usage log.\n",
      "232 Empirical_Software_Engineering : Refining code ownership with synchronous changes.\n",
      "233 Empirical_Software_Engineering : Studying the co-evolution of production and test code in open source and industrial developer test processes through repository mining.\n",
      "234 Empirical_Software_Engineering : An empirical study on the maintenance of source code clones.\n",
      "235 Empirical_Software_Engineering : An information retrieval process to aid in the analysis of code clones.\n",
      "236 Empirical_Software_Engineering : Experimental evaluation of a tool for the verification and transformation of source code in event-driven systems.\n",
      "237 Empirical_Software_Engineering : Subjective evaluation of software evolvability using code smells: An empirical study.\n",
      "238 Empirical_Software_Engineering : The Use of Procedural Roles in Code Inspections: An Experimental Study.\n",
      "239 Empirical_Software_Engineering : Software Evolution and the Code Fault Introduction Process.\n",
      "240 Empirical_Software_Engineering : An Experimental Evaluation of an Experience-Based Capture-Recapture Method in Software Code Inspections.\n",
      "241 Empirical_Software_Engineering : Comparing ada and FORTRAN lines of code: Some experimental results.\n",
      "242 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Sequential Compact Code Learning for Unsupervised Image Hashing.\n",
      "243 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : A gradual neural-network algorithm for jointly time-slot/code assignment problems in packet radio networks.\n",
      "244 IEEE_Transactions_on_Neural_Networks_and_Learning_Systems : Code vector density in topographic mappings: Scalar case.\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for journal in result.keys():\n",
    "    for item in result[journal]:\n",
    "        if len(item['matched_titles']['code']) != 0:\n",
    "            for each in [i['title'] for i in item['matched_titles']['code']]:\n",
    "                print(count, journal, \":\", each)\n",
    "                count+=1"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:titles2bibtex]",
   "language": "python",
   "name": "conda-env-titles2bibtex-py"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}