notebooks/RQs_Reproduce_Analysis_Results_LintQ.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RQs - LintQ - Analyzing Quantum Programs\n",
    "This notebook contains the results of the analysis of quantum programs with the LintQ analyses.\n",
    "The research questions and the main claims of the paper can be reproduced by running this code.\n",
    "\n",
    "\n",
    "Note that this notebook produces also the latex macro used in the main paper for the most important statistics used in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import project_path\n",
    "from rdlib import *  # this imports the base libraries\n",
    "\n",
    "import glob\n",
    "from typing import Dict, List\n",
    "import re\n",
    "import yaml\n",
    "import json\n",
    "from tqdm import tqdm\n",
    "from sarif import loader\n",
    "import shutil\n",
    "import random\n",
    "\n",
    "from IPython.display import display\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "# DATASET and ANALYSIS RUN\n",
    "LINTQ_ANALYSIS_RUN_FOLDER = \"../data/analysis_results/exp_v08/codeql_2024-03-01_08-43-53\"\n",
    "LINTQ_DATASET_FILES = \"../data/datasets/exp_v08/files_selected\"\n",
    "PATH_LINTQ_SARIF = os.path.join(LINTQ_ANALYSIS_RUN_FOLDER, \"data.sarif\")\n",
    "LOG_FILE_QUERIES = os.path.join(LINTQ_ANALYSIS_RUN_FOLDER, '_log_with_compile.txt')\n",
    "LOG_FILE_DB_CREATION = '../data/datasets/exp_v08/log_codeql.txt'\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "# ANNOTATIONS\n",
    "ANNOTATION_FOLDER = \"../bug_reports/\"\n",
    "PATH_LINTQ_ANNOTATION = os.path.join(\n",
    "    ANNOTATION_FOLDER, \"Inspection_LintQ_on_LintQ_dataset.csv\")\n",
    "PATH_REAL_BUGS = \"../bug_reports/Bug_reports_feedback_summary.csv\"\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "# LINTQ CORE\n",
    "\n",
    "# Abstraction\n",
    "DETECTORS_FOLDER = '../qlint/codeql/src'\n",
    "ABSTRACTION_FOLDER = '../qlint/codeql/lib/qiskit'\n",
    "# Abstractions to consider\n",
    "ABSTRACTIONS = [\n",
    "    \"QuantumCircuit\",\n",
    "    \"RegisterV2\",\n",
    "    \"QuantumRegisterV2\",\n",
    "    \"ClassicalRegisterV2\",\n",
    "    \"QubitUse\",\n",
    "    \"QuantumOperator\",\n",
    "    \"Measurement\",\n",
    "    \"Subcircuit\",\n",
    "    \"ComposeCall\",\n",
    "    \"TranspileCall\"\n",
    "]\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "# IMAGES\n",
    "OUTPUT_FOLDER = \"paper_artifacts\"\n",
    "\n",
    "# PRESENTATION PARAMETERS\n",
    "LINTQ_CHECKER_TERM = \"Analysis\"\n",
    "# Set color scheme\n",
    "import matplotlib.colors as mcolors\n",
    "THEME_COLOR_LIGHT_HEX = '#FF5733'\n",
    "THEME_COLOR_FULL_HEX = '#33FF57'\n",
    "THEME_COLOR_ACCENT_HEX = '#3366FF'\n",
    "THEME_COLOR_LIGHT_RGB = mcolors.hex2color(THEME_COLOR_LIGHT_HEX)\n",
    "THEME_COLOR_FULL_RGB = mcolors.hex2color(THEME_COLOR_FULL_HEX)\n",
    "THEME_COLOR_ACCENT_RGB = mcolors.hex2color(THEME_COLOR_ACCENT_HEX)\n",
    "\n",
    "# RULES\n",
    "NAME_MAPPING = {\n",
    "    # measurement\n",
    "    # ---\n",
    "    'ql-double-measurement': 'DoubleMeas',\n",
    "    'DoubleMeasurement.ql': 'DoubleMeas',\n",
    "    # ---\n",
    "    'ql-operation-after-measurement': 'OpAfterMeas',\n",
    "    'OpAfterMeasurement.ql': 'OpAfterMeas',\n",
    "    # ---\n",
    "    'ql-measure-all-abuse': 'MeasAllAbuse',\n",
    "    'MeasureAll.ql': 'MeasAllAbuse',\n",
    "    # ---\n",
    "    'ql-constant-classic-bit': 'ConstClasBit',\n",
    "    'ConstantClassicBit.ql': 'ConstClasBit',\n",
    "    # ---\n",
    "    'ql-conditional-without-measurement': 'CondWoMeas',\n",
    "    'ConditionalGateWithoutMeas.ql': 'CondWoMeas',\n",
    "\n",
    "    # resources\n",
    "    # ---\n",
    "    'ql-unmeasurable-qubits': 'InsuffClasReg',\n",
    "    'UnmeasurableQubits.ql': 'InsuffClasReg',\n",
    "    # ---\n",
    "    'ql-oversized-circuit': 'OversizedCircuit',\n",
    "    'OversizedCircuit.ql': 'OversizedCircuit',\n",
    "    # # ---\n",
    "\n",
    "    # api constraints\n",
    "    # ---\n",
    "    'ql-op-after-optimization': 'OpAfterTransp',\n",
    "    'OpAfterOptimization.ql': 'OpAfterTransp',\n",
    "    # ---\n",
    "    'ql-ghost-composition': 'GhostCompose',\n",
    "    'GhostComposition.ql': 'GhostCompose',\n",
    "    # ---\n",
    "    'ql-deprecated-identity': 'OldIdenGate',\n",
    "    'DeprecatedIdentity.ql': 'OldIdenGate',\n",
    "\n",
    "}\n",
    "\n",
    "RULE_NAME_MAPPING = {\n",
    "    k: v for k, v in NAME_MAPPING.items() if k.startswith('ql-')\n",
    "}\n",
    "FILE_NAME_RULE_MAPPING = {\n",
    "    k: v for k, v in NAME_MAPPING.items() if k.endswith('.ql')\n",
    "}\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "# SAMPLING\n",
    "SAMPLE_AGAIN = False\n",
    "FIXED_SAMPLE_SIZE = 10\n",
    "CONFIDENCE_LEVEL = .90\n",
    "MARGIN_ERROR = .10\n",
    "RND_SEED = 42\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper Functions\n",
    "\n",
    "def get_results_from_sarif_path(sarif_path: str) -> Dict[str, Any]:\n",
    "    \"\"\"Extract the results from the sarif file as json.\"\"\"\n",
    "    with open(sarif_path, \"r\") as f:\n",
    "        sarif_data = json.load(f)\n",
    "    all_results = []\n",
    "    n_runs = len(sarif_data['runs'])\n",
    "    for i in range(n_runs):\n",
    "        sarif_results = sarif_data[\"runs\"][i][\"results\"]\n",
    "        all_results.extend(sarif_results)\n",
    "    return all_results\n",
    "\n",
    "\n",
    "def get_df_from_sarif(sarif_results: List[Dict[str, Any]]):\n",
    "    \"\"\"Create a dataset from sarif results.\"\"\"\n",
    "    def process(record: Dict[str, Any]):\n",
    "        \"\"\"Parse some key info from the record.\"\"\"\n",
    "        region = record[\"locations\"][0][\"physicalLocation\"].get(\"region\", None)\n",
    "        line, col = None, None\n",
    "        if region:\n",
    "            line = region.get(\"startLine\", None)\n",
    "            col = region.get(\"startColumn\", None)\n",
    "        return {\n",
    "            \"rule_id\": record[\"ruleId\"],\n",
    "            \"message\": record[\"message\"][\"text\"],\n",
    "            \"file\": record[\"locations\"][0][\"physicalLocation\"][\"artifactLocation\"][\"uri\"],\n",
    "            \"line\": line,\n",
    "            \"col\": col,\n",
    "        }\n",
    "\n",
    "    processed_results = [\n",
    "        process(result)\n",
    "        for result in sarif_results\n",
    "    ]\n",
    "\n",
    "    df_results = pd.DataFrame.from_records(processed_results)\n",
    "    return df_results\n",
    "\n",
    "\n",
    "def compute_representative_sample_size(\n",
    "        population_size, margin_error=.05,confidence_level=.95,sigma=1/2):\n",
    "    \"\"\"Calculate sample size for a representative sample of the population.\n",
    "\n",
    "    Credits: https://github.com/shawnohare/samplesize/blob/master/samplesize.py\n",
    "    \"\"\"\n",
    "\n",
    "    alpha = 1 - (confidence_level)\n",
    "    zdict = {\n",
    "        .90: 1.645,\n",
    "        .91: 1.695,\n",
    "        .99: 2.576,\n",
    "        .97: 2.17,\n",
    "        .94: 1.881,\n",
    "        .93: 1.812,\n",
    "        .95: 1.96,\n",
    "        .98: 2.326,\n",
    "        .96: 2.054,\n",
    "        .92: 1.751\n",
    "    }\n",
    "    if confidence_level in zdict:\n",
    "        z = zdict[confidence_level]\n",
    "    else:\n",
    "        from scipy.stats import norm\n",
    "        z = norm.ppf(1 - (alpha/2))\n",
    "    N = population_size\n",
    "    M = margin_error\n",
    "    numerator = z**2 * sigma**2 * (N / (N-1))\n",
    "    denom = M**2 + ((z**2 * sigma**2)/(N-1))\n",
    "    return int(numerator/denom + 0.5)\n",
    "\n",
    "res = compute_representative_sample_size(10000, margin_error=.05,confidence_level=.95,sigma=1/2)\n",
    "assert res == 370\n",
    "\n",
    "def get_file_extension_dictionary(dir: str) -> dict:\n",
    "    \"\"\"Get a dictionary {filename: its extension, etc.} form a directory.\"\"\"\n",
    "    file_extensions = {}\n",
    "    for file in os.listdir(dir):\n",
    "        base_name = os.path.splitext(file)[0]\n",
    "        extension = os.path.splitext(file)[1]\n",
    "        file_extensions[base_name] = extension\n",
    "    return file_extensions\n",
    "\n",
    "\n",
    "def count_files(folder: str, allowed_formats: List[str] = [\".py\", \"ipynb\"]):\n",
    "    \"\"\"Count how many files with the given extension are in the target folder.\"\"\"\n",
    "    files_extension = get_file_extension_dictionary(folder)\n",
    "    return sum([\n",
    "        1\n",
    "        for file, extension in files_extension.items()\n",
    "        if extension in allowed_formats\n",
    "    ])\n",
    "\n",
    "\n",
    "def compute_warnings_table(\n",
    "        df_results: pd.DataFrame,\n",
    "        rule_name_mapping: Dict[str, str],\n",
    "        total_files_in_dataset: int,\n",
    "        rule_term: str):\n",
    "    \"\"\"Compute the table in latex with number and percentage of warnings.\"\"\"\n",
    "    # compute: total sum of warnings\n",
    "    df_abs = df_results.copy()\n",
    "    df_abs = df_abs[[\"rule_id\", \"file\"]]\n",
    "    df_abs = df_abs.groupby(\"rule_id\").count()\n",
    "    df_abs = df_abs.reset_index(drop=False)\n",
    "    df_abs = df_abs.rename(columns={\"file\": \"tot_warnings\"})\n",
    "\n",
    "    # compute: files affected\n",
    "    df = df_results.copy()\n",
    "    df = df[[\"rule_id\", \"file\"]]\n",
    "    df = df.drop_duplicates()  # << difference\n",
    "    df = df.groupby(\"rule_id\").count()\n",
    "    df = df.reset_index(drop=False)\n",
    "    df = df.rename(columns={\"file\": \"n_files_affected\"})\n",
    "\n",
    "    df = df.merge(df_abs, on=\"rule_id\", how=\"left\")\n",
    "    if rule_name_mapping is not None:\n",
    "        # add all the rules that are not in the dataframe with 0 warnings\n",
    "        for rule in list(rule_name_mapping.keys()):\n",
    "            if rule not in df['rule_id'].unique():\n",
    "                print(f\"WARN: no warnings for rule {rule}. Adding a 0 value.\")\n",
    "                df = pd.concat([df, pd.DataFrame([{\n",
    "                    'rule_id': rule,\n",
    "                    'tot_warnings': 0,\n",
    "                    'n_files_affected': 0}])], ignore_index=True)\n",
    "        # keep only rules that are in the mapping\n",
    "        rules_not_in_mapping = \\\n",
    "            set(df['rule_id'].unique()) - set(rule_name_mapping.keys())\n",
    "        if len(rules_not_in_mapping) > 0:\n",
    "            print(\"WARN: some rules are not in the mapping. Discarding them.\")\n",
    "            print(rules_not_in_mapping)\n",
    "            df = df[df['rule_id'].isin(rule_name_mapping.keys())]\n",
    "        # rename column rules with mapping\n",
    "        df['rule_id'] = df['rule_id'].apply(\n",
    "            lambda e: rule_name_mapping[e]\n",
    "            if e in rule_name_mapping.keys() else e)\n",
    "\n",
    "    # rename column\n",
    "    df['perc_of_affected_files'] = df['n_files_affected'].apply(\n",
    "        lambda e: (int(e) / total_files_in_dataset) * 100)\n",
    "\n",
    "    # compute the sample size\n",
    "\n",
    "\n",
    "    # compute average and median of the perc_of_affected_files\n",
    "    avg = df['perc_of_affected_files'].mean()\n",
    "    median = df['perc_of_affected_files'].median()\n",
    "    print(\"\\\\newcommand{\\\\avgWarningsPerc}{\" + f\"{avg:.2f}\" + \"\\\\%}\")\n",
    "    print(\"\\\\newcommand{\\\\medianWarningsPerc}{\" + f\"{median:.2f}\" + \"\\\\%}\")\n",
    "\n",
    "    # format as a percentage\n",
    "    df['perc_of_affected_files'] = df['perc_of_affected_files'].apply(\n",
    "        lambda e: \"{:.2f}%\".format(e))\n",
    "    if rule_name_mapping is not None:\n",
    "        # sort by canonical order\n",
    "        categories = [cat for cat in rule_name_mapping.values()]\n",
    "        df['rule_id'] = pd.Categorical(\n",
    "            df['rule_id'], categories=categories)\n",
    "        df = df.sort_values('rule_id')\n",
    "\n",
    "    # cosmetic renaming\n",
    "    mapping_column_to_name = {\n",
    "        \"rule_id\": f\"{rule_term} Name\",\n",
    "        \"tot_warnings\": \"Tot. warnings\",\n",
    "        \"perc_of_affected_files\": \"Files with warning\",\n",
    "    }\n",
    "    # drop col not in the mapping\n",
    "    df = df[mapping_column_to_name.keys()]\n",
    "    df = df.rename(columns=mapping_column_to_name)\n",
    "\n",
    "\n",
    "    table = df.to_latex(index=False, column_format=\"lrr\")\n",
    "    # replace % escaping\n",
    "    table = table.replace(\"%\", \"\\\\%\")\n",
    "    print(table)\n",
    "    display(df.reset_index(drop=True).head(20))\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Exploration: Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\nTotalFiles}{7,568}\n",
      "Some results from LintQ analysis:\n"
     ]
    },
    {
     "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>rule_id</th>\n",
       "      <th>message</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>col</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1912</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>01_classical_and_quantum_probability_distribut...</td>\n",
       "      <td>192.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1913</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>022_03b_bernstein_vazirani_algorithm_f13ae3.py</td>\n",
       "      <td>39.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1914</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>02b_deutsch_jozsa_algorithm_e9a399.py</td>\n",
       "      <td>46.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1915</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>4_qbits_decoherence_9bbc1f.py</td>\n",
       "      <td>67.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1916</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>4_qbits_decoherence_9bbc1f.py</td>\n",
       "      <td>195.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     rule_id                               message  \\\n",
       "1912  ql-deprecated-identity  The deprecated iden() API is called.   \n",
       "1913  ql-deprecated-identity  The deprecated iden() API is called.   \n",
       "1914  ql-deprecated-identity  The deprecated iden() API is called.   \n",
       "1915  ql-deprecated-identity  The deprecated iden() API is called.   \n",
       "1916  ql-deprecated-identity  The deprecated iden() API is called.   \n",
       "\n",
       "                                                   file   line  col  \n",
       "1912  01_classical_and_quantum_probability_distribut...  192.0  NaN  \n",
       "1913     022_03b_bernstein_vazirani_algorithm_f13ae3.py   39.0  9.0  \n",
       "1914              02b_deutsch_jozsa_algorithm_e9a399.py   46.0  9.0  \n",
       "1915                      4_qbits_decoherence_9bbc1f.py   67.0  9.0  \n",
       "1916                      4_qbits_decoherence_9bbc1f.py  195.0  9.0  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TOTAL_FILES_IN_DATASET = count_files(\n",
    "    folder=LINTQ_DATASET_FILES,\n",
    "    allowed_formats=[\".py\", \"ipynb\"]\n",
    ")\n",
    "print(\"\\\\newcommand{\\\\nTotalFiles}{\" + f\"{TOTAL_FILES_IN_DATASET:,}\" + \"}\")\n",
    "\n",
    "sarif_results_lintq = get_results_from_sarif_path(PATH_LINTQ_SARIF)\n",
    "df_results_lintq = get_df_from_sarif(sarif_results_lintq)\n",
    "\n",
    "# keep relevant rule_id in RULE_NAME_MAPPING\n",
    "df_results_lintq = df_results_lintq[\n",
    "    df_results_lintq[\"rule_id\"].isin(RULE_NAME_MAPPING.keys())]\n",
    "\n",
    "print(\"Some results from LintQ analysis:\")\n",
    "df_results_lintq.head()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Exploration: Warning Rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(5, 2.5))\n",
    "\n",
    "sns.countplot(\n",
    "    data=df_results_lintq,\n",
    "    color=THEME_COLOR_LIGHT_RGB,\n",
    "    y=\"rule_id\",\n",
    "    ax=ax\n",
    ")\n",
    "# log scale\n",
    "ax.set_xscale(\"log\")\n",
    "ax.set_xlabel(\"Number of warnings (log scale)\")\n",
    "ax.set_ylabel(LINTQ_CHECKER_TERM + \" Name\")\n",
    "# replace the y labels with the RULE_NAME_MAPPING\n",
    "original_labels = [label.get_text() for label in ax.get_yticklabels()]\n",
    "ax.set_yticks(np.arange(len(original_labels)))\n",
    "ax.set_yticklabels(\n",
    "    [RULE_NAME_MAPPING[label] for label in original_labels]\n",
    ")\n",
    "plt.tight_layout()\n",
    "plt.savefig(os.path.join(OUTPUT_FOLDER, \"EDA_fig_warnings_per_rule.pdf\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table 3 - Warnings generated by LintQ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\avgWarningsPerc}{2.69\\%}\n",
      "\\newcommand{\\medianWarningsPerc}{0.36\\%}\n",
      "\\begin{tabular}{lrr}\n",
      "\\toprule\n",
      "Analysis Name & Tot. warnings & Files with warning \\\\\n",
      "\\midrule\n",
      "DoubleMeas & 39 & 0.36\\% \\\\\n",
      "OpAfterMeas & 127 & 0.92\\% \\\\\n",
      "MeasAllAbuse & 22 & 0.26\\% \\\\\n",
      "ConstClasBit & 533 & 4.29\\% \\\\\n",
      "CondWoMeas & 46 & 0.22\\% \\\\\n",
      "InsuffClasReg & 3489 & 17.35\\% \\\\\n",
      "OversizedCircuit & 378 & 3.01\\% \\\\\n",
      "OpAfterTransp & 7 & 0.05\\% \\\\\n",
      "GhostCompose & 12 & 0.09\\% \\\\\n",
      "OldIdenGate & 46 & 0.37\\% \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "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>Analysis Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>39</td>\n",
       "      <td>0.36%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>127</td>\n",
       "      <td>0.92%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>22</td>\n",
       "      <td>0.26%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>533</td>\n",
       "      <td>4.29%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CondWoMeas</td>\n",
       "      <td>46</td>\n",
       "      <td>0.22%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>3489</td>\n",
       "      <td>17.35%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>378</td>\n",
       "      <td>3.01%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>7</td>\n",
       "      <td>0.05%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>12</td>\n",
       "      <td>0.09%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>OldIdenGate</td>\n",
       "      <td>46</td>\n",
       "      <td>0.37%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Analysis Name  Tot. warnings Files with warning\n",
       "0        DoubleMeas             39              0.36%\n",
       "1       OpAfterMeas            127              0.92%\n",
       "2      MeasAllAbuse             22              0.26%\n",
       "3      ConstClasBit            533              4.29%\n",
       "4        CondWoMeas             46              0.22%\n",
       "5     InsuffClasReg           3489             17.35%\n",
       "6  OversizedCircuit            378              3.01%\n",
       "7     OpAfterTransp              7              0.05%\n",
       "8      GhostCompose             12              0.09%\n",
       "9       OldIdenGate             46              0.37%"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_warnings_table = compute_warnings_table(\n",
    "    df_results=df_results_lintq,\n",
    "    rule_name_mapping=RULE_NAME_MAPPING,\n",
    "    total_files_in_dataset=TOTAL_FILES_IN_DATASET,\n",
    "    rule_term=LINTQ_CHECKER_TERM\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure 9 - Frequency of Gates in our Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gate level analysis\n",
    "from utils_eda import read_files_in_parallel\n",
    "from utils_eda import get_dataset_level_list\n",
    "from utils_eda import map_to_lower_gate_name\n",
    "import ast\n",
    "\n",
    "USE_PRECOMPUTED_STATS = True\n",
    "PATH_TO_PRECOMPUTED_STATS = \"../data/pre_computed_lintq_stats.csv\"\n",
    "\n",
    "list_files = os.listdir(LINTQ_DATASET_FILES)\n",
    "if not USE_PRECOMPUTED_STATS:\n",
    "    # read from files\n",
    "    df_all = read_files_in_parallel(\n",
    "        list_files, folder=LINTQ_DATASET_FILES)\n",
    "    # store the local file\n",
    "    # drop extra columns: content, classes and register_sizes\n",
    "    df_all.drop(columns=[\"content\", \"classes\", \"register_sizes\"], inplace=True)\n",
    "    # store\n",
    "    df_all.to_csv(PATH_TO_PRECOMPUTED_STATS, index=False)\n",
    "else:\n",
    "    # read from local file\n",
    "    df_all = pd.read_csv(PATH_TO_PRECOMPUTED_STATS)\n",
    "    # parse the api_calls as a list with ast\n",
    "    df_all['api_calls'] = df_all['api_calls'].apply(ast.literal_eval)\n",
    "\n",
    "\n",
    "N_FILES_IN_DATASET = len(list_files)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>file_name</th>\n",
       "      <th>api_calls</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>qiskit_runner_a05ff0.py</td>\n",
       "      <td>[export_to_qiskit, add_register, measure, Clas...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>01_operator_flow_87f6ae.py</td>\n",
       "      <td>[print, print, print, print, print, print, pri...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>graders_f3ed23.py</td>\n",
       "      <td>[Unroller, PassManager, count_ops, isinstance,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>challenge4_circuitdecomposition_6c33bd.py</td>\n",
       "      <td>[get_unitary, print, print, array, get_unitary...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>run_circuit_3a72ed.py</td>\n",
       "      <td>[measure, execute, job_monitor, result, get_co...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   file_name  \\\n",
       "0                    qiskit_runner_a05ff0.py   \n",
       "1                 01_operator_flow_87f6ae.py   \n",
       "2                          graders_f3ed23.py   \n",
       "3  challenge4_circuitdecomposition_6c33bd.py   \n",
       "4                      run_circuit_3a72ed.py   \n",
       "\n",
       "                                           api_calls  \n",
       "0  [export_to_qiskit, add_register, measure, Clas...  \n",
       "1  [print, print, print, print, print, print, pri...  \n",
       "2  [Unroller, PassManager, count_ops, isinstance,...  \n",
       "3  [get_unitary, print, print, array, get_unitary...  \n",
       "4  [measure, execute, job_monitor, result, get_co...  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_all.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique files that call gate-related API calls: 4964\n",
      "\\newcommand{\\avgGateCallsPerFile}{11.2}\n",
      "\\newcommand{\\avgGateCallsPerFileNoMeasure}{9.9}\n",
      "\\newcommand{\\avgMeasureCallsPerFile}{1.2}\n"
     ]
    }
   ],
   "source": [
    "# filter all API calls related to gates\n",
    "top_k = 10\n",
    "\n",
    "df_api_calls = get_dataset_level_list(df_all, 'api_calls')\n",
    "\n",
    "api_gate_calls_names_curated = list(map_to_lower_gate_name.values()) + list(map_to_lower_gate_name.keys())\n",
    "api_gate_calls_names_curated = list(set(api_gate_calls_names_curated))\n",
    "\n",
    "df_api_calls['is_gate_call'] = df_api_calls['api_call'].apply(\n",
    "    lambda x: x in api_gate_calls_names_curated)\n",
    "\n",
    "# filter all API calls related to gates\n",
    "df_gate_calls = df_api_calls[df_api_calls['is_gate_call'] == True]\n",
    "\n",
    "# normalize names with the curated list\n",
    "df_gate_calls.loc[:, 'api_call'] = df_gate_calls['api_call'].apply(\n",
    "    lambda x: map_to_lower_gate_name[x] if x in map_to_lower_gate_name.keys() else x)\n",
    "\n",
    "n_unique_files = df_gate_calls['file_name'].nunique()\n",
    "print(f'Number of unique files that call gate-related API calls: {n_unique_files}')\n",
    "\n",
    "n_gate_api_calls = df_gate_calls.shape[0]\n",
    "n_gate_calls_per_file = n_gate_api_calls / N_FILES_IN_DATASET\n",
    "print(\"\\\\newcommand{\\\\avgGateCallsPerFile}{\" + f\"{n_gate_calls_per_file:.1f}\" + \"}\")\n",
    "\n",
    "# exclude the measure gate\n",
    "df_tmp = df_gate_calls[df_gate_calls['api_call'] != 'measure']\n",
    "n_gate_api_calls_no_measure = df_tmp.shape[0]\n",
    "n_gate_calls_per_file_no_measure = n_gate_api_calls_no_measure / N_FILES_IN_DATASET\n",
    "print(\"\\\\newcommand{\\\\avgGateCallsPerFileNoMeasure}{\" + f\"{n_gate_calls_per_file_no_measure:.1f}\" + \"}\")\n",
    "\n",
    "# consider only measure\n",
    "df_measure_call_only = df_gate_calls[df_gate_calls['api_call'] == 'measure']\n",
    "n_measure_api_calls = df_measure_call_only.shape[0]\n",
    "n_measure_calls_per_file = n_measure_api_calls / N_FILES_IN_DATASET\n",
    "print(\"\\\\newcommand{\\\\avgMeasureCallsPerFile}{\" + f\"{n_measure_calls_per_file:.1f}\" + \"}\")\n",
    "\n",
    "# remove barrier\n",
    "df_gate_calls_no_barrier = df_gate_calls[df_gate_calls['api_call'] != 'barrier']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\topFirstGateName}{x}\n",
      "\\newcommand{\\topSecondGateName}{h}\n",
      "\\newcommand{\\topThridGateName}{cx}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x600 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Get the top 10 api_call and their frequencies\n",
    "top_10_api_calls = df_gate_calls_no_barrier['api_call'].value_counts().nlargest(10)\n",
    "\n",
    "# Create the countplot\n",
    "plt.figure(figsize=(12, 6))\n",
    "df_top_gate_calls = df_gate_calls_no_barrier[\n",
    "    df_gate_calls_no_barrier['api_call'].isin(top_10_api_calls.index)]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(3, 3))\n",
    "sns.countplot(\n",
    "    data=df_top_gate_calls,\n",
    "    order=top_10_api_calls.index,\n",
    "    y='api_call',\n",
    "    hue='api_call',\n",
    "    hue_order=top_10_api_calls.index,\n",
    "    palette=\"icefire\",\n",
    "    ax=ax\n",
    ")\n",
    "ax.set_xlabel('Number of occurrences \\nin the entire dataset')\n",
    "ax.set_ylabel('Quantum Operator')\n",
    "ax.grid(axis='x', color='lightgray')\n",
    "plt.tight_layout()\n",
    "df_gate_calls.head()\n",
    "\n",
    "fig.savefig(os.path.join(OUTPUT_FOLDER, 'FIG_9_gate_calls.pdf'), bbox_inches='tight')\n",
    "\n",
    "# print top 3 names of gate with new command\n",
    "top_k = 3\n",
    "top_k = 3\n",
    "\n",
    "# Get the counts of each gate name\n",
    "gate_counts = df_gate_calls_no_barrier['api_call'].value_counts()\n",
    "\n",
    "map_latex_index = {\n",
    "    1: \"First\",\n",
    "    2: \"Second\",\n",
    "    3: \"Thrid\"\n",
    "}\n",
    "\n",
    "# Print the top k gate names and their counts\n",
    "for i in range(top_k):\n",
    "    gate_name = gate_counts.index[i]\n",
    "    count = gate_counts.iloc[i]\n",
    "    # map 1 -> first, 2 -> second, 3 -> thrird\n",
    "\n",
    "    latex_index = map_latex_index[i + 1]\n",
    "    print(\"\\\\newcommand{\\\\top\" + latex_index + \"GateName}{\" + gate_name + \"}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RQ1:  Effectiveness of Abstractions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils_abstractions import get_abstractions_from_qll\n",
    "from utils_abstractions import get_predicates_from_qql\n",
    "from utils_abstractions import check_abstractions_used\n",
    "from utils_abstractions import get_color_for_abstr_family\n",
    "from utils_abstractions import read_files\n",
    "from utils_abstractions import get_abstractions_used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of queries: 31\n",
      "Number of abstractions: 13\n",
      "['/Backend/InitWithoutTranspilation.ql', '/Backend/MeasWithStatevector.ql', '/Measurement/OpAfterMeasurement.ql', '/Measurement/MeasureAll.ql', '/Measurement/DoubleMeasurement.ql', '/Measurement/ConditionalGateWithoutMeas.ql', '/Measurement/OpAfterMeasurementGeneral.ql', '/Qsmell/NoAlignmentLogicalPhysical.ql', '/Qsmell/NonParametrizedCircuit.ql', '/Extra/SimulatorSizeOverflow.ql', '/Extra/DeprecatedCircuitMethod.ql', '/Extra/GhostQASMImport.ql', '/Extra/SuperfluousOp.ql', '/Extra/TranspileWithoutLayout.ql', '/Extra/ExecuteWithSeed.ql', '/Extra/MultipleSubmission.ql', '/Extra/DeprecatedIdentity.ql', '/Extra/ImproperDraw.ql', '/Extra/SuperfluousOpPrecise.ql', '/Resource/OversizedCircuit.ql', '/Resource/ConstantClassicBit.ql', '/Resource/UnmeasurableQubits.ql', '/Simulation/InvalidPauliSyntaxError.ql', '/Simulation/InvalidPauliErrorSize.ql', '/Vulnerability/TokenLeakage.ql', '/Metrics/CircuitSize.ql', '/Interconnection/IncompatibleComposition.ql', '/Interconnection/UngovernedComposition.ql', '/Interconnection/GhostFromQasm.ql', '/Interconnection/GhostComposition.ql', '/Optimization/OpAfterOptimization.ql']\n",
      "['/Register.qll', '/BitDef.qll', '/SensitiveAPI.qll', '/Qubit.qll', '/Pauli.qll', '/Backend.qll', '/QuantumOperator.qll', '/NoiseModel.qll', '/BitUse.qll', '/Circuit.qll', '/QuantumDataFlow.qll', '/UnknownQuantumOperator.qll', '/Gate.qll']\n"
     ]
    }
   ],
   "source": [
    "query_files = read_files(\n",
    "    folder=DETECTORS_FOLDER, extension='.ql')\n",
    "abstraction_files = read_files(\n",
    "    folder=ABSTRACTION_FOLDER, extension='.qll')\n",
    "\n",
    "print(f'Number of queries: {len(query_files)}')\n",
    "print(f'Number of abstractions: {len(abstraction_files)}')\n",
    "all_query_names = list(query_files.keys())\n",
    "print(all_query_names)\n",
    "\n",
    "all_abstractions_names = list(abstraction_files.keys())\n",
    "print(all_abstractions_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FIG 10 - Which abstractions are used in the different queries?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of abstractions defined: 104\n",
      "['QuantumRegisterV2', 'ClassicalRegisterV2', 'ImplicitCircuitQubitDefinition', 'ImplicitCircuitClbitDefinition', 'ImplicitRegisterQubitDefinition', 'ImplicitRegisterClbitDefinition', 'ExplicitSingleQubitDefinition', 'ExplicitSingleClbitDefinition', 'isIntegerParameterOfCall', 'IBMCloudTokenSink', 'PauliString', 'Backend', 'BackendRunViaRunCall', 'BackendRunViaExecuteCall', 'BackendResult', 'Statevector', 'PauliError', 'EmptySetForString', 'EmptySetForInt', 'EmptySetForRegisterV2', 'EmptySetForQuantumCircuit', 'QubitUseViaAttribute', 'QubitUseViaAppend', 'QubitUseViaMeasureAll', 'OperatorSpecificationAttributeName', 'OperatorSpecificationObjectName', 'OperatorSpecificationReset', 'OperatorSpecificationMeasureAll', 'OperatorSpecificationMeasure', 'OperatorSpecificationInitialize', 'OperatorSpecificationUnitaryGateObj', 'OperatorSpecificationUnitaryCall', 'OperatorSpecificationSingleQubitNoParam', 'OperatorSpecificationPGate', 'OperatorSpecificationRXGate', 'OperatorSpecificationRYGate', 'OperatorSpecificationRZGate', 'OperatorSpecificationRVGate', 'OperatorSpecificationU1Gate', 'OperatorSpecificationU2Gate', 'OperatorSpecificationU3Gate', 'OperatorSpecificationCPGate', 'OperatorSpecificationCXGate', 'OperatorSpecificationCYGate', 'OperatorSpecificationCZGate', 'OperatorSpecificationCHGate', 'OperatorSpecificationCSGate', 'OperatorSpecificationCSdgGate', 'OperatorSpecificationCSXGate', 'OperatorSpecificationSwapGate', 'OperatorSpecificationISwapGate', 'OperatorSpecificationCRZGate', 'OperatorSpecificationCRYGate', 'OperatorSpecificationCRXGate', 'OperatorSpecificationCU1Gate', 'OperatorSpecificationCU3Gate', 'OperatorSpecificationCUGate', 'OperatorSpecificationCSwapGate', 'OperatorSpecificationCCXGate', 'OperatorSpecificationCCZGate', 'OperatorSpecificationRXXGate', 'OperatorSpecificationRYYGate', 'OperatorSpecificationRZZGate', 'OperatorSpecificationRZXGate', 'ComposeCall', 'AppendCall', 'FromQasmStrCall', 'ToInstructionCall', 'ToGateCall', 'SubCircuit', 'InstructionCircuit', 'ParametrizedCircuit', 'InstanceOfParameterizedCircuit', 'ReturnsNewValue', 'BuiltinParametrizedCircuitsConstructor', 'TranspileCall', 'AssembleCall', 'ExecuteCall', 'QuantumCircuitConstructor', 'CopyCircuitCall', 'UDFFunctionDefReturningAQuantumCircuit', 'UDFCallReturningAQuantumCircuit', 'QuantumCircuit', 'TranspiledCircuit', 'UDFQuantumCircuit', 'ComposedCircuit', 'mayFollow', 'manipulateSameQubit', 'manipulateSameQubit', 'mayFollowDirectly', 'sortedInOrder', 'UnknownQuantumOperatorViaUnknownArgument', 'UnknownQuantumOperatorViaAppend', 'CircuitExtenderFunctionViaArg', 'CircuitExtenderFunctionImplicit', 'Gate', 'MeasureGateCall', 'MeasureGateObj', 'MeasurementAll', 'ResetGateCall', 'ResetGateObj', 'InitializeGateCall', 'InitializeGateObj', 'checkCallAndSpecLinkedInAPIGraph']\n"
     ]
    }
   ],
   "source": [
    "all_abstraction_defined = []\n",
    "for abstraction_file in abstraction_files.values():\n",
    "    all_abstraction_defined += get_abstractions_from_qll(abstraction_file)\n",
    "    all_abstraction_defined += get_predicates_from_qql(abstraction_file)\n",
    "\n",
    "print(f'Number of abstractions defined: {len(all_abstraction_defined)}')\n",
    "print(all_abstraction_defined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Measurement/OpAfterMeasurement.ql: ['mayFollow', 'mayFollowDirectly', 'sortedInOrder', 'Gate']\n",
      "/Measurement/MeasureAll.ql: ['QuantumCircuit', 'MeasurementAll']\n",
      "/Measurement/DoubleMeasurement.ql: ['mayFollowDirectly', 'Gate']\n",
      "/Measurement/ConditionalGateWithoutMeas.ql: ['SubCircuit', 'Gate']\n",
      "/Extra/DeprecatedIdentity.ql: ['Backend', 'QuantumCircuit', 'Gate']\n",
      "/Resource/OversizedCircuit.ql: ['QuantumRegisterV2', 'SubCircuit', 'QuantumCircuitConstructor', 'QuantumCircuit', 'TranspiledCircuit']\n",
      "/Resource/ConstantClassicBit.ql: ['SubCircuit', 'QuantumCircuitConstructor', 'QuantumCircuit', 'mayFollow', 'Gate']\n",
      "/Resource/UnmeasurableQubits.ql: ['QuantumRegisterV2', 'QuantumCircuit', 'MeasureGateCall', 'MeasurementAll']\n",
      "/Interconnection/GhostComposition.ql: ['ComposeCall', 'ReturnsNewValue']\n",
      "/Optimization/OpAfterOptimization.ql: ['TranspiledCircuit', 'Gate']\n"
     ]
    }
   ],
   "source": [
    "query_to_abstraction = {}\n",
    "\n",
    "for query_name, query_content in query_files.items():\n",
    "    abstractions_used = check_abstractions_used(\n",
    "        abstraction=all_abstraction_defined,\n",
    "        content=query_content)\n",
    "    if abstractions_used:\n",
    "        base_name = os.path.basename(query_name)\n",
    "        if base_name in FILE_NAME_RULE_MAPPING:\n",
    "            base_name = FILE_NAME_RULE_MAPPING[base_name]\n",
    "        query_to_abstraction[base_name] = abstractions_used\n",
    "        # focus on relevant analyses\n",
    "        if any([query_name.endswith(query_ql) for query_ql in FILE_NAME_RULE_MAPPING]):\n",
    "            print(f'{query_name}: {abstractions_used}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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>source</th>\n",
       "      <th>target</th>\n",
       "      <th>type</th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>InitWithoutTranspilation.ql</td>\n",
       "      <td>Backend</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>InitWithoutTranspilation.ql</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>InitWithoutTranspilation.ql</td>\n",
       "      <td>TranspiledCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>InitWithoutTranspilation.ql</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>MeasWithStatevector.ql</td>\n",
       "      <td>Backend</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        source             target type  value\n",
       "0  InitWithoutTranspilation.ql            Backend  use      1\n",
       "1  InitWithoutTranspilation.ql     QuantumCircuit  use      1\n",
       "2  InitWithoutTranspilation.ql  TranspiledCircuit  use      1\n",
       "3  InitWithoutTranspilation.ql               Gate  use      1\n",
       "4       MeasWithStatevector.ql            Backend  use      1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\avgAbstractionsUsedPerQuery}{3.1}\n",
      "\\newcommand{\\avgQueriesSupportedPerAbstraction}{5.5}\n",
      "Number of null values: 57\n",
      "Number of null values: 0\n",
      "['DoubleMeas', 'OpAfterMeas', 'MeasAllAbuse', 'ConstClasBit', 'CondWoMeas', 'InsuffClasReg', 'OversizedCircuit', 'OpAfterTransp', 'GhostCompose', 'OldIdenGate']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_2982189/1264171816.py:46: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
      "  use_relationship_per_query = df_abstractions.groupby('source').count()['value']\n"
     ]
    },
    {
     "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>source</th>\n",
       "      <th>target</th>\n",
       "      <th>type</th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>OldIdenGate</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>OldIdenGate</td>\n",
       "      <td>Backend</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>OldIdenGate</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85</th>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>SubcircuitComposition</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>84</th>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>SubcircuitComposition</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>87</th>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>86</th>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>TranspiledCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>59</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>Register</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>60</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>SubcircuitComposition</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>TranspiledCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>61</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>72</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>Measurement</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>71</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>Measurement</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>70</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>Register</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>CondWoMeas</td>\n",
       "      <td>SubcircuitComposition</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>CondWoMeas</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>66</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>67</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>QuantumDataFlow</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>65</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>SubcircuitComposition</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>68</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>QuantumCircuit</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>QuantumDataFlow</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>QuantumDataFlow</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>QuantumDataFlow</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>Gate</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>QuantumDataFlow</td>\n",
       "      <td>use</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              source                 target type  value\n",
       "49       OldIdenGate                   Gate  use      1\n",
       "47       OldIdenGate                Backend  use      1\n",
       "48       OldIdenGate         QuantumCircuit  use      1\n",
       "85      GhostCompose  SubcircuitComposition  use      1\n",
       "84      GhostCompose  SubcircuitComposition  use      1\n",
       "87     OpAfterTransp                   Gate  use      1\n",
       "86     OpAfterTransp      TranspiledCircuit  use      1\n",
       "59  OversizedCircuit               Register  use      1\n",
       "60  OversizedCircuit  SubcircuitComposition  use      1\n",
       "62  OversizedCircuit         QuantumCircuit  use      1\n",
       "63  OversizedCircuit      TranspiledCircuit  use      1\n",
       "61  OversizedCircuit         QuantumCircuit  use      1\n",
       "72     InsuffClasReg            Measurement  use      1\n",
       "71     InsuffClasReg            Measurement  use      1\n",
       "70     InsuffClasReg         QuantumCircuit  use      1\n",
       "69     InsuffClasReg               Register  use      1\n",
       "18        CondWoMeas  SubcircuitComposition  use      1\n",
       "19        CondWoMeas                   Gate  use      1\n",
       "66      ConstClasBit         QuantumCircuit  use      1\n",
       "67      ConstClasBit        QuantumDataFlow  use      1\n",
       "65      ConstClasBit         QuantumCircuit  use      1\n",
       "64      ConstClasBit  SubcircuitComposition  use      1\n",
       "68      ConstClasBit                   Gate  use      1\n",
       "14      MeasAllAbuse         QuantumCircuit  use      1\n",
       "15      MeasAllAbuse            Measurement  use      1\n",
       "13       OpAfterMeas                   Gate  use      1\n",
       "11       OpAfterMeas        QuantumDataFlow  use      1\n",
       "10       OpAfterMeas        QuantumDataFlow  use      1\n",
       "12       OpAfterMeas        QuantumDataFlow  use      1\n",
       "17        DoubleMeas                   Gate  use      1\n",
       "16        DoubleMeas        QuantumDataFlow  use      1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "FAMILY_NAME_SUBCIRC = 'SubcircuitComposition'\n",
    "FAMILY_NAME_QDF = \"QuantumDataFlow\"\n",
    "FAMILY_NAME_MEAS = \"Measurement\"\n",
    "FAMILY_NAME_QC = \"QuantumCircuit\"\n",
    "ABSTRACTION_MAPPING = {\n",
    "    \"MeasureGateCall\": FAMILY_NAME_MEAS,\n",
    "    \"MeasurementAll\": FAMILY_NAME_MEAS,\n",
    "    \"mayFollow\": FAMILY_NAME_QDF,\n",
    "    \"mayFollowDirectly\": FAMILY_NAME_QDF,\n",
    "    \"sortedInOrder\": FAMILY_NAME_QDF,\n",
    "    \"ComposeCall\": FAMILY_NAME_SUBCIRC,\n",
    "    \"ReturnsNewValue\": FAMILY_NAME_SUBCIRC,\n",
    "    \"SubCircuit\": FAMILY_NAME_SUBCIRC,\n",
    "    \"QuantumRegisterV2\": \"Register\",\n",
    "    \"QuantumCircuit\": FAMILY_NAME_QC,\n",
    "    \"QuantumCircuitConstructor\": FAMILY_NAME_QC\n",
    "}\n",
    "\n",
    "\n",
    "from pySankey.sankey import sankey\n",
    "# source,target,type,value\n",
    "\n",
    "records = []\n",
    "for query_name, abstractions in query_to_abstraction.items():\n",
    "    for abstraction in abstractions:\n",
    "        records.append({\n",
    "            'source': query_name,\n",
    "            'target': abstraction,\n",
    "            'type': 'use',\n",
    "            'value': 1,\n",
    "        })\n",
    "df_abstractions = pd.DataFrame.from_records(records)\n",
    "# map abstraction names\n",
    "df_abstractions['target'] = df_abstractions['target'].apply(\n",
    "    lambda e: ABSTRACTION_MAPPING[e] if e in ABSTRACTION_MAPPING else e)\n",
    "\n",
    "display(df_abstractions.head())\n",
    "# sort by canonical order\n",
    "df_abstractions['source'] = pd.Categorical(\n",
    "    df_abstractions['source'],\n",
    "    categories=list(set(NAME_MAPPING.values()))\n",
    ")\n",
    "df_abstractions = df_abstractions.sort_values('source', ascending=False)\n",
    "df_abstractions.head()\n",
    "# compute the average number of records per source\n",
    "use_relationship_per_query = df_abstractions.groupby('source').count()['value']\n",
    "#print(use_relationship_per_query)\n",
    "avg_use_relationship_per_query = use_relationship_per_query.mean()\n",
    "print(\"\\\\newcommand{\\\\avgAbstractionsUsedPerQuery}{\" + f\"{avg_use_relationship_per_query:.1f}\" + \"}\")\n",
    "avg_use_relationship_per_abstraction = df_abstractions.groupby('target').count()['value'].mean()\n",
    "print(\"\\\\newcommand{\\\\avgQueriesSupportedPerAbstraction}{\" + f\"{avg_use_relationship_per_abstraction:.1f}\" + \"}\")\n",
    "\n",
    "\n",
    "# check null values, print and drop them\n",
    "print(f\"Number of null values: {df_abstractions.isnull().sum().sum()}\")\n",
    "df_abstractions = df_abstractions.dropna()\n",
    "print(f\"Number of null values: {df_abstractions.isnull().sum().sum()}\")\n",
    "\n",
    "per_family_color = get_color_for_abstr_family(\n",
    "    df=df_abstractions,\n",
    "    col_name='source',\n",
    ")\n",
    "\n",
    "# colorDict: yellow for target and blue for source\n",
    "colorDict = {\n",
    "    #**{k: 'slateblue' for k in df_abstractions['source'].unique()},\n",
    "    **per_family_color,\n",
    "    **{k: 'gray' for k in df_abstractions['target'].unique()}\n",
    "}\n",
    "\n",
    "# sort by canonical order\n",
    "canonical_order = list(RULE_NAME_MAPPING.values())\n",
    "print(canonical_order)\n",
    "df_abstractions['source'] = pd.Categorical(\n",
    "    df_abstractions['source'],\n",
    "    categories=canonical_order)\n",
    "df_abstractions = df_abstractions.sort_values('source', ascending=False)\n",
    "\n",
    "display(df_abstractions)\n",
    "sankey(\n",
    "    left=df_abstractions['source'],\n",
    "    right=df_abstractions['target'],\n",
    "    aspect=20,\n",
    "    colorDict=colorDict,\n",
    "    fontsize=15,\n",
    ")\n",
    "plt.gcf().set_size_inches(5, 5)\n",
    "plt.savefig(\n",
    "    os.path.join(OUTPUT_FOLDER, 'FIG_10_sankey_abstraction_v2.pdf'),\n",
    "    bbox_inches='tight')\n",
    "\n",
    "# go back to the initial rc configuration\n",
    "# plt.rcParams.update(rc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "\\newcommand{\\avgLoCQuery}{10.0}\n",
      "\\newcommand{\\minLoCQuery}{3}\n",
      "\\newcommand{\\maxLoCQuery}{17}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x220 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SHOW_QUERIES_DEBUG = False\n",
    "\n",
    "records = []\n",
    "for query_name, query_content in query_files.items():\n",
    "    # count the lines in the content excluding the imports and the comment lines\n",
    "    # comment start with: /* or * or //\n",
    "    # imports start with: import\n",
    "    lines = query_content.splitlines()\n",
    "    lines = [\n",
    "        line for line in lines\n",
    "        # use regex to ensure we account for spaces\n",
    "        if not re.match(r'^\\s*import', line) and\n",
    "        not re.match(r'^\\s*//', line) and\n",
    "        not re.match(r'^\\s*\\*', line) and\n",
    "        not re.match(r'^\\s*/\\*', line)\n",
    "    ]\n",
    "    # remove empty lines\n",
    "    lines = [l for l in lines if l != '']\n",
    "    loc = len(lines)\n",
    "    if SHOW_QUERIES_DEBUG:\n",
    "        print(\"\\n\".join(lines))\n",
    "        print(query_name, loc)\n",
    "        # check that none of the line is longer than 80 chars\n",
    "        for line in lines:\n",
    "            if len(line) > 80:\n",
    "                print(\"___________________ line too long: \", line)\n",
    "    base_query_name = os.path.basename(query_name)\n",
    "    # keep only if it is in the mapping (aka relevant queries)\n",
    "    if base_query_name in FILE_NAME_RULE_MAPPING:\n",
    "        records.append({\n",
    "            'query_name': FILE_NAME_RULE_MAPPING[base_query_name],\n",
    "            'loc': loc\n",
    "        })\n",
    "\n",
    "df_loc_queries = pd.DataFrame.from_records(records)\n",
    "print(len(df_loc_queries))\n",
    "# sort by canonical order\n",
    "categories = [\n",
    "    cat for cat in RULE_NAME_MAPPING.values()\n",
    "    if \"QSmell\" not in cat\n",
    "]\n",
    "df_loc_queries['query_name'] = pd.Categorical(\n",
    "    df_loc_queries['query_name'], categories=categories)\n",
    "df_loc_queries = df_loc_queries.sort_values('query_name')\n",
    "\n",
    "per_family_color = get_color_for_abstr_family(\n",
    "    df=df_loc_queries,\n",
    "    col_name='query_name',\n",
    ")\n",
    "\n",
    "# plot the lines of code histogram\n",
    "fig, ax = plt.subplots(figsize=(5, 2.2))\n",
    "sns.barplot(\n",
    "    data=df_loc_queries,\n",
    "    y='query_name',\n",
    "    hue='query_name',\n",
    "    x='loc',\n",
    "    palette=per_family_color.values(),\n",
    "    # sort\n",
    "    #order=df_loc_queries.sort_values('loc', ascending=True)['query_name'],\n",
    ")\n",
    "ax.set_xlabel('Lines of Code')\n",
    "ax.set_ylabel('Checker')\n",
    "mean_value = df_loc_queries['loc'].mean()\n",
    "# add red line for the mean\n",
    "ax.axvline(mean_value, color='red', linestyle='--')\n",
    "# plot the label of the mean\n",
    "ax.text(\n",
    "    mean_value + 1,\n",
    "    0.5,\n",
    "    f'Mean: {mean_value:.1f}',\n",
    "    color='red',\n",
    ")\n",
    "plt.tight_layout()\n",
    "fig.savefig(\n",
    "    os.path.join(OUTPUT_FOLDER, 'loc_queries.pdf')\n",
    ")\n",
    "print(\"\\\\newcommand{\\\\avgLoCQuery}{\" + f\"{mean_value:.1f}\" + \"}\")\n",
    "min_value = df_loc_queries['loc'].min()\n",
    "print(\"\\\\newcommand{\\\\minLoCQuery}{\" + f\"{min_value:.0f}\" + \"}\")\n",
    "max_value = df_loc_queries['loc'].max()\n",
    "print(\"\\\\newcommand{\\\\maxLoCQuery}{\" + f\"{max_value:.0f}\" + \"}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RQ2:  Bugs Detected by LintQ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>ID</th>\n",
       "      <th>Analysis</th>\n",
       "      <th>Description</th>\n",
       "      <th>Manif.</th>\n",
       "      <th>Issue</th>\n",
       "      <th>Status</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>Redundant measurement</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{06_fe6009_63}$</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing compose assignment in a test case</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{06_13ba80_90}$</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing compose assignment in a test case</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{06_13ba80_107}$</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing compose assignment in a test case</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{06_13ba80_107}$</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_ca5e66_35}$</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>Redundant measurment</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_e3f4e0_74}$</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measure all generates a twice as long output</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_c50734_412}$</td>\n",
       "      <td>Confirmed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>Non idiomatic teleportation, lack of c_if</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_9276a1_31}$</td>\n",
       "      <td>Confirmed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>Unused qubit</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{06_4c9443_35}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>Measure gate added after transpilation</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_c4c34f_59}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>11</td>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>Measure gate added after transpilation (Grover...</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_9232ea_55}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>12</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output (Bell p...</td>\n",
       "      <td>LongOut</td>\n",
       "      <td>$^{06_55fd07_25}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>13</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output (GHZ al...</td>\n",
       "      <td>LongOut</td>\n",
       "      <td>$^{06_7af332_35}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>14</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output</td>\n",
       "      <td>LongOut</td>\n",
       "      <td>$^{06_09be03_19}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>15</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing insertion of the inverse QFT (Shor's a...</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{06_df608f_322}$</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>16</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output (CTF co...</td>\n",
       "      <td>Silent</td>\n",
       "      <td>$^{08_12fb50_70}$</td>\n",
       "      <td>Not Fix</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    ID       Analysis                                        Description  \\\n",
       "0    1     DoubleMeas                              Redundant measurement   \n",
       "1    2   GhostCompose          Missing compose assignment in a test case   \n",
       "2    3   GhostCompose          Missing compose assignment in a test case   \n",
       "3    4   GhostCompose          Missing compose assignment in a test case   \n",
       "4    5   MeasAllAbuse             Measurement creates overly long output   \n",
       "5    6     DoubleMeas                               Redundant measurment   \n",
       "6    7   MeasAllAbuse       Measure all generates a twice as long output   \n",
       "7    8    OpAfterMeas          Non idiomatic teleportation, lack of c_if   \n",
       "8    9  InsuffClasReg                                       Unused qubit   \n",
       "9   10  OpAfterTransp             Measure gate added after transpilation   \n",
       "10  11  OpAfterTransp  Measure gate added after transpilation (Grover...   \n",
       "11  12   MeasAllAbuse  Measurement creates overly long output (Bell p...   \n",
       "12  13   MeasAllAbuse  Measurement creates overly long output (GHZ al...   \n",
       "13  14   MeasAllAbuse             Measurement creates overly long output   \n",
       "14  15   GhostCompose  Missing insertion of the inverse QFT (Shor's a...   \n",
       "15  16   MeasAllAbuse  Measurement creates overly long output (CTF co...   \n",
       "\n",
       "     Manif.               Issue     Status  \n",
       "0    Silent   $^{06_fe6009_63}$      Fixed  \n",
       "1    Silent   $^{06_13ba80_90}$      Fixed  \n",
       "2    Silent  $^{06_13ba80_107}$      Fixed  \n",
       "3    Silent  $^{06_13ba80_107}$      Fixed  \n",
       "4    Silent   $^{08_ca5e66_35}$      Fixed  \n",
       "5    Silent   $^{08_e3f4e0_74}$      Fixed  \n",
       "6    Silent  $^{08_c50734_412}$  Confirmed  \n",
       "7    Silent   $^{08_9276a1_31}$  Confirmed  \n",
       "8    Silent   $^{06_4c9443_35}$   Reported  \n",
       "9    Silent   $^{08_c4c34f_59}$   Reported  \n",
       "10   Silent   $^{08_9232ea_55}$   Reported  \n",
       "11  LongOut   $^{06_55fd07_25}$   Reported  \n",
       "12  LongOut   $^{06_7af332_35}$   Reported  \n",
       "13  LongOut   $^{06_09be03_19}$   Reported  \n",
       "14   Silent  $^{06_df608f_322}$   Reported  \n",
       "15   Silent   $^{08_12fb50_70}$    Not Fix  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_real_bugs_reported = pd.read_csv(PATH_REAL_BUGS)\n",
    "# keep only those reported by last version of detectors\n",
    "present_col_name = [\n",
    "    c for c in df_real_bugs_reported.columns if \"Present_in\" in c][0]\n",
    "df_real_bugs_reported = df_real_bugs_reported[\n",
    "    df_real_bugs_reported[present_col_name] == \"yes\"\n",
    "]\n",
    "# map longer output -> Long. Out.\n",
    "df_real_bugs_reported[\"manifestation\"] = df_real_bugs_reported[\"manifestation\"].apply(\n",
    "    lambda x: \"LongOut\" if x == \"Longer output\" else x\n",
    ")\n",
    "# map rule_id\n",
    "df_real_bugs_reported[\"rule_id\"] = df_real_bugs_reported[\"rule_id\"].apply(\n",
    "    lambda x: RULE_NAME_MAPPING[x] if x in RULE_NAME_MAPPING else x\n",
    ")\n",
    "# mapt the status\n",
    "# Reported -> Report.\n",
    "# Confirmed -> Confir\n",
    "# Fixed -> Fix\n",
    "mapping_status = {\n",
    "    \"Reported\": \"Reported\",\n",
    "    \"Confirmed\": \"Confirmed\",\n",
    "    \"Fixed\": 'Fixed'\n",
    "}\n",
    "df_real_bugs_reported[\"status\"] = df_real_bugs_reported[\"status\"].apply(\n",
    "    lambda x: mapping_status[x] if x in mapping_status else x\n",
    ")\n",
    "# sort them by status: Fixed, Confirmed, Reported, Not Fix\n",
    "df_real_bugs_reported[\"status\"] = pd.Categorical(\n",
    "    df_real_bugs_reported[\"status\"],\n",
    "    categories=[\"Fixed\", \"Confirmed\", \"Reported\", \"Not Fix\"]\n",
    ")\n",
    "df_real_bugs_reported = df_real_bugs_reported.sort_values(\"status\")\n",
    "\n",
    "df_real_bugs_reported = df_real_bugs_reported.reset_index(drop=True)\n",
    "# display(df_real_bugs_reported)\n",
    "# assign an increasing ID starting from 1\n",
    "df_real_bugs_reported[\"ID\"] = df_real_bugs_reported.index + 1\n",
    "\n",
    "\n",
    "# Keep only relevant columns columns\n",
    "df_real_bugs_reported = df_real_bugs_reported[\n",
    "    [\"ID\", \"rule_id\", \"description\", \"manifestation\", \"issue\", \"status\"]\n",
    "]\n",
    "\n",
    "# convert issue number in apex\n",
    "df_real_bugs_reported[\"issue\"] = df_real_bugs_reported[\"issue\"].apply(\n",
    "    lambda x: \"$^{\" + x+ \"}$\" if x != \"\" else x\n",
    ")\n",
    "\n",
    "# rename columns\n",
    "# rule_id > Analysis Name\n",
    "# description > Description\n",
    "# status -> Status\n",
    "# manifestation -> Manif.\n",
    "df_real_bugs_reported.rename(\n",
    "    columns={\n",
    "        \"rule_id\": LINTQ_CHECKER_TERM,\n",
    "        \"description\": \"Description\",\n",
    "        \"status\": \"Status\",\n",
    "        \"manifestation\": \"Manif.\",\n",
    "        \"issue\": \"Issue\"\n",
    "    }, inplace=True\n",
    ")\n",
    "display(df_real_bugs_reported)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Table 2 - Examples of true positives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>ID</th>\n",
       "      <th>Analysis</th>\n",
       "      <th>Description</th>\n",
       "      <th>Manif.</th>\n",
       "      <th>Status</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>Redundant measurement</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing compose assignment in a test case</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing compose assignment in a test case</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing compose assignment in a test case</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>Redundant measurment</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Fixed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measure all generates a twice as long output</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Confirmed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>Non idiomatic teleportation, lack of c_if</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Confirmed</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>Unused qubit</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>Measure gate added after transpilation</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>11</td>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>Measure gate added after transpilation (Grover...</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>12</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output (Bell p...</td>\n",
       "      <td>LongOut</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>13</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output (GHZ al...</td>\n",
       "      <td>LongOut</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>14</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output</td>\n",
       "      <td>LongOut</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>15</td>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>Missing insertion of the inverse QFT (Shor's a...</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Reported</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>16</td>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>Measurement creates overly long output (CTF co...</td>\n",
       "      <td>Silent</td>\n",
       "      <td>Not Fix</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    ID       Analysis                                        Description  \\\n",
       "0    1     DoubleMeas                              Redundant measurement   \n",
       "1    2   GhostCompose          Missing compose assignment in a test case   \n",
       "2    3   GhostCompose          Missing compose assignment in a test case   \n",
       "3    4   GhostCompose          Missing compose assignment in a test case   \n",
       "4    5   MeasAllAbuse             Measurement creates overly long output   \n",
       "5    6     DoubleMeas                               Redundant measurment   \n",
       "6    7   MeasAllAbuse       Measure all generates a twice as long output   \n",
       "7    8    OpAfterMeas          Non idiomatic teleportation, lack of c_if   \n",
       "8    9  InsuffClasReg                                       Unused qubit   \n",
       "9   10  OpAfterTransp             Measure gate added after transpilation   \n",
       "10  11  OpAfterTransp  Measure gate added after transpilation (Grover...   \n",
       "11  12   MeasAllAbuse  Measurement creates overly long output (Bell p...   \n",
       "12  13   MeasAllAbuse  Measurement creates overly long output (GHZ al...   \n",
       "13  14   MeasAllAbuse             Measurement creates overly long output   \n",
       "14  15   GhostCompose  Missing insertion of the inverse QFT (Shor's a...   \n",
       "15  16   MeasAllAbuse  Measurement creates overly long output (CTF co...   \n",
       "\n",
       "     Manif.     Status  \n",
       "0    Silent      Fixed  \n",
       "1    Silent      Fixed  \n",
       "2    Silent      Fixed  \n",
       "3    Silent      Fixed  \n",
       "4    Silent      Fixed  \n",
       "5    Silent      Fixed  \n",
       "6    Silent  Confirmed  \n",
       "7    Silent  Confirmed  \n",
       "8    Silent   Reported  \n",
       "9    Silent   Reported  \n",
       "10   Silent   Reported  \n",
       "11  LongOut   Reported  \n",
       "12  LongOut   Reported  \n",
       "13  LongOut   Reported  \n",
       "14   Silent   Reported  \n",
       "15   Silent    Not Fix  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{@{}rllll@{}}\n",
      "\\toprule\n",
      "ID & Analysis & Description & Manif. & Status \\\\\n",
      "\\midrule\n",
      "1 & DoubleMeas & Redundant measurement & Silent & Fixed \\\\\n",
      "2 & GhostCompose & Missing compose assignment in a test case & Silent & Fixed \\\\\n",
      "3 & GhostCompose & Missing compose assignment in a test case & Silent & Fixed \\\\\n",
      "4 & GhostCompose & Missing compose assignment in a test case & Silent & Fixed \\\\\n",
      "5 & MeasAllAbuse & Measurement creates overly long output & Silent & Fixed \\\\\n",
      "6 & DoubleMeas & Redundant measurment & Silent & Fixed \\\\\n",
      "7 & MeasAllAbuse & Measure all generates a twice as long output & Silent & Confirmed \\\\\n",
      "8 & OpAfterMeas & Non idiomatic teleportation, lack of c\\_if & Silent & Confirmed \\\\\n",
      "9 & InsuffClasReg & Unused qubit & Silent & Reported \\\\\n",
      "10 & OpAfterTransp & Measure gate added after transpilation & Silent & Reported \\\\\n",
      "11 & OpAfterTransp & Measure gate added after transpilation (Grover's algor.) & Silent & Reported \\\\\n",
      "12 & MeasAllAbuse & Measurement creates overly long output (Bell pair) & LongOut & Reported \\\\\n",
      "13 & MeasAllAbuse & Measurement creates overly long output (GHZ algor.) & LongOut & Reported \\\\\n",
      "14 & MeasAllAbuse & Measurement creates overly long output & LongOut & Reported \\\\\n",
      "15 & GhostCompose & Missing insertion of the inverse QFT (Shor's algor.) & Silent & Reported \\\\\n",
      "16 & MeasAllAbuse & Measurement creates overly long output (CTF competition) & Silent & Not Fix \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# drop Issue\n",
    "df_real_bugs_reported.drop(columns=[\"Issue\"], inplace=True)\n",
    "display(df_real_bugs_reported)\n",
    "\n",
    "# export to latex\n",
    "table = df_real_bugs_reported.to_latex(\n",
    "    # index=False, column_format=\"p{0.1cm}p{2cm}p{6.2cm}p{0.8cm}p{0.8cm}p{1.4cm}\")\n",
    "    index=False, column_format=\"@{}rllll@{}\")\n",
    "# escape %\n",
    "table = table.replace(\"%\", \"\\\\%\")\n",
    "table = table.replace(\"_\", \"\\_\")\n",
    "\n",
    "print(table)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RQ3: Precision and Recall"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Precision on LintQ Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_annotations = pd.read_csv(PATH_LINTQ_ANNOTATION, header=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Considering noteworthy as FP\n",
      "Average precision: 0.7159661319073083\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAewAAAF+CAYAAABAhCkoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACal0lEQVR4nOzdeVhU5f//8ecMIIsiqOGuYKK4oOHKosCA+74n7lpqWZqmllqmYBnkimWZpolZiuKSfczMFbRwL1JTyCXUVNJcABdwhjm/P/hxvo6gDogDt96P65pL56yvMzPMPec+73OORlEUBUmSJEmSijVtUQeQJEmSJOnxZIMtSZIkSQKQDbYkSZIkCUA22JIkSZIkANlgS5IkSZIAZIMtSZIkSQKQDbYkSZIkCcC6KFaalZWFXq8vilVLkiRJUrFhY2ODlZWVWdNatMFWFIWUlBRu3rxpydVKkiRJUrHl7OxMxYoV0Wg0j5zOog12TmNdvnx5HBwcHhtOkiRJkp5ViqJw584drly5AkClSpUeOb3FGuysrCy1sS5XrpylVitJkiRJxZa9vT0AV65coXz58o/sHrdY0VnOMWsHBwdLrVKSJEmSir2cdvFxtV0WrxKX3eCSJEmS9H/MbRflaV2SJEmSJADZYEuSJEmSAIrkPOwHpYaFWWxdTtOnmz3twYMHeffdd4mLi8PDw4OKFSuajN+/fz8ZGRmPXMaCBQtYtGgRGRkZJCcnFyTyI927d4+2bduSkJCAnZ0dderUQa/Xk5qaSrt27fjwww+fuG4gIyODWrVqsWHDBpo1awZAbGwsycnJDB069JHTiWRD0mWLrq+nx6MrQh+0fft2Zs6cSVxcHK+++ipLly5Vx6WmptKtWzcSEhKoU6cOb775JoMGDXrsMkNDQxk6dChubm75jW8RycnJREVFERoaqg6bOnUq3377LW5ubsTGxhZZtvzQEGqxdSn5XJebm5v6/mdkZHDgwAFeeuklnJ2dAUhISCAhIcHin5EZM2awatUqkpKSCAwMBODGjRtUqFCBOXPm0LBhwydex7hx4wCIjIwE4ObNm0RGRjJu3Dh1+/OarqgUiwa7uGrevDmxsbFoNBomT55s0jgBZn2Ax44di5OTk8kXTmEqUaIEsbGx6HQ63NzciIqKArIrDps1a8adO3dYtGjRE63DxsYGDw8PSpcurQ6LjY0lNjbW5DXJazqp8LRp04Y2bdqg0WhYtmwZ3bt3p3PnzgA4OTmpn4OoqCizv1zDwsLUz05xlJycTFhYmMnfz0cffYS1tbUwjbUIcl7L5ORkatSoQWRkJDqdDkD919KmTZtG9erVGTZsmJpPURTefPNN2rVrx8mTJ00a1YKoWrWqyfObN28SFhbG0KFDTZb94HRFRTbYT2DFihVFHeGhypcvT48ePVi1atUTN9hWVlbs2LGj0KaTnoyrqyt169ZlxIgRHDt2jBdeeKGoI0kCy9l7fJgHG6+ipNFoGDlyJIsWLSI+Pp6OHTs+0fImTpxYqNM9bfIYdgHk7FkGBgZiMBgYM2YMzZo1Q6fT4ePjww8//PDI+a9du0bv3r3x8/NDp9PRqVMnDhw4oI7/66+/aN++PT4+PrRo0YJx48Zx9+7dfOfU6/XY2NgAYDAYmDx5Mp6enjRr1oygoCD++OMPddqzZ8/Svn17AgIC8Pf35+WXXyYpKQmAtm3b4uzsrO7lzJs3j6ioKBISEtDpdOh0Ou7evWsy3d27d2nWrBkajYbmzZtz5MgRAHr27EnJkiV57bXXALh16xYjRoygUaNGBAYG0r17d86fP5/vbX3eLF++HIPBwKhRox453dy5c2nQoAHe3t74+Piwe/duAK5fv67uOY0bNw6dTqf+sDMYDEyaNAkvLy8CAwNp27Ytx48fB2DJkiW4uLhQuXJlJkyYAMD58+exsbHhxo0bQHZXZvny5Wnbtu1jcwB07twZZ2dn3n33XUaNGoW/vz8ajYZ58+apjUnO52zfvn0m2zd79mxat25NrVq1+OabbwA4duwYderUwcrKCp1OR2pqKtevX6dFixaUKVOG2bNnF+Qlf2aZ02D/999/6HQ6tXend+/eNGjQAGdnZyIiInBzc1M/T6mpqeq09/eCPOpzlR85pz7lfLdt3bqV5s2b4+3tTcOGDVm4cKE6raIoTJkyhaZNmxIcHExAQADffvstkP09VqdOHbV36cSJE4SEhAAQEhKCTqdj48aNuaabPn06jo6OVK9enZkzZwLZfxdubm7Ur1+fv//+G4BvvvmGxo0bExAQQIsWLdi4cWO+t/VBcg/7CWVkZPDjjz9y9OhRSpUqxV9//UXz5s05fPgw7u7uec7zwQcf4ODgQHx8PJDd9fPTTz/h7e1NZmYm7dq1Y9KkSbz++usYDAa6d+/OuHHjWLx4sdm5Tp48SXR0tPqFPm3aNLZt28b+/fspVaoUS5YsoU2bNpw6dQonJydGjx5N8+bNmTFjBgBDhgxh3759eHh4sG3bNpNusfHjx5OWlqZ2i+e4fzp7e3vi4+OpVKkSI0aMoEmTJkD2Mf3XXntN3ZaRI0cCcOTIEbRaLeHh4XTo0IGjR4+afX3d51HFihX56quv6NGjB99++y0DBw7MNc2SJUuIjIzk8OHDVKhQgW3bttGhQwdOnjxJjRo11MM993d/QvZnZf/+/Rw4cABbW1tWr15NUFAQZ8+eZeTIkVy6dImtW7cyd+5cADZv3ozBYGDr1q3069ePadOmsWPHDn7++WezcmzevBmdTkd0dDS//vor1apV45VXXqFNmzY0btyYoKCgPLu/jxw5wrRp03jnnXfYvHkzISEh9OjRgwYNGrB582Zq1arFnDlzcHJyArL3kn7//Xfeeeedwn9DnnHu7u7q5yUmJoZNmzZhY2ODr68vkydPJiMjQ32Pcg7PPHiq0qM+V46OjmbluHv3LhEREdSqVYsWLVpw4sQJunXrxs6dO2nZsiX//PMPjRs3ply5cvTr14+YmBhiYmI4efIkNjY27Nq1ixkzZjBw4EDGjx9P2bJl1R2RevXqER0dTY0aNYiOjjY5THT/dGFhYdy4cYMjR47w/vvvA9nfYxs2bGDZsmVUqVKFn3/+mfHjx5OQkEDVqlU5c+YML730Etu3b8fX17fA74PcwzZTRESE+iv//l+kDg4OxMXFUapUKQBq165N3bp12blz50OXdfHiRVJSUtSCtbFjx6pfuKtWreLatWtqQ2Ztbc2wYcP4+uuvyczMfGTGrVu3otPpaNGiBa+99hrTp08nLCyMu3fvMn/+fN58800156uvvorRaOSrr75SM124cIGsrCwAZs6cSZs2bQrwSv0fGxsb+vbty8qVK9Vh3333HQMGDACy9+qjo6MZP348Wm32R3HkyJGcOHFCHp80Q/fu3Xn11VcZM2YM//zzT67xM2fOZOjQoVSoUAHI7impU6eO2tDmJeezMmbMGGxtbQHo168fGRkZrF27FsjeIz506JB6OcWcBnjz5s0AnD59Gnd3d/UL29wcrVq1olq1agB8/fXXNGjQ4JHbX758eYKDgwEICAjg9u3bnD59GshuYPz9/fn666/V6VesWJGrDkXKv379+mFra4tWqzXpGXwUcz5Xj5Lz3RsYGEi5cuXYvXs3Dg4OfPLJJzRv3pyWLVsC2cea+/fvr+75Xrx4kdu3b3P16lUAgoKCmDVrVkE228SgQYOIj4/nzJkz6noAqlSpAsDHH39MSEiIeuy7Zs2aBAUF8cUXXzzReuUetpnuLzqLjY1Vi7u0Wi27du1ixYoV6PV6rKysOHnyJCkpKY9cVvfu3XF1deXll19m2LBhNG7cGIDjx4+TlZWlfhFB9l58lSpVuHz58iOLg9q3b6/mut/p06fJyMgw2eO3srLCzc2NY8eOAdm/GgcNGsTu3bsJCQnhlVdeoXbt2ma+Og83aNAg/Pz8SE5Oxs3Nje+//55du3YB8Oeff6IoCmPHjlW7tyD7GG3OH5j0aJGRkcTFxfHKK6+oe7QA6enpnD9/Plcvj7u7u/qe5yXnsxIeHm7StVihQgW1y7tJkyaUL1+eLVu28PLLL5OVlUW/fv0YN24cWVlZ/O9//6NTp075zpHfwp7KlSur/88pdExLS1OHDRs2jPHjxzNv3jxSU1O5ffs2L774Yr7WIeVWkAIscz5Xj/KwH/DHjx/PVS3u7u7O559/jl6vZ+DAgaxcuZKaNWvSrVs3BgwYoH42n0SzZs2oU6cO3377LdOnTzfZEcnJ9c8//5j0XP3333/UqVPnidYrG+wCyPm1BxATE8Pw4cPZs2eP2tWh0+lQFOWh8/v6+pKcnMyGDRv4+uuvadKkCZ999hmjR48G4IUXXrD4Hmb37t35559/iI6OZunSpcydO5eYmBi6d+/+RMv18fHB3d2db7/9lvbt21OnTp1cp5l9++231KhR44nW87wqVaoU3377LS1btuTzzz8vtOXOmTOHoKCgPMdpNBo6duzI5s2bKVeuHK1ataJjx44MHTqUffv2sW3bNrP2mh6U30MgeU1//99dnz59GDNmDBs3buTSpUt5HjaQ8i+v1/3B7u+cnroHPepz9TS4uLhw5MgRdu3aRVRUFL1796Zr167ExMQ88bIHDRrE8uXLmT59Ohs2bMjVqzpw4EDCCvmUZdkl/oT27NlD9erVTY5L3Lt375HzbNy4kRIlSjBgwAB27tzJxIkT1WO6np6eXL58mfT0dHV6vV7PkCFDMBgMBcro7u6OnZ2d2l0I2X9QycnJarfjunXrcHJy4rXXXuPQoUP06NGDZcuWPXSZOV3YkN0D8Khr4A4aNIiVK1fyzTffMHjwYHV4/fr1AdTithzTpk0jMTExfxv5HPP29mbq1KlMmjRJLdjLKYq5/z0HOHPmjElX8/1ftOnp6epn5cH3ZOHChezZs0d93rlzZ7Zt28bGjRvp3Lkz5cqVw8fHh1WrVqHRaNRjkubmeJj7P2cGgyFfxZelSpWiT58+fP3116xbt47evXubPa+UP46OjibfWTldxDnM/Vzll6enZ56fLQ8PD2xsbDh48CAXLlygVatWrFy5kg0bNrBu3TquXbuW5/Lu/7wZjUZu37790HUPGDCAM2fO8Pnnn1O7dm1KlixpkuvBbd29e/cTn7EjG+wnVK9ePf755x/++usvIPvDcn/1dV4WLFjAtm3b1Od6vV7tfu7fvz9Vq1YlPDxcHR8ZGYlWq8XaumAdIvb29rz99tt88cUX6gdw+fLlaLVaRowYAcCkSZNMKjbvz5QXFxcXtStr/PjxJtvzoIEDB3Lq1Cl+/vlnk1/XL774Iv369WPWrFnq8fz4+HjWr1//0II9KW9Tp06lYcOGaoUqwPvvv8+KFSvUY807duzg5MmTanU3/N/7eOXKFYKDg9XPysKFC9X399SpUyxYsED9gQXZ54RnZmZy8OBB9b3q1KkTX331Va7aB3NyPIyLiwuQfcGMDRs2MG3atHy9LsOGDWPHjh3Ur1/f5AtVKlxeXl4kJiaqn5nVq1ebjDf3c5VfkyZN4uDBg2oB78WLF1m1apVaDLZlyxaTnie9Xs8LL7xAmTJl8lxeuXLl0Gq13Lhxg8OHDz+y5sHV1ZWAgAAmTpxosiMC2Z/5H374QW0Lbt++zXvvvffEXeIoFnL37l3lxIkTyt27dy21yid24MABJTAwUAEUDw8PpX379rmm0ev1yqhRo5Rq1aop7dq1U4YPH640bNhQcXV1VWbNmqVERkYqHh4eiq2trRIYGKjcuXNH+fbbbxUfHx8lMDBQ8fPzU3r27KlcunRJXeZff/2ltG/fXvH09FQCAgKUkSNHKrdu3cozY2ZmphIYGKg4OTkpFSpUUAIDA5XExMQ8c06aNEmpX7++0rRpUyUwMFD5/fff1fGRkZHq8ObNmyvDhg1T0tPTFUVRlDZt2ihOTk6Kq6ur8v777yuKoij//vuv0qxZM6VFixZKx44dlYyMjDyny9GyZUtlypQpuXKlp6crI0eOVDw8PBSdTqd06dJFOXXq1OPfnOfQtm3blMDAQPWz9Oeff5qMP336tFKqVCnl77//VofNnj1b8fT0VJo1a6Y0b95c2blzp8k8n376qeLh4aE0b95cWb9+vaIo2Z+VyZMnKx4eHkpAQIDSunVr5dChQ7nytGnTRhk/frz6/I8//lAA5a+//so17aNy9O3bV/3cdOrUKde8/fv3V7y8vBRfX18lMTFRCQ8PV1xdXRUnJydl0KBBys2bN9W/05deeknZtm2bOq/RaFRq1Kih/PLLL495daWffvpJ8fb2Vl/Hzz77TB13+fJlk9f4wb9vRVGUN954Q6ldu7bSqVMnZdOmTeq0MTExiqKY/7nKERYWpnh4eCiAEhgYqERGRuY53ZYtW5SmTZsqzZs3Vzw9PU1yHzhwQOnQoYPi6+urBAYGKv7+/kp8fLyiKIoyd+5ck+/mnO+7d999V6lfv77i7e2t/PLLLw+dTlEUZenSpUqVKlWUrKysXLlWrlypNGjQQPH19VVatGihfPvttw/dVnPbR42iPOJgayHKyMjg77//pkaNGtjZ2VlilZIkPecyMjLw9/fn0KFDRR1Fkh7K3PZRdolLkvTMiYiIwGg0snr1al5++eWijiNJhUJWiUuS9MxJSEjA09OTatWqsX79+qKOI0mFQjbYkiQ9c6Kjo4s6giQVOtklLkmSJEkCsHiDbTQaLb1KSZIkSSq2zG0XLdYlXqJECbRaLZcuXcLFxYUSJUrkujqOJEmSJD0vFEXh3r17XL16Fa1WS4kSJR45vcVO64LsK4BdvnyZO3fuWGqVkiRJklSsOTg4UKlSpeLVYEP2LwqDwfDQa81KkiRJ0vPCysoKa2trs3qcLd5gS5IkSZKUf7JKXJIkSZIEIBtsSZIkSRKAbLAlSZIkSQCywZYkSZIkAcgGW5IkSZIEIBtsSZIkSRKAbLAlSZIkSQCywZYkSZIkAcgGW5IkSZIEIBtsSZIkSRKAbLAlSZIkSQCywZYkSZIkAcgGW5IkSZIEIBtsSZIkSRKAbLAlSZIkSQCywZYkSZIkAcgGW5IkSZIEIBtsSZIkSRKAbLAlSZIkSQDWRR1Aev4YjUYuXbqEo6MjGo2mqONIkiRZnKIopKenU7lyZbRa8/adZYMtWdylS5eoVq1aUceQJEkqchcuXKBq1apmTSsbbMniHB0dAUhOTqZMmTJFnCZ/srKyOH78OJ6enlhZWRV1HLOJmhvEzS5zW55I2dPS0qhWrZr6fWgOjaIoylPMJEm5pKWl4eTkRGpqKqVLly7qOJIkSRZXkO9BWXQmFZmsrKyijpBvWVlZ/P7778JlFzU3iJtd5rY8kbObQzbYUpExGo1FHSHfjEYj58+fFy67qLlB3Owyt+WJnN0cssGWJEmSJAHIojOpyKTPm4d1iRJPvJydISMLNF8vj8X5nsceLat5CSfCuYs4v+Kfdm6F0EJfpiRJpuQetlRkNALWO+q1CtEel9Frxcouam4ArVaLh4eH2eeqFhcyt+WJnN0ccg9bKjJaARtsg5VCdJ2Uoo6Rb6LmBrCysqJOnTpFHSPfZG7LEzm7OZ7NnyGPcfDgQXQ6HRqNhjp16qDT6fD19aVly5Z8/vnn6PX6QltXUlKSuq7Y2Ng8p4mLi8PHxweNRkNycrJZy92+fbu63Lp16/Kws/Pee+89NBoNPj4+rFq1qoBb8XRkCfgr2NagZXp8TWwNYmUXNTeAwWAgPj4eg8FQ1FHyRea2PJGzm0O8v95C0Lx5c7XxnDx5MrGxsezbt49vvvmG1atX06ZNGzIyMgplXR4eHg9tqHMEBgYSHR2dr+W2adOG2NhYbGxsSExMZPPmzbmmuX37Nl9//TUA0dHR9O/fP1/rkHLTKtDoamlE61kWNTdkX8Lx6tWrD/1RWlzJ3JYncnZzPJcN9sO8+OKL/PjjjyQlJTFt2rSijmOWypUr07JlS+bMmZNr3PLly2nbtm0RpJIkSZIKm2ywH+Dk5MSwYcNYvHgxBoMBg8HA5MmT8fT0pFmzZgQFBfHHH38AkJCQkKsre8qUKVSsWJGhQ4fmWnZSUhJdu3alcePGNGrUiCNHjjwyS0pKCn369KFp06b4+/szZMgQrl+/nmu6CRMmsGfPHg4fPqwOMxqNrF69mgEDBuS57NmzZ+Pl5UVgYCCBgYHs3btXHZecnEyfPn3w9fUlMDCQNm3acOLECXW8oihMmTKFpk2bEhwcTEBAAN9+++1DtyMzM5O0tDSThyRJkpQ/ssHOQ9OmTUlLS+Ovv/5i2rRpbNu2jf3793Po0CH69etHmzZtSE1NxcvLK1dXdnh4OO3bt89zuatXr2bNmjX89ttvdO/enW7dupGZmfnQHL169aJmzZocPnyYvXv3Ym9vT79+/XJN17VrV2rVqmWyl71x40bat2+Pra1trumXLFnCsmXLiI2NJS4ujvDwcNq2bcu5c+cAOH78OBqNhvj4eOLi4hg8eDA9evRQjwvFxMQQExPDvn372LVrF6GhoSxduvSh2xEeHo6Tk5P6yLnxh5BV4lYKC73Oo7cSK7uouSG7kMjLy6vYXxv6QTK35Ymc3Ryywc5DznVdb9y4wfz583nzzTcpVaoUAK+++ipGo5Gvvvoq38sdNGgQ9vb2AIwbN45Lly6xfv36PKfdvXs38fHxTJw4UR02YsQItm3bxpkzZ0ym1Wq1vP3226xbt05tdL/44gtGjRqV57JnzpzJ8OHDcXZ2BsDPzw93d3e10Q0MDOTLL79Ub3358ssv89dff6nrvXjxIrdv3+bq1asABAUFMWvWrIdu95QpU0hNTVUfFy5cyM4tYINt0CrscL2GQbCDwaLmhuzPt6urq3Cn6sjclidydnM8m1v1hFJTU4HshjsjIwN3d3d1nJWVFW5ubhw7dizfy3V1dVX/7+TkRLly5Th58mSe0x4/fhytVkvv3r3R6XTodDrGjh2Lq6srly9fzjX9kCFDcHZ2Zv78+ezbt49atWrxwgsv5JouPT2d8+fPs3z5cnW5Op0OvV5Peno6ANbW1ixYsAB/f38CAwNp164dkN1FDzBw4EAqVapEzZo1CQkJYfPmzTRt2vSh221ra0vp0qVNHiBmlbidQcunu+pgJ1i1tai5Ibvyd9euXcJV/srclidydnPI87DzcOjQIZycnMy6Hm3OXuj9srKyCq1LZufOnWYty8HBgVGjRhEZGUliYiILFix45PQTJ05k2LBhDx33008/sX//fsqXLw9kb2dO5aWLiwtHjhxh165dREVF0bt3b7p27UpMTEw+t048GgWqp9ujEWxHVdTckF0zkZ6eLlzlr8xteSJnN4d4P7efstTUVFasWMGoUaOoXbs2dnZ2nD59Wh2flZVFcnIyDRo0AP7v3s45e6eQ3WWcl/Pnz6v/v3nzJteuXaNu3bp5Tuvp6YnRaOTUqVMmw0eNGsW1a9fynGf06NHo9XpsbGzw8PDIcxpHR0eqV69OUlKSyfA1a9ao3fN79uwhKChIbazv3btnMu3Bgwe5cOECrVq1YuXKlWzYsIF169Y9NJckSZL05GSDfZ+zZ8/SuXNn6tWrR2hoKPb29rz99tt88cUX3L59G8g+VUqr1TJixAgAypYtS/Xq1YmPjwcgMTGRhISEPJe/bNky7t69C8CCBQuoXLkyvXr1ynPaoKAg/Pz8mDlzprqnHxMTQ2JiIuXKlctzngoVKhATE8Ps2bMfuZ3vv/8+K1asUH9AXL16lbCwMDw9PQGoV68e+/bt486dOwC5jrNv2bKFzz//XH2u1+t54YUXKFOmzCPXK0mSJBXcc9klfvDgQd59910AIiIiiIqKIjMzE61Wy4ABAxg5ciTW1tkvzYwZMzAajXh7e2Nvb0/JkiXZtm0bTk5O6vK+/PJL3n77bVatWkXz5s3p1KkTW7duZfjw4bzzzju89tprQHbVd8+ePfn3339RFIXvv/8eW1tb4uLimDRpEgAhISHMnz8fX19fNmzYwNixY/H09KRChQpUqFCBNWvWmGxDSkoKOp2Ob775hurVq9OlSxc115IlS/jiiy/U5U6aNIkePXowcuRIbt26Rfv27SlXrhxWVlZERkaqe+Xz5s1jxIgRNGjQAE9PTxo1agRkF8rNnj2bjh07Ehoaip+fHyVKlMBoNPLDDz/ku9BDI+At8DKtjIT6nibTSqzsouaG7LoRX19f4Sp/ZW7LEzm7OTTKs9rZLxVbaWlpODk5kZqaqhagSZIkPU8K8j0ou8SlIlOY12y3FL1ez48//ihcdlFzg7jZZW7LEzm7OWSDLUn5JOopI6LmBnGzy9yWJ3L2x5ENtiRJkiQJQDbYkiRJkiQAWXQmWVxOscXNmzdNqu1FkHNhBkdHxzwvmlNciZobxM0uc1ueSNll0ZkkWUDO9eBFI2puEDe7zG15Imd/HNlgS0VGxOIQg8HAli1bhMsuam4QN7vMbXkiZzeHbLAlSZIkSQCywZYkSZIkAcgGW5IkSZIEIKvEJYsTvUrcYDBgbW1d7KtQ7ydqbhA3u8xteSJll1XikmQBOXdcE42ouUHc7DK35Ymc/XFkgy0VGRErOQ0GA7t37xYuu6i5QdzsMrfliZzdHM/l7TWl4qEqc8mgRFHHyBd7tKzmJZwI5y7i3KpS1NwgbvbCzq0Q+uShJKHJPWxJkiRJEsBz02DfuXOH6dOn4+vri06nw8fHhyFDhpCcnFzgZQ4YMIA6deo8dPw777xDo0aN8PHx4eWXXyY2NpaoqKgCry+v9bu5uaHRaFi9enWe09y4cYNSpUpRsWJF2rZtW2jrfp7dsc4q6ggFImpuEDe7qLmtrcXtfBU5++M8F1XiGRkZ6HQ6WrZsSXh4ODY2NgCsXr2a8ePHs2PHDurXr5+vZd65c4dKlSqRlpbG4cOHadKkicn4uLg4OnbsyNWrV3FwcGDu3Lmkp6cTGxtLbGxsYW0aoaGhfPzxxzRs2JDDhw/nGh8eHs706dPp379/of5YeBI51ZGkTobStkUdR5KEILvEny2ySvwhQkNDuXfvHrNnz1Yba4B+/frRp08fBg8enO9lbtq0iWHDhlGyZElWrVqVa3xycjIuLi44ODgAMGHChIJvwGP07duXI0eOsHv3bpPh9+7dY/PmzXh7ez+1dT8JjTiHI1VaI3hdcUQrWHZRc4O42UXNbTQauXLlCkajYMERO7s5nvkG22Aw8OWXX9K3b988z8vr378/v/32G3Fxcfj4+KDRaFi8eDFt2rShfv36BAQEcPbs2VzzrVq1iuHDh9O1a1fWrFlj8gFZuHAh4eHhpKSkoNPpCAkJYd68eURFRZGQkIBOp0On06mnHxw8eJCAgAD8/Pzw8/Pjww8/JCsruytt6tSpuLm5odPpmDNnDu3ataNkyZJERkaq62vVqhVeXl7MmTMnV8Y+ffpgZWWVK/9ff/1F+/bt8fHxoUWLFowbN87kdIgvvvgCb29vgoKCaNasGTNnzuT+zpjffvuNwMBAdDodfn5+vPLKK6SkpOT5HmRmZpKWlmbyALDNKt7nSebFNktL6D53bLPE+tMRNTeIm13U3FlZWezbt0/9DhKJyNnNIdYnqQCSkpJITU2lbt26eY7PGf7nn38SHR0NwM8//8zWrVv5888/qVmzJn379jWZ5/r161y6dAlPT0/69evHxYsXiYuLU8ePHj2ayZMnU7FiRWJjY4mOjmb8+PEMHToULy8vtVvc3t6eq1ev0rZtW6ZMmUJ8fDzbt29n48aNzJo1C4CPPvqIoUOHcuTIEerUqcPPP//MwoULKVHCtLp6woQJ/PTTT5w8eVId9vXXX/Pqq6/m2ubMzEzatWtH9+7d2b9/P3FxcZw+fZpx48ap00RFRbFs2TJ2795NbGwsa9euZeXKler4gQMHMmTIEGJjY9m7dy/JyckkJibm+RqHh4fj5OSkPqpVq5bndJIkSdLDPfMN9s2bNwEoVapUnuNzht+4cUMd9uabb6p7pW+//TaHDx8mPj5eHb9u3Tp69+4NQLt27ShTpkye3eLmWLhwIVWrVqVDhw4AlCxZkgEDBvDFF1+YTPfCCy/QuXNnAIYNG8Ybb7xhMr5v375UrlyZuXPnArBt2za8vb1xdHTMtc5Vq1Zx7do1Ro4cCWQXaQwbNoyvv/6azMxMAGJiYvD09FQzdezYkZ9++kldxsWLFzl37hwAVlZWLF68mIYNG+a5jVOmTCE1NVV9XLhwIX8vkiRJkvTsn4ft7OwMwO3bt/Mcf+vWLQDKli2rDnN1dVX/X7NmTQBOnjyJn58fkF2stnz5cgBKlChBz549Wb9+PZ9//nmuPd/HOX78OJcvX0an05lksrGxQa/Xq8fcq1at+sjl2NjY8NZbbzFt2jRmzpzJp59+yqJFix66zqysLIKDg9VhGRkZVKlShcuXL+Pm5sY///zDW2+9xX///YeNjQ3JycnUqFFDnT48PJy3336bmJgY+vXrxyuvvGLyGt7P1tYWW9vcxWWKeD3iKBo473hXuOyi5gZxs4uaW6PR4OjoWOwv7ZkXkbOb45lvsD08PChdujQnT56kS5cuucbndCH7+PiYtbyLFy/yxx9/MHToUHXYzZs3uXHjBlu2bKF79+75zujp6fnYyvG8jkM/aOTIkXz44YeMGjXqsV3PL7zwwkPXee7cOdq0acOMGTOYOHEikF24d//0b7zxBr169eLbb79l6dKlzJo1ix07duSrwC3TWrwTFDKsjbwVnHfXf3Emam4QN7uoua2trU1+zItE5OzmeOa7xK2trXn99ddZu3ZtnuOjo6Px8/OjUaNG6rDz58+r/z9z5gzwf8e6o6OjiYiIUI9Dx8bG8ttvv1GlSpXHdotrtf/3cmdkZKDX6/H09OT06dMmRWtXrlxh9OjR+d5WZ2dnXn31VTZu3Mj48eMfOp2npyeXL18mPT1dHabX6xkyZAgGg4HDhw9z9+5dk2P39+7dM1nGunXrqFChAhMmTODYsWN4enry7bff5iuvlYCFnNZGDa3PlcPaKNYveFFzg7jZRc1tNBo5d+6ckJXWImc3xzPfYAOEhYVRokQJJk2aZHKN2bVr17J+/XpWrFhhMv2yZcvUNzwyMpKmTZuq3eHr16+nT58+JtNrtVr69+/P5s2bTRrBB7m4uKjHysePH8+2bdsYPXo0t2/fZunSpUD23WY+/PBDXFxcCrStkyZNYuXKlbnOC79f//79qVq1KuHh4eqwyMhItFot1tbW1KlTB41Gw86dO4Hsi+nff/waYPjw4Vy+fFl9bjAYqF27dr6y2ghYJW6TpWF0QnXhsouaG8TNLmrurKwsEhIShKy0Fjm7OZ6LBtvOzo6dO3fi4OBAQEAAOp0OX19ftm3bxv79+3F3dzeZvlOnTnTu3Jn69etz6tQp1qxZA0D79u05evSoWqyV48cff2TLli3cvXuXgIAAZsyYQUREhHpaV878vXr1wtbWlpYtW3Lu3Dlat26Ni4sL27dvZ+XKlTRu3JiAgAAcHR2ZOnUqABERESang50+fVpd7xtvvEFUVBQRERHMmDEDgEqVKjFw4EAge69Yp9ORkJDA1q1b6datG5B9TPnnn3/m999/p0GDBgQGBnL69GkWLlwIQP369Vm0aBFhYWEEBAQwePBgatasSUJCAgMGDFDX3blzZ4KCgvD19SUgICBXIZwkSZJUeJ6LK52ZK6ew6u+//8bNza2o4zyzcq7w899//1GuXLmijpMver2eLVu20LFjR5OL8BR3ouYGcbPL3JYnUnZ5pTNJKCJWcmo0GlxcXITLLmpuEDe7zG15Imc3h9zD/v/i4uKYNGkSBw4cwNvbm/nz5+Pr61vUsZ5JBfllKUmS9CyRe9hPIDAwkP3796MoCvv375eNtQWIWBiSlZVFYmKicNlFzQ3iZpe5LU/k7OaQDbZUZEQ89cJoNJKUlCRcdlFzg7jZZW7LEzm7OWSDLUmSJEkCkA22JEmSJAlANthSkbn/ym+i0Gq1VK9eXbjsouYGcbPL3JYncnZzyCpxyeJklbgkSc87WSUuCUXESs6srCx+//134bKLmhvEzS5zW57I2c0hG2ypyIhYyWk0Gjl//rxw2UXNDeJml7ktT+Ts5pANtiRJkiQJQDbYkiRJkiQA2WBLRUbESk6tVouHh4dw2UXNDeJml7ktT+Ts5pBV4pLF5VRHrjychEMpR3V4L4/FRZhKHAqhRR1BkqQnJKvEJbEYxavktDVomR5fE1uDWH86BoOB+Ph4DAZDUUfJN1Gzy9yWJ3J2c4j1rfMQ27dvR6fTodFoqFu3Lg/rNHjvvffQaDT4+PiwatUqi+VTFIVq1arx2muv5Ro3ZcoU3Nzc0Ol0ACQlJanbEhsb+0TLKvYE7NvRKtDoamm0gmVXFIWrV68+9G+jOBM1u8xteSJnN8cz0WC3adOG2NhYbGxsSExMZPPmzbmmuX37Nl9//TUA0dHR9O/f32L59uzZw+XLl1m3bh16vd5kXHh4OEOHDlWfe3h45NlQF2RZkiRJ0rPjmWiwc1SuXJmWLVsyZ86cXOOWL19O27ZtiyAVrFq1ikmTJnH9+nW2bt1abJYlSZIkieOZarABJkyYwJ49ezh8+LA6zGg0snr1agYMGJBr+tmzZ+Pl5UVgYCCBgYHs3btXHZecnEyfPn3w9fUlMDCQNm3acOLECXW8oihMmTKFpk2bEhwcTEBAAN9++63J8vV6PXv37iU0NJQqVao8UVd8fpb10Ucf0apVK6pXr86ECRPUCwmEhITg7OxMaGgoAHFxcXh5eaHRaMzerlu3bjFixAgaNWpEYGAg3bt35/z58/nfIK3m8dMUM3orhYVe59FbidXlZmVlhZeXF1ZWVkUdJd9EzS5zW57I2c3xzDXYXbt2pVatWiZ72Rs3bqR9+/bY2tqaTLtkyRKWLVtGbGwscXFxhIeH07ZtW86dOwfA8ePH0Wg0xMfHExcXx+DBg+nRo4da0BATE0NMTAz79u1j165dhIaGsnTpUpN1/Pzzz7Rq1QobGxv69u3LDz/8wO3btwu0beYu69ChQ3h4eLBz504OHjzIqlWr+OKLL4DswwFeXl7qtIGBgURGRprM/7jtGjlyJLdv3+bIkSPExcXh7e1Nhw4dHno5wMzMTNLS0kweAGjE+/gZtAo7XK9hEOwgtlarxdXVVcjTXUTNLnNbnsjZzfHMbZVWq+Xtt99m3bp1asP7xRdfMGrUqFzTzpw5k+HDh+Ps7AyAn58f7u7uauMUGBjIl19+qe59vvzyy/z111+cOXMGgIsXL3L79m2uXr0KQFBQELNmzTJZx6pVq9Tj5f369ePOnTt8//33Bdo2c5dVtmxZ+vTpA0DFihXp168fn376qdnredR2nT17lujoaMaPH6/+UYwcOZITJ0489Nh7eHg4Tk5O6qNatWrZIwSsErczaPl0Vx3sBKwS37Vrl5DVs6Jml7ktT+Ts5hDrW8dMQ4YMwdnZmfnz57Nv3z5q1arFCy+8YDJNeno658+fZ/ny5eh0OvWh1+tJT08HwNramgULFuDv709gYCDt2rUDICUlBYCBAwdSqVIlatasSUhICJs3b6Zp06bqOm7fvs2xY8fw9fUFoGnTpri7uxeoWzw/y3J1dTV5XrNmTc6cOZOrSO1hHrVdf/75J4qiMHbsWPU169WrF66urmoD/6ApU6aQmpqqPi5cuJA9QqydVAA0ClRPt0cjWHZFUUhPTxeyelbU7DK35Ymc3RzWRR3gaXBwcGDUqFFERkaSmJjIggULHjrtxIkTGTZs2EPH/fTTT+zfv5/y5csDoNFo1A+Di4sLR44cYdeuXURFRdG7d2+6du1KTEwMAJs2bSI9Pd3kNCu9Xs+2bdv477//cv2IeJTCXNb9x6sh912zHrddAN9++y01atQwa322tra5DkdIkiRJ+fNM7mEDjB49Gr1ej42NDR4eHrnGOzo6Ur16dZKSkkyGr1mzhvXr1wPZp1AFBQWpjfW9e/dMpj148CAXLlygVatWrFy5kg0bNrBu3TquXbsGwOrVq9m2bRuxsbHqY9u2bRgMBtauXZuv7cnPsh4sADtz5gw1a9bExsZG3facXgTI7gI3d7vq168PkOt1mzZtGomJifnaJkmSJMl8z2yDXaFCBWJiYpg9e/ZDp3n//fdZsWKF2sBdvXqVsLAwPD09AahXrx779u3jzp07AGpDnmPLli18/vnn6nO9Xs8LL7xAmTJluH79OtevX6d27dom89SuXZtmzZrlq1s8v8u6fPkyGzZsALK776Ojo3nrrbfU8V5eXuzfvx9FUTAYDKxbt87s7XrxxRfp168fs2bNIiMjA4D4+HjWr1+Pu7u72dsEgICFIZlWRkJ9T5NpJdbt+6ysrPD19RWyelbU7DK35Ymc3RzifWPm4eDBg+h0OlJSUtDpdGoD3KVLF+rUqQNkV4SPGzcOyD61aePGjYwcOZJ33nmH9u3b4+/vT58+fYiMjFT3yOfNm4ebmxsNGjSgW7du6l7luHHj2L59Ox07duTYsWP4+fmh0+mYN28eP/zwA6dOnSIoKIhz584xc+ZMk6wzZ87k0qVLxMfHo9PpmDJlClFRUSQkJKjryOn2HjduHJ988km+l+Xn58eBAwcICgqiefPm9OvXjzfeeEOd76233qJkyZI0atSIvn370rlzZwB0Oh2nT59+6HblFJktWbKEWrVq4eXlRVBQEBEREWzatAlr63weYdGId1qXUQsJ5dMxCvaXo9VqKV++vJDVs6Jml7ktT+Ts5pA3/5AsLuei9//99x/lypUr6jj5klM30LZtW/UQgwhEzQ3iZpe5LU+k7PLmH5JkAaKeMiJqbhA3u8xteSJnfxzZYEuSJEmSAGSDLUmSJEkCkMewJYvLOXZz8+ZNnJycijpOvuRcmMHR0THX+ezFmai5QdzsMrfliZRdHsOWJAuwt7cv6ggFImpuEDe7zG15Imd/HNlgS0VGxOIQg8HAli1bhMsuam4QN7vMbXkiZzeHbLAlSZIkSQCywZYkSZIkAcgGW5IkSZIEIKvEJYsTvUrcYDBgbW1d7KtQ7ydqbhA3u8xteSJlt2iVuF6vV6/ZbTSKdSMESXoSd+/eLeoIBSJqbhA3u8xteSJnf5x8N9iZmZm8/vrrlCxZkqCgIABeeeUVXn311Wf6hZIKn4iVnAaDgd27dwuXXdTcIG52mdvyRM5ujnw32JMnT+bixYtER0er94leunQpdevWZfz48YUeUJIkSZIkyOf9EOHw4cPExcWh1WpZuHBh9kKsrZk4caK6xy1J5kifNw/rEiWKOka+GLRaaNiQtIgIrAU6FPSw3DtDRhZhKjNlZWEF/O/Uv/D/73Pcy2Nx0WYygz1aVvMSToRzF3E+K6Lmhv/L/qzK9x52VlaWeq/RB+vVrl+/XjipJKkYs8rKKuoIBSJqbgBF0Psb37EW8zUXNTdk70A+q/L9V+Dk5MRXX30FoFbh3b59m6lTp1KlSpXCTfcU3LlzhxkzZuDv709QUBB+fn60bt2azz77jCtXrlgkQ0JCApGRkXmOO3HiBCEhIQQEBBAQEIC3tzeDBw/mf//7H1lZWcTFxeHj44NGoyE5OfmJs9y7dw+dToezszMVK1ZEp9Ph5+eHu7s7ISEhJq/JxYsXqVChAhcvXlSHff/993z//fcFWreVQHuoOayNRvyPHRNq7xrEzQ2AlRXG2k3VvWtR3LUx0r/TUe7aiPWai5obsrN36tSp2N8Lu6Dy3WB/+umnhIeH4+zszKFDh6hRowblypUjOjqazz777GlkLDR37twhKCiI1NRUdu/eze7du4mPj2f06NFMmDCBL774wiI5HtZgx8XF0apVK0aNGsWePXvYs2cPu3btwsrKiq5du3LhwgUCAwOJjo4utCwlSpQgNjYWLy8v2rdvT2xsLPHx8Rw+fJgjR47w5ptvqtPa2dnh4eFhcq3eJ2mwxfs6yM583dFRuOyi5gZAUeDWzex/BaI1gtcVR7SCveii5obs7FeuXHlmz1zKd4Ndq1YtEhMTmT9/Pq+99hq9evXiyy+/5MSJE9SsWfNpZCw006ZN4969e8yZM8ek26R79+4mDVNRyMzMZMCAAUyaNInAwEB1eMmSJVmyZIla4Gcpzs7OdOnShV27dqnDypUrx549eyhbtmyhrEPEbk6jVsvRmjUxCpZd1NwAGI1Y/fMXCPYlbJulJXSfO7ZZYr3mouaG7Oz79u0jS+DDP49SoHekRIkSDBs2jDlz5jBnzhyGDh1KiRIlOHr0aGHnKzQGg4GvvvqKkJCQPE+onzBhAr179wbg1KlTdOjQgSZNmtCgQQNGjx5NRkYGAOvWrcPLywuNRsPmzZvp2rUrtWrVYsyYMSbLW7VqFc2aNSMoKAhfX1+mTJmiDo+IiCAlJQWdTodOp+Pvv//mhx9+4OLFi/Tr1y9XNhsbG9atW4eLi8tDty80NJTmzZuj0+lo1qwZS5cuNRm/fft2fHx81DxvvfUWt2/ffuRrptfr1dfq+vXr6HQ67OzsiIqKAuDdd99l69atbN26FZ1OR7du3R65PEmSJKngCnx0Pi0tjdTUVJPCs9dff534+PhCCVbYEhMTSUtLo27dunmOr1q1KlWrViUzM5N27doxfPhw3nvvPe7du0fbtm0ZO3Ysixcvpnfv3rzwwgsEBQVx4sQJfvjhB65cuUL16tXp2bMnQUFBXLp0icGDB/PXX3/x4osvcvXqVerUqUN4eDj9+/fn3r17hIaGEhsbq67/888/p0yZMlSoUCHPfP7+/o/cvpUrV/LLL79QqVIlrly5gpeXF7Vr1yYgIACDwUDv3r3ZuHEjwcHB3L17l0aNGjF+/HhKliyZ5/LOnDnDunXrGD58OABly5YlNjYWNzc3dZpZs2apx7hzGvG8ZGZmkpmZqT5PS0t75LZIkiRJueV7D3vnzp28+OKLlClTBjc3N2rUqEGNGjVwc3PjwIEDTyNjoUhNTQWgVKlSj5xu1apVXLp0iXHjxgHZvQnjxo1j2bJl/PvvvybT5uwNly9fnnr16pGQkADAv//+S1ZWlloU5uLiwpYtWx6b73HZHmXXrl1UqlRJzRMYGMhPP/0EQHp6OmlpaWoee3t71q5dm+vHQc6eso+PD56envj6+jJ58uQCZ8oRHh6Ok5OT+qhWrdoTL7MoOQh6gSBRc6MBpYQ9FO8rTeaiaOC8410UmdtiFA04OjoW+8uSFlS+G+zRo0czadIkjh07xtmzZ00ezZs3fxoZC4WzszPAY7uBjx8/TqVKlXBwcFCHubu7k5WVxYkTJ0ymrVy5svp/R0dHdc/Ry8uLQYMG0bp1a4KDg1myZAmenp6Pzfe4bI9y7Ngx2rVrR8uWLdHpdOzevZuUlBQAypQpw5QpUxgxYgTNmzdn3rx5VK1aNdeN3nOKzvbv309qairVqlXDy8uLGzduFDgXwJQpU0hNTVUfFy5cAMStEm+elCRctbWouQHQWmF8sQFoxaoSz7A28lZwIhnWYr3mouaG7OzBwcHP7Kld+W6wq1SpwmuvvUa9evVwdXVVH25ubnz99ddPI2OhqFOnDk5OTrka3Sdhdd9pJhqNRj08oNFo+Oabbzh27BhNmjTh/fffx8vLi5s3bz50Wd7e3ly/fj3XXrw5Dhw4QLdu3RgxYgS//PILsbGxtG/f3uRwxccff8yZM2fo1KkTkZGR1K1bl7Nnzz50mSVKlOCDDz7g3LlzrF27Nt+Z7mdra0vp0qVNHgBGAX8FGzUaLpUtK1x2UXMDoBjR3LwCilgNiLVRQ+tz5bA2ivWai5obsrOfO3dOVonn6NWrF7/88kue4z755JMnDvS0WFlZMWrUqIc2Pl26dGHixIl4enpy+fJl7ty5o447c+YMVlZW1KtXz6x1Xbx4kX379lG/fn1mz57Nn3/+yaVLl9i5cyeAeuEZyD4POjMzk65du+Lq6sqaNWtyLe/y5cvY2tpy7NixPNf3yy+/oNFo6NWrl8lyc6Snp/Pzzz/j5ubG9OnTSUxMxN7eno0bNz5yO3J+pT7qurz3b8udO3fyVZ2pCNh4GDUa/qpeXbiGT9TcABgVtCnJYBTrtC6bLA2jE6pjkyXWay5qbsjOnpCQIKvEc/Tt25cPPviA2rVrExgYSHBwsPr44YcfnkbGQhMaGoqDgwPvvvuu2ggpisJnn33Gn3/+yTvvvEP//v2pXLkyn376KZBdKb1gwQJeffXVhxaEPejUqVO888476PV6IPtuZoqiUKtWLSD7mHZOwV5kZCRLly6lRIkSREdHM2vWLPbu3asu6/r16wwePJhXX32VBg0a5Lm+evXqqRdVAbh27Zr6/5znb7zxBrdu3VK3OSsri9q1az9yO5YsWYKdnR2tW7d+6DQuLi5ql3nv3r1JTEx83MsjSZIkFUC+O/r79u1LVlYWPXr0MDnOCxTKlbeeJltbW7Zv386sWbMIDAzExsaGzMxM6tevT1xcnNog//zzz4wZM4aYmBju3btHQEAAc+bMAbILs3IKsXQ6HRs2bGDChAkkJCSQnJxMyZIlGTRoELVq1cLX15dSpUpx+/ZtPv/8cxo2bAhAcHAwTZs2xdvbGwcHB2JiYgDw8fFhx44dTJ8+nffeew8rKysyMzPp168fo0ePBrIvrjJp0iQAQkJCmD9/Ph06dGD69OkMHjyYWrVqUalSJerUqcPWrVuZMGECM2bMoFOnTgQGBlK6dGnS09N588036dKli1oFn5CQQGJiIjqdDoCbN2/i6OjIxo0b8fDw4Pr16/Ts2ZOUlBQiIiK4desWo0ePZtiwYfTp0wd/f39q1KhB/fr1LfZ+SpIkPU80yoMXBH+MRo0a8fvvv+c5bv78+bz99tuFEkx6duXcuP3v996jjGA3/8jSajnu5oZncrJQRXMPyy3EzT+MWWgvnsJYpZZaeCbCzT9sDVomH6xBRPO/yRSogEvU3JCdfdfB1jRv3rzYF57lfA+mpqaqdT2Pk+8tatCgAZmZmdja2uYal3NakSSZo+ykSWZ/UIuTgKIOUEB55e5p8RQFVLeqyVOF0KLJkR/WgB8iJDUlam5Qsz+rCtRgBwUF0blzZypVqmRSKR0REUFISEihBpSeXSIWhmRlZXHq1Clq1apl8tkv7kTNDeJml7ktT+Ts5sh3gz1t2jQqVqyo3rHrfgU5JUl6fol46oXRaCQpKYmaNWsK9YUgam4QN7vMbXkiZzdHvhtsHx8fdu/enee4oKCgJw4kSZIkSVJu+T6ta/PmzQ8d97CGXJIkSZKkJ5PvBvthN4sAaNOmzROFkZ4vWgFv9ajVaqlevbpw2UXNDeJml7ktT+Ts5sj3aV16vZ5PPvmEn376iZSUFJPLX6akpJhcIUyS8lKQ0xkkSZKeJQX5Hsz3z5DJkyfz66+/MmTIEEqUKMH06dOZMmUK9erVo3///vkOLT2/RK0S//3334XLLmpuEDe7zG15Imc3R74b7F9//ZXNmzczcuRIKlWqxJAhQxgxYgSbNm164rs6Sc8XUavEz58/L1x2UXODuNllbssTObs5CnQMO6dc/v4bTFhZWXHp0qXCSyZJkiRJkirfDXZmZiZbt24FoHr16rz99tv8+uuvzJgx45G3j5QkSZIkqeDyfR722LFjWbZsGQ0aNGDq1KkEBwezYMECHBwc+O67755GRukZJWIlp1arxcPDQ7jsouYGcbPL3JYncnZz5LtK/EF37twhMTERNzc3ypYtW1i5pGeYrBKXJOl599Ru/rFz505atWqV5zgHBwcaN25sfkpJ+v9cDBHcQ6y7dYl6J6Pimtucm3gYDAYOHjwoxB2Y7idzW57I2c1hVr/BzJkzn3YO6TmkfaK+naKhVaDR1dLCZRc1N4CiKFy9epUn7Ay0OJnb8kTObg6zGux9+/bx4osv5nrUqFGDF198kfLly2NlZUWJYnZv4zt37jBjxgz8/f0JCgrCz8+P1q1b89lnn3HlypWnss5bt26h0+mws7MjKioKgM6dO2Nra0v16tUZM2aMOu2+ffvQaDScOnVKHTZ16lSqVq1Ks2bNOHHixCPXNWHCBOrUqYNGoyE8PDzPaQwGA66urjg7O6PT6bh+/fqTb6QkSZJkcWb1GTzqhh8//vgjI0aMoEaNGqxcubJQwz2JO3fuEBQURMuWLdm9e7faPfL999/z8ssvc+3aNUJDQwt9vaVKlSI2NhY3Nzd12ObNm2nTpg0ODg589tln6vCdO3cCsGvXLmrVqgXARx99REJCAmvWrHnkZWAB5s6dS4MGDRg5ciSfffYZEyZMyPWjKSYmhsuXL+Pn50dsbGzhbKQkSZJkcWbtYS9evDjXsNu3bzNy5Ei6du1Khw4dSEhIwNfXt9ADFtS0adO4d+8ec+bMMTmW0b17d958802L5wkODmbPnj0mV+D55Zdf8PPzUxtuyL70q16vf2xjfb8+ffrw77//5lmlv2TJEjp16vRk4Z8SvZV43VZ6K4WFXueFyy5qbsi+xoOXl5dwt0uUuS1P5OzmMKvBrl27tsnzX375hZdeeokNGzYQExPDsmXLKFWq1FMJWBAGg4GvvvqKkJAQNBpNrvETJkygd+/eAJw6dYoOHTrQpEkTGjRowOjRo8nIyABg3bp1eHl5odFo2Lx5M127dqVWrVom3dqQ3Q3ev39/atSoQbt27Vi6dGmudQYHB3Pz5k1+++03ADIyMjAYDHTt2pXdu3erx1wOHDiAt7e3Ot/KlSvx8vLC29ubRo0aERMTk2vZtWrVokuXLsydO9dkeGxsLC+99BJOTk655klJSaFPnz40bdoUf39/hgwZYtJdHhMTQ4sWLQgKCqJ58+aMHz+ezMxMdfzZs2dp3749AQEB+Pv78/LLL5OUlJRrPY+SJeCZFwatwg7XaxgEOxgsam7IPlXH1dVVuFN1ZG7LEzm7OfK1VXq9nnfffZegoCBq1qzJsWPH6Nmz59PKVmCJiYmkpaVRt27dPMdXrVoVT09PMjMzadeuHf7+/hw5coQjR45w/Phxxo4dC0Dv3r2JjIwE4MSJE/zwww/8+uuvfPXVVyaHCCZOnMjp06c5ceIEP//8M6mpqfz7778m62zatCmlS5dW96bj4+Px9fUlODiY//77j6NHjwLZ3ePBwcEAbNu2jTfeeIM1a9Zw4MABvvnmGwYPHkx8fHyubZo4cSJ//vmnelEbgMjISMaNG5fna9CrVy9q1qzJ4cOH2bt3L/b29vTr108dv2bNGt577z12797Nr7/+yokTJ/jkk0/U8aNHj6Z58+bs2bNHnX/fvn15riszM5O0tDSTB4CtIfePqeLOzqDl0111sDOI9YUgam7I/gG+a9cuDAZDUUfJF5nb8kTObg6z/3r/+OMPGjduzMKFC5kzZw4///wzlSpVMpmmuFzpLDU1FeCxe/2rVq3i0qVLaqNWokQJxo0bx7Jly3I1uDmNWfny5alXrx4JCQlA9t718uXLGTVqFPb29gC8+eabuT4wVlZWBAQEsGvXLiC7YW7VqhWNGzfGyclJbcj379+vHlqYOXMm3bt3x8PDA4AGDRrQrl07Pv7441zb0rJlS5o3b86cOXMASEpKwtbW1uRYeo7du3cTHx/PxIkT1WEjRoxg27ZtnDlzBoD58+fTsWNHAGxsbOjRowc//fSTOv3Fixe5cOGC2sU/c+bMh95eNTw8HCcnJ/VRrVo1ADTi7eyhUaB6ur1w2UXNDdmVv+np6cJV/srclidydnOY1WB//PHHeHt7Y21tzeHDh9U90AcVl71tZ2dnIPs4+6McP36cSpUq4eDgoA5zd3cnKysrV4V25cqV1f87Ojqqe4lnzpzh3r17vPjii+p4Ozs7ypcvn2t9wcHB/Prrr9y7d09tmK2srAgMDGTnzp1kZGSg1WqxtbVV87m7u5ssw93dnWPHjuW5PRMmTGDnzp0kJCQwb9483n777Ydut1arpXfv3uh0OnQ6HWPHjsXV1ZXLly8D2Sf19+/fHz8/P3Q6HfPnzyclJUVdRlhYGOvWraNmzZpMnjyZO3fuUKVKlTzXN2XKFFJTU9XHhQsX8pxOkiRJejizqsSnTp0KgL29PaNHj85zGkVR+OOPPwov2ROoU6cOTk5OnDhxgi5duhTKMu8vYtBoNI/9BZfXsfPg4GDu3LnD9u3bsbGxURvm4OBgPvjgA+Li4vDz8ytwxl69euHm5sZ7771HZmYmPj4+j5x+586deRZn3L59m+DgYPr27ct3332HVqslKirKpKq+e/fu/PPPP0RHR7N06VLmzp1LTEwM3bt3z7U8W1tbdVslSZKkgjFrD9vb25u///6b1atXs3z58oc+crpui5qVlRWjRo1i7dq1eY7v0qULEydOxNPTk8uXL3Pnzh113JkzZ7CysqJevXpmratmzZrY2Nhw9uxZdVhmZmauLnWAhg0b8sILLxAWFkZAQIA6PDg4mPT0dD755BP1+DWAp6cnp0+fNlnGmTNnaNCgwUO3e+zYsfz000+88cYbD83s6emJ0Wg0Of8bYNSoUVy7do3ExESuXLlCnz591OKN++/MBtkFeU5OTrz22mscOnSIHj16sGzZsoeuMy+ZAlYsZ1oZCfU9TaZV8blamDlEzQ3Zn+uc3iiRyNyWJ3J2c5jVYL/55pu4uro+8uHm5lYkp0s9TGhoKA4ODrz77rvq8WRFUfjss8/4888/eeedd+jfvz+VK1fm008/BbKL6hYsWMCrr75KhQoVzFpPqVKleOWVV1i0aBF3794FYOHChXnugWs0GnQ6HYcOHcrVMJcvX57Dhw/TtGlTdfj777/Ppk2b1IY1p6jsvffee2ie4cOHs3jxYnr06PHQaXIuIjNz5kz1vrExMTEkJiZSrlw53NzcsLe3V4+rZ2VlsWnTJpNlTJo0iePHj6vP9Xp9rrMJHkcRr/4JoxYSyqdjFCy7qLkhu/K3fPnywlX+ytyWJ3J2c5i1VQMHDjRrYeZOZwm2trZs376dUqVKERgYiE6nw8/Pjz/++IO4uDgqVKiAra0tP//8M7GxsTRp0oTGjRtTt25dtTJ869atakFazlXChg0bRkJCAlFRUcyePRuAOXPm4O7uTr169WjTpg1arZaqVasSERHBwoULTXIFBwdTunRpk4Y5pyEPCAgwOWe8bdu2LFy4kD59+uDt7c3AgQNZsWKF2m0+Y8YMIiIiiIqKUveoS5UqxciRI9UPbM+ePdm6dSsJCQnodDr1R8WGDRvQ6/V4enoSFBTE+vXrWbNmDQDlypXju+++Y/Xq1Xh7e9O7d28qVKhASkqKek35t956i2HDhqHT6fD29qZMmTKEhYXl6z2y04tXJW6v17Lqx4bY68X6QhA1N2T/GPzxxx/R6/VFHSVfZG7LEzm7OZ74bl2SlF85d6mx+28KGeWK1+VsH8der2X1lpfo1/EP7tqI071cXHObc/MPvV7Pli1b6NixIzY2Nk8/VCGRuS1PpOxP7W5dkvQ0/MMEylGuqGPkix49W9hCKlOwoXh/IdxP1NySJP0f8frHJEmSJOk5JLvEJYvL6Qq6efNmnpdNLc5yLszg6OiY56l7xZWouUHc7DK35YmUvSBd4vnewz516hTffPONeoGNH374gW7duvHOO++YnB4lSc+qnCvaiUbU3CBudpnb8kTO/jj5brCnTp2q3qzi1KlT9OnTBzs7O86cOcNbb731NDJKzygRr/drMBjYsmWLcNlFzQ3iZpe5LU/k7ObId9HZ5cuX2bNnD5B9ycmXXnpJPR2oON1eU5IkSZKeJfnew845v9doNBIdHc2IESPUcc9yV4QkSZIkFaV872Hb29sTGhrKhQsXuH79OiEhIUD2Vbged7MNSZIkSZIKJt9V4n///TejR4/m4sWLhIWF0a1bN9avX8+kSZMYO3YsY8aMeVpZpWeE6FXiBoMBa2vrYl+Fej9Rc4O42WVuyxMpe0GqxAv1tK47d+6Y3KpSkvIieoMtymkj9xM1N4ibXea2PJGyW+S0rkfp3LlzYS5OesaJWMlpMBjYvXu3cNlFzQ3iZpe5LU/k7OYw6xj2+PHjqVq1KuPHj6dGjRoP/eWSkpJSqOEkSZIkScpmVoN9f6+5nZ0dkydPznOaTz75pPCSSZIkSZKkMqvBnj9/vvr/kSNHMmTIkDynu3HjRuGkkp4L6fPmYV1CrLt1GbRarOrXJy0iAmtj8bnr1eOYm3tnyEgLpjJTVhZarZb/nfoXrKyKOo35niB3L4/FTynU49mjZZm1J06EcxdxPuNQNNnNueNcYSmUorMbN25QpkyZwsgjPQdyii3OT55MaTu7oo4j3adYNtjPoaJssKX8KWiDbZGis++++47g4GAOHz6Moij07duXcuXKUaFCBQ4ePJjv0NLzS6zf7tmMwHVHR+Gyi5obAEWBWzez/xWJoLm1RvC64ohWwA+LyNnNke8Ge8mSJXzwwQc0bdqUH3/8kU2bNrF582YWL17Mu++++zQymuXgwYPodDo0Gg116tRhxowZFlt3cnIyOp0Of39/vLy8WLVqFTdu3KBLly74+fnRqFEj5s6dC8CFCxcYMWIE/v7+BAYG4uPjQ58+fVizZg0ZGRkkJSWp2xEbG1so+Xr27EnFihVxdnZGp9MRGBhI/fr1adWqFceOHSuUdRSEohXv7q5GrZajNWtiFCy7qLkBMBqx+ucvEOgQBCBsbtssLaH73LHNEu+zInJ2c+R7q2xsbAgKCgKy97b79u1Lx44d6d69e5Ge99a8eXO1gZs8eTLTpk2z2LrDwsJwc3Nj7969xMTEUKpUKT799FPS09OJj49n586dlC1blpMnT+Lj40ObNm3Yu3cvcXFx7N27l9q1axMSEsL+/fvx8PAotIY6x4YNG2jfvj1eXl7ExsYSFxfHsWPHqFixIl27dkWv1xfq+iRJkqTCl+8GOzU1FaPRyOXLl/nhhx8YOnSoOu55/eJPTk7Gzc0NgFq1atG1a1eTYWXLlmXYsGEMHjyYPn368PLLL6vz2tjYMHPmTBo1amTRzFqtlpCQEJKTk0lKSrLouiVJkqT8y3eD3bp1a+rUqUPTpk2pW7cuQUFBXLhwgcmTJ+Ps7PwUIhbMrVu30Ol02NnZMWvWLAYNGkSzZs3w9fXl77//Vqc7e/Ys7du3JyAgAH9/f15++WWSkpJISUnJ1TW9YMEC3Nzc0Ol06vydO3fm999/JyoqCp1OR1RUFMOHD+enn35i69at6HQ6IiIiOHToEIcPH6Zfv3555l26dCn16tV76PZ88cUXeHt7ExQURLNmzZg5c6bJ6Xa//fYbgYGB6HQ6/Pz8eOWVVx57XnzOD6z7e0ZSUlLo06cPTZs2xd/fnyFDhnD9+nWT17V///7UqFGD1q1bM3fuXNzc3KhTpw4LFy7Mcz2ZmZmkpaWZPETmcPduUUcoEFFzowGlhD0U7wtX5SZobkUD5x3vogiWG8TObo58N9jh4eF89NFHvPPOO2zduhXI/pK3t7dn+vTphR6woEqVKkVsbCwVK1Zk3bp1LFq0iEOHDlGpUiVCQ0PV6UaPHk3z5s3Zs2cPe/fuxd7enn379lGxYsVcXdNjx4416VEA2Lx5M15eXgwdOpTY2FiGDh3K0qVLad++Pe3btyc2NpbJkydz4MABAOrWrZtn3saNG1O+fPmHbk9UVBTLli1j9+7dxMbGsnbtWlauXKmOHzhwIEOGDCE2Npa9e/eSnJxMYmLiQ5d3+/ZtvvzyS1q0aGHyQ6FXr17UrFmTw4cPq6/H/T8yJk6cyOnTpzlx4gQ7duzAaDTyzz//MHnyZEaPHp3nusLDw3FyclIf1apVA8BKsGN7ANZGI82TkoQ6pQvEzQ2A1grjiw1AK9ApXSBs7gxrI28FJ5JhLd5nReTs5sh3g/3OO+/w8ssvM27cOF544QUAmjVrxvTp02nWrFmhBywMXbp0oVSpUgDodDoSEhLUcRcvXuTChQtkZWUBMHPmTNq0aVPoGVJTUwHUHPkVExODp6cnACVLlqRjx4789NNP6viLFy9y7tw5AKysrFi8eDENGzY0WUZCQgI6nY5mzZpRrlw5mjZtyo4dO9Q97N27dxMfH8/EiRPVeUaMGMG2bds4c+YMt27dYvny5YwaNUq9leqYMWMeW7swZcoUUlNT1ceFCxcAMBbza/3mxajRcKlsWeGyi5obAMWI5uYVUAT7EhY0t7VRQ+tz5bA2ivdZETm7OfLdYH/55ZcMHTqUuLi4p5HnqahcubL6f0dHR5Mu2bCwMNatW0fNmjWZPHkyd+7coUqVKoWeIedwQUFvQfrPP//QrVs3WrRogU6nY/Xq1SZd3uHh4URERFCvXj0+/PBDHBwcKFu2rMkycorODh06xPTp0/n888+5evWqOv748eNotVp69+6NTqdDp9MxduxYXF1duXz5MmfOnOHevXu8+OKL6jx2dnaP7BkAsLW1pXTp0iYPAEXAxsOo0fBX9erCNXyi5gbAqKBNSQajWKdHiZrbJkvD6ITq2GSJ91kRObs58t1g+/n5MW7cODZs2IC3tzcffvihusdUXFndd5UhjUZjcuy3e/fu/PPPP0yZMoWdO3dSv359vv/++4cuK2dPPL+8vb0BOHHiRL7nPXfuHG3atMHf359ff/1V7Xq/fzveeOMNzp8/z6uvvsqqVauoU6eO2g2fl3feeQcXFxdmz56da9zOnTuJjY0lNjaWX375heTkZFq2bPnQZRX3u+JIkiQ9C/LdYP/88894eXmxYMECfvnlF+rXr8/o0aNp164dq1evJjMz82nkfGrWrVuHk5MTr732GocOHaJHjx4sW7ZMHe/o6Eh6err6/OLFiwVaT9OmTfHx8WHNmjW5xmVkZODi4sLmzZvznPfw4cPcvXuXvn37qsPu3buXazsqVKjAhAkTOHbsGJ6ennz77bcPzWNtbc3YsWP5+uuv1UvKenp6YjQaOXXqlMm0o0aN4tq1a9SsWRMbGxvOnj2rjsvMzOTff/99/AsgSZIkPZF8N9j3f5n/999/nDp1isTERHbs2MFXX31FQEAAY8aMEebOXZMmTeL48ePqc71eT+3atdXnXl5exMfHA/Dvv/+ye/fuAq/r22+/Zd26daxbt04ddvv2bUaMGEHz5s3p1KlTnvPVqVMHjUbDzp07Abh7967J8WuA4cOHc/nyZfW5wWAw2Y68vPLKK9jY2PDll18CEBQUhJ+fHzNnzsT4/4uTYmJiSExMpFy5cpQqVYpXXnmFRYsWcff/VxwvWrQIa2uzLkn/TNAAZdLSRCv8FTY3kF1tXbK0cNXWouY2auB3lzREPAwscnZz5LvBHjZsGBs2bKBTp064urqyePFiBgwYwNmzZ9m1axcHDhygZ8+e9OnT52nkfaicK50BREREMGPGDHQ6HSkpKURERLBq1SrWrFlDREQEKSkptGrVCoC33nqLYcOGodPp8Pb2pkyZMoSFhanLnTdvHps3b6ZFixZ88MEH9O7dm4SEBPXe3507dyYhIUE9rSs1NZXhw4ezdetW9bSunPOca9asyb59+9i6dat6LDo4OJhatWqxfv16NBqNeqUzgHHjxrFx40bq16/PokWLCAsLIyAggMGDB1OzZk0SEhIYMGAAkN0l3rlzZ4KCgvD19SUgIIA33ngDyL7S2datW9Wis9OnTwPZxWsjR47kk08+QafTcffuXTZs2IBer8fT05OgoCDWr19v0iswZ84c3N3dqVevHu3ataNUqVKUL18eGxubfL9nIlaJWxmNvHT2rHDZRc0NZFdbV6sjXLW1qLkzrY2E+Z0hU8BKa5GzmyPfN//QarWULFmSnj17qg3dg9LS0mjatCl//fVXYeWUiokbN25QunRptS7AaDRSsmRJduzYQYsWLcxaRs5F769fvy7cTWOysrI4deoUtWrVMqmNKO5EzQ3iZpe5LU+k7Ba5+cdLL73EpUuXWLFiRZ6NNWR3/fbs2TO/i5YEMHPmTJNj40uXLqV69eoFOqXPKODentFoJCkpSbjsouYGcbPL3JYncnZz5Pvg4/bt23F0dMxz3KZNm+jWrZvaFSs9e1q3bs2HH37I8uXLMRgMODs7s3nzZkoIdl9rSZIk0ZjVYO/Zs8eshYWFhdGtW7cnCiQVbzlXcJMkSZIsy6wG+2Fd3w+S5+NK+aEV8FaPWq2W6tWrC5dd1NwgbnaZ2/JEzm4Os4rOgoKCzDqdydzppOdbQYotJEmSniVPrehs8eLFZi3M3OkkCQp+1biilJWVxe+//y5cdlFzg7jZZW7LEzm7OcxqsB93AY4cb7755hOFkZ4vIlZyGo1Gzp8/L1x2UXODuNllbssTObs58l0lrtfr+eSTT/jpp59ISUkxuZ61KFc3kyRJkiTR5LvBnjx5MidOnGDIkCHMnz+fyZMnc+/ePTZt2kRwcPDTyChJkiRJz718N9i//vorv/76K1ZWVkRHRzNkyBAg+7rUL7/8cqEHlJ5dIlZyarVaPDw8hMsuam4QN7vMbXkiZzdHvhvskiVLqpd8u/+OUVZWVly6dKnwkknPvOJ+6cC8WFlZUadOnaKOkW+i5gZxs8vclidydnPk+2dIZmYmW7duBaB69eq8/fbb/Prrr8yYMYObN28Wdj7pGWYwGIo6Qr4ZDAbi4+OFyy5qbhA3u8xteSJnN0e+97DHjh3LsmXLaNCgAVOnTiU4OJgFCxbg4ODwyPsvS9KD8nnfmWJBURSuXr0qXHZRc4O42WVuyxM5uzny3WD36dNHvXVmlSpVOHv2LImJibi5uVG2bNlCDyg9u9LnzcNasGuQG7RaaNiQtIgIrC106sjOkJFPvpCsLKyA/536F4r5oYheHqbXc7BHy2pewolw7iLO6Toyd+FTCC3qCEXqiY/MOzg40LhxY8qWLcvcuXMLI5MkSZIkSQ/I9x42QFxcHAkJCaSlpZl0PURFRTFhwoR8LevOnTt88sknbNu2DVtbWzIyMvDw8CAsLAw3N7eCxCs0hw4domfPnpw6dQo7O7tCX/7w4cPZvHkz7du3JyoqymTcN998w/Lly9FoNNy7dw+j0Ujr1q0JCQmhXr16AIwbNw6AyMjIQs+Wl/nz5xMXF8f333+vDgsNDWXo0KEFeq80AnZbaRWF2ufPoxUtu1aDsaIbaMW73r/eSmGh13n0VmK95jK35VlZWeHl5SVkQas58t1gv/XWW3z11VfUq1cPR0dHkxt+5LfoLCMjg+DgYFq2bMmePXuwsbEBYPXq1fj6+rJjxw7q16+f34iFxtHREQ8PDzVXYVu6dClDhw7NNXz06NGcOHGCdevWUa5cOQBOnjxJ+/bt2bNnD7GxsQBUrVr1qeR6mIoVK/Liiy+aDAsLC0On0xWowRau0SM7c+Xr14s6Rv5ptCjO5Ys6RYEYtAo7XK8VdYx8k7ktT6vV4urqWtQxnpp8d4lv3bqV8+fPc+TIEWJjY9m9e7f66N69e76WFRoayr1795g9e7ZJo9ivXz/69OnD4MGD8xuvUNWpU4cdO3ZY9Nfa5s2bWbZsGatWrVIba4C6devy6aefmkw7ceJEJk6caLFs/fr1Y968eYW2vCwBz5U0aLUc9PDIPpYtEmMW2rPHwCjeNZbtDFo+3VUHO4NYr7nMbXkGg4Fdu3Y9s1Xi+X5H6tati4uLS57j8vNlbjAY+PLLL+nbt2+et+Xs378/v/32G0FBQdjY2FC7dm2WLVsGwIwZM6hYsSJNmjTh7t27AMyePRsvLy8CAwMJDAxk7969ANy6dQudToednR2zZ89m0KBBNG/eHI1Gw82bN9m+fTs+Pj4EBQXh6+vLW2+9xe3btzlx4gQ6nQ6NRqPu0YaGhuLl5YVOp0On0+Hp6YlGo2HDhg3qNk2aNEnN0bZtW44fP26yXR9++CGurq4EBgYyYcKEXBepX7RoETqdjooVK+Z6TTp06MC0adPU17pOnTrqnu3jthNgzpw5NGjQgICAAJo0acL06dMxGAxERETg5uam3kY1NTU117avWrUKLy8v9b26fv26Ov24cePQ6XQsWrQoz/c6MzOTtLQ0k4fI7tjbF3WE/FNAc+8uiNepgUaB6un2aATLLnNbnqIopKenyyrxHCNHjmTOnDn069ePypUrmzS2PXv2ZNeuXWYtJykpidTUVOrWrZvn+Jzhffr0wdHREUdHR1599VUApk2bxubNm9mzZw92dnYsWbKEZcuWsX//fpydnYmPj6dVq1YkJibi6upKbGwsbm5urFq1it27d+Ps7Ezr1q3RaDT07t2bjRs3EhwczN27d2nUqBHjx4+nXr16xMbG5voxERkZiU6nQ1EUWrduTZkyZdSehWnTprF//34OHDiAra0tq1evJigoiLNnz+Lo6Eh0dDRz5szh999/58UXX+TAgQO0bt2aXr16qcs/cODAQ3sWSpQooV7+dfz48ZQtW5bQ0FAASpUq9cjtXLJkCZ9++imHDx+mfPny/PXXXzRq1Ii3336byZMnk5GRoTbOTk5Ouba9f//+VK5cmaCgIADKli2rTpPzmjxMeHg4YWFhDx0vSZIkPV6+97C7dOnCu+++S/Xq1bG2tsbKykp9xMXFmb2cnL2+UqVK5Tk+Z/iNGzcYNGgQ33//Pbdu3QJg//79vPTSS2oh2MyZMxk+fDjOzs4A+Pn54e7uztKlS02W2b17d3WaHTt2YDQaSUtLIzk5GQB7e3vWrl1LhQoV8sz01ltv4e3tDcBnn33GgQMHiIqKQqvVcvfuXebPn8+YMWOwtbUFsruQMzIyWLt2LQCffvop3bt3V48De3t74+XlZbKO1NTUh74m5npwO52cnJg5cyZDhgyhfPns45i1a9dm+vTplLDAaVVTpkwhNTVVfVy4cOGpr1OSJOlZk+897JdeeinPqmRFURg+fLjZy8lpUG7fvp3n+JzGuWzZsnTp0oUSJUqwfv16hgwZwjfffKPuhaanp3P+/HmWL1/O5s2b1fn1ej3p6ekmy3ywSKtMmTJMmTKFESNG8OWXXxISEsLQoUOxf0iXZ8555klJSUyePJnZs2dTs2ZNAE6fPk1GRgbh4eEsXLhQnadChQrcuHEDyC4ca9eunckyq1evnut1edhrYq4HtzPnNXJ3dzcZ/u677z7Resxla2ur/oi5n0bAW+BpjUYanjmDVrTsWi1ZVWuDaMfegUwrI6G+p8m0Eus1l7ktz8rKCl9fX1klnmPq1KkEBgbmOc7Jycns5Xh4eFC6dGlOnjxJly5dco0/efIkAD4+PtjZ2dGnTx9WrlxJv379OHjwIJ9//rnJ9BMnTmTYsGGPXGdeb+LHH3/MyJEjWbFiBZGRkXzyySfs27cvVzV0jqysLIYMGYKvry9vvPFGrvFz5sxRu43N8WCXu7e3NydOnDB7/rwU5MP6YA5L3ABevKYjO3PZB34ICkGjgVLORZ2iQIxaSCgv3msuc1ueVqtVexGfRfn+zrz/eCvA0aNHmTx5Mm5ubiQkJJi9HGtra15//XW1u/hB0dHR+Pn50ahRIwAGDRrE7t27Wbx4MR07dlQbGEdHR6pXr05SUpLJ/GvWrGH9+vWPzJCens7PP/+Mm5sb06dPJzExEXt7ezZu3PjQeSIiIjhx4gRff/21WtCVnJyMu7s7dnZ2uXIsXLiQPXv2ANnH5c+ePWsy/vz58ybPx4wZQ2xsLP/++2+udc+dO5emTZs+cpvykvMaPbjupUuXqjdscXR0NOmRuHjxolnLvr+hf7BH43FErRLf26CBeFXiWVlo/zoMFvghVtjs9VpW/dgQe71Yr7nMbXl6vZ4ff/wRvV5f1FGeigK9I+fOnSM8PJwGDRrQqFEjPv30U7y9vdXuYXOFhYVRokQJJk2aZFKGv3btWtavX8+KFSvUYS1btqR69eq8++67uYqy3n//fVasWKE2flevXiUsLAxPT89Hrv/atWu88cYbave7oihkZWVRu3btPKdPSEggLCyM+fPnq+f6JSQkEBUVhb29PW+//TYLFy5Uu8BPnTrFggUL1HPJ33rrLb7//nu14Tx06BAHDhwwWUe7du0YPXo0AwYM4Pp95/vu3buXWbNmFfi0qvfff59vvvmGq1evAvDHH38wa9Ys9deol5cXiYmJavbVq1ebtVwXFxdu3LjBlStXnpv7oWcJ2t0m4iGIHA4GMV9zmdvyntVTuiAfXeL//fcfa9asYdWqVezfvx+tVotOpyMrK4v9+/dTunRpvv7663yt3M7Ojp07dzJr1iwCAgIoUaIEmZmZ1K9fn/3791OlShV1Wo1Gw8CBA9m5c2euY7EjR47k1q1btG/fnnLlymFlZUVkZCQeHh4A6HQ6UlJSiIiI4JdfflGL0VxcXOjUqROBgYGULl2a9PR03nzzTbp06cKJEyfULu9x48YxdepUoqKiMBgMfPXVV3z11VcApKWlqfcBnzFjBoqi4OvrS4UKFShRogSrV69Wz6cOCQnh9OnTBAUF4ebmRt26denZsydbt25l+PDhaq7Zs2fz3Xff0bNnTwCMRiOOjo5s2rQJHx8fIPu0riVLlpCSkoJOp2Pz5s107tw5z+3MeY1SU1MJDg6mTJky2NrasmHDBqytsz8CwcHBDB06FB8fH2rVqsXIkSNNtv3evXvMmjVLfT2XLl2Ku7s7U6dOZcqUKTg5OTFlypR8vf+SJElSPihmaNeunWJjY6NotVrFz89P+eyzz5R///1XURRFCQoKMmcRkqRKTU1VAOW///4r6ij5du/ePeX7779X7t27V9RR8kXU3IoibnaZ2/JEyp7zPZiammr2PGbtYeccm5wyZQoTJ05UK7wl6Unk7N2LxNramqCgIOGyi5obxM0uc1ueyNnNYdYx7F9//ZVTp05RqlQpWrduTbdu3VizZg0ZGRlPO58kFTsPO+2vuBM1N4ibXea2PJGzP47ZRWeurq5MnjyZw4cP8/HHH3P06FGaN29OYmIiO3fuRFEUxo4d+zSzSs8YEYtDDAYDW7ZsES67qLlB3Owyt+WJnN0cBaoSr1+/PjNnzuTo0aOsX7+eTZs20ahRI7MriyVJkiRJyp8n7uj39fXF19eXrKwsWrRoURiZJEmSJEl6QKGdGW9lZcW2bdsKa3GSJEmSJN1HoyjP6H3IpGIrLS0NJycnbt68ma/L2RYHiqJgMBiwtrbO87awxZWouUHc7DK35YmUPed7MDU1ldKlS5s1j3jXnpOkIpZzD3bRiJobxM0uc1ueyNkfRzbYUpERsZLTYDCwe/du4bKLmhvEzS5zW57I2c0hG2xJkiRJEoBssCVJkiRJALLBlqR8EvWyh6LmBnGzy9yWJ3L2x5FV4pLFFaQ6UpIk6VlSkO/BZ/eniFTsORvDUbAtsvUrhOZ7HqPRyH///ccLL7yAVitOB5WouUHc7DK35Ymc3RzP3hZJwrDNKt7nSeYlKyuLffv2kZWVVdRR8kXU3CBudpnb8kTObg5h97Dv3LnDJ598wrZt27C1tSUjIwMPDw/CwsJwc3Mr0DIHDBjAkSNHSExMzHP8O++8w44dO7C1taV69eq88cYbJCcnM3To0IJvyP8XFRVFaGiomj0xMZGMjAy8vLwAuHnzJl5eXkRFRT3xuiRJkiTxCLmHnZGRQXBwMLdv32bPnj3Exsayf/9+2rdvj6+vL3/++We+l3nnzh02b95MUlISR44cyTU+Li6OL774gl9//ZX9+/fj7e1NbGxsoTagQ4cOJTY2ltjYWNq3b4+Xl5f6PDIystDWI0mSJIlHyAY7NDSUe/fuMXv2bGxsbNTh/fr1o0+fPgwePDjfy9y0aRPDhg2jZMmSrFq1Ktf45ORkXFxccHBwAGDChAkF34A8eHl5odPpHjrezc2N7t27F+o6i5oiXo84Go0GR0fHYn/ZwweJmhvEzS5zW57I2c0hXINtMBj48ssv6du3b55vSv/+/fntt9+Ii4vDx8cHjUbD4sWLadOmDfXr1ycgIICzZ8/mmm/VqlUMHz6crl27smbNGoxGozpu4cKFhIeHk5KSgk6nIyQkhHnz5hEVFUVCQgI6nQ6dTqdeEu/gwYMEBATg5+eHn58fH374oXpMZerUqbi5uaHT6ZgzZw7t2rWjZMmSxMbGmtVgP2z+yMhIbty4wbBhw2jevDmBgYH4+/vz66+/mmxHnTp1cHNzIyoqig4dOuDu7k5ERITJuiIjI2natCnBwcH4+fmpe/cLFixQ5589ezatW7fGzc2NIUOGFOhygJnW4p2gYG1tTXBwsHCnjoiaG8TNLnNbnsjZzSHcViUlJZGamkrdunXzHJ8z/M8//yQ6OpoaNWrw888/s3XrVqysrBg2bBh9+/bl0KFD6jzXr1/n0qVLeHp60q9fP1avXk1cXBxBQUEAjB49mlKlShEaGkpsbKw6X1pamtplnePq1au0bduW1atX06FDB27fvo2/vz/W1tZMmTKFjz76CGtra+bOncvEiROZOHEiy5cvN7vBe9T8Fy9eJCkpifj4eKytrdm7dy/dunXj9OnTODs7q9sxatQoNBoNP/30E0ePHsXLy4s+ffpQs2ZNDh48yAcffMDFixcpXbo0f/31Fx07dmTcuHGMHTsWJycnhg8fjkajYceOHdy6dQtfX18++OAD5syZk2fmzMxMMjMzTV43ACsjiFYaYjQauXDhAtWqVROqClXU3CBudpnb8kTObg7htujmzZsAlCpVKs/xOcNv3LihDnvzzTexsrIC4O233+bw4cPEx8er49etW0fv3r0BaNeuHWXKlMmzW9wcCxcupGrVqnTo0AGAkiVLMmDAAL744guT6V544QU6d+4MwLBhw3jjjTfytZ685q9VqxYbN25Uf136+/tjY2PDgQMHTOZVFIUBAwYA0LBhQ5ydnTl69CgAFy9eRK/Xc/HiRQBq167Nd999ZzK/RqNh9OjRQPbrPWLECBYtWvTQ6/eGh4fj5OSkPqpVqwaAjaBV4gkJCcJVoYqaG8TNLnNbnsjZzSFcg+3s7AzA7du38xx/69YtAMqWLasOc3V1Vf9fs2ZNAE6ePKkOW716Nf369QOgRIkS9OzZk/Xr13Pv3r185zt+/DiXL19Wu8l1Oh2rV6/GxsYGvV6vTle1atV8L/t+ec1vY2PDd999R0BAAAEBAeh0Om7cuEFKSorJdC4uLiZdRo6Ojupeb4cOHfD396dhw4Z06dKFVatW0bhxY5P5K1SogJ2dnfq8Zs2a3Llzh3PnzuWZdcqUKaSmpqqPCxcuFHi7JUmSnlfCdYl7eHhQunRpTp48SZcuXXKNz2mIfXx8zFrexYsX+eOPP0xOzbp58yY3btxgy5YtBSr08vT0NOkmz0vOHn9B5TX/3LlzmTlzJocPH8bd3R3IPvb94MXsHpxXo9Go09jZ2bF9+3YOHDhAVFQUr732Gp999hl79+4t8HEhW1tbbG2L7gIpkiRJzwLh9rCtra15/fXXWbt2bZ7jo6Oj8fPzo1GjRuqw8+fPq/8/c+YM8H/HuqOjo4mIiFCPRcfGxvLbb79RpUqVx3aL33+MJCMjA71ej6enJ6dPnzYpWrty5Yrahfw07dmzhyZNmqiNNZDvXoLExESOHz+Ot7c3ixYtYv/+/ezfv58//vhDnebKlSsmx6TPnDmDg4ODSU+GOYzi9Yij0WhwcXERrgpV1NwgbnaZ2/JEzm4O4RpsgLCwMEqUKMGkSZNMjpuuXbuW9evXs2LFCpPply1bpjagORXQfn5+AKxfv54+ffqYTK/Vaunfvz+bN28mPT39oTlcXFzUY+Xjx49n27ZtjB49mtu3b7N06VIg+3jxhx9+iIuLy5Nv+GPUq1ePo0ePcvXqVQDi4+O5fPlyvpaxf/9+PvroI3WPW6/XqxeKyWFlZcWiRYuA7EMQS5cuZdSoUfneA78naJW4n5+fcFWoouYGcbPL3JYncnZzCNlg29nZsXPnThwcHNRjtb6+vmzbto39+/eb7GECdOrUic6dO1O/fn1OnTrFmjVrAGjfvj1Hjx5l5MiRJtP/+OOPbNmyhbt37xIQEMCMGTOIiIhQT+vKmb9Xr17Y2trSsmVLzp07R+vWrXFxcWH79u2sXLmSxo0bExAQgKOjI1OnTgUgIiLC5HSw06dP59q+kJAQtm7dqk6Tc1z+cfO///77tGrViqZNm9KlSxdiYmKoWLEiERERrFy5kqioKHU72rZtC2Qfs05JSVGn8fPzIysrCx8fH4KCgnj99ddZt26dyQ+OChUq4ODgQLt27fD09KRRo0Z8+OGH+X4frQSsC8nKyiIxMVG4ohZRc4O42WVuyxM5uzme6bt1JScnU6NGDf7+++8CX65UMpVzCdXk5OQCLyPnLjV2/00ho1yJwguXTwW5+Yder2fLli107NjR5KI9xZ2ouUHc7DK35YmUXd6tSxLKP0ygHOWKOoYkSZIQhOwSN0dcXBwhISFAdhfzvn37ijiR+BYsWGByaKAgVzeTJEmSCuaZ3cMODAxk//79RR3jmTJ27FjGjh1baMsT8UpEWq2W6tWrC5dd1NwgbnaZ2/JEzm6OZ/oYtlQ8FeTYjSRJ0rOkIN+Dz+bPEEkIIlZyZmVl8fvvvwuXXdTcIG52mdvyRM5uDtlgS0Xm/ovLiMJoNHL+/HnhsouaG8TNLnNbnsjZzSEbbEmSJEkSgGywJUmSJEkAssGWioyIlZxarRYPDw/hsouaG8TNLnNbnsjZzSGrxCWLk1XikiQ972SVuCSU+2/cIgqDwUB8fLxw2UXNDeJml7ktT+Ts5pANtlRkROzcURSFq1evCpdd1NwgbnaZ2/JEzm4O2WBLkiRJkgCe2UuTSsXfT2eu4PDfvSdeTi+PxYWQxjz2aFnNSzgRzl0efq5nQe4EJkmS9ChyD1sqOlpNUSfIN72VwkKv8+itxOpys7KywsvLCysrq6KOkm+iZpe5LU/k7OYQcg87IyOD+fPns2XLFqytrcnMzCQrK4s2bdrQr18/bty4wcSJEzlw4MBTvRd2ZGQkOp0OLy8vk+EGg4HPP/+c9evXY2VlhV6vR6vV0qlTJ0JCQnB1dX0qeYSjEe/3okGrsMP1WlHHyDetVivs507U7DK35Ymc3RzCNdh3796ldevWNGnShB07dmBrawvAwYMHad++PadPnyY6Opro6Ghq1KjxVLNERkbi7Oxs0mAbjUZ69eqFg4MDW7duxcHBAYD4+Hg6duzIyZMniYqKeqq5hGEU73q/dgYts/bU5t2Av8iwFufyhwaDgT179hAQEIC1tVh/9qJml7ktT+Ts5hBuF2fatGncuXOHBQsWqI01QPPmzfnwww+LMFm2L774goMHD/L111+rjTWAn58fYWFhRZisGBKrVxkAjQLV0+3RCJZdURTS09OFrJ4VNbvMbXkiZzeHUA22wWBgyZIlhISEoNHkPv7Zt29fhgwZYjLswIED9OjRg3r16tGvXz8yMzNNxs+dO5cGDRrg7e2Nj48Pu3fvVsddu3aN3r174+fnh06no1OnThw4cACAtm3bkpKSQkREBDqdjunTpwOwaNEiunfvjr29fa58gwcPZtSoUerzf//9l759++Ll5cVLL73EgAEDuH79OgC//PILPj4+aDQaoqOj6dGjB+7u7owePZqMjAzGjRuHr68vPj4+JCcnA5CUlIROp0Oj0TB37lw6dOhA48aNadSoEUeOHDHJsnLlSry8vPD29qZRo0bExMSo4zIyMhg+fDje3t4EBwfTqlUrfvrpJ3V8SkoKffr0oWnTpvj7+zNkyBA1tyRJkvR0CNVgJyUlkZaWRt26dfMc/8ILL9ChQweTYXFxcWzcuJHffvuNX375hVWrVqnjlixZQmRkJDt27ODAgQPMmDGDDh068PfffwPwwQcf4ODgQHx8PLGxsTRp0kRtuLZt20bFihWZPHkysbGxhIWFcevWLU6cOPHQfGXKlMHb21t93rNnT5ycnEhISCAhIQGAfv36AdCyZUuio6OB7O70jRs3cujQIaKiohgyZAjvv/8++/btw83NTd1z9/DwIDY2FoB169axYcMGfvvtN7p37063bt3UHyvbtm3jjTfeYM2aNRw4cIBvvvmGwYMHEx8fD8Cnn37KqVOnOHDgALt27WLAgAGsWbNGzd2rVy9q1qzJ4cOH2bt3L/b29mruvGRmZpKWlmbykCRJkvJHqAb75s2bAJQsWdLseXIaEjs7O5o1a6Y2jAAzZ85k6NChVKhQAcjea65Tpw5z584F4OLFi6SkpJCRkQHA2LFjGThw4EPXlZqaCkCpUqUem2v37t3Ex8czadIkADQaDe+88w7btm3j8OHDJtO+/PLLQHaDX69ePRwdHXFxcQHA39+f33//Pdfyhw8fru7ljxs3jkuXLrF+/Xp1u7t3746HhwcADRo0oF27dnz88cfqdt+4cUPdnpCQECZMmGCSe+LEieq6RowYwbZt2zhz5kye2xoeHo6Tk5P6qFatWvYIAa/3m2llJNT3NJlW4hy/huzqWV9fXyGrZ0XNLnNbnsjZzSHUN6azszMAt2/fNhm+b98+dDodTZs2zVURXrlyZfX/pUuXVvfu0tPTOX/+PO7u7ibTu7u7c+zYMQAmT57MH3/8gaurK2PGjOHcuXO5pjcnX16OHz+OlZWVSWFczrJz1p+jUqVK6v8dHBxMnpcsWVJtWO93f6Wkk5MT5cqV4+TJk+q6H7Xdo0eP5vbt21SvXp1XX32VgwcP0qBBA3VerVZL79690el06HQ6xo4di6urK5cvX85zW6dMmUJqaqr6uHDhQvaIPA5rFHdGLSSUT8co1F9OdvVs+fLlhbwpgqjZZW7LEzm7OYTaKg8PD0qXLs3x48dNhvv6+hIbG8vo0aM5d+6cybgHf2nlpxjB19eX5ORk5s2bx4kTJ2jSpAkLFy586PQlS5akfv36nDhxwux1mOPBbXiSbTJHrVq1SEpKYsWKFVy/fp3g4GDeeecdk2l27txJbGwssbGx/PLLLyQnJ9OyZcs8l2dra0vp0qVNHgBkiVclbq/XsurHhtjrhfrTQa/X8+OPP6LX64s6Sr6Jml3mtjyRs5tDqG8da2trRowYwerVqzEan6xL0tHRkerVq3P69GmT4WfOnFH3Jjdu3EiJEiUYMGAAO3fuZOLEiSxe/H9X1br/V1x6ejoAY8aMYdOmTWo3+v3GjBlD7969AfD09CQrK0s9Xp6zbkBd/5M4f/68+v+bN29y7do19di6p6fnI7d7586dpKen0717dzZu3Mhnn33Gl19+qc5rNBo5deqUyfyjRo3i2jXxzk8uCAeDmN1tIt8QQdTsMrfliZz9cYRqsAFmzJhByZIlGTVqFHfv3lWHX79+nV9++SXP6vGHef/991mxYgVXrlwBYMeOHZw8eVI9XrtgwQK2bdumTq/X66ldu7b63MXFhRs3bmAwGNRzsUeOHIm/vz/Dhw83ybd+/XpiYmL46KOPAAgKCsLPz4/Zs2cD2XvJc+bMoW3btjRt2jSfr0puK1euVNe/YMECKleuTK9evdTt3rRpk9ro/vnnn2zdupX33ntPnTen4O3B7c7JPXPmTPVHU0xMDImJiZQrV+6Jc0uSJEl5E+7McgcHB3bv3s3cuXMJCgrCzs6OW7dukZWVhZ+fH7/99hsJCQm8/vrrQHbB1Ndff83KlSvZunUrABMmTGDu3LmMHDmStLQ0WrVqhb29PRqNhi1btqjHlUeMGMGMGTP45JNP0Ov1VKxY0aRL/J133uH9999nzZo1vP3220B28djq1atZuHAhbdq0wdraGr1eT5UqVdi1axd16tRR59+wYQNjxozBy8sLRVHw9PRUq9jz2oaIiAgSEhJITk6mdOnSVKxYkYiICFJSUtDpdGqFOGSf4ta3b1/++ecfFEXh+++/V89bb9u2LQsXLqRPnz7Y2tpy7949VqxYgZ+fn7q+iIgIVq9eDYC9vT3fffedSe6xY8fi6elJhQoVqFChgkkVuSRJklT4NMqzeob5c0yj0bB79250Ol1RR8lTzo3bVx5KxMHRvBu3P4olb/6hVaBKuh0XHTMwPqIzp7jd/CPnghKOjo756oUqDkTNLnNbnkjZc74HU1NT/6+u5zGE28OWnh1dalXEycnpiZdjycZRQcFgb8AaazQU7y+EB+V1MR9RiJpd5rY8kbM/jnDHsKWHy7nSGWSfe71x48aiDfQYIhaHGAwGtmzZIlx2UXODuNllbssTObs55B72M+T+K51JkiRJzxa5hy1JkiRJApANtiRJkiQJQFaJSxaXUx158+bNQik6syRFUTAYDFhbWxf7KtT7iZobxM0uc1ueSNkLUiUu97AlKZ/uvyCOSETNDeJml7ktT+TsjyMbbKnIiFjJaTAY2L17t3DZRc0N4maXuS1P5OzmkA22JEmSJAlANtiSJEmSJADZYEtSPllbi3n5AlFzg7jZZW7LEzn748gqccniClIdKUmS9CyRVeKSUJ70nuZFwWg0cuXKFeGyi5obxM0uc1ueyNnN8ez2HUjF3s3Zs9GUKFHUMfLFoNWyr2FDWh49ivX//1LYGTKyQMuy5F3G7LO0rN73Ev06/sFdbfH5MjPnxi1ZWVns27ePjh07otWKs48hc1ueyNnN8extkSRJkiQ9g57bBvvOnTtMnz4dX19fdDodPj4+DBkyhOTkZADi4uLw8fFBo9Gowx70yy+/5JpmyZIleHl5odFo8PHx4Ycffshz3s6dO+Ps7ExoaGjhbxywfft2OnbsiE6nw9/fnyZNmjBo0CA2bNhAfsoWvv/+e77//vunklGSJEky33PZJZ6RkUFwcDAtW7Zkz5492NjYALB69Wp8fX3ZsWMHgYGBREdHU6NGjYcup2XLlrmmGTlyJLVr1yYoKIjo6Gjc3NzynHfz5s3qrTALW2RkJEuXLuX777/H3d0dgBs3bjB48GB69erF3bt3sbOzM2tZOY119+7dn0pWETkIeCUlRQPnHe+iFO+rNeZJo9Hg6OhY7C81+SCZ2/JEzm6O57LBDg0N5d69e8yePdvkje3Xrx/79u1j8ODBHDlypAgTFtzRo0eZOHEihw4dUhtrgDJlyrBixQoqVapUhOlMWQlYGGJtNNI8KamoY+RbhrWRt4ITizpGgVhbWxMcHFzUMfJN5rY8kbOb47nrEjcYDHz55Zf07ds3z19h/fv357fffuPgwYN5zp+UlESLFi1o0KABHTt2ZP/+/Wavd8yYMbi6utKqVSs+/vjjPKebPXs2Xl5eBAYGEhgYyN69ewG4desWOp0OOzs7Zs2axaBBg2jWrBm+vr78/fff6vyLFy+mVq1aNGrUKNeyy5Yty/Lly9UehRs3bjBs2DCaN29OYGAg/v7+/Prrr+r07777Llu3bmXr1q3odDq6deumjvvpp59o3rw5LVu2xM/Pjy+//NKs1+F+RgF/BRs1Gi6VLStcdmujhtbnymFtFCs3ZFf+njt3TrjKX5nb8kTObo7nbg87KSmJ1NRU6tatm+f4nOGHDx+mY8eOJuOMRiM9evSgVatWfPbZZ2RlZTFw4ECz1jtnzhw2b97Mb7/9Rrly5YiJiWHmzJkm3eJLlixh2bJl7N+/H2dnZ+Lj42nVqhWJiYm4uroSGxuLm5sb69atY9euXZQqVYqePXsSGhrKihUrADh48OBDtw2yf5DkuHjxIklJScTHx2Ntbc3evXvp1q0bp0+fxtnZmVmzZnHlyhUAoqKi1Pn+/PNPevfuTXx8PC+99BL//fcfXl5eODk50a9fv1zrzMzMJDMzU32elpYGgCJYowfZDfZf1atT/uZNtAJdwsAmS8PohOr8WvkGBq04uSG78jchIYHKlSsLVfkrc1ueyNnN8ext0WPcvHkTgFKlSuU5Pmf4jRs3co3bsWMHJ0+eZPz48QBYWVkxfPhws9b76aefMnjwYMqVKwdAnz59KFu2rMk0M2fOZPjw4Tg7OwPg5+eHu7s7S5cuNZmuS5cuak6dTkdCQoLJ9pUsWdKsTLVq1WLjxo3qlYH8/f2xsbHhwIEDj5xv1qxZBAUF8dJLLwHwwgsv0KNHD7744os8pw8PD8fJyUl9VKtWzax8kiRJ0v957vawcxrD27dv5zn+1q1bALkaU4CTJ09iZWWFq6urOqx69eqPXWdqaiqXL1/mxRdfNBl+/7zp6emcP3+e5cuXs3nzZnW4Xq8nPT3dZL7KlSur/3d0dFT3WCF7+/Latm7dupGamkpycjJz5syhd+/e2NjY8N1336mFZVqtlhs3bpCSkvLI7Tl+/DgpKSkmvQM3b958aCHblClT1B85kL2HLRttSZKk/HnuGmwPDw9Kly7NyZMn6dKlS67xJ0+eBMDHx8es5T1JNWJe806cOJFhw4Y9cj4rKyuTZdx/mlbz5s3Zvn17rnk2bdqkTp/zo2Tu3LnMnDmTw4cPqwVqbm5uZp321bp1a7Ub/nFsbW2xtbU1a9riTgOUSUtDtM58owZ+d0lDwEPYaDQaXFxchKv8lbktT+Ts5njuusStra15/fXXWbt2bZ7jo6Oj8fPzy7Noq27dumRlZXHu3Dl12Pnz5x+7TicnJypVqsTZs2dNht8/r6OjI9WrVyfpgQrkNWvWsH79+seuI8drr73GmTNnHlo0d789e/bQpEkTk2rye/fumUxz/3GgO3fukJWVhaenZ66cx48fZ8aMGWbnBDGrxK2MRl46e1a47JnWRsL8zpBpLVZuyP6b9fPzE+6mDjK35Ymc3RzPXYMNEBYWRokSJZg0aZLJjc7Xrl3L+vXrH7rn2Lp1a+rWrcu8efOA7AKHRYsWmbXOt956i2+++YZr164BsH79ei5fvmwyzfvvv8+KFSvUhvzq1auEhYXh6elp9rY1bNiQTz75hIEDB5KY+H+n8RiNRrWrPacRrlevHkePHuXq1asAxMfH58rk4uKiHs/v3bs3iYmJTJo0id9++41t27YB2d32H3zwgcmhAnOIVmkN2Zn/rlhRuOzWWRpCEitinSVWbsj+O0tMTCQrK6uoo+SLzG15Imc3x7P5M+Qx7Ozs2LlzJ7NmzSIgIIASJUqQmZlJ/fr12b9/P1WqVCEuLo5JkyYBEBISwvz58/H19WXjxo288soreHp6UrlyZV5++WXWrVtHSEgIc+bM4cSJE2rxVUhICO+99x5du3Zl4sSJXLp0iUaNGuHu7o63tzd+fn5ERUVhMBj46KOPGDlyJLdu3aJ9+/aUK1cOKysrIiMj8fDwALILzFJSUoiIiKBEiRJYWVkRERFBSkoKrVq1YufOnUB2t7qnpydvvfUWd+/eJSsri/T0dGrUqMF3331H3759gewfCOfOnaNp06Y0bNgQd3d3KlasSEREBFZWVgwaNIhhw4bRp08f/P39qVGjBvXr1wfgf//7H++99x5Tp06lRIkS9OrViyFDhuTrfRC1SvxcxYpUu3JFrCpxo4aQpEpsqnkFg5U4uSH7x2ZSUhI1a9Y0ORxU3MnclidydnPI22tKFpdzW7m/33uPMgLe/OMXEW/+odeyesv/v/mHTfHpFjfn5h96vZ4tW7bQsWNH9RoCIpC5LU+k7AW5veZzuYctFQ+O48fj9P9PcxOFXq+HLVsoPXmy+oXQs4DLMqexKix69GxhC6lMwYbi/UUmSVLenstj2FLxIOKFDbRaLdWrVxcuu6i5QdzsMrfliZzdHLJLXLK4gnQFSZIkPUsK8j34bP4MkYQgYiVnVlYWv//+u3DZRc0N4maXuS1P5OzmkA22VGREvEC/0Wjk/PnzwmUXNTeIm13mtjyRs5tDNtiSJEmSJABZJS5ZXE7ZRHp6erE/9eJBer2eO3fukJaWJlR2UXODuNllbssTKbt618J8lJHJBluyuJyrvdWoUaOIk0iSJBWt9PR0nJyczJpWNtiSxeXcCe38+fNmf1CLi5w7jV24cEGoCndRc4O42WVuyxMpu6IopKenm9x98XFkgy1ZXM45kk5OTsX+j+phSpcuLWR2UXODuNllbssTJXt+d1hk0ZkkSZIkCUA22JIkSZIkANlgSxZna2vL9OnTsbW1Leoo+SZqdlFzg7jZZW7LEzm7OeSlSSVJkiRJAHIPW5IkSZIEIBtsSZIkSRKAbLAlSZIkSQCywZYsbuPGjTRr1gx/f38CAwP5888/izpSnu7du8fkyZOxtrYmOTk51/jFixfTpEkTWrRoQadOnbh48aLlQz5g7dq1tG3bllatWtGsWTP69Oljkl1RFGbMmEHjxo1p3rw5AwcOJDU1tegC/3+bNm2iQ4cOtGrVipYtW9K4cWNWr15tMk1xzX6/hQsXotFoiI2NNRleHD8roaGheHl5odPp1EfPnj3V8cX99T579iy9evUiKCiI+vXr4+Pjw+HDh4Hin73AFEmyoAMHDiiOjo7KX3/9pSiKoqxYsUKpUqWKkpaWVsTJTP3999+Kj4+PMnjwYAVQ/v77b5Px69evVypVqqRcvXpVURRFCQsLU7y8vJSsrKwiSPt/bGxslK1btyqKoihZWVnKoEGDFA8PDyUjI0NRFEWZO3eu0rBhQ+XOnTuKoijKsGHDlC5duhRZ3hzt2rVTVqxYoT7/4YcfFI1Go/zxxx/qsOKaPcfFixeV6tWrK4Cye/dudXhx/axMnz7dJOeDivPrfeXKFcXNzU2Ji4tTFEVR9Hq9EhQUpKxevVpRlOKd/UnIBluyqB49eighISHq86ysLKVChQrKp59+WoSpcjt27Jhy6tQpZffu3Xk22I0aNVImT56sPr9586ZibW2t/PDDDxZOaqp3794mzw8dOqQASnx8vGIwGBQXFxflyy+/VMf/+eefCqAcPXrU0lFNHD58WNHr9erztLQ0BVA2btyoKIpSrLPn6Nmzp/Lll1/marCL62flUQ12cX+9J0yYoPTr189k2KlTp5SLFy8W++xPQnaJSxa1c+dOmjZtqj7XarU0adKEHTt2FGGq3Dw9PXF3d89z3PXr1/n9999NtsPJyYnatWsX+XbExMSYPLezswMgMzOTo0ePcvXqVZPcdevWpWTJkkWeu0mTJlhbZ18pWa/XM2fOHOrVq0fr1q0BinV2gP/973/Y2NjQrl07k+HF+bPyKMX99d6wYQMBAQEmw9zd3alcuXKxz/4kZIMtWcy1a9dIS0ujQoUKJsMrVqzI33//XUSp8i8nqwjbsW/fPipXrkyLFi04e/YsYJpbo9FQoUKFYpP7zTffxMXFhR07dvDzzz9TqlQpgGKd/fbt27z//vvMnz8/17ji/ln5+uuv0el0tGjRgiFDhnDmzBmg+L/ef//9N1lZWQwY8P/au9OgKI42DuD/BZIFBAUvCjwWCYgKyCURAu6uyBlR41ERrwqBSDyiYlKKBo1JGYNGJYuuISYiKGJhaYrySBkUE4hRtChRIwhyiDdHQEUOl/N5P1DbL+viEVHZ1f59Yma6e57umdoeenpmZsHT0xP+/v44evQoAM2Ovat4h829Mg0NDQCg9hYioVDItmkDbalHY2MjNm7cCLlcjrfeeksr4t62bRuqqqpYJ1JWVgZAs9t89erVmDdvHszNzdW2aXLcgwcPhrOzM9LT03Hy5EkMGTIErq6uuH37tkbHff/+fQDt7b58+XKcOnUKy5cvx4QJE3D8+HGNjr2reIfNvTKGhoYA2juSjhobG9k2baAt9fj0008xffp0TJ48GYD2xK2np4e1a9eira0NMTExADQ39pycHJw9exbz5s3rdLumxg0AoaGhWLp0KfT09KCjo4PVq1dDX18fP/74o0bHraurCwCYMGECHB0dAQDjxo2Dt7c3YmNjNTr2ruIdNvfK9OnTB7169UJFRYXK+vLyclhZWXVTVP+dMlZNrseKFStgaGiItWvXsnWPi7uioqLb425qalJZ1tHRwdChQ3H58mUAmhv7b7/9hocPH8Lb2xtSqRTBwcEAgIiICEilUrS1tbE4O9Kkc0VJV1cXlpaWKCkp0dj2BoB+/fpBKBRiwIABKutFIhFKS0s1Ovau4h0290p5e3vj3LlzbJmIkJOTwyYXaQNTU1M4Ozur1OPBgwcoLCzUiHqsX78eN2/ehFwuBwCcO3cO586dw8iRI9GvXz+VuPPz81FfX9/tcbu4uKitKysrg4WFBQBobOyrV69GTk4OMjIykJGRgZSUFACATCZDRkYG3NzcNPZcWbJkidq6O3fuYPDgwRrb3kD7hUXH2yVKFRUVGh97l3X3NHXuzXL27Fnq2bMnFRUVERFRUlKSRj6HrfS4x7p+/fVXsrCwoKqqKiIiWrt2rUY8WxsXF0d2dnaUlZVF2dnZlJ2dTWvWrKGEhAQian8+1dHRkT2fGhYWphHPpwoEAjpy5AhbTkpKIh0dHTp58iRbp6mxd1RaWtrpc9iaeK5YWlrSwYMH2fIvv/xC+vr6lJ+fT0Sa3d5paWlkampK169fJ6L2x7aEQiEdPnyYiDQ79q7Q6+4LBu7N8u677yIxMRHBwcEwMDCAjo4O0tLSYGxs3N2hqWhqaoKfnx+b4BIcHIxBgwaxx6amTJmCyspK+Pr6Ql9fH6ampjh8+DB0dLpv0Kq2thYLFy5EW1sbPDw8VLYlJCQAAJYuXYq6ujp4enpCT08PNjY22L17d3eEqyI2Nhbr1q1DdHQ02traIBAIcOjQIXh5ebE0mhq7UkREBM6cOcP+HjZsGFJSUjTyXAGAdevWQSaTISYmBk1NTRAKhUhPT8ewYcMAaHZ7+/n5YcuWLZg0aRKMjIzQ0tKCXbt2ISgoCIBmx94V/POaHMdxHKcF+D1sjuM4jtMCvMPmOI7jOC3AO2yO4ziO0wK8w+Y4juM4LcA7bI7jOI7TArzD5jiO4zgtwDtsjuM4jtMCvMPmOI7jOC3AO2yOewGOHz8OqVQKgUCATz75RGVbTU0NpFIpTExM4O7ujqSkpJcWx5UrV1gcGRkZL20/zyMmJgZOTk4YM2aM2pvYAEChUGDQoEHIzs7uhuie34ULFyCTybpURnFxcbcft8zMTLi7u0MgEODatWudptm3bx+cnJwgEAhebXBcu+5+NyrHvU4AEAD2TuOOJBKJ2jvJX2YcHd9n3d2U79hW1n/Tpk1qaVpaWmjcuHFUUFDwiqPrmoSEBBKJRC+krO4+bo8ep84o36/PvXr8XeIc9wKJRCIMHz4cc+fOxaVLl9C3b9/uDkkjXL9+HQBgaWkJAPjiiy/U0ujq6iI9Pf1VhsVxWoUPiXPcC5aQkICWlhbMnz//sWkSExMxbNgw1oEBQGBgIPT19ZGYmAgA+Pvvv9kQZUpKCiZPngxra2t89tlnUCgUiIiIgIeHB9zd3Tsdwrxy5QomTpwIFxcXtU88AsDu3bvh4uICsVgMT09PpKamsm1BQUEwMTHB8uXLMX/+fIwZMwYCgQAXLlzotD5FRUUIDAyEq6srHBwcWIwAcODAAfYpR6lUCqlU2mkZfn5+MDExwddff83yKYdfjxw5gokTJ8LGxgaLFi1Sybd37164ublh7Nix8PDwwMqVKwGoDt/u3r0bvr6+sLGxwcSJE1FVVcXyt7S0IDIyEk5OTpBIJPDz80Nubq7KPpKSkuDk5AQvLy+4uLjg888/R01NDfbu3Yv169ejvLyc1a20tBQAUFhYiICAALi7u8PT0xMRERF4+PAhK7O8vBzvv/8+hg4dioCAABw+fLjTdlHqOGS9fft2+Pr6ws7ODmKxGFevXgWges7s378fkyZNgrW1NZycnAAAdXV1CA8Ph4ODA1xcXDBhwoROz53Tp08jMDAQ9vb2KuU/zpPqKpfL2bmemJgIf39/WFlZISEhATdv3sSsWbNgZ2eHGTNmoLGxkZV5/PhxuLu7s+O6ePFi1NfXPzGO1153/4vPca8T5dBoamoqAaCkpCS27dEh8c6GUkUiEfsUJtH/hygXLVpERER3796lHj160IcffkiVlZVERDR9+nQKCQlRKQcASSQS9nnBr7/+mgYMGEAKhYKIiH7//Xfq06cP3bx5k4iIiouLqUePHnT69GmVeAcNGkQ3btwgIqKPP/6Y/vnnH7U6KxQKGjJkCK1bt46IiBobG0kikVB4eDhL86zDqBKJhNasWaOWb8OGDUREVFFRQUKhkP744w8iIrp9+zbp6upSSUkJERFVVlZS79691fIvXryYiIiam5vJx8eHpk6dytKsXLmSxGIxa5u9e/dS37592Sdf09LSyNjYmAoLC9k+zM3N6fz580TU+XFUKBRkaWlJcXFxbL/jx49XaRN/f3+aNGkS+8zmsmXLnjokrjwfJk+eTC0tLUREFBISQqNGjVJLExoaSq2trVRbW0tSqZSIiGbMmEGBgYHU3NzM6j5ixAhWljJvcHDwY8t/9Fg+S10TEhJIX1+f9uzZQ0REx44do7fffpu++uoramlpoYcPH5JIJKLExERWRs+ePenEiRNERNTQ0EC2trav7JaSpuIdNse9QB1/uMPCwsjExIR1il3psDt+F9rNzY3CwsLYslwuJ0dHR5VyANCOHTvY8v3790kgEFBycjIREYnFYlq4cKFKnqCgIJo9ezZblkgkahcCndm5cycJhUKqr69n61JTU0lXV5fKy8uJqOsdtvKigYjI2dmZYmJiiIgoJyeHALAfdiKiM2fOqOUvLi5m6w4ePEgCgYBu3bpFDQ0NpK+vT/v371eJw8jIiLWfWCxWaRciovj4ePYt5s6O486dO8nY2Fjlm9cHDhwgPT09UigUVFBQQADYhQdR+0XTs3bY6enpbN3FixcJAJ06dUolTUZGhkrekpISEggEKnnv3r1LAoGA1f9Zyn/0WD6trso2EgqF7EKhvr5e7YJ22rRptGTJEhYXAIqPj1eJQ3kB+qbi97A57iWRyWTIzMxEaGgo0tLSulSWubk5+9vQ0FBluUePHqipqVHLIxKJ2N+9evVCnz59kJ+fDwDIzc3FrVu3VIanq6qq2LeQlQYOHPjU2HJzc2Fubg5DQ0O2ztraGq2trbh8+TLMzMyeXsGnsLCwYH8bGxvjwYMHAAAnJyfMmTMHPj4+kEqlCA4OxqxZs9Tyd2yLd955B0SEgoIC9O/fHwqFAtHR0ZDL5SyNmZkZ7t27x+rn7e2tUl5oaOgT483NzUVra6tKPoVCgQEDBqCsrAwFBQUAACsrK7Z98ODBT22Hx9UHAPLz8/Hee++x9Y8eu7y8PBARrK2t2TpTU1P07t0bly5dwrRp0/5T+c9aV+Vtn379+kFPr73LUZ4rjzuPTU1NsXLlSsydOxc//fQTgoODERISAgMDg2dpntcW77A57iUxMjLCnj174OXlhW3btqlt7+zRmNbW1k7L0tXVfeIyPcdn7WfPno1vvvnmiWke3U936RiHQCBg9VXen46MjERiYiKioqKwceNGZGdnw8TE5JnL37RpE8aOHftCY+7bt+9jH9G6ePGi2roX/ajUqzx2T6qrUmfxPOk8/u677xAeHo5du3ZBJpNhw4YNyMrKUrnIedPwSWcc9xKNHj0aq1atQmRkJG7cuKGyzdjYGLW1tWy5ubkZlZWVL2zfHfd3//59VFdXY/jw4QAAe3t7XLlyRSX9n3/+ibi4uP+8H3t7e5SVlaGhoYGtKykpga6uLkaMGPGc0T+b27dvIysrC3Z2dti4cSPy8vJw584dnDhxQiVdx7YoKSmBQCCAra0trK2toa+vr9YWcrkcf/31F4D2+j066erAgQO4fPkyAEBH5/8/o01NTWhsbGRt8ujx/eijj9DS0sJGMjqW++j58SSP1gcAO7aPY2dnB6D9mW+le/fu4e7du3BwcHju8p9W1+dRW1uLtLQ0WFpaYs2aNSgoKICBgYHKxMg3Ee+wOe4lW7VqFUaOHMlmDys5Ojri3r17rLNITk5W+fHvqvj4eDZTNzY2FhYWFpg6dSoAICoqCocOHWL/6dXX1+PLL79UGxJ/FjNnzoSFhQW2bNkCoP3HOjY2FmFhYS9kOPxJioqKsGzZMjQ3NwMA2traQESwsbFRSffzzz8DaJ8RLpfLMWXKFAwcOBAGBgZYunQp5HI5GwIvKipCbGws6+CioqJw8OBB1nHdunULkZGR6N+/P4D2od6amhoQEWQyGXbs2IGZM2di4MCBiI6OZjHIZDLo6OhAT08Ptra28Pf3R2xsLNra2gBAZUj+aeLj41k+mUyGUaNGdTpc3ZGVlRVmzJiBH374gY3kbN68GcOHD8cHH3ygkjYuLu6Zy39aXZ9HdXU1FixYgLq6OgDt/3m3trZi6NChz1Xea6P7bp9z3Ovj2LFjJJFISCgUkkQioby8PJXtxcXFZGRkpDbL9dtvvyVra2vy8/OjHTt2kEgkIltbW9q6dSudP3+eRo8eTQBo9OjRlJeXR3PmzKFevXqRSCSizZs3U3JyMtna2rL9FhQUkEQiIQC0efNmCggIIGdnZ3JycqLs7GyVfSclJZGDgwN5eHiQp6cnm8FL1D7zXLmf8ePHP7X+hYWF5O/vTy4uLmRvb08LFixgE4T2799Pjo6ObOa6TCbrtAxfX1+2z6ioKDp69KhKvurqagoJCWFpvv/+eyorK6OQkBBydXUliURCo0aNop07d7IylROkUlNTyd/fn6ytrSkoKIj+/fdflqa5uZlWrFhBtra2JBaLycfHR62tdu3aRY6OjuTp6UlisZgyMzPZNoVCQT4+PuTm5kYSiYTN3i8sLKSAgACyt7cnsVhM4eHhVFdXx/KVlZVRQEAA2djYkI+PDyUnJxMAcnR0VJsEp6ScFJacnEyBgYE0YsQI8vLyYrPkHz1ntm7dqpK/traW5s6dS/b29uTs7Ezjx49n52RGRgbLu337dvL19VUrPyUlReWYXL169al1TUhIYOeor68vVVdXs3PU0dGRTpw4QcuWLSMzMzMyMzOjJUuWUF1dHS1atIhcXFxIKpWSq6srRUdHd9ombxIB0XPc/OI4jtMCGRkZGDt27HPd49dE165dw5AhQ1BaWqryDD/3ZuBD4hzHcRynBXiHzXHca2nfvn2IiIgAAJU3kGmrzMxMBAcHAwCCg4ORlZXVzRFxrxofEuc4juM4LcD/w+Y4juM4LcA7bI7jOI7TArzD5jiO4zgtwDtsjuM4jtMCvMPmOI7jOC3AO2yO4ziO0wK8w+Y4juM4LcA7bI7jOI7TAv8D9blKlTVJvZAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# focus on the last round annotation\n",
    "COL_AGREED_ANNOTATION = \"label_resolution\"\n",
    "COL_RULE = \"rule_id\"\n",
    "# # mark whatever is not agreed on as \"FP\"\n",
    "# df_annotations[COL_AGREED_ANNOTATION] = df_annotations.apply(\n",
    "#     lambda row: row[\"Annotator_1\"] if row[COL_AGREEMENT_REACHED] else \"FP\", axis=1)\n",
    "\n",
    "CONSIDERED_NW_IN_PRECISION = False\n",
    "\n",
    "if df_annotations[COL_AGREED_ANNOTATION].nunique() == 3:\n",
    "    COLORS = [\"lightcoral\", \"lightblue\", \"springgreen\"]\n",
    "else:\n",
    "    COLORS = [\"lightcoral\", \"springgreen\"]\n",
    "\n",
    "df_stacked_hist = df_annotations.copy()\n",
    "# keep COL_RULE, COL_AGREED_ANNOTATION columns\n",
    "df_stacked_hist = df_stacked_hist[[COL_RULE, COL_AGREED_ANNOTATION, \"message\"]]\n",
    "# count for each category\n",
    "df_stacked_hist = df_stacked_hist.groupby(\n",
    "    [COL_RULE, COL_AGREED_ANNOTATION]).count()\n",
    "\n",
    "# rename message > count and reset index\n",
    "df_stacked_hist = df_stacked_hist.rename(columns={\"message\": \"count\"})\n",
    "df_stacked_hist = df_stacked_hist.reset_index(drop=False)\n",
    "# convert rule_id in categorical and sort\n",
    "df_stacked_hist[COL_RULE] = pd.Categorical(\n",
    "    df_stacked_hist[COL_RULE], categories=list(RULE_NAME_MAPPING.keys()))\n",
    "df_stacked_hist = df_stacked_hist.sort_values(COL_RULE, ascending=True)\n",
    "# rename the rule_id with their mapping\n",
    "df_stacked_hist[COL_RULE] = df_stacked_hist[COL_RULE].apply(\n",
    "    lambda e: RULE_NAME_MAPPING[e] if e in RULE_NAME_MAPPING.keys() else e)\n",
    "\n",
    "# put the different annotation categories as columns\n",
    "df_pivoted = df_stacked_hist.pivot(\n",
    "    index=COL_RULE, columns=COL_AGREED_ANNOTATION, values='count')\n",
    "# rename categories\n",
    "MAPPING_CATEGORY_NAMES = {\n",
    "    \"TP\": \"True Positive\",\n",
    "    \"NW\": \"Noteworthy\",\n",
    "    \"FP\": \"False Positive\"\n",
    "}\n",
    "df_pivoted = df_pivoted.rename(columns=MAPPING_CATEGORY_NAMES)\n",
    "# flip vertically\n",
    "df_pivoted = df_pivoted.iloc[::-1]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5, 4))\n",
    "df_pivoted.plot(\n",
    "    kind='barh',\n",
    "    stacked=True,\n",
    "    color=COLORS,\n",
    "    ax=ax\n",
    ")\n",
    "\n",
    "# remove title from the legend\n",
    "plt.legend(\n",
    "    title=None,\n",
    "    loc='upper center', bbox_to_anchor=(0.3, 1.2), ncol=3)\n",
    "\n",
    "# add the labels\n",
    "plt.xlabel(\"Number of inspected problems\")\n",
    "plt.ylabel(LINTQ_CHECKER_TERM + \" Name\")\n",
    "\n",
    "# add vertical grid\n",
    "plt.grid(axis='x', linestyle='--')\n",
    "\n",
    "# STATS\n",
    "if CONSIDERED_NW_IN_PRECISION:\n",
    "    print(f\"Considering noteworthy as TP\")\n",
    "    tp_labels = [\"TP\", \"NW\"]\n",
    "else:\n",
    "    print(f\"Considering noteworthy as FP\")\n",
    "    tp_labels = [\"TP\"]\n",
    "average_precision = df_annotations.groupby(\n",
    "    COL_RULE).apply(\n",
    "        lambda df: (df[COL_AGREED_ANNOTATION].isin(tp_labels)).mean()).mean()\n",
    "print(f\"Average precision: {average_precision}\")\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "fig.savefig(\n",
    "    os.path.join(OUTPUT_FOLDER, \"precision_estimate_abs.pdf\"),\n",
    "    bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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>label_resolution</th>\n",
       "      <th>rule_id</th>\n",
       "      <th>False Positive</th>\n",
       "      <th>Noteworthy</th>\n",
       "      <th>True Positive</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>OldIdenGate</td>\n",
       "      <td>11.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>16.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>29.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>22.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>23.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>CondWoMeas</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>28.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>21.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>29.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>16.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>44.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>4.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>18.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "label_resolution           rule_id  False Positive  Noteworthy  True Positive\n",
       "0                      OldIdenGate            11.0         3.0           14.0\n",
       "1                     GhostCompose             0.0         4.0            8.0\n",
       "2                    OpAfterTransp             0.0         0.0            7.0\n",
       "3                 OversizedCircuit            16.0        13.0           29.0\n",
       "4                    InsuffClasReg            22.0        21.0           23.0\n",
       "5                       CondWoMeas             0.0         0.0           28.0\n",
       "6                     ConstClasBit            21.0        10.0           29.0\n",
       "7                     MeasAllAbuse             0.0         1.0           16.0\n",
       "8                      OpAfterMeas             0.0         0.0           44.0\n",
       "9                       DoubleMeas             4.0         3.0           18.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_precision_with_subannotations = df_pivoted.reset_index()\n",
    "# fill na in all columns, excepts for rule_id\n",
    "for col in df_precision_with_subannotations.columns:\n",
    "    if col != COL_RULE:\n",
    "        df_precision_with_subannotations[col] = df_precision_with_subannotations[col].fillna(0)\n",
    "df_precision_with_subannotations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TABLE 3 - Warnings and precision of the LintQ analyses and the result of manual inspection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\nInspectedWarnings}{345}\n",
      "\\newcommand{\\nTruePositivesLintQ}{216}\n",
      "\\newcommand{\\allTPOverAllWarningsLintQ}{62.6\\%}\n",
      "\\newcommand{\\medianPrecisionLintQ}{69.3\\%}\n",
      "\\newcommand{\\avgPrecisionLintQ}{71.6\\%}\n",
      "\\newcommand{\\minPrecisionLintQ}{34.8\\%}\n",
      "\\newcommand{\\maxPrecisionLintQ}{100.0\\%}\n",
      "\\newcommand{\\nCheckersAboveFiftyPrecision}{6}\n",
      "\\newcommand{\\nInspectedWarningsBestCheckers}{133}\n",
      "\\newcommand{\\nTruePositivesLintQBestCheckers}{121}\n",
      "\\newcommand{\\allTPOverAllWarningsLintQBestCheckers}{91.0\\%}\n",
      "\\newcommand{\\medianPrecisionLintQBestCheckers}{97.1\\%}\n",
      "\\newcommand{\\avgPrecisionLintQBestCheckers}{88.8\\%}\n",
      "\\newcommand{\\minPrecisionLintQBestCheckers}{66.7\\%}\n",
      "\\newcommand{\\maxPrecisionLintQBestCheckers}{100.0\\%}\n"
     ]
    },
    {
     "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>Analysis Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>% Files</th>\n",
       "      <th>Precision</th>\n",
       "      <th>FP / NW / TP</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DoubleMeas</td>\n",
       "      <td>39</td>\n",
       "      <td>0.36%</td>\n",
       "      <td>72.0%</td>\n",
       "      <td>\\dbFP{1.60}\\dbNW{1.20}\\dbTP{7.20} 4/3/18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>OpAfterMeas</td>\n",
       "      <td>127</td>\n",
       "      <td>0.92%</td>\n",
       "      <td>100.0%</td>\n",
       "      <td>\\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/44</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MeasAllAbuse</td>\n",
       "      <td>22</td>\n",
       "      <td>0.26%</td>\n",
       "      <td>94.1%</td>\n",
       "      <td>\\dbFP{0.00}\\dbNW{0.59}\\dbTP{9.41} 0/1/16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ConstClasBit</td>\n",
       "      <td>533</td>\n",
       "      <td>4.29%</td>\n",
       "      <td>48.3%</td>\n",
       "      <td>\\dbFP{3.50}\\dbNW{1.67}\\dbTP{4.83} 21/10/29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CondWoMeas</td>\n",
       "      <td>46</td>\n",
       "      <td>0.22%</td>\n",
       "      <td>100.0%</td>\n",
       "      <td>\\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>InsuffClasReg</td>\n",
       "      <td>3489</td>\n",
       "      <td>17.35%</td>\n",
       "      <td>34.8%</td>\n",
       "      <td>\\dbFP{3.33}\\dbNW{3.18}\\dbTP{3.48} 22/21/23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>378</td>\n",
       "      <td>3.01%</td>\n",
       "      <td>50.0%</td>\n",
       "      <td>\\dbFP{2.76}\\dbNW{2.24}\\dbTP{5.00} 16/13/29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>OpAfterTransp</td>\n",
       "      <td>7</td>\n",
       "      <td>0.05%</td>\n",
       "      <td>100.0%</td>\n",
       "      <td>\\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>GhostCompose</td>\n",
       "      <td>12</td>\n",
       "      <td>0.09%</td>\n",
       "      <td>66.7%</td>\n",
       "      <td>\\dbFP{0.00}\\dbNW{3.33}\\dbTP{6.67} 0/4/8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>OldIdenGate</td>\n",
       "      <td>46</td>\n",
       "      <td>0.37%</td>\n",
       "      <td>50.0%</td>\n",
       "      <td>\\dbFP{3.93}\\dbNW{1.07}\\dbTP{5.00} 11/3/14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Analysis Name  Tot. warnings % Files Precision  \\\n",
       "0        DoubleMeas             39   0.36%     72.0%   \n",
       "1       OpAfterMeas            127   0.92%    100.0%   \n",
       "2      MeasAllAbuse             22   0.26%     94.1%   \n",
       "3      ConstClasBit            533   4.29%     48.3%   \n",
       "4        CondWoMeas             46   0.22%    100.0%   \n",
       "5     InsuffClasReg           3489  17.35%     34.8%   \n",
       "6  OversizedCircuit            378   3.01%     50.0%   \n",
       "7     OpAfterTransp              7   0.05%    100.0%   \n",
       "8      GhostCompose             12   0.09%     66.7%   \n",
       "9       OldIdenGate             46   0.37%     50.0%   \n",
       "\n",
       "                                 FP / NW / TP  \n",
       "0    \\dbFP{1.60}\\dbNW{1.20}\\dbTP{7.20} 4/3/18  \n",
       "1   \\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/44  \n",
       "2    \\dbFP{0.00}\\dbNW{0.59}\\dbTP{9.41} 0/1/16  \n",
       "3  \\dbFP{3.50}\\dbNW{1.67}\\dbTP{4.83} 21/10/29  \n",
       "4   \\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/28  \n",
       "5  \\dbFP{3.33}\\dbNW{3.18}\\dbTP{3.48} 22/21/23  \n",
       "6  \\dbFP{2.76}\\dbNW{2.24}\\dbTP{5.00} 16/13/29  \n",
       "7    \\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/7  \n",
       "8     \\dbFP{0.00}\\dbNW{3.33}\\dbTP{6.67} 0/4/8  \n",
       "9   \\dbFP{3.93}\\dbNW{1.07}\\dbTP{5.00} 11/3/14  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{lp{1.75cm}p{0.9cm}|p{1cm}l@{}}\n",
      "\\toprule\n",
      "Analysis Name & Tot. warnings & \\% Files & Precision & FP / NW / TP \\\\\n",
      "\\midrule\n",
      "DoubleMeas & 39 & 0.36\\% & 72.0\\% & \\dbFP{1.60}\\dbNW{1.20}\\dbTP{7.20} 4/3/18 \\\\\n",
      "OpAfterMeas & 127 & 0.92\\% & 100.0\\% & \\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/44 \\\\\n",
      "MeasAllAbuse & 22 & 0.26\\% & 94.1\\% & \\dbFP{0.00}\\dbNW{0.59}\\dbTP{9.41} 0/1/16 \\\\\n",
      "ConstClasBit & 533 & 4.29\\% & 48.3\\% & \\dbFP{3.50}\\dbNW{1.67}\\dbTP{4.83} 21/10/29 \\\\\n",
      "CondWoMeas & 46 & 0.22\\% & 100.0\\% & \\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/28 \\\\\n",
      "InsuffClasReg & 3489 & 17.35\\% & 34.8\\% & \\dbFP{3.33}\\dbNW{3.18}\\dbTP{3.48} 22/21/23 \\\\\n",
      "OversizedCircuit & 378 & 3.01\\% & 50.0\\% & \\dbFP{2.76}\\dbNW{2.24}\\dbTP{5.00} 16/13/29 \\\\\n",
      "OpAfterTransp & 7 & 0.05\\% & 100.0\\% & \\dbFP{0.00}\\dbNW{0.00}\\dbTP{10.00} 0/0/7 \\\\\n",
      "GhostCompose & 12 & 0.09\\% & 66.7\\% & \\dbFP{0.00}\\dbNW{3.33}\\dbTP{6.67} 0/4/8 \\\\\n",
      "OldIdenGate & 46 & 0.37\\% & 50.0\\% & \\dbFP{3.93}\\dbNW{1.07}\\dbTP{5.00} 11/3/14 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "precision_series = df_annotations.groupby(\n",
    "    COL_RULE).apply(\n",
    "        lambda df: (df[COL_AGREED_ANNOTATION].isin(tp_labels)).mean())\n",
    "df_precision_table = pd.DataFrame(precision_series).reset_index(drop=False)\n",
    "# rename col 1 -> Precision\n",
    "df_precision_table.rename(columns={0: \"precision\"}, inplace=True)\n",
    "# \\nInspectedWarnings{}\n",
    "n_inspected_warnings = df_annotations.shape[0]\n",
    "print(\"\\\\newcommand{\\\\nInspectedWarnings}{\" + f\"{n_inspected_warnings:,}\" + \"}\")\n",
    "n_true_positives = df_annotations[COL_AGREED_ANNOTATION].isin(tp_labels).sum()\n",
    "print(\"\\\\newcommand{\\\\nTruePositivesLintQ}{\" + f\"{n_true_positives}\" + \"}\")\n",
    "\n",
    "full_dataset_precision = df_annotations[COL_AGREED_ANNOTATION].isin(tp_labels).mean()\n",
    "print(\"\\\\newcommand{\\\\allTPOverAllWarningsLintQ}{\" + f\"{full_dataset_precision * 100:.1f}\" + \"\\%}\")\n",
    "median_precision = df_precision_table['precision'].median() * 100\n",
    "print(\"\\\\newcommand{\\\\medianPrecisionLintQ}{\" + f\"{median_precision:.1f}\" + \"\\%}\")\n",
    "mean_precision = df_precision_table['precision'].mean() * 100\n",
    "print(\"\\\\newcommand{\\\\avgPrecisionLintQ}{\" + f\"{mean_precision:.1f}\" + \"\\%}\")\n",
    "min_precision = df_precision_table['precision'].min() * 100\n",
    "print(\"\\\\newcommand{\\\\minPrecisionLintQ}{\" + f\"{min_precision:.1f}\" + \"\\%}\")\n",
    "max_precision = df_precision_table['precision'].max() * 100\n",
    "print(\"\\\\newcommand{\\\\maxPrecisionLintQ}{\" + f\"{max_precision:.1f}\" + \"\\%}\")\n",
    "\n",
    "# keep only checkers with more than 50% precision\n",
    "from statistics import mean\n",
    "\n",
    "checkers_above_average = list(df_precision_table[\n",
    "    df_precision_table['precision'] > 0.5][COL_RULE])\n",
    "# print(checkers_above_average)\n",
    "print(\"\\\\newcommand{\\\\nCheckersAboveFiftyPrecision}{\" + f\"{len(checkers_above_average)}\" + \"}\")\n",
    "\n",
    "df_annotations_best_checkers = df_annotations[\n",
    "    df_annotations[COL_RULE].isin(checkers_above_average)]\n",
    "df_precision_table_best_checkers = df_precision_table[\n",
    "    df_precision_table[COL_RULE].isin(checkers_above_average)]\n",
    "\n",
    "full_dataset_precision_best = df_annotations_best_checkers[\n",
    "    COL_AGREED_ANNOTATION].isin(tp_labels).mean()\n",
    "n_true_positives_best = df_annotations_best_checkers[\n",
    "    COL_AGREED_ANNOTATION].isin(tp_labels).sum()\n",
    "n_inspected_warnings_best = df_annotations_best_checkers.shape[0]\n",
    "print(\"\\\\newcommand{\\\\nInspectedWarningsBestCheckers}{\" + f\"{n_inspected_warnings_best:,}\" + \"}\")\n",
    "print(\"\\\\newcommand{\\\\nTruePositivesLintQBestCheckers}{\" + f\"{n_true_positives_best}\" + \"}\")\n",
    "print(\"\\\\newcommand{\\\\allTPOverAllWarningsLintQBestCheckers}{\" + f\"{full_dataset_precision_best * 100:.1f}\" + \"\\%}\")\n",
    "median_precision_best = df_precision_table_best_checkers['precision'].median() * 100\n",
    "print(\"\\\\newcommand{\\\\medianPrecisionLintQBestCheckers}{\" + f\"{median_precision_best:.1f}\" + \"\\%}\")\n",
    "mean_precision_best = df_precision_table_best_checkers['precision'].mean() * 100\n",
    "print(\"\\\\newcommand{\\\\avgPrecisionLintQBestCheckers}{\" + f\"{mean_precision_best:.1f}\" + \"\\%}\")\n",
    "min_precision_best = df_precision_table_best_checkers['precision'].min() * 100\n",
    "print(\"\\\\newcommand{\\\\minPrecisionLintQBestCheckers}{\" + f\"{min_precision_best:.1f}\" + \"\\%}\")\n",
    "max_precision_best = df_precision_table_best_checkers['precision'].max() * 100\n",
    "print(\"\\\\newcommand{\\\\maxPrecisionLintQBestCheckers}{\" + f\"{max_precision_best:.1f}\" + \"\\%}\")\n",
    "\n",
    "\n",
    "# rename precision with Precision\n",
    "df_precision_table.rename(columns={\"precision\": \"Precision\"}, inplace=True)\n",
    "# rename rule_id with mapping\n",
    "df_precision_table[COL_RULE] = df_precision_table[COL_RULE].apply(\n",
    "    lambda e: RULE_NAME_MAPPING[e] if e in RULE_NAME_MAPPING.keys() else e)\n",
    "# format with %\n",
    "df_precision_table[\"Precision\"] = df_precision_table[\"Precision\"].apply(\n",
    "    lambda e: \"{:.1f}%\".format(e * 100))\n",
    "\n",
    "# merge df_precision_table and df_warnings_table on the first column\n",
    "df_precision_table_renamed = df_precision_table.rename(\n",
    "    columns={COL_RULE: LINTQ_CHECKER_TERM + \" Name\"})\n",
    "df_precision_warnings_table = df_warnings_table.merge(\n",
    "    df_precision_table_renamed, on=LINTQ_CHECKER_TERM + \" Name\", how=\"left\")\n",
    "\n",
    "# merge with df_precision_with_subannotations\n",
    "df_precision_with_subannotations_renamed = df_precision_with_subannotations.rename(\n",
    "    columns={COL_RULE: LINTQ_CHECKER_TERM + \" Name\"})\n",
    "df_precision_warnings_table = df_precision_warnings_table.merge(\n",
    "    df_precision_with_subannotations_renamed, on=LINTQ_CHECKER_TERM + \" Name\", how=\"left\")\n",
    "\n",
    "# add progress bar: \\dbTP{6}\\dbNW{2}\\dbFP{2}\n",
    "def create_progress_bar(row):\n",
    "    \"\"\"Create a progressbar using TP, NW, FP as a percentage.\"\"\"\n",
    "    output = \"\"\n",
    "    max_length = 10\n",
    "    fp = int(row[\"False Positive\"])\n",
    "    nw = int(row[\"Noteworthy\"])\n",
    "    tp = int(row[\"True Positive\"])\n",
    "    total = tp + nw + fp\n",
    "    perc_fp = fp / total * max_length\n",
    "    perc_nw = nw / total * max_length\n",
    "    perc_tp = max_length - perc_fp - perc_nw\n",
    "    output += \"\\\\dbFP{\" + f\"{perc_fp:.2f}\" + \"}\"\n",
    "    output += \"\\\\dbNW{\" + f\"{perc_nw:.2f}\" + \"}\"\n",
    "    output += \"\\\\dbTP{\" + f\"{perc_tp:.2f}\" + \"}\"\n",
    "    output += \" \" + f\"{fp:.0f}/{nw:.0f}/{tp:.0f}\"\n",
    "    return output\n",
    "\n",
    "\n",
    "# take values from the columns: False Positive\tNoteworthy\tTrue Positive\n",
    "df_precision_warnings_table['FP / NW / TP'] = df_precision_warnings_table.apply(\n",
    "    lambda row: create_progress_bar(row), axis=1)\n",
    "\n",
    "# drop those columns\n",
    "df_precision_warnings_table = df_precision_warnings_table.drop(\n",
    "    columns=[\"False Positive\", \"Noteworthy\", \"True Positive\"])\n",
    "\n",
    "\n",
    "# rename Files with warning -> % Files\n",
    "# Precision -> Prec.\n",
    "df_precision_warnings_table.rename(\n",
    "    columns={\n",
    "        \"Files with warning\": \"% Files\",\n",
    "    }, inplace=True)\n",
    "\n",
    "display(df_precision_warnings_table)\n",
    "\n",
    "# export to latex\n",
    "table = df_precision_warnings_table.to_latex(\n",
    "    index=False, column_format=\"lp{1.75cm}p{0.9cm}|p{1cm}l@{}\")\n",
    "# escape %\n",
    "table = table.replace(\"%\", \"\\\\%\")\n",
    "print(table)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recall on Bugs4Q Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\nWarningsBugsFourQ}{31}\n",
      "\\newcommand{\\nTPBugsFourQ}{9}\n",
      "\\newcommand{\\nFPBugsFourQ}{18}\n",
      "\\newcommand{\\nNWBugsFourQ}{4}\n",
      "\\newcommand{\\precRuleqlconstantclassicbitBugsFourQ}{100.0\\%}\n",
      "\\newcommand{\\precRuleqlmeasureallabuseBugsFourQ}{100.0\\%}\n",
      "\\newcommand{\\precRuleqloperationaftermeasurementBugsFourQ}{100.0\\%}\n",
      "\\newcommand{\\precRuleqldeprecatedidentityBugsFourQ}{100.0\\%}\n",
      "\\newcommand{\\precRuleqloversizedcircuitBugsFourQ}{66.7\\%}\n",
      "\\newcommand{\\precRuleqlunmeasurablequbitsBugsFourQ}{0.0\\%}\n",
      "\\newcommand{\\nBuggyFilesDetectedBugsFourQ}{3}\n",
      "\\newcommand{\\recallBugsFourQ}{7.1\\%}\n"
     ]
    }
   ],
   "source": [
    "## BEFORE REVISION\n",
    "PATH_BUGS4Q_ANNOTATION_LINTQ = \"../bug_reports/Inspection_LintQ_on_Bugs4Q_dataset.csv\"\n",
    "COL_AGREED_ANNOTATION = \"label_resolution\"\n",
    "COL_RULE = \"rule_id\"\n",
    "TOTAL_FILES_IN_BUGS4Q = 42\n",
    "\n",
    "df_annotations_bugs4q = pd.read_csv(PATH_BUGS4Q_ANNOTATION_LINTQ, header=1)\n",
    "n_warnings_bugs4q = len(df_annotations_bugs4q)\n",
    "print(\"\\\\newcommand{\\\\nWarningsBugsFourQ}{\" + f\"{n_warnings_bugs4q}\" + \"}\")\n",
    "\n",
    "n_TP_bugs4q = len(df_annotations_bugs4q[\n",
    "    df_annotations_bugs4q[COL_AGREED_ANNOTATION] == \"TP\"])\n",
    "print(\"\\\\newcommand{\\\\nTPBugsFourQ}{\" + f\"{n_TP_bugs4q}\" + \"}\")\n",
    "\n",
    "n_FP_bugs4q = len(df_annotations_bugs4q[\n",
    "    df_annotations_bugs4q[COL_AGREED_ANNOTATION] == \"FP\"])\n",
    "print(\"\\\\newcommand{\\\\nFPBugsFourQ}{\" + f\"{n_FP_bugs4q}\" + \"}\")\n",
    "\n",
    "n_NW_bugs4q = len(df_annotations_bugs4q[\n",
    "    df_annotations_bugs4q[COL_AGREED_ANNOTATION] == \"NW\"])\n",
    "print(\"\\\\newcommand{\\\\nNWBugsFourQ}{\" + f\"{n_NW_bugs4q}\" + \"}\")\n",
    "\n",
    "# precision per rule_id\n",
    "df_annotations_bugs4q['rule_id'].unique()\n",
    "df_annotations_bugs4q['rule_id'].value_counts()\n",
    "\n",
    "# compute precision per rule\n",
    "dict_precision_per_rule = {}\n",
    "for rule_id in df_annotations_bugs4q['rule_id'].unique():\n",
    "    df_rule = df_annotations_bugs4q[df_annotations_bugs4q['rule_id'] == rule_id]\n",
    "    n_TP = len(df_rule[df_rule[COL_AGREED_ANNOTATION] == \"TP\"])\n",
    "    n_FP = len(df_rule[df_rule[COL_AGREED_ANNOTATION] == \"FP\"])\n",
    "    n_NW = len(df_rule[df_rule[COL_AGREED_ANNOTATION] == \"NW\"])\n",
    "    precision = n_TP / (n_TP + n_FP + n_NW)\n",
    "    dict_precision_per_rule[rule_id] = precision\n",
    "    print(\"\\\\newcommand{\\\\precRule\" + rule_id.replace(\"-\", \"\") + \"BugsFourQ}{\" + f\"{precision*100:.1f}\\\\%\" + \"}\")\n",
    "\n",
    "# number of files where is_bug_for_bugs4q is true\n",
    "n_buggy_files_detected = len(df_annotations_bugs4q[\n",
    "    df_annotations_bugs4q['is_bug_for_bugs4q'] == True]['Location'].unique())\n",
    "print(\"\\\\newcommand{\\\\nBuggyFilesDetectedBugsFourQ}{\" + f\"{n_buggy_files_detected}\" + \"}\")\n",
    "\n",
    "recall = n_buggy_files_detected / TOTAL_FILES_IN_BUGS4Q\n",
    "print(\"\\\\newcommand{\\\\recallBugsFourQ}{\" + f\"{recall*100:.1f}\\\\%\" + \"}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RQ4: Comparison with Prior Work\n",
    "Here we check if the competitor can find the true positives issues found by LintQ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QCheckers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'DO': 4133, 'IM': 4133, 'CM': 4133, 'QE': 4133, 'CE': 4133, 'IIS': 4136, 'IG': 4133, 'MI': 4133, 'PE': 4133}\n",
      "['DO' 'IG' 'IIS' 'PE' 'IM' 'QE' 'CE']\n",
      "Total warnings: 3812\n"
     ]
    },
    {
     "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>rule_id</th>\n",
       "      <th>message</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>col</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DO</td>\n",
       "      <td>print(\"Votre tâche (job) a l'identifiant à ret...</td>\n",
       "      <td>qiskit_job_execute_a1a942.py</td>\n",
       "      <td>35.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>DO</td>\n",
       "      <td>middle.iden(q)</td>\n",
       "      <td>t1_f9bfa8.py</td>\n",
       "      <td>42.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>DO</td>\n",
       "      <td>print('Not all keys are identical. This sh...</td>\n",
       "      <td>task_2_4f46b2.py</td>\n",
       "      <td>60.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DO</td>\n",
       "      <td>full_basis = np.identity(n)</td>\n",
       "      <td>item3_weighted_ssvqe_2_824c3d.py</td>\n",
       "      <td>70.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>DO</td>\n",
       "      <td>Hm = sum([pauli_x(i, -1) for i in range(n_qubi...</td>\n",
       "      <td>07_variational_circuits_qiskit_8df8ee.py</td>\n",
       "      <td>67.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  rule_id                                            message  \\\n",
       "0      DO  print(\"Votre tâche (job) a l'identifiant à ret...   \n",
       "1      DO                                     middle.iden(q)   \n",
       "2      DO      print('Not all keys are identical. This sh...   \n",
       "3      DO                        full_basis = np.identity(n)   \n",
       "4      DO  Hm = sum([pauli_x(i, -1) for i in range(n_qubi...   \n",
       "\n",
       "                                       file  line  col  \n",
       "0              qiskit_job_execute_a1a942.py  35.0    1  \n",
       "1                              t1_f9bfa8.py  42.0    1  \n",
       "2                          task_2_4f46b2.py  60.0    1  \n",
       "3          item3_weighted_ssvqe_2_824c3d.py  70.0    1  \n",
       "4  07_variational_circuits_qiskit_8df8ee.py  67.0    1  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARN: no warnings for rule MI. Adding a 0 value.\n",
      "WARN: no warnings for rule CM. Adding a 0 value.\n",
      "WARN: some rules are not in the mapping. Discarding them.\n",
      "{'IM'}\n",
      "\\newcommand{\\avgWarningsPerc}{2.94\\%}\n",
      "\\newcommand{\\medianWarningsPerc}{1.39\\%}\n",
      "\\begin{tabular}{lrr}\n",
      "\\toprule\n",
      "Rule Name & Tot. warnings & Files with warning \\\\\n",
      "\\midrule\n",
      "IncorrectUseGate & 310 & 2.05\\% \\\\\n",
      "MeasurementIssue & 0 & 0.00\\% \\\\\n",
      "IncorrectInitState & 1282 & 8.47\\% \\\\\n",
      "ParameterError & 884 & 5.84\\% \\\\\n",
      "CommandMisuse & 0 & 0.00\\% \\\\\n",
      "CallError & 958 & 6.33\\% \\\\\n",
      "QasmError & 18 & 0.12\\% \\\\\n",
      "DiscardedOrder & 110 & 0.73\\% \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "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>Rule Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>IncorrectUseGate</td>\n",
       "      <td>310</td>\n",
       "      <td>2.05%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MeasurementIssue</td>\n",
       "      <td>0</td>\n",
       "      <td>0.00%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>IncorrectInitState</td>\n",
       "      <td>1282</td>\n",
       "      <td>8.47%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ParameterError</td>\n",
       "      <td>884</td>\n",
       "      <td>5.84%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CommandMisuse</td>\n",
       "      <td>0</td>\n",
       "      <td>0.00%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>CallError</td>\n",
       "      <td>958</td>\n",
       "      <td>6.33%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>QasmError</td>\n",
       "      <td>18</td>\n",
       "      <td>0.12%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>DiscardedOrder</td>\n",
       "      <td>110</td>\n",
       "      <td>0.73%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Rule Name  Tot. warnings Files with warning\n",
       "0    IncorrectUseGate            310              2.05%\n",
       "1    MeasurementIssue              0              0.00%\n",
       "2  IncorrectInitState           1282              8.47%\n",
       "3      ParameterError            884              5.84%\n",
       "4       CommandMisuse              0              0.00%\n",
       "5           CallError            958              6.33%\n",
       "6           QasmError             18              0.12%\n",
       "7      DiscardedOrder            110              0.73%"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Rule Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>IncorrectUseGate</td>\n",
       "      <td>310</td>\n",
       "      <td>2.05%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>MeasurementIssue</td>\n",
       "      <td>0</td>\n",
       "      <td>0.00%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>IncorrectInitState</td>\n",
       "      <td>1282</td>\n",
       "      <td>8.47%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>ParameterError</td>\n",
       "      <td>884</td>\n",
       "      <td>5.84%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>CommandMisuse</td>\n",
       "      <td>0</td>\n",
       "      <td>0.00%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CallError</td>\n",
       "      <td>958</td>\n",
       "      <td>6.33%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>QasmError</td>\n",
       "      <td>18</td>\n",
       "      <td>0.12%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>DiscardedOrder</td>\n",
       "      <td>110</td>\n",
       "      <td>0.73%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Rule Name  Tot. warnings Files with warning\n",
       "2    IncorrectUseGate            310              2.05%\n",
       "7    MeasurementIssue              0              0.00%\n",
       "3  IncorrectInitState           1282              8.47%\n",
       "5      ParameterError            884              5.84%\n",
       "8       CommandMisuse              0              0.00%\n",
       "0           CallError            958              6.33%\n",
       "6           QasmError             18              0.12%\n",
       "1      DiscardedOrder            110              0.73%"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "FOLDER_WITH_QCHECKER_WARNINGS = \"../data/analysis_results/exp_v08_competitors/qchecker\"\n",
    "COL_AGREED_ANNOTATION = \"label_resolution\"\n",
    "\n",
    "RULE_NAME_MAPPING_QCHECKER = {\n",
    "    \"IG\": \"IncorrectUseGate\",\n",
    "    \"MI\": \"MeasurementIssue\",\n",
    "    \"IIS\": \"IncorrectInitState\",\n",
    "    \"PE\": \"ParameterError\",\n",
    "    \"CM\": \"CommandMisuse\",\n",
    "    \"CE\": \"CallError\",\n",
    "    \"QE\": \"QasmError\",\n",
    "    \"DO\": \"DiscardedOrder\"\n",
    "}\n",
    "\n",
    "# check how many files are in all the subfolders ending in \"_error\"\n",
    "error_folders = glob.glob(\n",
    "    os.path.join(FOLDER_WITH_QCHECKER_WARNINGS, \"*_errors\"))\n",
    "dict_error_per_rule_qchecker = {}\n",
    "for folder_path in error_folders:\n",
    "    folder_name = os.path.basename(folder_path)\n",
    "    rule_name = folder_name.split(\"_\")[0]\n",
    "    n_files = len(os.listdir(folder_path))\n",
    "    dict_error_per_rule_qchecker[rule_name] = n_files\n",
    "print(dict_error_per_rule_qchecker)\n",
    "\n",
    "# scan all the .sarif files and join them\n",
    "all_sarif_files = glob.glob(\n",
    "    os.path.join(FOLDER_WITH_QCHECKER_WARNINGS, \"*.sarif\"))\n",
    "# skip all_detectors.sarif\n",
    "all_sarif_files = [f for f in all_sarif_files if \"all_detectors.sarif\" not in f]\n",
    "\n",
    "df_results_qchecker = pd.concat([\n",
    "    get_df_from_sarif(get_results_from_sarif_path(sarif_file))\n",
    "    for sarif_file in all_sarif_files\n",
    "])\n",
    "\n",
    "# unique values rule_id\n",
    "print(df_results_qchecker[\"rule_id\"].unique())\n",
    "\n",
    "# remove file:/// prefix\n",
    "df_results_qchecker[\"file\"] = df_results_qchecker[\"file\"].apply(\n",
    "    lambda e: e.replace(\"file:///\", \"\"))\n",
    "\n",
    "print(f\"Total warnings: {len(df_results_qchecker)}\")\n",
    "display(df_results_qchecker.head())\n",
    "\n",
    "\n",
    "compute_warnings_table(\n",
    "    df_results=df_results_qchecker,\n",
    "    rule_name_mapping=RULE_NAME_MAPPING_QCHECKER,\n",
    "    total_files_in_dataset=TOTAL_FILES_IN_DATASET,\n",
    "    rule_term=\"Rule\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QSmell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'LPQ': 21, 'NC': 21}\n"
     ]
    },
    {
     "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>rule_id</th>\n",
       "      <th>message</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>col</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>LPQ</td>\n",
       "      <td>LPQ smell - No-alignment between the Logical a...</td>\n",
       "      <td>unittest_7125fc.py</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>LPQ</td>\n",
       "      <td>LPQ smell - No-alignment between the Logical a...</td>\n",
       "      <td>4_c6ba6b.py</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>LPQ</td>\n",
       "      <td>LPQ smell - No-alignment between the Logical a...</td>\n",
       "      <td>test_4a62dd.py</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>LPQ</td>\n",
       "      <td>LPQ smell - No-alignment between the Logical a...</td>\n",
       "      <td>our_vqe_gjg_591c88.py</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>LPQ</td>\n",
       "      <td>LPQ smell - No-alignment between the Logical a...</td>\n",
       "      <td>alternating_operator_63165f.py</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   rule_id                                            message  \\\n",
       "5      LPQ  LPQ smell - No-alignment between the Logical a...   \n",
       "21     LPQ  LPQ smell - No-alignment between the Logical a...   \n",
       "38     LPQ  LPQ smell - No-alignment between the Logical a...   \n",
       "41     LPQ  LPQ smell - No-alignment between the Logical a...   \n",
       "44     LPQ  LPQ smell - No-alignment between the Logical a...   \n",
       "\n",
       "                              file  line  col  \n",
       "5               unittest_7125fc.py     1    1  \n",
       "21                     4_c6ba6b.py     1    1  \n",
       "38                  test_4a62dd.py     1    1  \n",
       "41           our_vqe_gjg_591c88.py     1    1  \n",
       "44  alternating_operator_63165f.py     1    1  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total warnings: 2916\n",
      "\\newcommand{\\avgWarningsPerc}{19.27\\%}\n",
      "\\newcommand{\\medianWarningsPerc}{19.27\\%}\n",
      "\\begin{tabular}{lrr}\n",
      "\\toprule\n",
      "Rule Name & Tot. warnings & Files with warning \\\\\n",
      "\\midrule\n",
      "LogicalPhysicalQubits & 698 & 9.22\\% \\\\\n",
      "NonParameterizedCircuit & 2218 & 29.31\\% \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "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>Rule Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>LogicalPhysicalQubits</td>\n",
       "      <td>698</td>\n",
       "      <td>9.22%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NonParameterizedCircuit</td>\n",
       "      <td>2218</td>\n",
       "      <td>29.31%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Rule Name  Tot. warnings Files with warning\n",
       "0    LogicalPhysicalQubits            698              9.22%\n",
       "1  NonParameterizedCircuit           2218             29.31%"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Rule Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>LogicalPhysicalQubits</td>\n",
       "      <td>698</td>\n",
       "      <td>9.22%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NonParameterizedCircuit</td>\n",
       "      <td>2218</td>\n",
       "      <td>29.31%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Rule Name  Tot. warnings Files with warning\n",
       "0    LogicalPhysicalQubits            698              9.22%\n",
       "1  NonParameterizedCircuit           2218             29.31%"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "FOLDER_WITH_QSMELL_WARNINGS = \"../data/analysis_results/exp_v08_competitors/qsmell\"\n",
    "\n",
    "RULE_NAME_MAPPING_QSMELL = {\n",
    "    'LPQ': 'LogicalPhysicalQubits',\n",
    "    'NC': 'NonParameterizedCircuit',\n",
    "}\n",
    "\n",
    "# LOAD QSMELL WARNINGS\n",
    "all_csv_files = [\n",
    "    os.path.join(FOLDER_WITH_QSMELL_WARNINGS, f)\n",
    "    for f in os.listdir(FOLDER_WITH_QSMELL_WARNINGS)\n",
    "    if f.endswith(\".csv\")\n",
    "]\n",
    "df_results_qsmell = pd.concat([pd.read_csv(f) for f in all_csv_files])\n",
    "df_results_qsmell.rename(columns={\n",
    "    \"metric\": \"rule_id\", \"filename\": \"file\"\n",
    "}, inplace=True)\n",
    "# add default line column to 1\n",
    "df_results_qsmell[\"line\"] = 1\n",
    "df_results_qsmell[\"col\"] = 1\n",
    "\n",
    "\n",
    "def derive_message(row):\n",
    "    if row[\"value\"] == \"error\":\n",
    "        return \"error\"\n",
    "    if int(row[\"value\"]) >= 1:\n",
    "        if row[\"rule_id\"] == \"NC\":\n",
    "            return f\"{row['rule_id']} smell - \" + \\\n",
    "                \"Non-parameterized Circuit\"\n",
    "        if row[\"rule_id\"] == \"LPQ\":\n",
    "            return f\"{row['rule_id']} smell - \" + \\\n",
    "                \"No-alignment between the Logical and Physical Qubits\"\n",
    "    return \"no smell\"\n",
    "\n",
    "df_results_qsmell['message'] = df_results_qsmell.apply(derive_message, axis=1)\n",
    "\n",
    "# count the errors per rule\n",
    "dict_error_per_rule_qsmell = df_results_qsmell[\n",
    "    df_results_qsmell[\"message\"] == \"error\"\n",
    "].groupby(\"rule_id\").size().to_dict()\n",
    "print(dict_error_per_rule_qsmell)\n",
    "\n",
    "# drop errors\n",
    "df_results_qsmell = df_results_qsmell[df_results_qsmell[\"message\"] != \"error\"]\n",
    "# drop no smells\n",
    "df_results_qsmell = df_results_qsmell[df_results_qsmell[\"message\"] != \"no smell\"]\n",
    "\n",
    "# keep only rule_id, msg, file, line, col and drop remaining columns\n",
    "df_results_qsmell = df_results_qsmell[\n",
    "    [\"rule_id\", \"message\", \"file\", \"line\", \"col\"]]\n",
    "display(df_results_qsmell.head())\n",
    "\n",
    "print(f\"Total warnings: {len(df_results_qsmell)}\")\n",
    "\n",
    "compute_warnings_table(\n",
    "    df_results=df_results_qsmell,\n",
    "    rule_name_mapping=RULE_NAME_MAPPING_QSMELL,\n",
    "    total_files_in_dataset=TOTAL_FILES_IN_DATASET,\n",
    "    rule_term=\"Rule\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pylint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOTE: add this field to the yaml config file of Pylint (e.g., pylint_vXX.yaml in the config folder)\n",
      "then run: python -m competitors.pylint.run_pylint_folder config/competitors/pylint_v08.yaml\n",
      "subset_files_to_analyze:\n",
      "  - test_sdk_352e8e.py\n",
      "  - test_circuit_load_from_qasm_bf30ab.py\n",
      "  - test_circuit_qasm_ae5268.py\n",
      "  - test_decompose_78559e.py\n",
      "  - test_structure_aaba85.py\n",
      "  - ahmed154_73ece9.py\n",
      "  - task_0f414b.py\n",
      "  - tutorial03_quantumoperations_061e13.py\n",
      "  - test_unroll_3q_or_more_7bf310.py\n",
      "  - xqiskit_test_ab1d81.py\n",
      "  - b24_hadamard_solutions_2ba19d.py\n",
      "  - example_qiskit_conditional_5ae7f6.py\n",
      "  - example_qiskit_conditional_67fb51.py\n",
      "  - example_qiskit_conditional_78732d.py\n",
      "  - gates_20overview_44ffd3.py\n",
      "  - constante_1_00_d02e10.py\n",
      "  - ex1_a7614b.py\n",
      "  - measurement_postulate_single_qubit_f_fb7a34.py\n",
      "  - measurement_tests_fdc8b4.py\n",
      "  - quantum_encoding_5a7eeb.py\n",
      "  - qxq_ylc_lab_5_student_e32900.py\n",
      "  - superpositions_26c0f1.py\n",
      "  - a00_qiskit_introduction_checkpoint_78fe1f.py\n",
      "  - functionsjozsa_428a2d.py\n",
      "  - representing_qubit_states_610048.py\n",
      "  - tabula_rasa_768589.py\n",
      "  - test_compiler_907f66.py\n",
      "  - test_compiler_af868d.py\n",
      "  - test_mapper_217a32.py\n",
      "  - balanceada_2_48d67f.py\n",
      "  - balanceada_3_11881b.py\n",
      "  - a00_qiskit_introduction_1ba1af.py\n",
      "  - a00_qiskit_introduction_79143b.py\n",
      "  - aatoms_of_computation_ed6fac.py\n",
      "  - atoms_computation_01fe8e.py\n",
      "  - basics_64c7b2.py\n",
      "  - deutsch_jozsa_s_20functions_b84a95.py\n",
      "  - err_10214c.py\n",
      "  - ex1_98892e.py\n",
      "  - hadamard_b2fac2.py\n",
      "  - hello_b14c35.py\n",
      "  - herrtestcomptimetiffoli_cf1dac.py\n",
      "  - 4_qbits_decoherence_9bbc1f.py\n",
      "  - bit_flip_code_f40402.py\n",
      "  - discrete_solver_7f2f57.py\n",
      "  - 01_classical_and_quantum_probability_distributions_411e21.py\n",
      "  - helper_functions_a521e2.py\n",
      "  - energyrelaxation_230ca7.py\n",
      "  - phase_flip_code_4072b2.py\n",
      "  - t1_3fa19f.py\n",
      "  - t2_ramsey_2e0f5a.py\n",
      "  - unitary_simulator_25e259.py\n",
      "  - quantum_e3f4e0.py\n",
      "  - rsa_breaker_4_bit_0f27ff.py\n",
      "  - test_qasm_simulator_edd048.py\n",
      "  - qrpgcg_cd84f9.py\n",
      "  - qubitstates_903372.py\n",
      "  - qubits_d78ad0.py\n",
      "  - qubits_intro_974f92.py\n",
      "  - sandbox_e52934.py\n",
      "  - shorbreaker_5299e4.py\n",
      "  - test_circuit_to_dag_5333cb.py\n",
      "  - test_qasm_simulator_682153.py\n",
      "  - test_stochastic_swap_89a6ef.py\n",
      "  - 02_measurements_and_mixed_states_qiskit_ee25f6.py\n",
      "  - example_d675c9.py\n",
      "  - h2evo_6bb46f.py\n",
      "  - neoh2evo_28b965.py\n",
      "  - test_mc_gate_13ba80.py\n",
      "  - transpiled_stabilizer_test_7be7ce.py\n",
      "  - h2evoqlm_f7e7b5.py\n",
      "  - shor_df608f.py\n",
      "  - bell_states_example_55fd07.py\n",
      "  - polarization_20rotator_20angle_25374b.py\n",
      "  - quantum_entanglement_f902fe.py\n",
      "  - mnist_dd2c4f.py\n",
      "  - interferibmc_c22d6b.py\n",
      "  - qrng_9498d5.py\n",
      "  - matchgate_tools_mudground_checkpoint_a852d9.py\n",
      "  - test_parse_counts_0953d6.py\n",
      "  - example_1_c6d971.py\n",
      "  - main_2f60d4.py\n",
      "  - n_qubit_grovers_algorithm_ff6131.py\n",
      "  - qiskit_c50734.py\n",
      "  - qrng_09be03.py\n",
      "  - code_12fb50.py\n",
      "  - ghz_ca5e66.py\n",
      "  - ghz_7af332.py\n",
      "  - real_system_c4c34f.py\n",
      "  - groverfuncs_9232ea.py\n",
      "  - source_59a0eb956a0d4e6b8720f272136f2799_9b8ba7.py\n",
      "  - source_948f90de9947418289b220bd2e61caa3_caae3b.py\n",
      "  - quantumteleportationprotocol_7da521.py\n",
      "  - one_qubit_fb6117.py\n",
      "  - quantumteleportation_2823d6.py\n",
      "  - ch_3_28325b.py\n",
      "  - teleportation_07c3ca.py\n",
      "  - task_3_4b4e03.py\n",
      "  - python_quantum_number_generator_1_6_multi_qasm_76fe84.py\n",
      "  - quantum_random_pixel_generator_multi_qasm_bebc43.py\n",
      "  - q04_qiskit_installation_and_test_7d0f02.py\n",
      "  - q02_417981.py\n",
      "  - quantum_key_distribution_875841.py\n",
      "  - quantum_pixel_generator_multi_qasm_fractional_variable_d8275b.py\n",
      "  - quantum_random_pixel_generator_multi_qasm_complete_8582ba.py\n",
      "  - quantum_random_pixel_generator_multi_qasm_variable_1f937f.py\n",
      "  - quantum_teleport_4f22f3.py\n",
      "  - quantum_teleportation_1881c2.py\n",
      "  - quantum_teleportation_9276a1.py\n",
      "  - teleportation_a12212.py\n",
      "  - teleportation_practice_4ae2ea.py\n",
      "  - quntum_204_dec_2005_202020_206_2042_20am_16e278.py\n",
      "  - single_qubit_01e1c7.py\n",
      "  - task_2_4f46b2.py\n",
      "  - teleportation_50c827.py\n",
      "  - teleportation_8f1eaf.py\n",
      "  - the_20quantum_20teleportation_20algorithm_c014d5.py\n",
      "  - two_qubit_4cff15.py\n",
      "  - 12_quantum_key_distribution_checkpoint_4165fd.py\n",
      "  - correlations_31df66.py\n",
      "  - demo3_quantum_teleportation_5b8be6.py\n",
      "  - electroquantum_39cf94.py\n",
      "  - encrpytion_e53b97.py\n",
      "  - hardware_3936ea.py\n",
      "  - main_20code_20soccer_20quantum_20predicter_a83463.py\n",
      "  - quantumdice_bc7351.py\n",
      "  - quantum_key_distribution_e8abe3.py\n",
      "  - 4atoms_of_computation_332679.py\n",
      "  - day_203_20universality_69a67f.py\n",
      "  - jakoyhtalot_algoritmit_8daaee.py\n",
      "  - easy_qnn_0305db.py\n",
      "  - qgates_4e7d74.py\n",
      "  - qkd_dashboard_greesan_5bf1cb.py\n",
      "  - quantum_match_filtering_paper_replication_cdc179.py\n",
      "  - test_code_91c4dd.py\n",
      "  - quantum_walker_cbff5a.py\n",
      "  - test_identifiers_6ec4a8.py\n",
      "  - test_iqm_backend_9dfa5b.py\n",
      "  - z_gate_d06a00.py\n",
      "  - test_circuit_combine_extend_a76ce4.py\n",
      "  - test_output_bd6143.py\n",
      "  - test_quantumprogram_6f378f.py\n",
      "  - 07_variational_circuits_f6a719.py\n",
      "  - circuit_d01243.py\n",
      "  - demo_6973fd.py\n",
      "  - dmft6_3cfa29.py\n",
      "  - gateset_4ffe74.py\n",
      "  - a03_deutsch_algorithm_solutions_checkpoint_cd1511.py\n",
      "  - 3_more_circuit_identities_checkpoint_986a09.py\n",
      "  - multiple_qubits_entangled_states_d1b18b.py\n",
      "  - multiplier_5c47de.py\n",
      "  - qiskit_and_ibmq_ad1bdd.py\n",
      "  - test_qulacs_converter_ec6aa2.py\n",
      "  - test_sdg_gate_56b97a.py\n",
      "  - quantum_walks_project_329d10.py\n",
      "  - rotation_95ca93.py\n",
      "  - test_qiskit_738074.py\n",
      "  - wrapper_iae_fab9d4.py\n",
      "  - challenge4_circuitdecomposition_a80a1d.py\n",
      "  - decomposed_a7ee15.py\n",
      "  - draft_qnn12_0e9c87.py\n",
      "  - ex2_fr_dc4911.py\n",
      "  - inverse_dcf9ae.py\n",
      "  - lab_2_malihe_e61048.py\n",
      "  - test_u_gate_940648.py\n"
     ]
    }
   ],
   "source": [
    "# print the list of only those files that have received TP from our annotation\n",
    "TP_annotations_files = list(df_annotations[\n",
    "    df_annotations[COL_AGREED_ANNOTATION] == \"TP\"\n",
    "][\"file\"].unique())\n",
    "print(\n",
    "    \"NOTE: add this field to the yaml config file of Pylint \"\n",
    "    \"(e.g., pylint_vXX.yaml in the config folder)\")\n",
    "print(\"then run: python -m competitors.pylint.run_pylint_folder config/competitors/pylint_v08.yaml\")\n",
    "print(\"subset_files_to_analyze:\")\n",
    "for file in TP_annotations_files:\n",
    "    print(f\"  - {file}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>rule_id</th>\n",
       "      <th>message</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>col</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>C0301</td>\n",
       "      <td>Line too long (114/100).</td>\n",
       "      <td>task_2_4f46b2.py</td>\n",
       "      <td>60</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>C0304</td>\n",
       "      <td>Final newline missing.</td>\n",
       "      <td>task_2_4f46b2.py</td>\n",
       "      <td>64</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C0114</td>\n",
       "      <td>Missing module docstring.</td>\n",
       "      <td>task_2_4f46b2.py</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>C0103</td>\n",
       "      <td>Constant name \"alice_key\" doesn't conform to U...</td>\n",
       "      <td>task_2_4f46b2.py</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>C0103</td>\n",
       "      <td>Constant name \"bob_key\" doesn't conform to UPP...</td>\n",
       "      <td>task_2_4f46b2.py</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  rule_id                                            message  \\\n",
       "0   C0301                           Line too long (114/100).   \n",
       "1   C0304                             Final newline missing.   \n",
       "2   C0114                          Missing module docstring.   \n",
       "3   C0103  Constant name \"alice_key\" doesn't conform to U...   \n",
       "4   C0103  Constant name \"bob_key\" doesn't conform to UPP...   \n",
       "\n",
       "               file  line  col  \n",
       "0  task_2_4f46b2.py    60    1  \n",
       "1  task_2_4f46b2.py    64    1  \n",
       "2  task_2_4f46b2.py     1    1  \n",
       "3  task_2_4f46b2.py     5    1  \n",
       "4  task_2_4f46b2.py     6    1  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total warnings: 9958\n",
      "\\newcommand{\\avgWarningsPerc}{9.14\\%}\n",
      "\\newcommand{\\medianWarningsPerc}{2.42\\%}\n",
      "\\begin{tabular}{lrr}\n",
      "\\toprule\n",
      "Rule Name & Tot. warnings & Files with warning \\\\\n",
      "\\midrule\n",
      "C0103 & 1560 & 66.06\\% \\\\\n",
      "C0114 & 138 & 83.64\\% \\\\\n",
      "C0115 & 28 & 4.85\\% \\\\\n",
      "C0116 & 438 & 43.03\\% \\\\\n",
      "C0121 & 3 & 1.82\\% \\\\\n",
      "C0123 & 2 & 1.21\\% \\\\\n",
      "C0200 & 31 & 7.27\\% \\\\\n",
      "C0201 & 1 & 0.61\\% \\\\\n",
      "C0206 & 6 & 1.82\\% \\\\\n",
      "C0209 & 53 & 14.55\\% \\\\\n",
      "C0301 & 1599 & 55.76\\% \\\\\n",
      "C0302 & 5 & 3.03\\% \\\\\n",
      "C0303 & 2954 & 51.52\\% \\\\\n",
      "C0304 & 36 & 21.82\\% \\\\\n",
      "C0305 & 54 & 32.73\\% \\\\\n",
      "C0321 & 8 & 2.42\\% \\\\\n",
      "C0325 & 28 & 6.67\\% \\\\\n",
      "C0410 & 1 & 0.61\\% \\\\\n",
      "C0411 & 107 & 33.33\\% \\\\\n",
      "C0412 & 58 & 20.61\\% \\\\\n",
      "C0413 & 390 & 40.00\\% \\\\\n",
      "C0415 & 6 & 0.61\\% \\\\\n",
      "C1802 & 1 & 0.61\\% \\\\\n",
      "C1803 & 3 & 0.61\\% \\\\\n",
      "C2401 & 10 & 1.21\\% \\\\\n",
      "C3001 & 8 & 1.82\\% \\\\\n",
      "E0102 & 7 & 2.42\\% \\\\\n",
      "E0401 & 197 & 43.03\\% \\\\\n",
      "E0402 & 8 & 4.24\\% \\\\\n",
      "E0601 & 6 & 3.03\\% \\\\\n",
      "E0602 & 149 & 20.00\\% \\\\\n",
      "E0611 & 89 & 22.42\\% \\\\\n",
      "E0633 & 1 & 0.61\\% \\\\\n",
      "E1101 & 221 & 21.21\\% \\\\\n",
      "E1102 & 4 & 1.82\\% \\\\\n",
      "E1111 & 3 & 0.61\\% \\\\\n",
      "E1120 & 25 & 3.03\\% \\\\\n",
      "E1121 & 1 & 0.61\\% \\\\\n",
      "E1123 & 12 & 1.21\\% \\\\\n",
      "R0123 & 25 & 0.61\\% \\\\\n",
      "R0124 & 7 & 0.61\\% \\\\\n",
      "R0133 & 25 & 0.61\\% \\\\\n",
      "R0205 & 2 & 1.21\\% \\\\\n",
      "R0402 & 5 & 1.21\\% \\\\\n",
      "R0902 & 1 & 0.61\\% \\\\\n",
      "R0903 & 5 & 2.42\\% \\\\\n",
      "R0904 & 2 & 1.21\\% \\\\\n",
      "R0912 & 10 & 4.85\\% \\\\\n",
      "R0913 & 34 & 6.67\\% \\\\\n",
      "R0914 & 31 & 11.52\\% \\\\\n",
      "R0915 & 17 & 8.48\\% \\\\\n",
      "R0916 & 1 & 0.61\\% \\\\\n",
      "R1703 & 1 & 0.61\\% \\\\\n",
      "R1704 & 3 & 0.61\\% \\\\\n",
      "R1705 & 18 & 7.27\\% \\\\\n",
      "R1710 & 5 & 3.03\\% \\\\\n",
      "R1711 & 1 & 0.61\\% \\\\\n",
      "R1714 & 9 & 2.42\\% \\\\\n",
      "R1716 & 6 & 0.61\\% \\\\\n",
      "R1720 & 5 & 1.21\\% \\\\\n",
      "R1721 & 12 & 3.03\\% \\\\\n",
      "R1724 & 3 & 1.82\\% \\\\\n",
      "R1728 & 1 & 0.61\\% \\\\\n",
      "R1729 & 1 & 0.61\\% \\\\\n",
      "R1732 & 1 & 0.61\\% \\\\\n",
      "R1734 & 4 & 0.61\\% \\\\\n",
      "R1735 & 1 & 0.61\\% \\\\\n",
      "W0101 & 1 & 0.61\\% \\\\\n",
      "W0102 & 1 & 0.61\\% \\\\\n",
      "W0104 & 39 & 10.91\\% \\\\\n",
      "W0105 & 24 & 7.27\\% \\\\\n",
      "W0106 & 9 & 4.24\\% \\\\\n",
      "W0108 & 1 & 0.61\\% \\\\\n",
      "W0122 & 15 & 1.21\\% \\\\\n",
      "W0123 & 5 & 1.21\\% \\\\\n",
      "W0125 & 1 & 0.61\\% \\\\\n",
      "W0133 & 1 & 0.61\\% \\\\\n",
      "W0201 & 2 & 0.61\\% \\\\\n",
      "W0212 & 24 & 4.24\\% \\\\\n",
      "W0301 & 28 & 4.85\\% \\\\\n",
      "W0311 & 104 & 9.09\\% \\\\\n",
      "W0401 & 65 & 23.64\\% \\\\\n",
      "W0404 & 176 & 17.58\\% \\\\\n",
      "W0511 & 15 & 3.64\\% \\\\\n",
      "W0601 & 18 & 1.21\\% \\\\\n",
      "W0602 & 12 & 1.21\\% \\\\\n",
      "W0603 & 18 & 1.21\\% \\\\\n",
      "W0611 & 311 & 52.73\\% \\\\\n",
      "W0612 & 70 & 18.18\\% \\\\\n",
      "W0613 & 50 & 9.09\\% \\\\\n",
      "W0614 & 50 & 21.21\\% \\\\\n",
      "W0621 & 357 & 21.21\\% \\\\\n",
      "W0622 & 13 & 6.67\\% \\\\\n",
      "W0631 & 1 & 0.61\\% \\\\\n",
      "W0702 & 5 & 2.42\\% \\\\\n",
      "W0719 & 8 & 3.03\\% \\\\\n",
      "W1309 & 12 & 0.61\\% \\\\\n",
      "W1310 & 1 & 0.61\\% \\\\\n",
      "W1401 & 3 & 1.21\\% \\\\\n",
      "W1514 & 30 & 3.03\\% \\\\\n",
      "W3101 & 1 & 0.61\\% \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\n"
     ]
    },
    {
     "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>Rule Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>C0103</td>\n",
       "      <td>1560</td>\n",
       "      <td>66.06%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>C0114</td>\n",
       "      <td>138</td>\n",
       "      <td>83.64%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C0115</td>\n",
       "      <td>28</td>\n",
       "      <td>4.85%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>C0116</td>\n",
       "      <td>438</td>\n",
       "      <td>43.03%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>C0121</td>\n",
       "      <td>3</td>\n",
       "      <td>1.82%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>C0123</td>\n",
       "      <td>2</td>\n",
       "      <td>1.21%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>C0200</td>\n",
       "      <td>31</td>\n",
       "      <td>7.27%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>C0201</td>\n",
       "      <td>1</td>\n",
       "      <td>0.61%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>C0206</td>\n",
       "      <td>6</td>\n",
       "      <td>1.82%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>C0209</td>\n",
       "      <td>53</td>\n",
       "      <td>14.55%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>C0301</td>\n",
       "      <td>1599</td>\n",
       "      <td>55.76%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>C0302</td>\n",
       "      <td>5</td>\n",
       "      <td>3.03%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>C0303</td>\n",
       "      <td>2954</td>\n",
       "      <td>51.52%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>C0304</td>\n",
       "      <td>36</td>\n",
       "      <td>21.82%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>C0305</td>\n",
       "      <td>54</td>\n",
       "      <td>32.73%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>C0321</td>\n",
       "      <td>8</td>\n",
       "      <td>2.42%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>C0325</td>\n",
       "      <td>28</td>\n",
       "      <td>6.67%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>C0410</td>\n",
       "      <td>1</td>\n",
       "      <td>0.61%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>C0411</td>\n",
       "      <td>107</td>\n",
       "      <td>33.33%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>C0412</td>\n",
       "      <td>58</td>\n",
       "      <td>20.61%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Rule Name  Tot. warnings Files with warning\n",
       "0      C0103           1560             66.06%\n",
       "1      C0114            138             83.64%\n",
       "2      C0115             28              4.85%\n",
       "3      C0116            438             43.03%\n",
       "4      C0121              3              1.82%\n",
       "5      C0123              2              1.21%\n",
       "6      C0200             31              7.27%\n",
       "7      C0201              1              0.61%\n",
       "8      C0206              6              1.82%\n",
       "9      C0209             53             14.55%\n",
       "10     C0301           1599             55.76%\n",
       "11     C0302              5              3.03%\n",
       "12     C0303           2954             51.52%\n",
       "13     C0304             36             21.82%\n",
       "14     C0305             54             32.73%\n",
       "15     C0321              8              2.42%\n",
       "16     C0325             28              6.67%\n",
       "17     C0410              1              0.61%\n",
       "18     C0411            107             33.33%\n",
       "19     C0412             58             20.61%"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Rule Name</th>\n",
       "      <th>Tot. warnings</th>\n",
       "      <th>Files with warning</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>C0103</td>\n",
       "      <td>1560</td>\n",
       "      <td>66.06%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>C0114</td>\n",
       "      <td>138</td>\n",
       "      <td>83.64%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>C0115</td>\n",
       "      <td>28</td>\n",
       "      <td>4.85%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>C0116</td>\n",
       "      <td>438</td>\n",
       "      <td>43.03%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>C0121</td>\n",
       "      <td>3</td>\n",
       "      <td>1.82%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>W1309</td>\n",
       "      <td>12</td>\n",
       "      <td>0.61%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>W1310</td>\n",
       "      <td>1</td>\n",
       "      <td>0.61%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>W1401</td>\n",
       "      <td>3</td>\n",
       "      <td>1.21%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>W1514</td>\n",
       "      <td>30</td>\n",
       "      <td>3.03%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>W3101</td>\n",
       "      <td>1</td>\n",
       "      <td>0.61%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>101 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    Rule Name  Tot. warnings Files with warning\n",
       "0       C0103           1560             66.06%\n",
       "1       C0114            138             83.64%\n",
       "2       C0115             28              4.85%\n",
       "3       C0116            438             43.03%\n",
       "4       C0121              3              1.82%\n",
       "..        ...            ...                ...\n",
       "96      W1309             12              0.61%\n",
       "97      W1310              1              0.61%\n",
       "98      W1401              3              1.21%\n",
       "99      W1514             30              3.03%\n",
       "100     W3101              1              0.61%\n",
       "\n",
       "[101 rows x 3 columns]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "FOLDER_WITH_PYLINT_WARNINGS = \"../data/analysis_results/exp_v08_competitors/pylint\"\n",
    "\n",
    "sarif_results_pylint = get_results_from_sarif_path(\n",
    "    os.path.join(FOLDER_WITH_PYLINT_WARNINGS, \"data.sarif\"))\n",
    "df_results_pylint = get_df_from_sarif(sarif_results_pylint)\n",
    "\n",
    "# transform the file keeping only filename\n",
    "df_results_pylint[\"file\"] = df_results_pylint[\"file\"].apply(\n",
    "    lambda e: os.path.basename(e))\n",
    "# convert line to int\n",
    "df_results_pylint[\"line\"] = df_results_pylint[\"line\"].astype(int)\n",
    "\n",
    "display(df_results_pylint.head())\n",
    "print(f\"Total warnings: {len(df_results_pylint)}\")\n",
    "\n",
    "compute_warnings_table(\n",
    "    df_results=df_results_pylint,\n",
    "    rule_name_mapping=None,\n",
    "    total_files_in_dataset=len(TP_annotations_files),\n",
    "    rule_term=\"Rule\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Overlap on TP\n",
    "Here we compute the overlap between the true positive found by LintQ and what the competitors can find on the same files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>rule_id</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>message</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ql-conditional-without-measurement</td>\n",
       "      <td>test_sdk_352e8e.py</td>\n",
       "      <td>34</td>\n",
       "      <td>Conditional gate 'h' on qubit '2' (l: 34, c: 1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ql-conditional-without-measurement</td>\n",
       "      <td>test_circuit_load_from_qasm_bf30ab.py</td>\n",
       "      <td>114</td>\n",
       "      <td>Conditional gate 'x' on qubit '0' (l: 114, c: ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ql-conditional-without-measurement</td>\n",
       "      <td>test_circuit_qasm_ae5268.py</td>\n",
       "      <td>47</td>\n",
       "      <td>Conditional gate 'z' on qubit '0' (l: 47, c: 9...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ql-conditional-without-measurement</td>\n",
       "      <td>test_decompose_78559e.py</td>\n",
       "      <td>83</td>\n",
       "      <td>Conditional gate 'x' on qubit '0' (l: 83, c: 9...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ql-conditional-without-measurement</td>\n",
       "      <td>test_decompose_78559e.py</td>\n",
       "      <td>75</td>\n",
       "      <td>Conditional gate 'h' on qubit '0' (l: 75, c: 9...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              rule_id                                   file  \\\n",
       "0  ql-conditional-without-measurement                     test_sdk_352e8e.py   \n",
       "1  ql-conditional-without-measurement  test_circuit_load_from_qasm_bf30ab.py   \n",
       "2  ql-conditional-without-measurement            test_circuit_qasm_ae5268.py   \n",
       "3  ql-conditional-without-measurement               test_decompose_78559e.py   \n",
       "4  ql-conditional-without-measurement               test_decompose_78559e.py   \n",
       "\n",
       "   line                                            message  \n",
       "0    34  Conditional gate 'h' on qubit '2' (l: 34, c: 1...  \n",
       "1   114  Conditional gate 'x' on qubit '0' (l: 114, c: ...  \n",
       "2    47  Conditional gate 'z' on qubit '0' (l: 47, c: 9...  \n",
       "3    83  Conditional gate 'x' on qubit '0' (l: 83, c: 9...  \n",
       "4    75  Conditional gate 'h' on qubit '0' (l: 75, c: 9...  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total QChecker warnings: 200\n",
      "Ratio of QChecker warnings on relevant files: 0.42424242424242425\n",
      "Checking QChecker\n",
      "Overlapping QChecker: 9\n"
     ]
    },
    {
     "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>rule_id_lintq</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>message_lintq</th>\n",
       "      <th>rule_id_prior_work</th>\n",
       "      <th>message_prior_work</th>\n",
       "      <th>tool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>01_classical_and_quantum_probability_distribut...</td>\n",
       "      <td>192</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>DO</td>\n",
       "      <td>circuit.iden(q[0])</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>energyrelaxation_230ca7.py</td>\n",
       "      <td>29</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>DO</td>\n",
       "      <td>middle.iden(q)</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>t1_3fa19f.py</td>\n",
       "      <td>26</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>DO</td>\n",
       "      <td>middle.iden(q)</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>t2_ramsey_2e0f5a.py</td>\n",
       "      <td>31</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>DO</td>\n",
       "      <td>middle.iden(q)</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>unitary_simulator_25e259.py</td>\n",
       "      <td>42</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>DO</td>\n",
       "      <td>circ.iden([0,1])</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>ql-double-measurement</td>\n",
       "      <td>qubitstates_903372.py</td>\n",
       "      <td>12</td>\n",
       "      <td>Two consecutive measurements on qubit '0' at l...</td>\n",
       "      <td>IIS</td>\n",
       "      <td>qc.measure(0, 1)</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>ql-op-after-optimization</td>\n",
       "      <td>source_59a0eb956a0d4e6b8720f272136f2799_9b8ba7.py</td>\n",
       "      <td>34</td>\n",
       "      <td>Operation measure applied to transpiled circui...</td>\n",
       "      <td>IIS</td>\n",
       "      <td>qc.measure(qr, cr)</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>one_qubit_fb6117.py</td>\n",
       "      <td>41</td>\n",
       "      <td>Operation 'cz' on qubit 1 after measurement at...</td>\n",
       "      <td>IM</td>\n",
       "      <td>circuit.cz(1, 2)</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>quantum_pixel_generator_multi_qasm_fractional_...</td>\n",
       "      <td>33</td>\n",
       "      <td>Operation 'cz' on qubit 1 after measurement at...</td>\n",
       "      <td>IM</td>\n",
       "      <td>qc.cz(1,0)#Set to |-&gt; if control qubit is ...</td>\n",
       "      <td>QChecker</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     rule_id_lintq  \\\n",
       "0           ql-deprecated-identity   \n",
       "2           ql-deprecated-identity   \n",
       "4           ql-deprecated-identity   \n",
       "6           ql-deprecated-identity   \n",
       "8           ql-deprecated-identity   \n",
       "10           ql-double-measurement   \n",
       "12        ql-op-after-optimization   \n",
       "14  ql-operation-after-measurement   \n",
       "16  ql-operation-after-measurement   \n",
       "\n",
       "                                                 file  line  \\\n",
       "0   01_classical_and_quantum_probability_distribut...   192   \n",
       "2                          energyrelaxation_230ca7.py    29   \n",
       "4                                        t1_3fa19f.py    26   \n",
       "6                                 t2_ramsey_2e0f5a.py    31   \n",
       "8                         unitary_simulator_25e259.py    42   \n",
       "10                              qubitstates_903372.py    12   \n",
       "12  source_59a0eb956a0d4e6b8720f272136f2799_9b8ba7.py    34   \n",
       "14                                one_qubit_fb6117.py    41   \n",
       "16  quantum_pixel_generator_multi_qasm_fractional_...    33   \n",
       "\n",
       "                                        message_lintq rule_id_prior_work  \\\n",
       "0                The deprecated iden() API is called.                 DO   \n",
       "2                The deprecated iden() API is called.                 DO   \n",
       "4                The deprecated iden() API is called.                 DO   \n",
       "6                The deprecated iden() API is called.                 DO   \n",
       "8                The deprecated iden() API is called.                 DO   \n",
       "10  Two consecutive measurements on qubit '0' at l...                IIS   \n",
       "12  Operation measure applied to transpiled circui...                IIS   \n",
       "14  Operation 'cz' on qubit 1 after measurement at...                 IM   \n",
       "16  Operation 'cz' on qubit 1 after measurement at...                 IM   \n",
       "\n",
       "                                   message_prior_work      tool  \n",
       "0                                  circuit.iden(q[0])  QChecker  \n",
       "2                                      middle.iden(q)  QChecker  \n",
       "4                                      middle.iden(q)  QChecker  \n",
       "6                                      middle.iden(q)  QChecker  \n",
       "8                                    circ.iden([0,1])  QChecker  \n",
       "10                                   qc.measure(0, 1)  QChecker  \n",
       "12                                 qc.measure(qr, cr)  QChecker  \n",
       "14                                   circuit.cz(1, 2)  QChecker  \n",
       "16      qc.cz(1,0)#Set to |-> if control qubit is ...  QChecker  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total QSmell warnings: 77\n",
      "Ratio of QSmell warnings on relevant files: 0.46060606060606063\n",
      "Checking QSmell\n",
      "Overlapping QSmell: 0\n"
     ]
    },
    {
     "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>rule_id_lintq</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>message_lintq</th>\n",
       "      <th>rule_id_prior_work</th>\n",
       "      <th>message_prior_work</th>\n",
       "      <th>tool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [rule_id_lintq, file, line, message_lintq, rule_id_prior_work, message_prior_work, tool]\n",
       "Index: []"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Pylint warnings: 8627\n",
      "Ratio of Pylint warnings on relevant files: 1.0\n",
      "Checking Pylint\n",
      "Overlapping Pylint: 42\n"
     ]
    },
    {
     "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>rule_id_lintq</th>\n",
       "      <th>file</th>\n",
       "      <th>line</th>\n",
       "      <th>message_lintq</th>\n",
       "      <th>rule_id_prior_work</th>\n",
       "      <th>message_prior_work</th>\n",
       "      <th>tool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ql-constant-classic-bit</td>\n",
       "      <td>ex1_a7614b.py</td>\n",
       "      <td>66</td>\n",
       "      <td>Circuit 'qc' measures qubit '1' but never uses...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ql-constant-classic-bit</td>\n",
       "      <td>measurement_tests_fdc8b4.py</td>\n",
       "      <td>74</td>\n",
       "      <td>Circuit 'qc' measures qubit '0' but never uses...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ql-constant-classic-bit</td>\n",
       "      <td>superpositions_26c0f1.py</td>\n",
       "      <td>12</td>\n",
       "      <td>Circuit 'qc' measures qubit '1' but never uses...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ql-constant-classic-bit</td>\n",
       "      <td>ex1_a7614b.py</td>\n",
       "      <td>93</td>\n",
       "      <td>Circuit 'qc' measures qubit '2' but never uses...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ql-constant-classic-bit</td>\n",
       "      <td>ex1_98892e.py</td>\n",
       "      <td>93</td>\n",
       "      <td>Circuit 'qc' measures qubit '2' but never uses...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>4_qbits_decoherence_9bbc1f.py</td>\n",
       "      <td>397</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>bit_flip_code_f40402.py</td>\n",
       "      <td>48</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>bit_flip_code_f40402.py</td>\n",
       "      <td>47</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>4_qbits_decoherence_9bbc1f.py</td>\n",
       "      <td>394</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>4_qbits_decoherence_9bbc1f.py</td>\n",
       "      <td>268</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>bit_flip_code_f40402.py</td>\n",
       "      <td>49</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>discrete_solver_7f2f57.py</td>\n",
       "      <td>70</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>01_classical_and_quantum_probability_distribut...</td>\n",
       "      <td>192</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>helper_functions_a521e2.py</td>\n",
       "      <td>104</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>energyrelaxation_230ca7.py</td>\n",
       "      <td>29</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>phase_flip_code_4072b2.py</td>\n",
       "      <td>52</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>t1_3fa19f.py</td>\n",
       "      <td>26</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>t2_ramsey_2e0f5a.py</td>\n",
       "      <td>31</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>ql-deprecated-identity</td>\n",
       "      <td>unitary_simulator_25e259.py</td>\n",
       "      <td>42</td>\n",
       "      <td>The deprecated iden() API is called.</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'iden' mem...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>ql-double-measurement</td>\n",
       "      <td>rsa_breaker_4_bit_0f27ff.py</td>\n",
       "      <td>137</td>\n",
       "      <td>Two consecutive measurements on qubit '0' at l...</td>\n",
       "      <td>C0303</td>\n",
       "      <td>Trailing whitespace.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>ql-double-measurement</td>\n",
       "      <td>shorbreaker_5299e4.py</td>\n",
       "      <td>35</td>\n",
       "      <td>Two consecutive measurements on qubit '0' at l...</td>\n",
       "      <td>C0303</td>\n",
       "      <td>Trailing whitespace.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>ql-ghost-composition</td>\n",
       "      <td>transpiled_stabilizer_test_7be7ce.py</td>\n",
       "      <td>413</td>\n",
       "      <td>Ghost composition at location: (413, 1)</td>\n",
       "      <td>E1120</td>\n",
       "      <td>No value for argument 'other' in method call.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>quantumteleportation_2823d6.py</td>\n",
       "      <td>16</td>\n",
       "      <td>Operation 'cz' on qubit 0 after measurement at...</td>\n",
       "      <td>W0311</td>\n",
       "      <td>Bad indentation. Found 1 spaces, expected 4.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>teleportation_a12212.py</td>\n",
       "      <td>41</td>\n",
       "      <td>Operation 'cx' on qubit 1 after measurement at...</td>\n",
       "      <td>W0301</td>\n",
       "      <td>Unnecessary semicolon.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>qubits_d78ad0.py</td>\n",
       "      <td>28</td>\n",
       "      <td>Operation 'cx' on qubit 1 after measurement at...</td>\n",
       "      <td>C0303</td>\n",
       "      <td>Trailing whitespace.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>teleportation_50c827.py</td>\n",
       "      <td>40</td>\n",
       "      <td>Operation 'u1' on qubit 0 after measurement at...</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'u1' membe...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>teleportation_8f1eaf.py</td>\n",
       "      <td>40</td>\n",
       "      <td>Operation 'u1' on qubit 0 after measurement at...</td>\n",
       "      <td>E1101</td>\n",
       "      <td>Instance of 'QuantumCircuit' has no 'u1' membe...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>ql-operation-after-measurement</td>\n",
       "      <td>quantumteleportation_2823d6.py</td>\n",
       "      <td>15</td>\n",
       "      <td>Operation 'cx' on qubit 1 after measurement at...</td>\n",
       "      <td>W0311</td>\n",
       "      <td>Bad indentation. Found 1 spaces, expected 4.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>measurement_tests_fdc8b4.py</td>\n",
       "      <td>224</td>\n",
       "      <td>Circuit 'qc' never manipulates some of its 1qu...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>test_structure_aaba85.py</td>\n",
       "      <td>1084</td>\n",
       "      <td>Circuit 'qc' never manipulates some of its 2qu...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>test_structure_aaba85.py</td>\n",
       "      <td>45</td>\n",
       "      <td>Circuit 'qc' never manipulates some of its 2qu...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>test_structure_aaba85.py</td>\n",
       "      <td>760</td>\n",
       "      <td>Circuit 'qc' never manipulates some of its 2qu...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>circuit_d01243.py</td>\n",
       "      <td>359</td>\n",
       "      <td>Circuit 'tempCircuit' never manipulates some o...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"tempCircuit\" doesn't conform to...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>gateset_4ffe74.py</td>\n",
       "      <td>304</td>\n",
       "      <td>Circuit 'qc' never manipulates some of its 2qu...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>gateset_4ffe74.py</td>\n",
       "      <td>82</td>\n",
       "      <td>Circuit 'qc' never manipulates some of its 1qu...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>ql-oversized-circuit</td>\n",
       "      <td>a03_deutsch_algorithm_solutions_checkpoint_cd1...</td>\n",
       "      <td>129</td>\n",
       "      <td>Circuit 'circuit' never manipulates some of it...</td>\n",
       "      <td>W0621</td>\n",
       "      <td>Redefining name 'circuit' from outer scope (li...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>ql-unmeasurable-qubits</td>\n",
       "      <td>test_structure_aaba85.py</td>\n",
       "      <td>1504</td>\n",
       "      <td>Circuit 'qc' has more qubits (1) than classica...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>ql-unmeasurable-qubits</td>\n",
       "      <td>test_sdg_gate_56b97a.py</td>\n",
       "      <td>30</td>\n",
       "      <td>Circuit 'qc' has more qubits (3) than classica...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>ql-unmeasurable-qubits</td>\n",
       "      <td>test_qiskit_738074.py</td>\n",
       "      <td>29</td>\n",
       "      <td>Circuit 'qc' has more qubits (3) than classica...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>ql-unmeasurable-qubits</td>\n",
       "      <td>gates_20overview_44ffd3.py</td>\n",
       "      <td>193</td>\n",
       "      <td>Circuit 'ccX_circ' has more qubits (3) than cl...</td>\n",
       "      <td>C0303</td>\n",
       "      <td>Trailing whitespace.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>ql-unmeasurable-qubits</td>\n",
       "      <td>gates_20overview_44ffd3.py</td>\n",
       "      <td>183</td>\n",
       "      <td>Circuit 'cRz_circ' has more qubits (2) than cl...</td>\n",
       "      <td>C0303</td>\n",
       "      <td>Trailing whitespace.</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>ql-unmeasurable-qubits</td>\n",
       "      <td>test_u_gate_940648.py</td>\n",
       "      <td>43</td>\n",
       "      <td>Circuit 'qc' has more qubits (3) than classica...</td>\n",
       "      <td>C0103</td>\n",
       "      <td>Variable name \"qc\" doesn't conform to snake_ca...</td>\n",
       "      <td>Pylint</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     rule_id_lintq  \\\n",
       "0          ql-constant-classic-bit   \n",
       "1          ql-constant-classic-bit   \n",
       "2          ql-constant-classic-bit   \n",
       "3          ql-constant-classic-bit   \n",
       "4          ql-constant-classic-bit   \n",
       "5           ql-deprecated-identity   \n",
       "6           ql-deprecated-identity   \n",
       "7           ql-deprecated-identity   \n",
       "8           ql-deprecated-identity   \n",
       "9           ql-deprecated-identity   \n",
       "10          ql-deprecated-identity   \n",
       "11          ql-deprecated-identity   \n",
       "12          ql-deprecated-identity   \n",
       "13          ql-deprecated-identity   \n",
       "14          ql-deprecated-identity   \n",
       "15          ql-deprecated-identity   \n",
       "16          ql-deprecated-identity   \n",
       "17          ql-deprecated-identity   \n",
       "18          ql-deprecated-identity   \n",
       "19           ql-double-measurement   \n",
       "20           ql-double-measurement   \n",
       "21            ql-ghost-composition   \n",
       "22  ql-operation-after-measurement   \n",
       "23  ql-operation-after-measurement   \n",
       "24  ql-operation-after-measurement   \n",
       "25  ql-operation-after-measurement   \n",
       "26  ql-operation-after-measurement   \n",
       "27  ql-operation-after-measurement   \n",
       "28            ql-oversized-circuit   \n",
       "29            ql-oversized-circuit   \n",
       "30            ql-oversized-circuit   \n",
       "31            ql-oversized-circuit   \n",
       "32            ql-oversized-circuit   \n",
       "33            ql-oversized-circuit   \n",
       "34            ql-oversized-circuit   \n",
       "35            ql-oversized-circuit   \n",
       "36          ql-unmeasurable-qubits   \n",
       "37          ql-unmeasurable-qubits   \n",
       "38          ql-unmeasurable-qubits   \n",
       "39          ql-unmeasurable-qubits   \n",
       "40          ql-unmeasurable-qubits   \n",
       "41          ql-unmeasurable-qubits   \n",
       "\n",
       "                                                 file  line  \\\n",
       "0                                       ex1_a7614b.py    66   \n",
       "1                         measurement_tests_fdc8b4.py    74   \n",
       "2                            superpositions_26c0f1.py    12   \n",
       "3                                       ex1_a7614b.py    93   \n",
       "4                                       ex1_98892e.py    93   \n",
       "5                       4_qbits_decoherence_9bbc1f.py   397   \n",
       "6                             bit_flip_code_f40402.py    48   \n",
       "7                             bit_flip_code_f40402.py    47   \n",
       "8                       4_qbits_decoherence_9bbc1f.py   394   \n",
       "9                       4_qbits_decoherence_9bbc1f.py   268   \n",
       "10                            bit_flip_code_f40402.py    49   \n",
       "11                          discrete_solver_7f2f57.py    70   \n",
       "12  01_classical_and_quantum_probability_distribut...   192   \n",
       "13                         helper_functions_a521e2.py   104   \n",
       "14                         energyrelaxation_230ca7.py    29   \n",
       "15                          phase_flip_code_4072b2.py    52   \n",
       "16                                       t1_3fa19f.py    26   \n",
       "17                                t2_ramsey_2e0f5a.py    31   \n",
       "18                        unitary_simulator_25e259.py    42   \n",
       "19                        rsa_breaker_4_bit_0f27ff.py   137   \n",
       "20                              shorbreaker_5299e4.py    35   \n",
       "21               transpiled_stabilizer_test_7be7ce.py   413   \n",
       "22                     quantumteleportation_2823d6.py    16   \n",
       "23                            teleportation_a12212.py    41   \n",
       "24                                   qubits_d78ad0.py    28   \n",
       "25                            teleportation_50c827.py    40   \n",
       "26                            teleportation_8f1eaf.py    40   \n",
       "27                     quantumteleportation_2823d6.py    15   \n",
       "28                        measurement_tests_fdc8b4.py   224   \n",
       "29                           test_structure_aaba85.py  1084   \n",
       "30                           test_structure_aaba85.py    45   \n",
       "31                           test_structure_aaba85.py   760   \n",
       "32                                  circuit_d01243.py   359   \n",
       "33                                  gateset_4ffe74.py   304   \n",
       "34                                  gateset_4ffe74.py    82   \n",
       "35  a03_deutsch_algorithm_solutions_checkpoint_cd1...   129   \n",
       "36                           test_structure_aaba85.py  1504   \n",
       "37                            test_sdg_gate_56b97a.py    30   \n",
       "38                              test_qiskit_738074.py    29   \n",
       "39                         gates_20overview_44ffd3.py   193   \n",
       "40                         gates_20overview_44ffd3.py   183   \n",
       "41                              test_u_gate_940648.py    43   \n",
       "\n",
       "                                        message_lintq rule_id_prior_work  \\\n",
       "0   Circuit 'qc' measures qubit '1' but never uses...              C0103   \n",
       "1   Circuit 'qc' measures qubit '0' but never uses...              C0103   \n",
       "2   Circuit 'qc' measures qubit '1' but never uses...              C0103   \n",
       "3   Circuit 'qc' measures qubit '2' but never uses...              C0103   \n",
       "4   Circuit 'qc' measures qubit '2' but never uses...              C0103   \n",
       "5                The deprecated iden() API is called.              E1101   \n",
       "6                The deprecated iden() API is called.              E1101   \n",
       "7                The deprecated iden() API is called.              E1101   \n",
       "8                The deprecated iden() API is called.              E1101   \n",
       "9                The deprecated iden() API is called.              E1101   \n",
       "10               The deprecated iden() API is called.              E1101   \n",
       "11               The deprecated iden() API is called.              E1101   \n",
       "12               The deprecated iden() API is called.              E1101   \n",
       "13               The deprecated iden() API is called.              E1101   \n",
       "14               The deprecated iden() API is called.              E1101   \n",
       "15               The deprecated iden() API is called.              E1101   \n",
       "16               The deprecated iden() API is called.              E1101   \n",
       "17               The deprecated iden() API is called.              E1101   \n",
       "18               The deprecated iden() API is called.              E1101   \n",
       "19  Two consecutive measurements on qubit '0' at l...              C0303   \n",
       "20  Two consecutive measurements on qubit '0' at l...              C0303   \n",
       "21            Ghost composition at location: (413, 1)              E1120   \n",
       "22  Operation 'cz' on qubit 0 after measurement at...              W0311   \n",
       "23  Operation 'cx' on qubit 1 after measurement at...              W0301   \n",
       "24  Operation 'cx' on qubit 1 after measurement at...              C0303   \n",
       "25  Operation 'u1' on qubit 0 after measurement at...              E1101   \n",
       "26  Operation 'u1' on qubit 0 after measurement at...              E1101   \n",
       "27  Operation 'cx' on qubit 1 after measurement at...              W0311   \n",
       "28  Circuit 'qc' never manipulates some of its 1qu...              C0103   \n",
       "29  Circuit 'qc' never manipulates some of its 2qu...              C0103   \n",
       "30  Circuit 'qc' never manipulates some of its 2qu...              C0103   \n",
       "31  Circuit 'qc' never manipulates some of its 2qu...              C0103   \n",
       "32  Circuit 'tempCircuit' never manipulates some o...              C0103   \n",
       "33  Circuit 'qc' never manipulates some of its 2qu...              C0103   \n",
       "34  Circuit 'qc' never manipulates some of its 1qu...              C0103   \n",
       "35  Circuit 'circuit' never manipulates some of it...              W0621   \n",
       "36  Circuit 'qc' has more qubits (1) than classica...              C0103   \n",
       "37  Circuit 'qc' has more qubits (3) than classica...              C0103   \n",
       "38  Circuit 'qc' has more qubits (3) than classica...              C0103   \n",
       "39  Circuit 'ccX_circ' has more qubits (3) than cl...              C0303   \n",
       "40  Circuit 'cRz_circ' has more qubits (2) than cl...              C0303   \n",
       "41  Circuit 'qc' has more qubits (3) than classica...              C0103   \n",
       "\n",
       "                                   message_prior_work    tool  \n",
       "0   Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "1   Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "2   Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "3   Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "4   Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "5   Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "6   Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "7   Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "8   Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "9   Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "10  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "11  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "12  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "13  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "14  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "15  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "16  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "17  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "18  Instance of 'QuantumCircuit' has no 'iden' mem...  Pylint  \n",
       "19                               Trailing whitespace.  Pylint  \n",
       "20                               Trailing whitespace.  Pylint  \n",
       "21      No value for argument 'other' in method call.  Pylint  \n",
       "22       Bad indentation. Found 1 spaces, expected 4.  Pylint  \n",
       "23                             Unnecessary semicolon.  Pylint  \n",
       "24                               Trailing whitespace.  Pylint  \n",
       "25  Instance of 'QuantumCircuit' has no 'u1' membe...  Pylint  \n",
       "26  Instance of 'QuantumCircuit' has no 'u1' membe...  Pylint  \n",
       "27       Bad indentation. Found 1 spaces, expected 4.  Pylint  \n",
       "28  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "29  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "30  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "31  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "32  Variable name \"tempCircuit\" doesn't conform to...  Pylint  \n",
       "33  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "34  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "35  Redefining name 'circuit' from outer scope (li...  Pylint  \n",
       "36  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "37  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "38  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  \n",
       "39                               Trailing whitespace.  Pylint  \n",
       "40                               Trailing whitespace.  Pylint  \n",
       "41  Variable name \"qc\" doesn't conform to snake_ca...  Pylint  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Latex\n",
      "\\newcommand{\\nWarningsOnLintQTPwithQChecker}{200}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithQCheckerOverlap}{9}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithQCheckerMissed}{207}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithQSmell}{77}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithQSmellOverlap}{0}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithQSmellMissed}{216}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithPylint}{8627}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithPylintOverlap}{42}\n",
      "\\newcommand{\\nWarningsOnLintQTPwithPylintMissed}{174}\n",
      "\\newcommand{\\nTPsMissedByAllCompetitors}{199}\n",
      "\\newcommand{\\percTPsMissedByAllCompetitors}{92.1\\%}\n",
      "\\newcommand{\\nTPsFoundByAtLeastOneCompetitor}{17}\n",
      "\\newcommand{\\percTPsFoundByAtLeastOneCompetitor}{7.9\\%}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_lintq_tp  = df_annotations[df_annotations[COL_AGREED_ANNOTATION] == \"TP\"]\n",
    "\n",
    "# keep only those in the mapping RULE_MAPPING\n",
    "# the value in the column rule_id must belong to the keys of RULE_MAPPING\n",
    "df_lintq_tp = df_lintq_tp[\n",
    "    df_lintq_tp[\"rule_id\"].isin(RULE_NAME_MAPPING.keys())]\n",
    "\n",
    "n_lintq_tps = len(df_lintq_tp)\n",
    "\n",
    "relevant_files_w_tp = df_lintq_tp[\"file\"].unique()\n",
    "n_relevant_files_w_tp = len(relevant_files_w_tp)\n",
    "\n",
    "# check the intersection between these files and lines and the dataset\n",
    "# of qsmell and qchecker\n",
    "df_lintq_tp = df_lintq_tp[[\"rule_id\", \"file\", \"line\", \"message\"]]\n",
    "# convert line to int\n",
    "df_lintq_tp[\"line\"] = df_lintq_tp[\"line\"].astype(int)\n",
    "\n",
    "COMPETITORS = [\n",
    "    {\"name\": \"QChecker\", \"df\": df_results_qchecker},\n",
    "    {\"name\": \"QSmell\", \"df\": df_results_qsmell},\n",
    "    {\"name\": \"Pylint\", \"df\": df_results_pylint}\n",
    "]\n",
    "display(df_lintq_tp.head())\n",
    "\n",
    "dfs_competitors = []\n",
    "\n",
    "latex_commands = \"\"\n",
    "for competitor in COMPETITORS:\n",
    "    name = competitor[\"name\"]\n",
    "    df = competitor[\"df\"]\n",
    "\n",
    "    df_on_relevant_files = df[df[\"file\"].isin(relevant_files_w_tp)]\n",
    "    print(f\"Total {name} warnings: {len(df_on_relevant_files)}\")\n",
    "    latex_commands += \"\\\\newcommand{\\\\nWarningsOnLintQTPwith\" + name + \"}{\" + f\"{len(df_on_relevant_files)}\" + \"}\\n\"\n",
    "    n_files_flagged_by_competitor = len(df_on_relevant_files[\"file\"].unique())\n",
    "    flag_ratio = n_files_flagged_by_competitor / n_relevant_files_w_tp\n",
    "    perc_flag_ratio = flag_ratio * 100\n",
    "    print(f\"Ratio of {name} warnings on relevant files: {flag_ratio}\")\n",
    "    # latex_commands += \"\\\\newcommand{\\\\percRatio\" + name + \"OnTP}{\" + f\"{perc_flag_ratio:.1f}\" + \"\\\\%}\\n\"\n",
    "\n",
    "    print(f\"Checking {name}\")\n",
    "    # convert line to int\n",
    "    df[\"line\"] = df[\"line\"].astype(int)\n",
    "    df = df[[\"rule_id\", \"file\", \"line\", \"message\"]]\n",
    "    # merge\n",
    "    df_competitor_pointing_to_lintq_lines = df_lintq_tp.merge(\n",
    "        df,\n",
    "        how=\"inner\",\n",
    "        on=[\"file\", \"line\"],\n",
    "        suffixes=(\"_lintq\", \"_prior_work\"),\n",
    "    )\n",
    "    df_competitor_pointing_to_lintq_lines[\"tool\"] = name\n",
    "    # drop duplicate lines\n",
    "    df_competitor_pointing_to_lintq_lines = \\\n",
    "        df_competitor_pointing_to_lintq_lines.drop_duplicates()\n",
    "    # count\n",
    "    overlap_size = len(df_competitor_pointing_to_lintq_lines)\n",
    "    print(f\"Overlapping {name}: {overlap_size}\")\n",
    "    latex_commands += \"\\\\newcommand{\\\\nWarningsOnLintQTPwith\" + name + \"Overlap}{\" + f\"{overlap_size}\" + \"}\\n\"\n",
    "    warnings_overlooked = n_lintq_tps - overlap_size\n",
    "    latex_commands += \"\\\\newcommand{\\\\nWarningsOnLintQTPwith\" + name + \"Missed}{\" + f\"{warnings_overlooked}\" + \"}\\n\"\n",
    "    display(df_competitor_pointing_to_lintq_lines)\n",
    "    dfs_competitors.append(df_competitor_pointing_to_lintq_lines)\n",
    "\n",
    "\n",
    "# concatenate the competitors\n",
    "df_competitors = pd.concat(dfs_competitors)\n",
    "# # export as csv\n",
    "# df_competitors.to_csv(\n",
    "#     os.path.join(OUTPUT_FOLDER, \"df_competitors.csv\"), index=False)\n",
    "\n",
    "# read annotated competitors\n",
    "df_annotated_competitors = pd.read_csv(\n",
    "    os.path.join(ANNOTATION_FOLDER, \"Complementarity_prior_work_on_LintQ_TPs.csv\")\n",
    ")\n",
    "\n",
    "# keep those found by any of the tool\n",
    "df_annotated_competitors = df_annotated_competitors[\n",
    "    df_annotated_competitors[\"same_issue\"] == \"yes\"]\n",
    "# deduplicate the rows referring to the same LintQ issue\n",
    "df_annotated_competitors = df_annotated_competitors.drop_duplicates(\n",
    "    subset=[\"file\", \"line\", \"rule_id_lintq\"])\n",
    "n_overlooked_by_all_competitors = n_lintq_tps - len(df_annotated_competitors)\n",
    "latex_commands += \"\\\\newcommand{\\\\nTPsMissedByAllCompetitors}{\" + f\"{n_overlooked_by_all_competitors}\" + \"}\\n\"\n",
    "perc_missed_by_all_competitors = n_overlooked_by_all_competitors / n_lintq_tps * 100\n",
    "latex_commands += \"\\\\newcommand{\\\\percTPsMissedByAllCompetitors}{\" + f\"{perc_missed_by_all_competitors:.1f}\" + \"\\\\%}\\n\"\n",
    "\n",
    "n_found_by_at_least_one_competitor = len(df_annotated_competitors)\n",
    "latex_commands += \"\\\\newcommand{\\\\nTPsFoundByAtLeastOneCompetitor}{\" + f\"{n_found_by_at_least_one_competitor}\" + \"}\\n\"\n",
    "perc_found_by_at_least_one_competitor = n_found_by_at_least_one_competitor / n_lintq_tps * 100\n",
    "latex_commands += \"\\\\newcommand{\\\\percTPsFoundByAtLeastOneCompetitor}{\" + f\"{perc_found_by_at_least_one_competitor:.1f}\" + \"\\\\%}\\n\"\n",
    "\n",
    "print(\"-\" * 80)\n",
    "print(\"Latex\")\n",
    "print(latex_commands)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RQ5: Efficiency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\avgPerDetectorQueryCompilationTimeSec}{9.7}\n",
      "\\newcommand{\\avgPerDetectorEvaluationTimeSec}{972.7}\n",
      "\\newcommand{\\totalDatasetQueryCompilationTimeSec}{97.0}\n",
      "\\newcommand{\\totalDatasetEvaluationTimeSec}{9727.0}\n",
      "\\newcommand{\\totalDatasetEvaluationTimeMin}{162}\n",
      "\\newcommand{\\totalDatasetCreationTimeSec}{4447.5}\n",
      "\\newcommand{\\totalDatasetCreationTimeMin}{74}\n",
      "\\newcommand{\\avgPerProgramEvaluationTimeSec}{1.3}\n"
     ]
    },
    {
     "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>detector_rule</th>\n",
       "      <th>compilation_time</th>\n",
       "      <th>evaluation_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>DoubleMeasurement</td>\n",
       "      <td>16.8</td>\n",
       "      <td>2290.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OpAfterMeasurement</td>\n",
       "      <td>16.0</td>\n",
       "      <td>1761.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>MeasureAll</td>\n",
       "      <td>8.0</td>\n",
       "      <td>385.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>ConstantClassicBit</td>\n",
       "      <td>10.0</td>\n",
       "      <td>1420.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ConditionalGateWithoutMeas</td>\n",
       "      <td>10.7</td>\n",
       "      <td>1130.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>UnmeasurableQubits</td>\n",
       "      <td>6.6</td>\n",
       "      <td>385.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>OversizedCircuit</td>\n",
       "      <td>9.0</td>\n",
       "      <td>1201.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>OpAfterOptimization</td>\n",
       "      <td>8.4</td>\n",
       "      <td>385.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>GhostComposition</td>\n",
       "      <td>6.6</td>\n",
       "      <td>385.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DeprecatedIdentity</td>\n",
       "      <td>4.9</td>\n",
       "      <td>385.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                detector_rule  compilation_time  evaluation_time\n",
       "6           DoubleMeasurement              16.8           2290.0\n",
       "3          OpAfterMeasurement              16.0           1761.0\n",
       "5                  MeasureAll               8.0            385.0\n",
       "7          ConstantClassicBit              10.0           1420.0\n",
       "2  ConditionalGateWithoutMeas              10.7           1130.0\n",
       "9          UnmeasurableQubits               6.6            385.0\n",
       "8            OversizedCircuit               9.0           1201.0\n",
       "4         OpAfterOptimization               8.4            385.0\n",
       "1            GhostComposition               6.6            385.0\n",
       "0          DeprecatedIdentity               4.9            385.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\topThreeDetectorRuleOne}{DoubleMeasurement}\n",
      "\\newcommand{\\topThreeDetectorRuleOneTimeSec}{2,290}\n",
      "\\newcommand{\\topThreeDetectorRuleTwo}{OpAfterMeasurement}\n",
      "\\newcommand{\\topThreeDetectorRuleTwoTimeSec}{1,761}\n",
      "\\newcommand{\\topThreeDetectorRuleThree}{ConstantClassicBit}\n",
      "\\newcommand{\\topThreeDetectorRuleThreeTimeSec}{1,420}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# READ LOG DATA\n",
    "log_content = open(LOG_FILE_QUERIES, 'r').read()\n",
    "log_content_db = open(LOG_FILE_DB_CREATION, 'r').read()\n",
    "\n",
    "# modules in 4447.50s\n",
    "for db_log_line in log_content_db.splitlines():\n",
    "    if \" modules in \" in db_log_line:\n",
    "        #print(db_log_line)\n",
    "        total_time_db = float(re.findall(r'modules in (\\d+\\.?\\d+?)s', db_log_line)[0])\n",
    "\n",
    "\n",
    "# a line looks like this\n",
    "# [1/14 comp 9.1s] Compiled /home/.../codeql/src/Interconnection/GhostComposition.ql.\n",
    "# parse the time and the file name\n",
    "lines = log_content.splitlines()\n",
    "compilation_lines = [l for l in lines if \"Compiled\" in l]\n",
    "compilation_times = {\n",
    "    re.findall(r'([a-zA-Z]+)\\.ql\\.$', l)[0] : float(re.findall(r'(\\d+\\.?\\d?)s', l)[0])\n",
    "    for l in compilation_lines\n",
    "}\n",
    "evaluation_lines = [l for l in lines if \"Evaluation done\" in l]\n",
    "evaluation_times = {}\n",
    "for l in evaluation_lines:\n",
    "    key =  re.findall(r'([a-zA-Z]+)\\.bqrs\\.$', l)[0]\n",
    "    seconds = float(re.findall(r'(\\d+\\.?\\d?)s', l)[0])\n",
    "    if minutes_regex := re.findall(r'(\\d+\\.?\\d?)m', l):\n",
    "        seconds += float(minutes_regex[0]) * 60\n",
    "    evaluation_times[key] = seconds\n",
    "evaluation_times\n",
    "\n",
    "# create a dataframe with the compilation and evaluation times\n",
    "df_times = pd.DataFrame.from_dict(\n",
    "    {\n",
    "        'compilation_time': compilation_times,\n",
    "        'evaluation_time': evaluation_times\n",
    "    }\n",
    ")\n",
    "df_times.reset_index(inplace=True)\n",
    "df_times.rename(columns={'index': 'detector_rule'}, inplace=True)\n",
    "\n",
    "# remove blacklisted detectors\n",
    "RELEVANT_QUERY = [name.replace(\".ql\", \"\") for name in FILE_NAME_RULE_MAPPING.keys()]\n",
    "df_times = df_times[\n",
    "    df_times['detector_rule'].isin(RELEVANT_QUERY)]\n",
    "df_times.reset_index(drop=True, inplace=True)\n",
    "# sort by canonical order\n",
    "df_times['detector_rule'] = pd.Categorical(\n",
    "    df_times['detector_rule'], categories=RELEVANT_QUERY)\n",
    "df_times = df_times.sort_values('detector_rule')\n",
    "\n",
    "avg_comp_time = df_times['compilation_time'].mean()\n",
    "avg_exec_time = df_times['evaluation_time'].mean()\n",
    "print(\"\\\\newcommand{\\\\avgPerDetectorQueryCompilationTimeSec}{\" + f\"{avg_comp_time:.1f}\" + \"}\")\n",
    "print(\"\\\\newcommand{\\\\avgPerDetectorEvaluationTimeSec}{\" + f\"{avg_exec_time:.1f}\" + \"}\")\n",
    "\n",
    "total_comp_time = df_times['compilation_time'].sum()\n",
    "total_exec_time = df_times['evaluation_time'].sum()\n",
    "total_exec_time_min = total_exec_time / 60\n",
    "print(\"\\\\newcommand{\\\\totalDatasetQueryCompilationTimeSec}{\" + f\"{total_comp_time:.1f}\" + \"}\")\n",
    "print(\"\\\\newcommand{\\\\totalDatasetEvaluationTimeSec}{\" + f\"{total_exec_time:.1f}\" + \"}\")\n",
    "print(\"\\\\newcommand{\\\\totalDatasetEvaluationTimeMin}{\" + f\"{total_exec_time_min:.0f}\" + \"}\")\n",
    "\n",
    "\n",
    "total_time_db_min = total_time_db / 60\n",
    "print(\"\\\\newcommand{\\\\totalDatasetCreationTimeSec}{\" + f\"{total_time_db:.1f}\" + \"}\")\n",
    "print(\"\\\\newcommand{\\\\totalDatasetCreationTimeMin}{\" + f\"{total_time_db_min:.0f}\" + \"}\")\n",
    "\n",
    "normalized_time_per_query = total_exec_time / TOTAL_FILES_IN_DATASET\n",
    "print(\"\\\\newcommand{\\\\avgPerProgramEvaluationTimeSec}{\" + f\"{normalized_time_per_query:.1f}\" + \"}\")\n",
    "\n",
    "display(df_times)\n",
    "\n",
    "# get the top three detector rules per evaluation time\n",
    "df = df_times.copy()\n",
    "df.sort_values(by='evaluation_time', ascending=False, inplace=True)\n",
    "df = df.head(3)\n",
    "number_prefixes = ['One', 'Two', 'Three']\n",
    "i = 0\n",
    "for _, row in df.iterrows():\n",
    "    name = row['detector_rule']\n",
    "    time = row['evaluation_time']\n",
    "    print(\"\\\\newcommand{\\\\topThreeDetectorRule\" + str(number_prefixes[i]) + \"}{\" + name + \"}\")\n",
    "    print(\"\\\\newcommand{\\\\topThreeDetectorRule\" + str(number_prefixes[i]) + \"TimeSec}{\" + f\"{time:,.0f}\" + \"}\")\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DoubleMeasurement',\n",
       " 'OpAfterMeasurement',\n",
       " 'MeasureAll',\n",
       " 'ConstantClassicBit',\n",
       " 'ConditionalGateWithoutMeas',\n",
       " 'UnmeasurableQubits',\n",
       " 'OversizedCircuit',\n",
       " 'OpAfterOptimization',\n",
       " 'GhostComposition',\n",
       " 'DeprecatedIdentity']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[name.replace(\".ql\", \"\") for name in FILE_NAME_RULE_MAPPING.keys()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reasons for Not Reporting Warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_annotations = pd.read_csv(PATH_LINTQ_ANNOTATION, header=1)\n",
    "\n",
    "mapping_reported_as = {\n",
    "    \"no_inactive\": \"Unreported Because Unmantained\",\n",
    "    \"no_single_file_repo\": \"Unreported Because Incomplete Personal Program Sketches\",\n",
    "    \"no_because_test\": \"Unreported Because Testing Other Features\",\n",
    "    \"no_teaching_code\": \"Unreported Because Teaching Code\",\n",
    "    \"comment_in_related_report\": \"Reported\",\n",
    "    \"new_report\": \"Reported\",\n",
    "    \"no_sketch_code\": \"Unreported Because Incomplete Personal Program Sketches\",\n",
    "    \"TO_REPORT\": \"new detector To Report\",\n",
    "    \"no_repo_archived\": \"Unreported Because Archived\",\n",
    "    \"no_interactive_use\": \"Unreported Because Intermediate Visualization\",\n",
    "}\n",
    "# map reported_as column to a more readable format\n",
    "# use the map function\n",
    "df_annotations[\"reported_as\"] = \\\n",
    "    df_annotations[\"reported_as\"].map(\n",
    "        mapping_reported_as)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\newcommand{\\TPReported}{70}\n",
      "\\newcommand{\\TPUnreportedBecauseTeachingCode}{47}\n",
      "\\newcommand{\\TPUnreportedBecauseUnmantained}{31}\n",
      "\\newcommand{\\TPUnreportedBecauseTestingOtherFeatures}{27}\n",
      "\\newcommand{\\TPUnreportedBecauseIncompletePersonalProgramSketches}{16}\n",
      "\\newcommand{\\TPUnreportedBecauseIntermediateVisualization}{16}\n",
      "\\newcommand{\\TPUnreportedBecauseArchived}{9}\n"
     ]
    }
   ],
   "source": [
    "# keep only the true positives\n",
    "df_TP = df_annotations[df_annotations[\"label_resolution\"] == \"TP\"]\n",
    "value_counts = df_TP['reported_as'].value_counts()\n",
    "for reason, number_of_issues in value_counts.items():\n",
    "    # capitalize each word of the reasons and remove spaces, then join\n",
    "    reason = \"\".join([x.capitalize() for x in reason.split(\" \")])\n",
    "    # print newcommand in latex\n",
    "    print(f\"\\\\newcommand{{\\\\TP{reason}}}{{{number_of_issues}}}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done. Analysis successfully completed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Done. Analysis successfully completed!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "fuzz-everything",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}