diff --git "a/Dataset_Exploration__Used_DataSet_Nizamani.ipynb" "b/Dataset_Exploration__Used_DataSet_Nizamani.ipynb"
new file mode 100644--- /dev/null
+++ "b/Dataset_Exploration__Used_DataSet_Nizamani.ipynb"
@@ -0,0 +1,3342 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def get_latest_update(report):\n",
+        "    \"\"\"Get the latest non-empty update value from a report\"\"\"\n",
+        "    updates = report.findall('.//update')\n",
+        "    latest_value = None\n",
+        "    latest_time = -1\n",
+        "\n",
+        "    for update in updates:\n",
+        "        when = int(update.find('when').text)\n",
+        "        what = update.find('what').text\n",
+        "\n",
+        "        if when > latest_time and what is not None and what.strip():\n",
+        "            latest_time = when\n",
+        "            latest_value = what.strip()\n",
+        "\n",
+        "    return latest_value\n",
+        "\n",
+        "def process_project(project):\n",
+        "    print(f\"\\nProcessing project: {project}\")\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "    severity_file = os.path.join(project_folder, 'severity.xml')\n",
+        "\n",
+        "    if not os.path.exists(severity_file):\n",
+        "        print(f\"Severity file not found for {project}\")\n",
+        "        return pd.DataFrame()\n",
+        "\n",
+        "    try:\n",
+        "        tree = ET.parse(severity_file)\n",
+        "        root = tree.getroot()\n",
+        "\n",
+        "        # Print raw severity values for debugging\n",
+        "        print(f\"\\nRaw severity values found in {project}:\")\n",
+        "        severity_values = set()\n",
+        "        for report in root.findall('.//report'):\n",
+        "            for update in report.findall('.//update'):\n",
+        "                what = update.find('what')\n",
+        "                if what is not None and what.text:\n",
+        "                    severity_values.add(what.text.lower())\n",
+        "        print(severity_values)\n",
+        "\n",
+        "        # Check specifically for enhancement\n",
+        "        enhancement_count = 0\n",
+        "        total_reports = 0\n",
+        "        latest_severities = {}\n",
+        "\n",
+        "        for report in root.findall('.//report'):\n",
+        "            bug_id = report.get('id')\n",
+        "            latest_value = get_latest_update(report)\n",
+        "\n",
+        "            if latest_value:\n",
+        "                total_reports += 1\n",
+        "                latest_value = latest_value.lower()\n",
+        "                latest_severities[bug_id] = latest_value\n",
+        "                if latest_value == 'enhancement':\n",
+        "                    enhancement_count += 1\n",
+        "\n",
+        "        print(f\"\\nProject: {project}\")\n",
+        "        print(f\"Total bug reports: {total_reports}\")\n",
+        "        print(f\"Enhancement reports: {enhancement_count}\")\n",
+        "\n",
+        "        # Create DataFrame\n",
+        "        records = [\n",
+        "            {'project': project, 'bug_id': bug_id, 'severity': severity}\n",
+        "            for bug_id, severity in latest_severities.items()\n",
+        "        ]\n",
+        "\n",
+        "        return pd.DataFrame(records)\n",
+        "\n",
+        "    except ET.ParseError as e:\n",
+        "        print(f\"Error parsing severity file for {project}: {e}\")\n",
+        "        return pd.DataFrame()\n",
+        "\n",
+        "# Process all projects and combine data\n",
+        "dfs = []\n",
+        "enhancement_stats = []\n",
+        "\n",
+        "for project in projects:\n",
+        "    df = process_project(project)\n",
+        "    if not df.empty:\n",
+        "        dfs.append(df)\n",
+        "\n",
+        "        # Collect enhancement statistics\n",
+        "        project_enhancements = df[df['severity'] == 'enhancement'].shape[0]\n",
+        "        project_total = df.shape[0]\n",
+        "        enhancement_stats.append({\n",
+        "            'project': project,\n",
+        "            'total_bugs': project_total,\n",
+        "            'enhancements': project_enhancements,\n",
+        "            'enhancement_percentage': (project_enhancements/project_total*100) if project_total > 0 else 0\n",
+        "        })\n",
+        "\n",
+        "if dfs:\n",
+        "    all_data = pd.concat(dfs, ignore_index=True)\n",
+        "\n",
+        "    # Overall statistics\n",
+        "    print(\"\\n=== Overall Statistics ===\")\n",
+        "    print(\"\\nTotal bug reports by severity:\")\n",
+        "    severity_counts = all_data['severity'].value_counts()\n",
+        "    print(severity_counts)\n",
+        "\n",
+        "    # Enhancement specific statistics\n",
+        "    print(\"\\n=== Enhancement Statistics ===\")\n",
+        "    enhancement_df = pd.DataFrame(enhancement_stats)\n",
+        "    print(\"\\nEnhancement counts by project:\")\n",
+        "    print(enhancement_df.to_string(index=False))\n",
+        "\n",
+        "    # Visualization of severity distribution\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    severity_by_project = pd.crosstab(all_data['project'], all_data['severity'])\n",
+        "\n",
+        "    # Print raw data for verification\n",
+        "    print(\"\\n=== Raw Data Verification ===\")\n",
+        "    print(\"\\nUnique severity values found:\", sorted(all_data['severity'].unique()))\n",
+        "    print(\"\\nCross-tabulation of severity by project:\")\n",
+        "    print(severity_by_project)\n",
+        "\n",
+        "    # Create stacked bar chart\n",
+        "    severity_by_project.plot(kind='bar', stacked=True)\n",
+        "    plt.title('Distribution of Severity Labels by Project')\n",
+        "    plt.xlabel('Project')\n",
+        "    plt.ylabel('Number of Bug Reports')\n",
+        "    plt.legend(title='Severity', bbox_to_anchor=(1.05, 1))\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "else:\n",
+        "    print(\"\\nNo data found to visualize\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "sjFTDaV_wkpp",
+        "outputId": "41db39a2-b74f-4716-d832-0c15a036b6c9"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n",
+            "\n",
+            "Processing project: Bugzilla\n",
+            "\n",
+            "Raw severity values found in Bugzilla:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: Bugzilla\n",
+            "Total bug reports: 4616\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: CDT\n",
+            "\n",
+            "Raw severity values found in CDT:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: CDT\n",
+            "Total bug reports: 5640\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: Core\n",
+            "\n",
+            "Raw severity values found in Core:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: Core\n",
+            "Total bug reports: 74292\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: Firefox\n",
+            "\n",
+            "Raw severity values found in Firefox:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: Firefox\n",
+            "Total bug reports: 69879\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: JDT\n",
+            "\n",
+            "Raw severity values found in JDT:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: JDT\n",
+            "Total bug reports: 10814\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: PDE\n",
+            "\n",
+            "Raw severity values found in PDE:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: PDE\n",
+            "Total bug reports: 5655\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: Platform\n",
+            "\n",
+            "Raw severity values found in Platform:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: Platform\n",
+            "Total bug reports: 24775\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "Processing project: Thunderbird\n",
+            "\n",
+            "Raw severity values found in Thunderbird:\n",
+            "{'critical', 'minor', 'normal', 'blocker', 'trivial', 'major', 'enhancement'}\n",
+            "\n",
+            "Project: Thunderbird\n",
+            "Total bug reports: 19237\n",
+            "Enhancement reports: 0\n",
+            "\n",
+            "=== Overall Statistics ===\n",
+            "\n",
+            "Total bug reports by severity:\n",
+            "severity\n",
+            "normal      155104\n",
+            "major        21901\n",
+            "critical     20761\n",
+            "minor        10750\n",
+            "trivial       4734\n",
+            "blocker       1658\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "=== Enhancement Statistics ===\n",
+            "\n",
+            "Enhancement counts by project:\n",
+            "    project  total_bugs  enhancements  enhancement_percentage\n",
+            "   Bugzilla        4616             0                     0.0\n",
+            "        CDT        5640             0                     0.0\n",
+            "       Core       74292             0                     0.0\n",
+            "    Firefox       69879             0                     0.0\n",
+            "        JDT       10814             0                     0.0\n",
+            "        PDE        5655             0                     0.0\n",
+            "   Platform       24775             0                     0.0\n",
+            "Thunderbird       19237             0                     0.0\n",
+            "\n",
+            "=== Raw Data Verification ===\n",
+            "\n",
+            "Unique severity values found: ['blocker', 'critical', 'major', 'minor', 'normal', 'trivial']\n",
+            "\n",
+            "Cross-tabulation of severity by project:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla         275       176    506    766    2478      415\n",
+            "CDT               78       166    490    275    4547       84\n",
+            "Core             451     10542   4243   2072   56125      859\n",
+            "Firefox          233      6603   9486   4145   47635     1777\n",
+            "JDT               94       274   1000    781    8306      359\n",
+            "PDE               47       117    476    208    4693      114\n",
+            "Platform         415       989   2718   1088   18891      674\n",
+            "Thunderbird       65      1894   2982   1415   12429      452\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def get_latest_update(report):\n",
+        "    \"\"\"Get the latest non-empty update value from a report\"\"\"\n",
+        "    updates = report.findall('.//update')\n",
+        "    latest_value = None\n",
+        "    latest_time = -1\n",
+        "\n",
+        "    for update in updates:\n",
+        "        when = int(update.find('when').text)\n",
+        "        what = update.find('what').text\n",
+        "\n",
+        "        if when > latest_time and what is not None and what.strip():\n",
+        "            latest_time = when\n",
+        "            latest_value = what.strip()\n",
+        "\n",
+        "    return latest_value\n",
+        "\n",
+        "def parse_severity_file(file_path):\n",
+        "    \"\"\"Parse severity XML file and return a dictionary of id: severity\"\"\"\n",
+        "    if not os.path.exists(file_path):\n",
+        "        print(f\"File not found: {file_path}\")\n",
+        "        return {}\n",
+        "\n",
+        "    try:\n",
+        "        tree = ET.parse(file_path)\n",
+        "        root = tree.getroot()\n",
+        "        severity_dict = {}\n",
+        "\n",
+        "        for report in root.findall('.//report'):\n",
+        "            bug_id = report.get('id')\n",
+        "            latest_value = get_latest_update(report)\n",
+        "\n",
+        "            if bug_id and latest_value:\n",
+        "                severity_dict[bug_id] = latest_value.lower()\n",
+        "\n",
+        "        return severity_dict\n",
+        "    except ET.ParseError as e:\n",
+        "        print(f\"Error parsing {file_path}: {e}\")\n",
+        "        return {}\n",
+        "\n",
+        "def process_project(project):\n",
+        "    print(f\"\\nProcessing project: {project}\")\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Parse severity file\n",
+        "    severity_dict = parse_severity_file(os.path.join(project_folder, 'severity.xml'))\n",
+        "\n",
+        "    # Create records for all bugs with severity information\n",
+        "    records = []\n",
+        "    for bug_id, severity in severity_dict.items():\n",
+        "        records.append({\n",
+        "            'project': project,\n",
+        "            'bug_id': bug_id,\n",
+        "            'severity': severity\n",
+        "        })\n",
+        "\n",
+        "    df = pd.DataFrame(records)\n",
+        "    print(f\"\\nFound {len(df)} bugs with severity information for {project}\")\n",
+        "    if not df.empty:\n",
+        "        print(\"\\nSeverity distribution:\")\n",
+        "        print(df['severity'].value_counts())\n",
+        "\n",
+        "    return df\n",
+        "\n",
+        "# Process all projects and combine data\n",
+        "dfs = []\n",
+        "for project in projects:\n",
+        "    df = process_project(project)\n",
+        "    if not df.empty:\n",
+        "        dfs.append(df)\n",
+        "\n",
+        "if dfs:\n",
+        "    all_data = pd.concat(dfs, ignore_index=True)\n",
+        "\n",
+        "    # Print overall severity distribution\n",
+        "    print(\"\\nOverall Severity Distribution:\")\n",
+        "    severity_counts = all_data['severity'].value_counts()\n",
+        "    print(severity_counts)\n",
+        "\n",
+        "    # Create a bar plot for overall severity distribution\n",
+        "    plt.figure(figsize=(12, 6))\n",
+        "    severity_counts.plot(kind='bar')\n",
+        "    plt.title('Overall Distribution of Severity Labels')\n",
+        "    plt.xlabel('Severity')\n",
+        "    plt.ylabel('Number of Bug Reports')\n",
+        "    plt.xticks(rotation=45)\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Create heatmap of severity distribution by project\n",
+        "    severity_by_project = pd.crosstab(all_data['project'], all_data['severity'])\n",
+        "\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    sns.heatmap(severity_by_project, annot=True, fmt='d', cmap='YlOrRd')\n",
+        "    plt.title('Distribution of Severity Labels by Project')\n",
+        "    plt.ylabel('Project')\n",
+        "    plt.xlabel('Severity')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Create stacked bar chart of severity distribution by project\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    severity_by_project.plot(kind='bar', stacked=True)\n",
+        "    plt.title('Distribution of Severity Labels by Project')\n",
+        "    plt.xlabel('Project')\n",
+        "    plt.ylabel('Number of Bug Reports')\n",
+        "    plt.legend(title='Severity', bbox_to_anchor=(1.05, 1))\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Print detailed statistics\n",
+        "    print(\"\\nDetailed Statistics:\")\n",
+        "    print(\"\\n1. Total bug reports by severity:\")\n",
+        "    print(severity_counts)\n",
+        "\n",
+        "    print(\"\\n2. Severity distribution by project:\")\n",
+        "    print(severity_by_project)\n",
+        "\n",
+        "    print(\"\\n3. Percentage distribution of severities within each project:\")\n",
+        "    percentage_by_project = severity_by_project.div(severity_by_project.sum(axis=1), axis=0) * 100\n",
+        "    print(percentage_by_project.round(2))\n",
+        "\n",
+        "    print(\"\\n4. Summary statistics:\")\n",
+        "    print(f\"Total number of bug reports: {len(all_data)}\")\n",
+        "    print(\"\\nBug reports per project:\")\n",
+        "    print(all_data['project'].value_counts())\n",
+        "\n",
+        "else:\n",
+        "    print(\"\\nNo data found to visualize\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "4qdfRH8IJIG0",
+        "outputId": "71f69442-d357-476f-a79a-a4ad2e44863e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Processing project: Bugzilla\n",
+            "\n",
+            "Found 4616 bugs with severity information for Bugzilla\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2478\n",
+            "minor        766\n",
+            "major        506\n",
+            "trivial      415\n",
+            "blocker      275\n",
+            "critical     176\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: CDT\n",
+            "\n",
+            "Found 5640 bugs with severity information for CDT\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      4547\n",
+            "major        490\n",
+            "minor        275\n",
+            "critical     166\n",
+            "trivial       84\n",
+            "blocker       78\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Core\n",
+            "\n",
+            "Found 74292 bugs with severity information for Core\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      56125\n",
+            "critical    10542\n",
+            "major        4243\n",
+            "minor        2072\n",
+            "trivial       859\n",
+            "blocker       451\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Firefox\n",
+            "\n",
+            "Found 69879 bugs with severity information for Firefox\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      47635\n",
+            "major        9486\n",
+            "critical     6603\n",
+            "minor        4145\n",
+            "trivial      1777\n",
+            "blocker       233\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: JDT\n",
+            "\n",
+            "Found 10814 bugs with severity information for JDT\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      8306\n",
+            "major       1000\n",
+            "minor        781\n",
+            "trivial      359\n",
+            "critical     274\n",
+            "blocker       94\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: PDE\n",
+            "\n",
+            "Found 5655 bugs with severity information for PDE\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      4693\n",
+            "major        476\n",
+            "minor        208\n",
+            "critical     117\n",
+            "trivial      114\n",
+            "blocker       47\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Platform\n",
+            "\n",
+            "Found 24775 bugs with severity information for Platform\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      18891\n",
+            "major        2718\n",
+            "minor        1088\n",
+            "critical      989\n",
+            "trivial       674\n",
+            "blocker       415\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Thunderbird\n",
+            "\n",
+            "Found 19237 bugs with severity information for Thunderbird\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      12429\n",
+            "major        2982\n",
+            "critical     1894\n",
+            "minor        1415\n",
+            "trivial       452\n",
+            "blocker        65\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Overall Severity Distribution:\n",
+            "severity\n",
+            "normal      155104\n",
+            "major        21901\n",
+            "critical     20761\n",
+            "minor        10750\n",
+            "trivial       4734\n",
+            "blocker       1658\n",
+            "Name: count, dtype: int64\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Detailed Statistics:\n",
+            "\n",
+            "1. Total bug reports by severity:\n",
+            "severity\n",
+            "normal      155104\n",
+            "major        21901\n",
+            "critical     20761\n",
+            "minor        10750\n",
+            "trivial       4734\n",
+            "blocker       1658\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "2. Severity distribution by project:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla         275       176    506    766    2478      415\n",
+            "CDT               78       166    490    275    4547       84\n",
+            "Core             451     10542   4243   2072   56125      859\n",
+            "Firefox          233      6603   9486   4145   47635     1777\n",
+            "JDT               94       274   1000    781    8306      359\n",
+            "PDE               47       117    476    208    4693      114\n",
+            "Platform         415       989   2718   1088   18891      674\n",
+            "Thunderbird       65      1894   2982   1415   12429      452\n",
+            "\n",
+            "3. Percentage distribution of severities within each project:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla        5.96      3.81  10.96  16.59   53.68     8.99\n",
+            "CDT             1.38      2.94   8.69   4.88   80.62     1.49\n",
+            "Core            0.61     14.19   5.71   2.79   75.55     1.16\n",
+            "Firefox         0.33      9.45  13.57   5.93   68.17     2.54\n",
+            "JDT             0.87      2.53   9.25   7.22   76.81     3.32\n",
+            "PDE             0.83      2.07   8.42   3.68   82.99     2.02\n",
+            "Platform        1.68      3.99  10.97   4.39   76.25     2.72\n",
+            "Thunderbird     0.34      9.85  15.50   7.36   64.61     2.35\n",
+            "\n",
+            "4. Summary statistics:\n",
+            "Total number of bug reports: 214908\n",
+            "\n",
+            "Bug reports per project:\n",
+            "project\n",
+            "Core           74292\n",
+            "Firefox        69879\n",
+            "Platform       24775\n",
+            "Thunderbird    19237\n",
+            "JDT            10814\n",
+            "PDE             5655\n",
+            "CDT             5640\n",
+            "Bugzilla        4616\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "# Define all known severity labels\n",
+        "SEVERITY_LABELS = {\n",
+        "    'blocker',\n",
+        "    'critical',\n",
+        "    'major',\n",
+        "    'normal',\n",
+        "    'minor',\n",
+        "    'trivial',\n",
+        "    'enhancement'\n",
+        "}\n",
+        "\n",
+        "def get_latest_update(report):\n",
+        "    \"\"\"Get the latest non-empty update value from a report\"\"\"\n",
+        "    updates = report.findall('.//update')\n",
+        "    latest_value = None\n",
+        "    latest_time = -1\n",
+        "\n",
+        "    for update in updates:\n",
+        "        when = int(update.find('when').text)\n",
+        "        what = update.find('what').text\n",
+        "\n",
+        "        if when > latest_time and what is not None and what.strip():\n",
+        "            latest_time = when\n",
+        "            latest_value = what.strip()\n",
+        "\n",
+        "    return latest_value\n",
+        "\n",
+        "def parse_xml_file(file_path):\n",
+        "    \"\"\"Parse XML file and return a dictionary of id: latest_value\"\"\"\n",
+        "    if not os.path.exists(file_path):\n",
+        "        print(f\"File not found: {file_path}\")\n",
+        "        return {}\n",
+        "\n",
+        "    try:\n",
+        "        tree = ET.parse(file_path)\n",
+        "        root = tree.getroot()\n",
+        "        bug_dict = {}\n",
+        "        all_values = set()  # Track all unique values\n",
+        "\n",
+        "        for report in root.findall('.//report'):\n",
+        "            bug_id = report.get('id')\n",
+        "            latest_value = get_latest_update(report)\n",
+        "\n",
+        "            if bug_id and latest_value:\n",
+        "                latest_value = latest_value.lower()  # Normalize to lowercase\n",
+        "                bug_dict[bug_id] = latest_value\n",
+        "                all_values.add(latest_value)\n",
+        "\n",
+        "        return bug_dict, all_values\n",
+        "    except ET.ParseError as e:\n",
+        "        print(f\"Error parsing {file_path}: {e}\")\n",
+        "        return {}, set()\n",
+        "\n",
+        "def process_project(project):\n",
+        "    print(f\"\\nProcessing project: {project}\")\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Parse all relevant files\n",
+        "    status_dict, status_values = parse_xml_file(os.path.join(project_folder, 'bug_status.xml'))\n",
+        "    resolution_dict, resolution_values = parse_xml_file(os.path.join(project_folder, 'resolution.xml'))\n",
+        "    severity_dict, severity_values = parse_xml_file(os.path.join(project_folder, 'severity.xml'))\n",
+        "\n",
+        "    # Print debug information\n",
+        "    print(f\"Total bugs with status: {len(status_dict)}\")\n",
+        "    print(f\"Status values found: {status_values}\")\n",
+        "    print(f\"Total bugs with resolution: {len(resolution_dict)}\")\n",
+        "    print(f\"Resolution values found: {resolution_values}\")\n",
+        "    print(f\"Total bugs with severity: {len(severity_dict)}\")\n",
+        "    print(f\"Severity values found: {severity_values}\")\n",
+        "\n",
+        "    # Create records for bugs that meet all conditions\n",
+        "    records = []\n",
+        "    for bug_id in status_dict:\n",
+        "        if (bug_id in resolution_dict and\n",
+        "            bug_id in severity_dict and\n",
+        "            status_dict[bug_id].upper() == 'RESOLVED' and\n",
+        "            resolution_dict[bug_id].upper() == 'FIXED'):\n",
+        "\n",
+        "            severity = severity_dict[bug_id].lower()\n",
+        "            if severity in SEVERITY_LABELS:  # Only include known severity labels\n",
+        "                records.append({\n",
+        "                    'project': project,\n",
+        "                    'bug_id': bug_id,\n",
+        "                    'severity': severity,\n",
+        "                    'status': status_dict[bug_id],\n",
+        "                    'resolution': resolution_dict[bug_id]\n",
+        "                })\n",
+        "\n",
+        "    df = pd.DataFrame(records)\n",
+        "    print(f\"\\nFound {len(df)} bugs with status='RESOLVED', resolution='FIXED' and severity for {project}\")\n",
+        "    if not df.empty:\n",
+        "        print(\"\\nSeverity distribution:\")\n",
+        "        print(df['severity'].value_counts())\n",
+        "\n",
+        "    return df\n",
+        "\n",
+        "# Process all projects and combine data\n",
+        "dfs = []\n",
+        "for project in projects:\n",
+        "    df = process_project(project)\n",
+        "    if not df.empty:\n",
+        "        dfs.append(df)\n",
+        "\n",
+        "if dfs:\n",
+        "    all_data = pd.concat(dfs, ignore_index=True)\n",
+        "\n",
+        "    # Print data summary\n",
+        "    print(\"\\nOverall Data Summary:\")\n",
+        "    print(f\"Total number of bugs: {len(all_data)}\")\n",
+        "    print(\"\\nBugs per project:\")\n",
+        "    print(all_data['project'].value_counts())\n",
+        "    print(\"\\nSeverity levels found:\")\n",
+        "    print(all_data['severity'].value_counts())\n",
+        "    print(\"\\nAll possible severity levels:\", sorted(SEVERITY_LABELS))\n",
+        "    print(\"Severity levels found in data:\", sorted(all_data['severity'].unique()))\n",
+        "\n",
+        "    # Create visualization with consistent colors for severity levels\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "\n",
+        "    # Create a color palette for all severity levels\n",
+        "    colors = sns.color_palette(\"husl\", n_colors=len(SEVERITY_LABELS))\n",
+        "    severity_colors = dict(zip(sorted(SEVERITY_LABELS), colors))\n",
+        "\n",
+        "    # Create the plot\n",
+        "    sns.countplot(data=all_data, x='project', hue='severity',\n",
+        "                 hue_order=sorted(SEVERITY_LABELS & set(all_data['severity'].unique())),\n",
+        "                 palette=[severity_colors[s] for s in sorted(SEVERITY_LABELS & set(all_data['severity'].unique()))])\n",
+        "\n",
+        "    plt.title('Distribution of Severity Labels for Resolved & Fixed Bugs by Project')\n",
+        "    plt.xlabel('Project')\n",
+        "    plt.ylabel('Number of Bugs')\n",
+        "    plt.xticks(rotation=45)\n",
+        "    plt.legend(title='Severity', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Print summary statistics\n",
+        "    print(\"\\nSummary Statistics:\")\n",
+        "    summary = all_data.groupby(['project', 'severity']).size().unstack(fill_value=0)\n",
+        "    print(summary)\n",
+        "\n",
+        "    # Calculate percentages\n",
+        "    percentages = summary.div(summary.sum(axis=1), axis=0) * 100\n",
+        "    print(\"\\nPercentage Distribution:\")\n",
+        "    print(percentages.round(2))\n",
+        "else:\n",
+        "    print(\"\\nNo data found to visualize\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "8wuc4OXnHyMg",
+        "outputId": "ccbcfe4a-395b-4dd1-8928-494dcd93dabb"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Processing project: Bugzilla\n",
+            "Total bugs with status: 4616\n",
+            "Status values found: {'verified', 'resolved', 'closed'}\n",
+            "Total bugs with resolution: 4616\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'incomplete', 'duplicate', 'invalid', 'fixed'}\n",
+            "Total bugs with severity: 4616\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 2375 bugs with status='RESOLVED', resolution='FIXED' and severity for Bugzilla\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      996\n",
+            "minor       483\n",
+            "trivial     285\n",
+            "blocker     262\n",
+            "major       251\n",
+            "critical     98\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: CDT\n",
+            "Total bugs with status: 5640\n",
+            "Status values found: {'verified', 'resolved', 'closed'}\n",
+            "Total bugs with resolution: 5640\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'duplicate', 'invalid', 'not_eclipse', 'fixed'}\n",
+            "Total bugs with severity: 5640\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 3982 bugs with status='RESOLVED', resolution='FIXED' and severity for CDT\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      3368\n",
+            "major        261\n",
+            "minor        177\n",
+            "critical      79\n",
+            "trivial       63\n",
+            "blocker       34\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Core\n",
+            "Total bugs with status: 74292\n",
+            "Status values found: {'verified', 'resolved'}\n",
+            "Total bugs with resolution: 74292\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'incomplete', 'duplicate', 'invalid', 'fixed'}\n",
+            "Total bugs with severity: 74292\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 41299 bugs with status='RESOLVED', resolution='FIXED' and severity for Core\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      33990\n",
+            "critical     3956\n",
+            "major        1532\n",
+            "minor        1000\n",
+            "trivial       578\n",
+            "blocker       243\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Firefox\n",
+            "Total bugs with status: 69879\n",
+            "Status values found: {'verified', 'resolved'}\n",
+            "Total bugs with resolution: 69879\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'incomplete', 'duplicate', 'invalid', 'fixed'}\n",
+            "Total bugs with severity: 69879\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 8474 bugs with status='RESOLVED', resolution='FIXED' and severity for Firefox\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      7143\n",
+            "major        414\n",
+            "minor        342\n",
+            "trivial      316\n",
+            "critical     178\n",
+            "blocker       81\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: JDT\n",
+            "Total bugs with status: 10814\n",
+            "Status values found: {'verified', 'resolved', 'closed'}\n",
+            "Total bugs with resolution: 10814\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'duplicate', 'invalid', 'not_eclipse', 'fixed'}\n",
+            "Total bugs with severity: 10814\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 1928 bugs with status='RESOLVED', resolution='FIXED' and severity for JDT\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      1584\n",
+            "minor        185\n",
+            "trivial      120\n",
+            "major         28\n",
+            "critical      10\n",
+            "blocker        1\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: PDE\n",
+            "Total bugs with status: 5655\n",
+            "Status values found: {'verified', 'resolved', 'closed'}\n",
+            "Total bugs with resolution: 5655\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'duplicate', 'invalid', 'not_eclipse', 'fixed'}\n",
+            "Total bugs with severity: 5655\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 2688 bugs with status='RESOLVED', resolution='FIXED' and severity for PDE\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2285\n",
+            "major        167\n",
+            "minor        118\n",
+            "trivial       55\n",
+            "critical      50\n",
+            "blocker       13\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Platform\n",
+            "Total bugs with status: 24775\n",
+            "Status values found: {'verified', 'resolved', 'closed'}\n",
+            "Total bugs with resolution: 24775\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'duplicate', 'invalid', 'not_eclipse', 'fixed'}\n",
+            "Total bugs with severity: 24775\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 7623 bugs with status='RESOLVED', resolution='FIXED' and severity for Platform\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      6044\n",
+            "major        677\n",
+            "minor        298\n",
+            "trivial      271\n",
+            "critical     249\n",
+            "blocker       84\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Thunderbird\n",
+            "Total bugs with status: 19237\n",
+            "Status values found: {'verified', 'resolved'}\n",
+            "Total bugs with resolution: 19237\n",
+            "Resolution values found: {'worksforme', 'wontfix', 'incomplete', 'duplicate', 'invalid', 'fixed'}\n",
+            "Total bugs with severity: 19237\n",
+            "Severity values found: {'critical', 'minor', 'normal', 'blocker', 'major', 'trivial'}\n",
+            "\n",
+            "Found 3310 bugs with status='RESOLVED', resolution='FIXED' and severity for Thunderbird\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2615\n",
+            "major        231\n",
+            "minor        196\n",
+            "trivial      133\n",
+            "critical     115\n",
+            "blocker       20\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Overall Data Summary:\n",
+            "Total number of bugs: 71679\n",
+            "\n",
+            "Bugs per project:\n",
+            "project\n",
+            "Core           41299\n",
+            "Firefox         8474\n",
+            "Platform        7623\n",
+            "CDT             3982\n",
+            "Thunderbird     3310\n",
+            "PDE             2688\n",
+            "Bugzilla        2375\n",
+            "JDT             1928\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity levels found:\n",
+            "severity\n",
+            "normal      58025\n",
+            "critical     4735\n",
+            "major        3561\n",
+            "minor        2799\n",
+            "trivial      1821\n",
+            "blocker       738\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "All possible severity levels: ['blocker', 'critical', 'enhancement', 'major', 'minor', 'normal', 'trivial']\n",
+            "Severity levels found in data: ['blocker', 'critical', 'major', 'minor', 'normal', 'trivial']\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Summary Statistics:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla         262        98    251    483     996      285\n",
+            "CDT               34        79    261    177    3368       63\n",
+            "Core             243      3956   1532   1000   33990      578\n",
+            "Firefox           81       178    414    342    7143      316\n",
+            "JDT                1        10     28    185    1584      120\n",
+            "PDE               13        50    167    118    2285       55\n",
+            "Platform          84       249    677    298    6044      271\n",
+            "Thunderbird       20       115    231    196    2615      133\n",
+            "\n",
+            "Percentage Distribution:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla       11.03      4.13  10.57  20.34   41.94    12.00\n",
+            "CDT             0.85      1.98   6.55   4.45   84.58     1.58\n",
+            "Core            0.59      9.58   3.71   2.42   82.30     1.40\n",
+            "Firefox         0.96      2.10   4.89   4.04   84.29     3.73\n",
+            "JDT             0.05      0.52   1.45   9.60   82.16     6.22\n",
+            "PDE             0.48      1.86   6.21   4.39   85.01     2.05\n",
+            "Platform        1.10      3.27   8.88   3.91   79.29     3.56\n",
+            "Thunderbird     0.60      3.47   6.98   5.92   79.00     4.02\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def get_latest_update(report):\n",
+        "    \"\"\"Get the latest non-empty update value from a report\"\"\"\n",
+        "    updates = report.findall('.//update')\n",
+        "    latest_value = None\n",
+        "    latest_time = -1\n",
+        "\n",
+        "    for update in updates:\n",
+        "        when = int(update.find('when').text)\n",
+        "        what = update.find('what').text\n",
+        "\n",
+        "        if when > latest_time and what is not None and what.strip():\n",
+        "            latest_time = when\n",
+        "            latest_value = what.strip()\n",
+        "\n",
+        "    return latest_value\n",
+        "\n",
+        "def parse_xml_file(file_path):\n",
+        "    \"\"\"Parse XML file and return a dictionary of id: latest_value\"\"\"\n",
+        "    if not os.path.exists(file_path):\n",
+        "        print(f\"File not found: {file_path}\")\n",
+        "        return {}, set()\n",
+        "\n",
+        "    try:\n",
+        "        tree = ET.parse(file_path)\n",
+        "        root = tree.getroot()\n",
+        "        bug_dict = {}\n",
+        "        all_values = set()\n",
+        "\n",
+        "        for report in root.findall('.//report'):\n",
+        "            bug_id = report.get('id')\n",
+        "            latest_value = get_latest_update(report)\n",
+        "\n",
+        "            if bug_id and latest_value:\n",
+        "                latest_value = latest_value.upper()  # Normalize to uppercase\n",
+        "                bug_dict[bug_id] = latest_value\n",
+        "                all_values.add(latest_value)\n",
+        "\n",
+        "        return bug_dict, all_values\n",
+        "    except ET.ParseError as e:\n",
+        "        print(f\"Error parsing {file_path}: {e}\")\n",
+        "        return {}, set()\n",
+        "\n",
+        "def process_project(project):\n",
+        "    print(f\"\\nProcessing project: {project}\")\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Parse all relevant files\n",
+        "    status_dict, status_values = parse_xml_file(os.path.join(project_folder, 'bug_status.xml'))\n",
+        "    resolution_dict, resolution_values = parse_xml_file(os.path.join(project_folder, 'resolution.xml'))\n",
+        "    severity_dict, severity_values = parse_xml_file(os.path.join(project_folder, 'severity.xml'))\n",
+        "\n",
+        "    # Print debug information\n",
+        "    print(f\"Total bugs with status: {len(status_dict)}\")\n",
+        "    print(f\"Status values found: {status_values}\")\n",
+        "    print(f\"Total bugs with resolution: {len(resolution_dict)}\")\n",
+        "    print(f\"Resolution values found: {resolution_values}\")\n",
+        "    print(f\"Total bugs with severity: {len(severity_dict)}\")\n",
+        "    print(f\"Severity values found: {severity_values}\")\n",
+        "\n",
+        "    # Create records for bugs with RESOLVED status\n",
+        "    records = []\n",
+        "    for bug_id in status_dict:\n",
+        "        if (bug_id in resolution_dict and\n",
+        "            bug_id in severity_dict and\n",
+        "            status_dict[bug_id] == 'RESOLVED'):\n",
+        "\n",
+        "            records.append({\n",
+        "                'project': project,\n",
+        "                'bug_id': bug_id,\n",
+        "                'severity': severity_dict[bug_id].lower(),\n",
+        "                'status': status_dict[bug_id],\n",
+        "                'resolution': resolution_dict[bug_id]\n",
+        "            })\n",
+        "\n",
+        "    df = pd.DataFrame(records)\n",
+        "    print(f\"\\nFound {len(df)} bugs with status='RESOLVED' and both resolution and severity for {project}\")\n",
+        "    if not df.empty:\n",
+        "        print(\"\\nResolution distribution:\")\n",
+        "        print(df['resolution'].value_counts())\n",
+        "        print(\"\\nSeverity distribution:\")\n",
+        "        print(df['severity'].value_counts())\n",
+        "\n",
+        "    return df\n",
+        "\n",
+        "# Process all projects and combine data\n",
+        "dfs = []\n",
+        "for project in projects:\n",
+        "    df = process_project(project)\n",
+        "    if not df.empty:\n",
+        "        dfs.append(df)\n",
+        "\n",
+        "if dfs:\n",
+        "    all_data = pd.concat(dfs, ignore_index=True)\n",
+        "\n",
+        "    # Print data summary\n",
+        "    print(\"\\nOverall Data Summary:\")\n",
+        "    print(f\"Total number of bugs: {len(all_data)}\")\n",
+        "\n",
+        "    print(\"\\nBugs per project:\")\n",
+        "    print(all_data['project'].value_counts())\n",
+        "\n",
+        "    print(\"\\nResolution types found:\")\n",
+        "    print(all_data['resolution'].value_counts())\n",
+        "\n",
+        "    print(\"\\nSeverity levels found:\")\n",
+        "    print(all_data['severity'].value_counts())\n",
+        "\n",
+        "    # Create visualization for severity distribution by resolution\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    severity_resolution = pd.crosstab(all_data['resolution'], all_data['severity'])\n",
+        "    severity_resolution.plot(kind='bar', stacked=True)\n",
+        "    plt.title('Distribution of Severity Labels by Resolution Type')\n",
+        "    plt.xlabel('Resolution')\n",
+        "    plt.ylabel('Number of Bugs')\n",
+        "    plt.xticks(rotation=45)\n",
+        "    plt.legend(title='Severity', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Create visualization for project distribution by resolution\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    project_resolution = pd.crosstab(all_data['project'], all_data['resolution'])\n",
+        "    project_resolution.plot(kind='bar', stacked=True)\n",
+        "    plt.title('Distribution of Resolution Types by Project')\n",
+        "    plt.xlabel('Project')\n",
+        "    plt.ylabel('Number of Bugs')\n",
+        "    plt.xticks(rotation=45)\n",
+        "    plt.legend(title='Resolution', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Print detailed cross-tabulation\n",
+        "    print(\"\\nCross-tabulation of Resolution and Severity:\")\n",
+        "    print(pd.crosstab(all_data['resolution'], all_data['severity']))\n",
+        "\n",
+        "    print(\"\\nCross-tabulation of Project and Resolution:\")\n",
+        "    print(pd.crosstab(all_data['project'], all_data['resolution']))\n",
+        "\n",
+        "    # Calculate percentages for each resolution type\n",
+        "    resolution_percentages = all_data['resolution'].value_counts(normalize=True) * 100\n",
+        "    print(\"\\nPercentage Distribution of Resolution Types:\")\n",
+        "    print(resolution_percentages.round(2))\n",
+        "\n",
+        "else:\n",
+        "    print(\"\\nNo data found to visualize\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "0aHK8dZyIaXX",
+        "outputId": "a0caf82b-1466-47a3-f81d-171a896ab336"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Processing project: Bugzilla\n",
+            "Total bugs with status: 4616\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 4616\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 4616\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 4287 bugs with status='RESOLVED' and both resolution and severity for Bugzilla\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "FIXED         2375\n",
+            "DUPLICATE      742\n",
+            "INVALID        597\n",
+            "WORKSFORME     412\n",
+            "WONTFIX        156\n",
+            "INCOMPLETE       5\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2275\n",
+            "minor        727\n",
+            "major        476\n",
+            "trivial      383\n",
+            "blocker      272\n",
+            "critical     154\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: CDT\n",
+            "Total bugs with status: 5640\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 5640\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 5640\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'MINOR', 'NORMAL', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 5129 bugs with status='RESOLVED' and both resolution and severity for CDT\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "FIXED          3982\n",
+            "DUPLICATE       512\n",
+            "INVALID         317\n",
+            "WORKSFORME      161\n",
+            "WONTFIX         101\n",
+            "NOT_ECLIPSE      56\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      4191\n",
+            "major        410\n",
+            "minor        245\n",
+            "critical     141\n",
+            "trivial       75\n",
+            "blocker       67\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Core\n",
+            "Total bugs with status: 74292\n",
+            "Status values found: {'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 74292\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 74292\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 67225 bugs with status='RESOLVED' and both resolution and severity for Core\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "FIXED         41299\n",
+            "DUPLICATE     10090\n",
+            "WORKSFORME     7590\n",
+            "INVALID        4336\n",
+            "WONTFIX        2483\n",
+            "INCOMPLETE     1427\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      52308\n",
+            "critical     8355\n",
+            "major        3573\n",
+            "minor        1856\n",
+            "trivial       787\n",
+            "blocker       346\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Firefox\n",
+            "Total bugs with status: 69879\n",
+            "Status values found: {'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 69879\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 69879\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 61072 bugs with status='RESOLVED' and both resolution and severity for Firefox\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "DUPLICATE     17426\n",
+            "INCOMPLETE    13584\n",
+            "WORKSFORME    10425\n",
+            "INVALID        9421\n",
+            "FIXED          8474\n",
+            "WONTFIX        1742\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      41634\n",
+            "major        8462\n",
+            "critical     5644\n",
+            "minor        3664\n",
+            "trivial      1499\n",
+            "blocker       169\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: JDT\n",
+            "Total bugs with status: 10814\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 10814\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 10814\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 5394 bugs with status='RESOLVED' and both resolution and severity for JDT\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "FIXED          1928\n",
+            "DUPLICATE      1440\n",
+            "WORKSFORME      824\n",
+            "INVALID         648\n",
+            "WONTFIX         471\n",
+            "NOT_ECLIPSE      83\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      4285\n",
+            "minor        480\n",
+            "major        317\n",
+            "trivial      169\n",
+            "critical     104\n",
+            "blocker       39\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: PDE\n",
+            "Total bugs with status: 5655\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 5655\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 5655\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 4150 bugs with status='RESOLVED' and both resolution and severity for PDE\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "FIXED          2688\n",
+            "DUPLICATE       652\n",
+            "WORKSFORME      379\n",
+            "INVALID         266\n",
+            "WONTFIX         146\n",
+            "NOT_ECLIPSE      19\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      3483\n",
+            "major        314\n",
+            "minor        167\n",
+            "critical      81\n",
+            "trivial       71\n",
+            "blocker       34\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Platform\n",
+            "Total bugs with status: 24775\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 24775\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 24775\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 17216 bugs with status='RESOLVED' and both resolution and severity for Platform\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "FIXED          7623\n",
+            "DUPLICATE      3990\n",
+            "WORKSFORME     2120\n",
+            "INVALID        1572\n",
+            "WONTFIX        1489\n",
+            "NOT_ECLIPSE     422\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      13240\n",
+            "major        1803\n",
+            "minor         731\n",
+            "critical      710\n",
+            "trivial       392\n",
+            "blocker       340\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Thunderbird\n",
+            "Total bugs with status: 19237\n",
+            "Status values found: {'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 19237\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 19237\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'MINOR', 'NORMAL', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 18012 bugs with status='RESOLVED' and both resolution and severity for Thunderbird\n",
+            "\n",
+            "Resolution distribution:\n",
+            "resolution\n",
+            "DUPLICATE     6308\n",
+            "FIXED         3310\n",
+            "INCOMPLETE    3034\n",
+            "WORKSFORME    2844\n",
+            "INVALID       2236\n",
+            "WONTFIX        280\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      11695\n",
+            "major        2786\n",
+            "critical     1768\n",
+            "minor        1305\n",
+            "trivial       416\n",
+            "blocker        42\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Overall Data Summary:\n",
+            "Total number of bugs: 182485\n",
+            "\n",
+            "Bugs per project:\n",
+            "project\n",
+            "Core           67225\n",
+            "Firefox        61072\n",
+            "Thunderbird    18012\n",
+            "Platform       17216\n",
+            "JDT             5394\n",
+            "CDT             5129\n",
+            "Bugzilla        4287\n",
+            "PDE             4150\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Resolution types found:\n",
+            "resolution\n",
+            "FIXED          71679\n",
+            "DUPLICATE      41160\n",
+            "WORKSFORME     24755\n",
+            "INVALID        19393\n",
+            "INCOMPLETE     18050\n",
+            "WONTFIX         6868\n",
+            "NOT_ECLIPSE      580\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity levels found:\n",
+            "severity\n",
+            "normal      133111\n",
+            "major        18141\n",
+            "critical     16957\n",
+            "minor         9175\n",
+            "trivial       3792\n",
+            "blocker       1309\n",
+            "Name: count, dtype: int64\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAHWCAYAAADO2QWWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACjo0lEQVR4nOzdeVxN+f8H8NdtT6soiShSyRYh2SNCDMY+lkr2GMqanUH2fWmsmbEzNIZRSDHIWEaWZGkmYrQYWgil+vz+8Ot8XYWi3C6v5+NxHzP3cz7nc97n3OPed5/zOZ8jE0IIEBEREVGJp6LoAIiIiIioYJi4ERERESkJJm5ERERESoKJGxEREZGSYOJGREREpCSYuBEREREpCSZuREREREqCiRsRERGRkmDiRkRERKQkmLiVIDNnzoRMJvss22rZsiVatmwpvQ8PD4dMJsO+ffs+y/Y9PDxgYWHxWbb1sZ49e4ZBgwbB1NQUMpkMY8aMUXRIH83CwgIeHh5F2mbuORMeHl6k7X6NPDw8oKurq+gwikxgYCBkMhnu3r2r6FCIvjhM3IpJ7hdX7ktLSwtmZmZwdXXFypUr8fTp0yLZzsOHDzFz5kxERkYWSXtFqSTHVhDz5s1DYGAghg8fjp9//hn9+/d/Z10LCwu5z1tHRwcNGzbETz/99BkjLh5r165FYGCgosMAkPff1bteJf2PAkV5+zw1MTFBs2bNcODAAUWHVihnz57FzJkzkZKSouhQiD47NUUH8KWbPXs2LC0t8erVKyQkJCA8PBxjxozB0qVLcfDgQdSuXVuqO3XqVEyaNKlQ7T98+BCzZs2ChYUF7O3tC7ze0aNHC7Wdj/G+2DZs2ICcnJxij+FTnDhxAo0aNcKMGTMKVN/e3h5jx44FAMTHx2Pjxo1wd3dHRkYGBg8eXJyhFqu1a9eibNmyeXrsmjdvjhcvXkBDQ+OzxdK8eXP8/PPPcmWDBg1Cw4YNMWTIEKnsS+q9KmpvnqcPHz7Ejz/+iG+//Rbr1q3DsGHDimQb/fv3R+/evaGpqVkk7b3t7NmzmDVrFjw8PGBoaFgs2yAqqZi4FbP27dujfv360ns/Pz+cOHECHTt2xDfffIPo6Ghoa2sDANTU1KCmVrwfyfPnz1GqVKnP+mObH3V1dYVuvyCSkpJgZ2dX4PoVKlRAv379pPceHh6oUqUKli1bptSJ27uoqKhAS0vrs26zSpUqqFKlilzZsGHDUKVKFbljT+/29nk6YMAAWFlZYdmyZe9M3LKyspCTk1Pg7w1VVVWoqqoWSbxEJI+XShWgVatWmDZtGu7du4dt27ZJ5fmNcTt27BiaNm0KQ0ND6OrqwsbGBpMnTwbweoxRgwYNAACenp7S5Y/cy1otW7ZEzZo1cenSJTRv3hylSpWS1n17jFuu7OxsTJ48GaamptDR0cE333yD+/fvy9V513ipN9v8UGz5jXFLT0/H2LFjYW5uDk1NTdjY2GDx4sUQQsjVk8lkGDlyJIKCglCzZk1oamqiRo0aCA4Ozv+AvyUpKQleXl4oV64ctLS0UKdOHWzdulVanjt2KzY2FocPH5ZiL+x4HWNjY9ja2uLvv/+WK8/JycHy5ctRo0YNaGlpoVy5chg6dCiSk5Pl6l28eBGurq4oW7YstLW1YWlpiYEDB8rVKegxe9u7xlO+PTbJwsICUVFROHnypHQc3vyM8xvjtnfvXjg4OEBbWxtly5ZFv3798O+//8rVyR3T9e+//6JLly7Q1dWFsbExxo0bh+zs7PfG/j7Pnj2Djo4ORo8enWfZgwcPoKqqCn9/f7l9PXXqFIYOHYoyZcpAX18fAwYMyPNZAMCRI0fQrFkz6OjoQE9PD25uboiKipKrk5CQAE9PT1SsWBGampooX748OnfuXOBz559//oGrqyt0dHRgZmaG2bNnS5+lEAIWFhbo3LlznvVevnwJAwMDDB06tEDbeZOpqSmqV6+O2NhYAMDdu3chk8mwePFiLF++HFWrVoWmpiZu3LgB4HVPdO5xMDQ0ROfOnREdHS3X5rvGuBXkGALAzZs30bNnTxgbG0NbWxs2NjaYMmUKgNfn7vjx4wEAlpaWH/3vk0hZscdNQfr374/Jkyfj6NGj7+yNiYqKQseOHVG7dm3Mnj0bmpqaiImJwZkzZwAA1atXx+zZszF9+nQMGTIEzZo1AwA0btxYauPx48do3749evfujX79+qFcuXLvjWvu3LmQyWSYOHEikpKSsHz5cri4uCAyMlLqGSyIgsT2JiEEvvnmG4SFhcHLywv29vYICQnB+PHj8e+//2LZsmVy9U+fPo39+/djxIgR0NPTw8qVK9GtWzfExcWhTJky74zrxYsXaNmyJWJiYjBy5EhYWlpi79698PDwQEpKCkaPHo3q1avj559/ho+PDypWrChdVjI2Ni7w/gOveykePHiA0qVLy5UPHToUgYGB8PT0xPfff4/Y2FisXr0aly9fxpkzZ6Curo6kpCS0bdsWxsbGmDRpEgwNDXH37l3s37//o4/Zx1i+fDlGjRoFXV1d6YfzfedQ7n41aNAA/v7+SExMxIoVK3DmzBlcvnxZ7rJWdnY2XF1d4ejoiMWLF+P48eNYsmQJqlatiuHDh39UvLq6uujatSt2796NpUuXyvX67Ny5E0II9O3bV26dkSNHwtDQEDNnzsStW7ewbt063Lt3T0pMAeDnn3+Gu7s7XF1dsWDBAjx//hzr1q1D06ZNcfnyZemPkG7duiEqKgqjRo2ChYUFkpKScOzYMcTFxX1w3F12djbatWuHRo0aYeHChQgODsaMGTOQlZWF2bNnQyaToV+/fli4cCGePHkCIyMjad3ffvsNaWlpH9Xr+OrVK9y/fz/Pv5stW7bg5cuXGDJkCDQ1NWFkZITjx4+jffv2qFKlCmbOnIkXL15g1apVaNKkCf7666/37mNBj+HVq1fRrFkzqKurY8iQIbCwsMDff/+N3377DXPnzsW3336L27dvY+fOnVi2bBnKli0LoPD/PomUlqBisWXLFgFAXLhw4Z11DAwMRN26daX3M2bMEG9+JMuWLRMAxKNHj97ZxoULFwQAsWXLljzLWrRoIQCIgICAfJe1aNFCeh8WFiYAiAoVKoi0tDSpfM+ePQKAWLFihVRWuXJl4e7u/sE23xebu7u7qFy5svQ+KChIABBz5syRq9e9e3chk8lETEyMVAZAaGhoyJVduXJFABCrVq3Ks603LV++XAAQ27Ztk8oyMzOFk5OT0NXVldv3ypUrCzc3t/e292bdtm3bikePHolHjx6Ja9euif79+wsAwtvbW6r3xx9/CABi+/btcusHBwfLlR84cOCD509hjtnbn9nb51qu3PM2NjZWKqtRo4bc55or95wJCwsTQrw+jiYmJqJmzZrixYsXUr1Dhw4JAGL69OlSmbu7uwAgZs+eLddm3bp1hYODwzv3OT86Ojpy+xYSEiIAiCNHjsjVq127ttx+5O6rg4ODyMzMlMoXLlwoAIhff/1VCCHE06dPhaGhoRg8eLBcewkJCcLAwEAqT05OFgDEokWLChW/EP87HqNGjZLKcnJyhJubm9DQ0JC+A27duiUAiHXr1smt/8033wgLCwuRk5Pz3u28fZ5euXJF9O7dW27bsbGxAoDQ19cXSUlJcuvb29sLExMT8fjxY6nsypUrQkVFRQwYMEAqe/s8KugxFEKI5s2bCz09PXHv3j25um/u26JFi/Kcp0RfC14qVSBdXd333l2a2zvx66+/fvRAfk1NTXh6eha4/oABA6Cnpye97969O8qXL4/ff//9o7ZfUL///jtUVVXx/fffy5WPHTsWQggcOXJErtzFxQVVq1aV3teuXRv6+vr4559/PrgdU1NT9OnTRypTV1fH999/j2fPnuHkyZMfvQ9Hjx6FsbExjI2NUatWLfz888/w9PTEokWLpDp79+6FgYEB2rRpg//++096OTg4QFdXF2FhYQD+99kfOnQIr169eue+FOaYFbeLFy8iKSkJI0aMkBv75ubmBltbWxw+fDjPOm+PqWrWrNkHP8MPcXFxgZmZGbZv3y6VXb9+HVevXs23R2rIkCFyYy6HDx8ONTU16Zw/duwYUlJS0KdPH7nPTFVVFY6OjtJnpq2tDQ0NDYSHh+d7qbUgRo4cKf1/7pCAzMxMHD9+HABgbW0NR0dHuX178uQJjhw5gr59+xZoOqE3z9M6depg79696N+/PxYsWCBXr1u3bnK9WPHx8YiMjISHh4dcb1/t2rXRpk2b935HFPQYPnr0CKdOncLAgQNRqVIluTY+11RJRCUdEzcFevbsmVyS9LZevXqhSZMmGDRoEMqVK4fevXtjz549hUriKlSoUKgbEapVqyb3XiaTwcrKqtjHj9y7dw9mZmZ5jkf16tWl5W96+0sdAEqXLv3BH8x79+6hWrVqUFGRP/XftZ3CcHR0xLFjxxAcHIzFixfD0NAQycnJcsf/zp07SE1NhYmJifTjmft69uwZkpKSAAAtWrRAt27dMGvWLJQtWxadO3fGli1bkJGRIbcvhTlmxS13ezY2NnmW2dra5olHS0srz+WtgnyGH6KiooK+ffsiKCgIz58/BwBs374dWlpa6NGjR576b5/zurq6KF++vHTO37lzB8Drsalvf2ZHjx6VPjNNTU0sWLAAR44cQbly5dC8eXMsXLgQCQkJBY777RsvrK2tAUDu39+AAQNw5swZ6Xju3bsXr169eu90NW/KPU+PHz+Os2fP4r///sNPP/2UZyiEpaWl3Pv3fb7Vq1fHf//9h/T09Hy3WdBjmJu016xZs0D7QvQ14hg3BXnw4AFSU1NhZWX1zjra2to4deoUwsLCcPjwYQQHB2P37t1o1aoVjh49WqC7tgozLq2g3vWXb3Z29me7k+xd2xEfGJRfnMqWLQsXFxcAgKurK2xtbdGxY0esWLECvr6+AF7fmGBiYiLXY/Km3EQmdzLkc+fO4bfffkNISAgGDhyIJUuW4Ny5c5883cX7PsPPpTjPlQEDBmDRokUICgpCnz59sGPHDnTs2BEGBgaFbiv3D6Wff/4ZpqameZa/eSf4mDFj0KlTJwQFBSEkJATTpk2Dv78/Tpw4gbp16378Dr2hd+/e8PHxwfbt2zF58mRs27YN9evXzzehys+b5+n7FOV3R2GOIRG9H3vcFCR3LipXV9f31lNRUUHr1q2xdOlS3LhxA3PnzsWJEyekSwtFffkg9y/jXEIIxMTEyA06Ll26dL4TX77do1KY2CpXroyHDx/muXR88+ZNaXlRqFy5Mu7cuZOn17KotwO8vkTYokULzJs3T+qJqFq1Kh4/fowmTZrAxcUlz6tOnTpybTRq1Ahz587FxYsXsX37dkRFRWHXrl1SrB97zHJvmHj7c8yvl66gn2Pu9m7dupVn2a1bt4r02H5IzZo1UbduXWzfvh1//PEH4uLi3tkj9fY5/+zZM8THx0vnfO4leRMTk3w/s7fvzq5atSrGjh2Lo0eP4vr168jMzMSSJUs+GHNOTk6ey8S3b98GALl/f0ZGRnBzc8P27dtx7949nDlzpsC9bZ/ifZ/vzZs3UbZsWejo6OS7bkGPYW6P4/Xr198bCy+b0teMiZsCnDhxAj/88AMsLS3z3OH2pidPnuQpy53INveSWe4XZVHNIP7TTz/JJQL79u1DfHw82rdvL5VVrVoV586dQ2ZmplR26NChPNOGFCa2Dh06IDs7G6tXr5YrX7ZsGWQymdz2P0WHDh2QkJCA3bt3S2VZWVlYtWoVdHV10aJFiyLZTq6JEyfi8ePH2LBhAwCgZ8+eyM7Oxg8//JCnblZWlnSskpOT8/Qevv3Zf8oxy/0hPXXqlFSWnp4uNy1KLh0dnQJ9hvXr14eJiQkCAgLkLukeOXIE0dHRcHNz+2AbRal///44evQoli9fjjJlyrzzeKxfv15uHOG6deuQlZUl1Xd1dYW+vj7mzZuX73jDR48eAXg9R+LLly/lllWtWhV6enpyx+N93vwshRBYvXo11NXV0bp16zz7duPGDYwfPx6qqqro3bt3gdr/FOXLl4e9vT22bt0qdz5cv34dR48eRYcOHd65bkGPobGxMZo3b47NmzcjLi5Ors6b/x6K+nuPSJmwf7qYHTlyBDdv3kRWVhYSExNx4sQJHDt2DJUrV8bBgwffO4Hp7NmzcerUKbi5uaFy5cpISkrC2rVrUbFiRTRt2hTA6x8GQ0NDBAQEQE9PDzo6OnB0dMwzPqWgjIyM0LRpU3h6eiIxMRHLly+HlZWV3JQlgwYNwr59+9CuXTv07NkTf//9N7Zt2yZ3s0BhY+vUqROcnZ0xZcoU3L17F3Xq1MHRo0fx66+/YsyYMXna/lhDhgzBjz/+CA8PD1y6dAkWFhbYt28fzpw5g+XLl793zOHHaN++PWrWrImlS5fC29sbLVq0wNChQ+Hv74/IyEi0bdsW6urquHPnDvbu3YsVK1age/fu2Lp1K9auXYuuXbuiatWqePr0KTZs2AB9fX3pB/JTjlnbtm1RqVIleHl5ST/+mzdvhrGxcZ4fTAcHB6xbtw5z5syBlZUVTExM0KpVqzxtqqurY8GCBfD09ESLFi3Qp08faToQCwsL+Pj4FOmx/ZDvvvsOEyZMwIEDBzB8+PB3TvqcmZmJ1q1bo2fPnrh16xbWrl2Lpk2b4ptvvgEA6OvrY926dejfvz/q1auH3r17S8fp8OHDaNKkCVavXo3bt29L7djZ2UFNTQ0HDhxAYmJigRIrLS0tBAcHw93dHY6Ojjhy5AgOHz6MyZMn5xkL6ObmhjJlymDv3r1o3749TExMPv2AFcCiRYvQvn17ODk5wcvLS5oOxMDAADNnznznegU9hgCwcuVKNG3aFPXq1cOQIUNgaWmJu3fv4vDhw9Lj8xwcHAAAU6ZMQe/evaGuro5OnTq9s8eP6IuiwDtav2i5t8PnvjQ0NISpqalo06aNWLFihdy0E7nenqIhNDRUdO7cWZiZmQkNDQ1hZmYm+vTpI27fvi233q+//irs7OyEmpqa3PQbLVq0EDVq1Mg3vndNB7Jz507h5+cnTExMhLa2tnBzc8tzW74QQixZskRUqFBBaGpqiiZNmoiLFy/mafN9sb09HYgQr6cM8PHxEWZmZkJdXV1Uq1ZNLFq0KM8UB3hrio1c75qm5G2JiYnC09NTlC1bVmhoaIhatWrlO2VJYacDeVfdwMDAPNOirF+/Xjg4OAhtbW2hp6cnatWqJSZMmCAePnwohBDir7/+En369BGVKlUSmpqawsTERHTs2FFcvHhRru2CHrP8js2lS5eEo6Oj0NDQEJUqVRJLly7NdzqQhIQE4ebmJvT09AQA6TN+ezqQXLt37xZ169YVmpqawsjISPTt21c8ePBAro67u7vQ0dHJc6zeNU3J+7w9HcibOnToIACIs2fP5lmWu68nT54UQ4YMEaVLlxa6urqib9++ctNd5AoLCxOurq7CwMBAaGlpiapVqwoPDw/pM/nvv/+Et7e3sLW1FTo6OsLAwEA4OjqKPXv2fHAfco/H33//Ldq2bStKlSolypUrJ2bMmCGys7PzXWfEiBECgNixY8cH289VkHM6dzqQd01rcvz4cdGkSROhra0t9PX1RadOncSNGzfk6uR3Hgnx4WOY6/r166Jr167C0NBQaGlpCRsbGzFt2jS5Oj/88IOoUKGCUFFR4dQg9FWRCaHA0dxERMWoa9euuHbtGmJiYvIsy50s+MKFC3KPpVMWPj4+2LRpExISElCqVClFhyNn06ZNGDRoEO7fv4+KFSsqOhyiLwrHuBHRFyk+Ph6HDx/+LAP3P7eXL19i27Zt6NatW4lL2oDXx14mk8nN90ZERYNj3IjoixIbG4szZ85g48aNUFdX/6jnd5ZUSUlJOH78OPbt24fHjx/n+0xWRUpMTMS+ffsQEBAAJyenEplUEik7Jm5E9EU5efIkPD09UalSJWzdujXfecOU1Y0bN9C3b1+YmJhg5cqV0p3GJUV0dDTGjx+Phg0bSndSE1HR4hg3IiIiIiXBMW5ERERESoKJGxEREZGSUOgYNwsLi3wfsTNixAisWbMGL1++xNixY7Fr1y5kZGTA1dUVa9euRbly5aS6cXFxGD58OMLCwqCrqwt3d3f4+/vLPfsuPDwcvr6+iIqKgrm5OaZOnQoPDw+5ba5ZswaLFi1CQkIC6tSpg1WrVqFhw4YF3pecnBw8fPgQenp6fBwLEZECCCHw9OlTmJmZQUWF/RL0hVLkJHJJSUkiPj5eeh07dkxuQs9hw4YJc3NzERoaKi5evCgaNWokGjduLK2flZUlatasKVxcXMTly5fF77//LsqWLSv8/PykOv/8848oVaqU8PX1FTdu3BCrVq0SqqqqIjg4WKqza9cuoaGhITZv3iyioqLE4MGDhaGhoUhMTCzwvty/f19uwl2++OKLL74U87p///6n/0ARlVAl6uaEMWPG4NChQ7hz5w7S0tJgbGyMHTt2oHv37gBeP8i4evXqiIiIQKNGjXDkyBF07NgRDx8+lHrhAgICMHHiRDx69AgaGhqYOHEiDh8+LPfQ4t69eyMlJQXBwcEAAEdHRzRo0EB65EpOTg7Mzc0xatQoTJo0qUCxp6amwtDQEPfv34e+vn5RHhYiIiqAtLQ0mJubIyUlBQYGBooOh6hYlJjpQDIzM7Ft2zb4+vpCJpPh0qVLePXqFVxcXKQ6tra2qFSpkpS4RUREoFatWnKXTl1dXTF8+HBERUWhbt26iIiIkGsjt86YMWOk7V66dAl+fn7SchUVFbi4uCAiIuKd8WZkZMg9ODr3wez6+vpM3IiIFIjDVehLVmIGAQQFBSElJUUae5aQkAANDQ0YGhrK1StXrhwSEhKkOm8mbbnLc5e9r05aWhpevHiB//77D9nZ2fnWyW0jP/7+/jAwMJBe5ubmhd5nIiIiosIoMYnbpk2b0L59e5iZmSk6lALx8/NDamqq9Lp//76iQyIiIqIvXIm4VHrv3j0cP34c+/fvl8pMTU2RmZmJlJQUuV63xMREaSZ0U1NTnD9/Xq6txMREaVnuf3PL3qyjr68PbW1tqKqqQlVVNd8675txXVNTE5qamoXfWSIiIqKPVCISty1btsDExARubm5SmYODA9TV1REaGopu3boBAG7duoW4uDg4OTkBAJycnDB37lwkJSXBxMQEAHDs2DHo6+vDzs5OqvP777/Lbe/YsWNSGxoaGnBwcEBoaCi6dOkC4PXNCaGhoRg5cmSx7jcRESmnnJwcZGZmKjoM+kKoq6tDVVW1QHUVnrjl5ORgy5YtcHd3l5t7zcDAAF5eXvD19YWRkRH09fUxatQoODk5oVGjRgCAtm3bws7ODv3798fChQuRkJCAqVOnwtvbW+oNGzZsGFavXo0JEyZg4MCBOHHiBPbs2YPDhw9L2/L19YW7uzvq16+Phg0bYvny5UhPT4enp+fnPRhERFTiZWZmIjY2Fjk5OYoOhb4ghoaGMDU1/eDNNQpP3I4fP464uDgMHDgwz7Jly5ZBRUUF3bp1k5uAN5eqqioOHTqE4cOHw8nJCTo6OnB3d8fs2bOlOpaWljh8+DB8fHywYsUKVKxYERs3boSrq6tUp1evXnj06BGmT5+OhIQE2NvbIzg4OM8NC0RE9HUTQiA+Ph6qqqowNzfnRL/0yYQQeP78OZKSkgAA5cuXf2/9EjWPmzJLS0uDgYEBUlNTOR0IEZECfI7v4VevXiEmJgZmZmacK46K1OPHj5GUlARra+v3XjblnwpEREQFlJ2dDeD1+GiiolSqVCkAr/84eB8mbkRERIXESX6pqBX0nGLiRkRERKQkmLgRERFRkfHw8JCm1/oUM2fOhL29/Se386Vh4kZERPQF8fDwgEwmg0wmg7q6OiwtLTFhwgS8fPlS0aG9k0wmQ1BQkFzZuHHjEBoaqpiASjCFTwdCRERERatdu3bYsmULXr16hUuXLsHd3R0ymQwLFixQdGgFpqurC11dXUWHUeIwcaMv1oNJfxRLuxXnNyuWdomIioqmpqb02EZzc3O4uLjg2LFjWLBgAXJycrBgwQKsX78eCQkJsLa2xrRp09C9e3cAQHJyMkaOHImjR4/i2bNnqFixIiZPnixNSn/t2jWMHj0aERERKFWqFLp164alS5e+M8mysLDAmDFjMGbMGKnM3t4eXbp0wcyZM2FhYQEA6Nq1KwCgcuXKuHv3LmbOnImgoCBERkYCeD1h/5w5c7B+/Xo8evQI1atXx/z589GuXTsAwN27d2FpaYlffvkFq1atwp9//olq1aohICBAelrSl4CXSomIiL5g169fx9mzZ6UpTPz9/fHTTz8hICAAUVFR8PHxQb9+/XDy5EkAwLRp03Djxg0cOXIE0dHRWLduHcqWLQsASE9Ph6urK0qXLo0LFy5g7969OH78+Cc9IvLChQsAXj/+Mj4+Xnr/thUrVmDJkiVYvHgxrl69CldXV3zzzTe4c+eOXL0pU6Zg3LhxiIyMhLW1Nfr06YOsrKyPjq+kYY8bERHRF+bQoUPQ1dVFVlYWMjIyoKKigtWrVyMjIwPz5s3D8ePHpV6oKlWq4PTp0/jxxx/RokULxMXFoW7duqhfvz4ASD1iALBjxw68fPkSP/30E3R0dAAAq1evRqdOnbBgwYKPeuKQsbExgP898uldFi9ejIkTJ6J3794AgAULFiAsLAzLly/HmjVrpHrjxo2Tnn0+a9Ys1KhRAzExMbC1tS10bCUREzciIqIvjLOzM9atW4f09HQsW7YMampq6NatG6KiovD8+XO0adNGrn5mZibq1q0LABg+fDi6deuGv/76C23btkWXLl3QuHFjAEB0dDTq1KkjJW0A0KRJE+Tk5ODWrVvF9qjItLQ0PHz4EE2aNJErb9KkCa5cuSJXVrt2ben/cx8flZSUxMSNiIiISiYdHR1YWVkBADZv3ow6depg06ZNqFmzJgDg8OHDqFChgtw6mpqaAID27dvj3r17+P3333Hs2DG0bt0a3t7eWLx48UfFoqKigrefrvmhpwN8CnV1den/cye1zcnJKbbtfW4c40ZERPQFU1FRweTJkzF16lTY2dlBU1MTcXFxsLKyknuZm5tL6xgbG8Pd3R3btm3D8uXLsX79egBA9erVceXKFaSnp0t1z5w5AxUVFdjY2OS7fWNjY8THx0vv09LSEBsbK1dHXV1depxYfvT19WFmZoYzZ87IlZ85cwZ2dnYFPxhfACZuREREX7gePXpAVVUVP/74I8aNGwcfHx9s3boVf//9N/766y+sWrUKW7duBQBMnz4dv/76K2JiYhAVFYVDhw6hevXqAIC+fftCS0sL7u7uuH79OsLCwjBq1Cj079//nZdJW7VqhZ9//hl//PEHrl27Bnd39zwPUbewsEBoaCgSEhKQnJycbzvjx4/HggULsHv3bty6dQuTJk1CZGQkRo8eXYRHquTjpVIiIqIvnJqaGkaOHImFCxciNjYWxsbG8Pf3xz///ANDQ0PUq1cPkydPBgBoaGjAz88Pd+/ehba2Npo1a4Zdu3YBeP0g9JCQEIwePRoNGjSQmw7kXfz8/BAbG4uOHTvCwMAAP/zwQ54etyVLlsDX1xcbNmxAhQoVcPfu3TztfP/990hNTcXYsWORlJQEOzs7HDx4ENWqVSu6A6UEZOLtC8/0UdLS0mBgYIDU1FTo6+srOhwC53Ej+tp8ju/hly9fIjY2FpaWltDS0iqWbdDXqaDnFi+VEhERESkJJm5ERERESoKJGxEREZGSYOJGREREpCSYuBEREREpCSZuREREREqCiRsRERGRkmDiRkRERKQkmLgRERERKQkmbkRERERKgs8qJSIi+kQWkw5/1u3dne9WqPoeHh7SQ+TV1NRgZGSE2rVro0+fPvDw8ICKyut+HJlMhgMHDqBLly551k9JSUFQUBAAoGXLljh58iQAQFNTE1WqVMHIkSMxYsQIAEBgYCDGjBmDlJSUd8bzZnsAkJCQgLlz5+Lw4cP4999/YWJiAnt7e4wZMwatW7eWW9/f3x9Tp07F/PnzMX78eACvH1R/7969dx4Dd3d3BAYGQiaT5bt8586d6N279zvXLynY40ZERPQVaNeuHeLj43H37l0cOXIEzs7OGD16NDp27IisrKxCtzd48GDEx8fjxo0b6NmzJ7y9vbFz586Piu3u3btwcHDAiRMnsGjRIly7dg3BwcFwdnaGt7d3nvqbN2/GhAkTsHnzZqnswoULiI+PR3x8PH755RcAwK1bt6SyFStWSHW3bNkilee+3k5WSyr2uBEREX0FNDU1YWpqCgCoUKEC6tWrh0aNGqF169YIDAzEoEGDCtVeqVKlpPZmzpyJHTt24ODBg+jTp0+hYxsxYgRkMhnOnz8PHR0dqbxGjRoYOHCgXN2TJ0/ixYsXmD17Nn766SecPXsWjRs3hrGxsVTHyMgIAGBiYgJDQ8M82zM0NJRiVzbscSMiIvpKtWrVCnXq1MH+/fs/uS1tbW1kZmYWer0nT54gODgY3t7ecklbrrcTr02bNqFPnz5QV1dHnz59sGnTpo8NWSkxcSMiIvqK2dra4u7dux+9fnZ2NrZt24arV6+iVatWhV4/JiYGQgjY2tp+sG5aWhr27duHfv36AQD69euHPXv24NmzZ4XaZp8+faCrqyv3iouLK3TsisBLpURERF8xIcQ7B+y/z9q1a7Fx40ZkZmZCVVUVPj4+GD58+Edtv6B27tyJqlWrok6dOgAAe3t7VK5cGbt374aXl1eB21m2bBlcXFzkyszMzAq8viIxcSMiIvqKRUdHw9LSEgCgp6eH1NTUPHVSUlJgYGAgV9a3b19MmTIF2traKF++vHRnamFVq1YNMpkMN2/e/GDdTZs2ISoqCmpq/0tfcnJysHnz5kIlbqamprCysvqoeBWNl0qJiIi+UidOnMC1a9fQrVs3AICNjQ0uXbokVyc7OxtXrlyBtbW1XLmBgQGsrKxQoUKFj07agNc3Eri6umLNmjVIT0/Pszx3SpFr167h4sWLCA8PR2RkpPQKDw9HREREgRK/LwF73IiIiL4CGRkZSEhIQHZ2NhITExEcHAx/f3907NgRAwYMAAD4+vrCy8sLtra2aNOmDdLT07Fq1SokJycX+q7T7OxsREZGypVpamqievXqeequWbMGTZo0QcOGDTF79mzUrl0bWVlZOHbsGNatW4fo6Ghs2rQJDRs2RPPmzfOs36BBA2zatAmLFi0qUGwpKSlISEiQK9PT08v35oiShokbERHRVyA4OBjly5eHmpoaSpcujTp16mDlypVwd3eXesz69OkDIQSWLl2KSZMmoVSpUnBwcMCpU6dQrly5Qm3v2bNnqFu3rlxZ1apVERMTk6dulSpV8Ndff2Hu3LkYO3Ys4uPjYWxsDAcHB6xbtw6ZmZnYtm0bJk6cmO+2unXrhiVLlmDevHlQV1f/YGyenp55yvz9/TFp0qQC7p3iyERhRgUWg3///RcTJ07EkSNH8Pz5c1hZWWHLli2oX78+gNeDFmfMmIENGzYgJSUFTZo0wbp161CtWjWpjSdPnmDUqFH47bffoKKigm7dumHFihXQ1dWV6ly9ehXe3t64cOECjI2NMWrUKEyYMEEulr1792LatGm4e/cuqlWrhgULFqBDhw4F2o+0tDQYGBggNTUV+vr6RXBk6FM9mPRHsbRbcX6zYmlX2eIlKmk+x/fwy5cvERsbC0tLS2hpaRXLNujrVNBzS6Fj3JKTk9GkSROoq6vjyJEjuHHjBpYsWYLSpUtLdRYuXIiVK1ciICAAf/75J3R0dODq6oqXL19Kdfr27YuoqCgcO3YMhw4dwqlTpzBkyBBpeVpaGtq2bYvKlSvj0qVLWLRoEWbOnIn169dLdc6ePYs+ffrAy8sLly9fRpcuXdClSxdcv3798xwMIiIiog9QaI/bpEmTcObMGfzxR/49DUIImJmZYezYsRg3bhwAIDU1FeXKlUNgYCB69+6N6Oho2NnZ4cKFC1IvXXBwMDp06IAHDx7AzMwM69atw5QpU5CQkAANDQ1p20FBQdJgxl69eiE9PR2HDh2Stt+oUSPY29sjICDgg/vCHreSR9l6sJQtXqKShj1upMyUosft4MGDqF+/Pnr06AETExPUrVsXGzZskJbHxsYiISFBbq4VAwMDODo6IiIiAgAQEREBQ0NDKWkDABcXF6ioqODPP/+U6jRv3lxK2gDA1dUVt27dQnJyslTn7TldXF1dpe0QERERKZpCE7d//vlHGq8WEhKC4cOH4/vvv8fWrVsBQLrj4+0BkeXKlZOWJSQkwMTERG65mpoajIyM5Ork18ab23hXnbfvOsmVkZGBtLQ0uRcRERFRcVLoXaU5OTmoX78+5s2bBwCoW7curl+/joCAALi7uysytA/y9/fHrFmzFB0GERERfUUUmriVL18ednZ2cmXVq1fHL7/8AuD1zMYAkJiYiPLly0t1EhMTYW9vL9VJSkqSayMrKwtPnjyR1jc1NUViYqJcndz3H6qTu/xtfn5+8PX1ld6npaXB3Nz8wztNn83u2AXF0u5YcMwYEREphkIvlTZp0gS3bt2SK7t9+zYqV64MALC0tISpqSlCQ0Ol5Wlpafjzzz/h5OQEAHByckJKSorcTM8nTpxATk4OHB0dpTqnTp3Cq1evpDrHjh2DjY2NdAerk5OT3HZy6+Ru522amprQ19eXexEREREVJ4Umbj4+Pjh37hzmzZuHmJgY7NixA+vXr4e3tzcAQCaTYcyYMZgzZw4OHjyIa9euYcCAATAzM0OXLl0AvO6ha9euHQYPHozz58/jzJkzGDlyJHr37i09MPa7776DhoYGvLy8EBUVhd27d2PFihVyPWajR49GcHAwlixZgps3b2LmzJm4ePEiRo4c+dmPCxEREVF+FHqptEGDBjhw4AD8/Pwwe/ZsWFpaYvny5ejbt69UZ8KECUhPT8eQIUOQkpKCpk2bIjg4WO5W2e3bt2PkyJFo3bq1NAHvypUrpeUGBgY4evQovL294eDggLJly2L69Olyc701btwYO3bswNSpUzF58mRUq1YNQUFBqFmz5uc5GEREREQfoPAnJ3wpOI9bybOkV8diaXfs7kMfrvQROI8b0afhPG6kzAp6bvFZpURERJ9qpsFn3l5qoap7eHhIU2296c6dO5gzZw5SUlIQFBSE7OxsNGvWDKampti/f79ULzU1FTVr1sSAAQMwd+5c3L17F5aWlvluKyIiAo0aNUJgYKD0TFAVFRXo6+vD2toabm5uGD16NAwMPvMx+0IwcSMiIvoKtGvXDlu2bJErMzY2lnuvqqqKwMBA2NvbY/v27dLQpVGjRsHIyAgzZsyQq3/8+HHUqFFDrqxMmTLS/+vr6+PWrVsQQiAlJQVnz56Fv78/tmzZgjNnzkhj0angmLgRERF9BTQ1Nd85xdWbrK2tMX/+fIwaNQqtWrXC+fPnsWvXLly4cEHuCUTA6yTtfW3KZDJpefny5VG9enV06tQJNWrUwIQJE7Bt27ZP26mvkELvKiUiIqKSZ9SoUahTpw769++PIUOGYPr06ahTp06RtG1iYoK+ffvi4MGDyM7OLpI2vyZM3IiIiL4Chw4dgq6urvTq0aPHO+vKZDKsW7cOoaGhKFeuHCZNmpRvvcaNG8u1qaurW6BYbG1t8fTpUzx+/Pij9uVrxkulREREXwFnZ2esW7dOeq+jo/Pe+ps3b0apUqUQGxuLBw8ewMLCIk+d3bt3o3r16oWOJXdCC5lMVuh1v3ZM3IiIiL4COjo6sLKyKlDds2fPYtmyZTh69CjmzJkDLy8vHD9+PE+iZW5uXuA23xQdHQ19fX25GxmoYJi40Rerw5W/FR0CEZHSef78OTw8PDB8+HA4OzvD0tIStWrVQkBAAIYPH/7J7SclJWHHjh3o0qULVFQ4YquwmLgRERGRxM/PD0IIzJ8/HwBgYWGBxYsXY9y4cWjfvr3cJdPHjx8jISFBbn1DQ0NpAlkhBBISEqTpQCIiIjBv3jwYGBhI7VPhMHEjIiIiAMDJkyexZs0ahIeHo1SpUlL50KFDsX//fumSaS4XF5c8bezcuRO9e/cG8PppFuXLl4dMJoO+vj5sbGzg7u6O0aNH8ylDH4mPvCoifORVyRNtW/gBswVR/WZ0sbTLR14RfRo+8oqUWUHPLV5cJiIiIlISTNyIiIiIlAQTNyIiIiIlwcSNiIiISEkwcSMiIiJSEkzciIiIiJQEEzciIiIiJcHEjYiIiEhJMHEjIiIiUhJM3IiIiIiUBJ9VSkRE9Ilqba31Wbd3zf1aoep7eHggJSUFQUFB8PDwwNatW+Hv749JkyZJdYKCgtC1a1e8+SRMIQQ2bNiATZs2ISoqCmpqarCyskK/fv0wZMgQ6XmmT548wezZs3HgwAHEx8ejbNmyaNeuHWbOnIlKlSrJxbF161YMHToUAQEBcjF6e3tj7dq1cHd3R2BgoFx9AFBXV0elSpUwYMAATJ48GWpqaggPD4ezszOSk5NhaGiYZ79nzpyJWbNm5Sm3sbFBcHAwLC0t33vctmzZAgsLCzg7O+e7PD4+Hqampu9to6ixx42IiOgro6WlhQULFiA5Ofm99fr3748xY8agc+fOCAsLQ2RkJKZNm4Zff/0VR48eBfA6aWvUqBGOHz+OgIAAxMTEYNeuXYiJiUGDBg3wzz//yLVpbm6OXbt24cWLF1LZy5cvsWPHDrkkL1e7du0QHx+PO3fuYOzYsZg5cyYWLVpU4H2tUaMG4uPj5V6nT5+Gubm5XNnYsWPz1O3Vq5fUzq1bt/K0Y2JiUuA4igp73IiIiL4yLi4uiImJgb+/PxYuXJhvnT179mD79u0ICgpC586dpXILCwt88803SEtLAwBMmTIFDx8+RExMjNT7VKlSJYSEhKBatWrw9vbGkSNHpPXr1auHv//+G/v370ffvn0BAPv370elSpXy7QHT1NSU2h0+fDgOHDiAgwcPws/Pr0D7qqam9s5esTfLdXV131vXxMQk3169z409bkRERF8ZVVVVzJs3D6tWrcKDBw/yrbN9+3bY2NjIJW25ZDIZDAwMkJOTg127dqFv3755Eh5tbW2MGDECISEhePLkidyygQMHYsuWLdL7zZs3w9PTs0Cxa2trIzMzs0B1v0RM3IiIiL5CXbt2hb29PWbMmJHv8jt37sDGxua9bTx69AgpKSmoXr16vsurV68OIQRiYmLkyvv164fTp0/j3r17uHfvHs6cOYN+/fq9d1tCCBw/fhwhISFo1arVe+u+6dq1a9DV1ZV7DRs2rMDr56pYsaJcGzVq1Ch0G0WBl0qJiIi+UgsWLECrVq0wbty4PMvevEnhQwpTFwCMjY3h5uaGwMBACCHg5uaGsmXL5lv30KFD0NXVxatXr5CTk4PvvvsOM2fOLPC2bGxscPDgQbkyfX39QsULAH/88Qf09PSk9+rq6oVuoygwcaMvVk+/4jm9C3cvFxFRydW8eXO4urrCz88PHh4ecsusra1x8+bN965vbGwMQ0NDREdH57s8OjoaMpkMVlZWeZYNHDgQI0eOBACsWbPmndtwdnbGunXroKGhATMzM6ipFe67XUNDI9/tF5alpSXHuBEREZFizZ8/H7/99hsiIiLkyr/77jvcvn0bv/76a551hBBITU2FiooKevbsiR07diAhIUGuzosXL7B27Vq4urrCyMgoTxvt2rVDZmYmXr16BVdX13fGp6OjAysrK1SqVKnQSduXiEeAiIjoK1arVi307dsXK1eulCvv2bMnDhw4gD59+mDq1Klo27YtjI2Nce3aNSxbtgyjRo1Cly5dMG/ePISGhqJNmzZYuHAhatasidjYWEydOhWvXr16Z2+aqqqq1FOnqqr6Sftw7do1ucuYMpkMderUAQBkZWXlSSplMhnKlStXqG0kJSXh5cuXcmVlypT57JdMmbgRERF95WbPno3du3fLlclkMuzYsQPr16/H5s2bMXfuXKipqaFatWoYMGCA1EtWpkwZnDt3DrNnz8bQoUORkJAAIyMjtG/fHtu2bct3brZcHzPWLD/NmzeXe6+qqoqsrCwAQFRUFMqXLy+3XFNTM08S9iH53agRERGBRo0aFTLaTyMThR1RSPlKS0uDgYEBUlNTi+xEpE9TXDOZF3bG8oJ6MOmPYmm34vxmxdIuUUnzOb6HX758idjYWFhaWkJLS6tYtkFfp4KeWxzjRkRERKQkmLgRERERKQmOcaMv1rXYOEWHQEREVKTY40ZERESkJBSauM2cORMymUzuZWtrKy1/+fIlvL29UaZMGejq6qJbt25ITEyUayMuLg5ubm4oVaoUTExMMH78eOlOklzh4eGoV68eNDU1YWVlhcDAwDyxrFmzBhYWFtDS0oKjoyPOnz9fLPtMRERE9LEUfqm0Ro0aOH78uPT+zcn1fHx8cPjwYezduxcGBgYYOXIkvv32W5w5cwYAkJ2dDTc3N5iamuLs2bOIj4/HgAEDoK6ujnnz5gEAYmNj4ebmhmHDhmH79u0IDQ3FoEGDUL58eelW5t27d8PX1xcBAQFwdHTE8uXL4erqilu3bsHExOQzHg36mu2OXVAs7Y4F7yolIvpSKPxSqZqaGkxNTaVX7rPKUlNTsWnTJixduhStWrWCg4MDtmzZgrNnz+LcuXMAgKNHj+LGjRvYtm0b7O3t0b59e/zwww9Ys2YNMjMzAQABAQGwtLTEkiVLUL16dYwcORLdu3fHsmXLpBiWLl2KwYMHw9PTE3Z2dggICECpUqWwefPmz39AiIiIiN5B4YnbnTt3YGZmhipVqqBv376Ii3s9oPzSpUt49eoVXFxcpLq2traoVKmS9FiOiIgI1KpVS272Y1dXV6SlpSEqKkqq82YbuXVy28jMzMSlS5fk6qioqMDFxSXP4z/elJGRgbS0NLkXERERUXFSaOLm6OiIwMBABAcHY926dYiNjUWzZs3w9OlTJCQkQENDI88DXcuVKyc9uiIhISHPIyty33+oTlpaGl68eIH//vsP2dnZ+dZ5+xEZb/L394eBgYH0Mjc3/6hjQERERFRQCh3j1r59e+n/a9euDUdHR1SuXBl79uyBtra2AiP7MD8/P/j6+krv09LSmLwRERFRsVL4zQlvMjQ0hLW1NWJiYtCmTRtkZmYiJSVFrtctMTERpqamAABTU9M8d3/m3nX6Zp2370RNTEyEvr4+tLW1oaqqClVV1Xzr5LaRH01NTWhqan70vhIR0Zcj2rb6Z91e9ZvRharv4eGBlJQUBAUFwcPDA1u3boW/vz8mTZok1QkKCkLXrl0hhMAvv/yCnj17Ii4uDhUqVMjTXrVq1dCpUycsXboUwOthSU2bNkW7du1w+PBhubp3796FpaUlLl++DHt7+zxtBQYGYsyYMUhJSZHee3p6Ang9dElfXx/W1tZwc3PD6NGjYWBgUKh9/9IofIzbm549e4a///4b5cuXh4ODA9TV1REaGiotv3XrFuLi4uDk5AQAcHJywrVr15CUlCTVOXbsGPT19WFnZyfVebON3Dq5bWhoaMDBwUGuTk5ODkJDQ6U6REREXxItLS0sWLAAycnJ+S7/5ptvUKZMGWzdujXPslOnTiEmJgZeXl5S2aZNmzBq1CicOnUKDx8+/OT49PX1ER8fjwcPHuDs2bMYMmQIfvrpJ9jb2xdJ+8pMoYnbuHHjcPLkSdy9exdnz55F165doaqqij59+sDAwABeXl7w9fVFWFgYLl26BE9PTzg5OaFRo0YAgLZt28LOzg79+/fHlStXEBISgqlTp8Lb21vqDRs2bBj++ecfTJgwATdv3sTatWuxZ88e+Pj4SHH4+vpiw4YN2Lp1K6KjozF8+HCkp6dLGT8REdGXxMXFBaampvD39893ubq6Ovr375/vvKebN2+Go6MjatSoAeB1p8vu3bsxfPhwuLm55btOYclkMpiamqJ8+fKoXr06vLy8cPbsWTx79gwTJkz45PaVmUIvlT548AB9+vTB48ePYWxsjKZNm+LcuXMwNjYGACxbtgwqKiro1q0bMjIy4OrqirVr10rrq6qq4tChQxg+fDicnJygo6MDd3d3zJ49W6pjaWmJw4cPw8fHBytWrEDFihWxceNGaQ43AOjVqxcePXqE6dOnIyEhAfb29ggODs5zwwJRcepw5W9Fh0BEXwlVVVXMmzcP3333Hb7//ntUrFgxTx0vLy8sXboUp06dQvPmzQG8TtL27dsnN6XWnj17YGtrCxsbG/Tr1w9jxoyBn58fZDJZkcZsYmKCvn37YvPmzcjOzoaqqmqRtq8sFJq47dq1673LtbS0sGbNGqxZs+addSpXrozff//9ve20bNkSly9ffm+dkSNHYuTIke+tQ0RE9KXo2rUr7O3tMWPGDGzatCnPcjs7OzRq1AibN2+WErc9e/ZACIHevXtL9TZt2oR+/foBANq1a4fU1FScPHkSLVu2LPKYbW1t8fTpUzx+/PirnSC/RI1xIyIios9nwYIF0jCh/AwcOBD79u3D06dPAby+TNqjRw/o6ekBeD32/Pz58+jTpw+A15Pq9+rVK99EsCgIIQCgyHvzlAkTNyIioq9U8+bN4erqCj8/v3yX5/as7dmzB3fu3MGZM2fy3JSQlZUFMzMzqKmpQU1NDevWrcMvv/yC1NTUIo83Ojoa+vr6KFOmTJG3rSxK1HQgRERE9HnNnz8f9vb2sLGxybNMT08PPXr0wObNm/H333/D2toazZq9fv5xVlYWfvrpJyxZsgRt27aVW69Lly7YuXMnhg0bVmRxJiUlYceOHejSpQtUVL7eficmbkRERF+xWrVqoW/fvli5cmW+y728vNCsWTNER0dj4sSJUvmhQ4eQnJwMLy+vPHOrdevWDZs2bZJL3G7dupWn7dw7U98mhEBCQgKEEEhJSUFERATmzZsHAwMDzJ8//2N284vBxI2IiOgrN3v2bOzevTvfZU2bNoWNjQ1iYmIwYMAAqXzTpk1wcXHJd0Lcbt26YeHChbh69Sr09fUBQO6Ghlz379/Pd5tpaWkoX748ZDIZ9PX1YWNjA3d3d4wePVpq72slE7kj/eiTpKWlwcDAAKmpqV/9SVVizCym2bVnFv24DaD4Zl4v7AzrRMrqc3wPv3z5ErGxsbC0tISWllaxbIO+TgU9t77ei8RERERESqbQidtff/2Fa9euSe9//fVXdOnSBZMnT0ZmZmaRBkdERERE/1PoxG3o0KG4ffs2AOCff/5B7969UapUKezdu/erfwwFERERUXEqdOJ2+/Zt2NvbAwD27t2L5s2bY8eOHQgMDMQvv/xS1PERERER0f8rdOImhEBOTg4A4Pjx4+jQoQMAwNzcHP/991/RRkdEREREkkInbvXr18ecOXPw888/4+TJk3BzcwMAxMbG8qHsRERERMWo0Inb8uXL8ddff2HkyJGYMmUKrKysAAD79u1D48aNizxAIiIiInqt0BPw1q5dW+6u0lyLFi2CqqpqkQRFRERERHkV2ZMTOBEhERERUfEqdOJWunRpyGSyPOUymQxaWlqwsrKCh4cHPD09iyRAIiIiInqt0Inb9OnTMXfuXLRv3x4NGzYEAJw/fx7BwcHw9vZGbGwshg8fjqysLAwePLjIAyYiIipp1gw78Vm35x3QqlD1PTw8sHXrVvj7+2PSpElSeVBQELp27Yrcp19mZ2dj5cqV2Lx5M+7cuQNtbW00atQIU6dORZMmTQAALVu2xMmTJ9+5rRYtWiA8PPy98VhYWODevXt5yt+O75dffsGqVatw+fJlZGdno0qVKujevTtGjhwJIyMjBAYGYsyYMUhJSXnnfqekpCAoKEjuOACAuro6KlWqhAEDBmDy5MlQU3udEm3YsAGrV6/G33//DTU1NVhaWqJnz57w8/MDAMycOROzZs3Ksy0bGxvcvHnzvftdFAqduJ0+fRpz5szBsGHD5Mp//PFHHD16FL/88gtq166NlStXMnEjIiIqIbS0tLBgwQIMHToUpUuXzrNcCIHevXvj+PHjWLRoEVq3bo20tDSsWbMGLVu2xN69e9GlSxfs379felLS/fv30bBhQxw/fhw1atQAAGhoaBQontmzZ+fJE/T09KT/nzJlChYsWAAfHx/MmzcPZmZmuHPnDgICAvDzzz9j9OjRH3Uc2rVrhy1btiAjIwO///47vL29oa6uDj8/P2zevBljxozBypUr0aJFC2RkZODq1au4fv26XBs1atTA8ePH5cpyE7/iVuithISEYMGCBXnKW7dujbFjxwIAOnToIJcxExERkWK5uLggJiYG/v7+WLhwYZ7le/bswb59+3Dw4EF06tRJKl+/fj0eP36MQYMGoU2bNjAyMpKWvXz5EgBQpkwZmJqaFioePT29d65z/vx5zJs3D8uXL5dL0CwsLNCmTZt39rAVhKamprTd4cOH48CBAzh48CD8/Pxw8OBB9OzZE15eXlL93IT0TWpqaoXe36JS6OlAjIyM8Ntvv+Up/+2336QPMz09XS5rJiIiIsVSVVXFvHnzsGrVKjx48CDP8h07dsDa2louacs1duxYPH78GMeOHfscoWL79u3Q1dXFiBEj8l1uaGhYZNvS1taWehBNTU1x7ty5fC/jlhSFTtymTZuG8ePH45tvvsGcOXMwZ84cdO7cGRMmTMCMGTMAAMeOHUOLFi2KPFgiIiL6eF27doW9vb30e/2m27dvo3r16vmul1ue+6zyojBx4kTo6urKvf744w8AwJ07d1ClShWoq6sX2fbeJoTA8ePHERISglatXo8ZnDFjBgwNDWFhYQEbGxt4eHhgz5490hOjcl27di1P7G8PISsuhb5UOnjwYNjZ2WH16tXYv38/gNcD8k6ePClNwJt7yZSIiIhKlgULFqBVq1YYN25cnmW5Nyl8DuPHj4eHh4dcWYUKFYo9jkOHDkFXVxevXr1CTk4OvvvuO8ycORMAUL58eUREROD69es4deoUzp49C3d3d2zcuBHBwcFQUXnd32VjY4ODBw/Ktauvr19sMb/po0bSNWnSRLq7hIiIiJRH8+bN4erqCj8/P7nEydraGtHR0fmuk1tubW1dZHGULVtWevrS26ytrXH69Gm8evWqyHvdnJ2dsW7dOmhoaMDMzCzfmwpq1qyJmjVrYsSIERg2bBiaNWuGkydPwtnZGcDrGzDeFXtxK/Sl0ri4uPe+iIiIqGSbP38+fvvtN0REREhlvXv3xp07d/Idx75kyRKUKVMGbdq0+Szxfffdd3j27BnWrl2b7/JPuTlBR0cHVlZWqFSpUoHuBLWzswPwevx+SVDoHjcLC4t8J+DNlZ2d/UkBERERUfGqVasW+vbti5UrV0plvXv3xt69e+Hu7p5nOpCDBw9i79690NHRKbIYnj59ioSEBLmyUqVKQV9fH46OjpgwYQLGjh2Lf//9F127doWZmRliYmIQEBCApk2bSnebZmdnIzIyUq4dTU3Nd47Xe5/hw4fDzMwMrVq1QsWKFREfH485c+bA2NgYTk5OUr2srKw8sctkMpQrV67Q2yysQiduly9flnv/6tUrXL58GUuXLsXcuXOLLDAiIiIqPrNnz8bu3bul9zKZDHv27MHy5cuxbNkyjBgxAlpaWnByckJ4eHiRD5GaPn06pk+fLlc2dOhQBAQEAHg9Fs/BwQFr1qxBQEAAcnJyULVqVXTv3h3u7u7SOs+ePUPdunXl2qlatSpiYmIKHZOLiws2b96MdevW4fHjxyhbtiycnJwQGhqKMmXKSPWioqJQvnx5uXU1NTWl6VGKk0wU0QjAw4cPY9GiRR+cLflLlZaWBgMDA6Smpn62AYr0ATMNiqnd1GJpNtq28H8dFkT1m/mPWSH60nyO7+GXL18iNjYWlpaWfEY3FamCnluFHuP2LjY2Nrhw4UJRNUdEREREbyn0pdK0tDS590IIxMfHY+bMmahWrVqRBUZERETKZ/v27Rg6dGi+yypXroyoqKjPHNGXpdCJm6GhYZ6bE4QQMDc3x65du4osMCIiIlI+33zzDRwdHfNdVpwT6n4tCp24hYWFyb1XUVGBsbExrKysPtsDVomIiKhk0tPT42Mvi1GhMy0+yoqIiIhIMQqduD1+/Fi6Jfb+/fvYsGEDXrx4gU6dOqF58+ZFHiARERERvVbgu0qvXbsGCwsLmJiYwNbWFpGRkWjQoAGWLVuG9evXo1WrVggKCirGUImIiIi+bgVO3CZMmIBatWrh1KlTaNmyJTp27Ag3NzekpqYiOTkZQ4cOxfz584szViIiIqKvWoETtwsXLmDu3Llo0qQJFi9ejIcPH2LEiBFQUVGBiooKRo0ahZs3b350IPPnz4dMJsOYMWOkspcvX8Lb2xtlypSBrq4uunXrhsTERLn14uLi4ObmhlKlSsHExATjx49HVlaWXJ3w8HDUq1cPmpqasLKyQmBgYJ7tr1mzBhYWFtDS0oKjoyPOnz//0ftCREREVBwKnLg9efIEpqamAABdXV3o6OigdOnS0vLSpUvj6dOnHxXEhQsX8OOPP6J27dpy5T4+Pvjtt9+wd+9enDx5Eg8fPsS3334rLc/OzoabmxsyMzNx9uxZbN26FYGBgXKP0IiNjYWbmxucnZ0RGRmJMWPGYNCgQQgJCZHq7N69G76+vpgxYwb++usv1KlTB66urkhKSvqo/SEiIiIqDoW6OeHt+dve97D5gnr27Bn69u2LDRs2YM6cOVJ5amoqNm3ahB07dqBVq1YAgC1btqB69eo4d+4cGjVqhKNHj+LGjRs4fvw4ypUrB3t7e/zwww+YOHEiZs6cCQ0NDQQEBMDS0hJLliwBAFSvXh2nT5/GsmXL4OrqCgBYunQpBg8eDE9PTwBAQEAADh8+jM2bN2PSpEmfvI9ERPRlW9Kr42fd3tjdhwpVPyAgAOPHj0dycrI0ddezZ89QunRpNGnSRO5xleHh4XB2dkZMTAyqVq2Ks2fPYs6cOYiIiMCLFy9QrVo1eHp6YvTo0VBVVZXWk8lk0NTUxK1bt1C5cmWpvEuXLjA0NERgYOAH84YZM2bAw8MDlpaWeZb17dsX27Ztw927d2FpaYnLly/D3t4ev//+O7p06YJz586hXr16Uv0lS5bA398f169flzqevgSFeuSVh4cHvv32W3z77bd4+fIlhg0bJr0fOHDgRwXg7e0NNzc3uLi4yJVfunQJr169kiu3tbVFpUqVEBERAQCIiIhArVq1UK5cOamOq6sr0tLSpJmZIyIi8rTt6uoqtZGZmYlLly7J1VFRUYGLi4tUh4iISJk5Ozvj2bNnuHjxolT2xx9/wNTUFH/++afcw9HDwsJQqVIlVK1aFQcOHECLFi1QsWJFhIWF4ebNmxg9ejTmzJmD3r174+3HnctksjwPjn9TfHy89Fq+fDn09fXlysaNGyfVPX78uNyyNWvW5Ntmhw4dMGDAAAwYMAAZGRkAgBs3bmDq1KlYs2bNF5W0AYVI3Nzd3WFiYgIDAwMYGBigX79+MDMzk96bmJhgwIABhdr4rl278Ndff8Hf3z/PsoSEBGhoaMDQ0FCuvFy5ckhISJDqvJm05S7PXfa+OmlpaXjx4gX+++8/ZGdn51snt438ZGRkIC0tTe5FRERUEtnY2KB8+fJ5etY6d+4MS0tLnDt3Tq7c2dkZ6enpGDx4ML755husX78e9vb2sLCwwKBBg7B161bs27cPe/bskdvOyJEjsW3bNly/fj3fOExNTaWXgYEBZDKZXJmurq5Ut0yZMnnqv8uyZcvw7NkzzJgxA1lZWXB3d0enTp3Qq1evjzxiJVeBL5Vu2bKlSDd8//59jB49GseOHYOWllaRtv05+Pv7Y9asWYoOg4iIqECcnZ0RFhYmDQEKCwvDhAkTkJ2djbCwMLRs2RIvXrzAn3/+iYEDB+Lo0aN4/PixXC9Yrk6dOsHa2ho7d+6US46aNGmC27dvY9KkSTh0qHCXcz+Fnp4eNm/eDFdXV8TGxuL+/fsIDg7+bNv/nAp1qbQoXbp0CUlJSahXrx7U1NSgpqaGkydPYuXKlVBTU0O5cuWQmZmJlJQUufUSExOlbk9TU9M8d5nmvv9QHX19fWhra6Ns2bJQVVXNt877ulf9/PyQmpoqve7fv/9Rx4GIiOhzcHZ2xpkzZ5CVlYWnT5/i8uXLaNGiBZo3by71xEVERCAjIwPOzs64ffs2gNdjw/Nja2sr1XmTv78/goOD8ccff3xSvI0bN4aurq70unz58nvrt2rVCt27d8eePXuwcuVK6WEBXxqFPVy0devWuHbtmlyZp6cnbG1tMXHiRJibm0NdXR2hoaHo1q0bAODWrVuIi4uDk5MTAMDJyQlz585FUlISTExMAADHjh2Dvr4+7OzspDq///673HaOHTsmtaGhoQEHBweEhoaiS5cuAICcnByEhoZi5MiR74xfU1MTmpqan34giP5fT7/i+ed47cNViOgr0LJlS6Snp+PChQtITk6GtbU1jI2N0aJFC3h6euLly5cIDw9HlSpVUKlSJWm9t8exfYidnR0GDBiASZMm4cyZMx8d7+7du+WSRnNz8/fW//fffxEcHIxSpUrhjz/+QM+ePT962yWZwhI3PT091KxZU65MR0cHZcqUkcq9vLzg6+sLIyMj6OvrY9SoUXByckKjRo0AAG3btoWdnR369++PhQsXIiEhAVOnToW3t7eUVA0bNgyrV6/GhAkTMHDgQJw4cQJ79uzB4cOHpe36+vrC3d0d9evXR8OGDbF8+XKkp6dLd5kSEREpOysrK+kmg+TkZOnZ42ZmZjA3N8fZs2cRFhYmzeRgbW0NAIiOjkbjxo3ztBcdHS11krxt1qxZsLa2/qQnKpmbm8PKyqrA9QcPHgwHBwdMmTIFbdq0Qffu3b/I56srLHEriGXLlkFFRQXdunVDRkYGXF1dsXbtWmm5qqoqDh06hOHDh8PJyQk6Ojpwd3fH7NmzpTqWlpY4fPgwfHx8sGLFClSsWBEbN26UpgIBgF69euHRo0eYPn06EhISYG9vj+Dg4Dw3LBARESkzZ2dnhIeHIzk5GePHj5fKmzdvjiNHjuD8+fMYPnw4gNedI0ZGRliyZEmexO3gwYO4c+cOfvjhh3y3Y25ujpEjR2Ly5MmoWrVq8e3Q/9u4cSNOnz6Na9euoXLlyhg+fDgGDhyIq1evQkdHp9i3/zkVaIxbvXr1kJycDACYPXs2nj9/XizBhIeHY/ny5dJ7LS0trFmzBk+ePEF6ejr279+fZ9xZ5cqV8fvvv+P58+d49OgRFi9eLM1Rk6tly5a4fPkyMjIy8Pfff8PDwyPPtkeOHIl79+4hIyMDf/75JxwdHYtjF4mIiBTG2dkZp0+fRmRkpFxvVIsWLfDjjz8iMzMTzs7OAF5fBfvxxx/x66+/YsiQIbh69Sru3r2LTZs2wcPDA927d3/v5Ug/Pz88fPgQx48fL9Z9unfvHnx9fbF48WJp/rgFCxZAJpN9kXOxFihxi46ORnp6OoDX3Z/Pnj0r1qCIiIio6Dk7O+PFixewsrKSu6rUokULPH36VJo2JFf37t0RFhaGuLg4NGvWDDY2Nli2bBmmTJmCXbt2vXdCXSMjI0ycOFFujriiJoSAl5cXnJycMGTIEKm8VKlSCAwMxLp163Dy5Mli274iyEQBRh06OTlBV1cXTZs2xaxZszBu3Di5uVbe9L6J975kaWlpMDAwQGpqKvT19RUdDgHAzHfP+fNp7aYWS7O1ttYqlnavufP2BPo6fI7v4ZcvXyI2NhaWlpZKOZUVlVwFPbcKNMYtMDAQM2bMwKFDhyCTyXDkyJE8lyOBD8+YTEREREQfr0CJm42NDXbt2gXg9eOgQkNDpek3iIiIiOjzKPRdpTk5OcURBxERERF9wEdNB/L3339j+fLliI6OBvB6sr3Ro0d/llt+iYiIiL5WhX7kVUhICOzs7HD+/HnUrl0btWvXxp9//okaNWrg2LFjxREjEREREeEjetwmTZoEHx8fzJ8/P0/5xIkT0aZNmyILjoiIiIj+p9A9btHR0fDy8spTPnDgQNy4caNIgiIiIiKivAqduBkbGyMyMjJPeWRkJO80JSIiIipGhb5UOnjwYAwZMgT//POP9OyyM2fOYMGCBfD19S3yAImIiIjotUInbtOmTYOenh6WLFkCPz8/AICZmRlmzpyJ77//vsgDJCIiIqLXCp24yWQy+Pj4wMfHB0+fPgUA6OnpFXlgREREyuLBpD8+6/Yqzm9WqPoBAQEYP348kpOTpScfPXv2DKVLl0aTJk0QHh4u1Q0PD4ezszNiYmJQtWpVnD17FnPmzEFERARevHiBatWqwdPTE6NHj4aqqqq03pvPLdXT04ONjQ2mTp2Kzp07S+WBgYEYM2YMUlJSpLLo6Gi0bdsWjRo1wvbt26GqqopFixYhMDAQ9+7dg7a2NqpVq4bBgwdj0KBBAAAPDw9s3bo1z37euXMHVlZWAID79+9jxowZCA4Oxn///Yfy5cujS5cumD59OsqUKSOt07JlS+l5ppqamqhUqRI8PT0xadIkaZ/u3r0LS0tLqKioIC4uDhUqVJDWj4+Ph7m5ObKzsxEbGwsLCwupfn4iIiLQqFGj939g71HoMW5v0tPTY9JGRERUwjk7O+PZs2e4ePGiVPbHH3/A1NQUf/75p9yD4MPCwlCpUiVUrVoVBw4cQIsWLVCxYkWEhYXh5s2bGD16NObMmYPevXvj7cedb9myBfHx8bh48SKaNGmC7t2749q1dz8v+cKFC2jWrBnatWuH3bt3Q0NDA7NmzcKyZcvwww8/4MaNGwgLC8OQIUPkkj0AaNeuHeLj4+VeucnSP//8g/r16+POnTvYuXMnYmJiEBAQgNDQUDg5OeHJkydybQ0ePBjx8fG4desW/Pz8MH36dAQEBOSJt0KFCvjpp5/kyrZu3SqXyL3p+PHjeWJ0cHB45/EoiE9K3IiIiKjks7GxQfny5fP0rHXu3BmWlpY4d+6cXLmzszPS09MxePBgfPPNN1i/fj3s7e1hYWGBQYMGYevWrdi3bx/27Nkjtx1DQ0OYmprC2toaP/zwA7KyshAWFpZvTCdOnECrVq3g5eWFDRs2QEXldUpy8OBBjBgxAj169IClpSXq1KkDLy8vjBs3Tm59TU1NmJqayr1yewC9vb2hoaGBo0ePokWLFqhUqRLat2+P48eP499//8WUKVPk2ipVqhRMTU1RuXJleHp6onbt2vnOTevu7o4tW7bIlW3ZsgXu7u757mOZMmXyxKiurp5v3YJi4kZERPQVcHZ2lkuiwsLC0LJlS7Ro0UIqf/HiBf788084Ozvj6NGjePz4cZ6ECQA6deoEa2tr7Ny5M99tZWVlYdOmTQAADQ2NPMsPHDgANzc3TJ06FQsWLJBbZmpqihMnTuDRo0cftZ9PnjxBSEgIRowYAW1t7Txt9+3bF7t3787TWwgAQgj88ccfuHnzZr5xf/PNN0hOTsbp06cBAKdPn0ZycjI6der0UbF+DCZuREREXwFnZ2ecOXMGWVlZePr0KS5fvowWLVqgefPmUk9cREQEMjIy4OzsjNu3bwMAqlevnm97tra2Up1cffr0ga6uLjQ1NeHj4wMLCwv07NlTrs6zZ8/Qo0cPjB8/HhMnTszT7tKlS/Ho0SOYmpqidu3aGDZsGI4cOZKn3qFDh6Crqyu9evToAeD1ODchxDvjrl69OpKTk+USw7Vr10pxN2/eHDk5OfnecKmuro5+/fph8+bNAIDNmzejX79+7+xFa9y4sVyMurq6+dYrjEIlbq9evULr1q1x586dT94wERERfT4tW7ZEeno6Lly4gD/++APW1tYwNjZGixYtpHFu4eHhqFKlCipVqiStl1/P1LssW7YMkZGROHLkCOzs7LBx40YYGRnJ1dHW1kabNm2wYcMG6Znnb7Kzs8P169dx7tw5DBw4EElJSejUqZN0Y0IuZ2dnREZGSq+VK1fKLS9M3H379kVkZCTOnDmD9u3bY8qUKdKUZ28bOHAg9u7di4SEBOzduxcDBw58Z7u7d++WizG/eXALq1CJm7q6Oq5evfrJGyUiIqLPy8rKSrrJICwsDC1atADwekovc3NznD17FmFhYWjVqhUAwNraGgDyTa5yy3Pr5DI1NYWVlRXatm2LLVu2oFevXkhKSpKro6qqiqCgINSrVw/Ozs75tq+iooIGDRpgzJgx2L9/PwIDA7Fp0ybExsZKdXR0dGBlZSW9ypcvL+2nTCZ7b9ylS5eGsbGxVGZgYAArKys0aNAAe/bswerVq3H8+PF8169VqxZsbW3Rp08fVK9eHTVr1sy3HgCYm5vLxZh7x+unKPSl0n79+knXrYmIiEh5ODs7Izw8HOHh4WjZsqVU3rx5cxw5cgTnz5+Hs7MzAKBt27YwMjLCkiVL8rRz8OBB3LlzB3369Hnntho2bAgHBwfMnTs3zzJNTU3s378fDRo0gLOz8wcfmWlnZwcASE9P/+A+lilTBm3atMHatWvx4sULuWUJCQnYvn07evXqJTd9yZt0dXUxevRojBs37p29dgMHDkR4ePh7e9uKS6ETt6ysLKxbtw7169fH0KFD4evrK/ciIiKiksnZ2RmnT59GZGSk1OMGAC1atMCPP/6IzMxMKXHT0dHBjz/+iF9//RVDhgzB1atXcffuXWzatAkeHh7o3r17nvFrbxszZgx+/PFH/Pvvv3mWaWpq4pdffoGjoyOcnZ0RFRUFAOjevTuWLVuGP//8E/fu3UN4eDi8vb1hbW0NW1vbAu3n6tWrkZGRAVdXV5w6dQr3799HcHAw2rRpgwoVKuSbTL5p6NChuH37Nn755Zd8lw8ePBiPHj3Kc/n2bY8fP0ZCQoLc682pVz5GoRO369evo169etDT08Pt27dx+fJl6VUU126JiIioeDg7O+PFixewsrJCuXLlpPIWLVrg6dOn0rQhubp3746wsDDExcWhWbNmsLGxwbJlyzBlyhTs2rXrnb1Wudq1awdLS8t3JkoaGhrYt28fGjduDGdnZ1y/fh2urq747bffpDtX3d3dYWtri6NHj0qTB39ItWrVcPHiRVSpUgU9e/ZE1apVMWTIEDg7OyMiIiLPuLu3GRkZYcCAAZg5cyZycnLyLFdTU0PZsmU/GI+LiwvKly8v9woKCirQPryLTBRm9B69U1paGgwMDJCamgp9fX1Fh0MAMNOgmNpNLZZma22tVSztXnN/9+SXRF+Sz/E9/PLlS8TGxsLS0hJaWlrFsg36OhX03Pro6UBiYmIQEhIiXT9m/kdERERUvAqduD1+/BitW7eGtbU1OnTogPj4eACAl5cXxo4dW+QBEhEREdFrhU7cfHx8oK6ujri4OJQqVUoq79WrF4KDg4s0OCIiIiL6n4KN8nvD0aNHERISgooVK8qVV6tWDffu3SuywIiIiIhIXqF73NLT0+V62nI9efIEmpqaRRIUERFRScZx3VTUCnpOFTpxa9asGX766SfpvUwmQ05ODhYuXCjN/UJERPQlUlVVBQBkZmYqOBL60jx//hwA3vnc01yFvlS6cOFCtG7dGhcvXkRmZiYmTJiAqKgoPHnyBGfOnPm4aImIiJSAmpoaSpUqhUePHkFdXR0qKh89OQMRgNc9bc+fP0dSUhIMDQ2lPw7epdCJW82aNXH79m2sXr0aenp6ePbsGb799lt4e3vLTdpHRET0pZHJZChfvjxiY2M5rpuKlKGhIUxNTT9Yr9CJG/D6YaxTpkz5mFWJiIiUmoaGBqpVq8bLpVRk1NXVP9jTluujErfk5GRs2rQJ0dHRAF4//NXT0/ODj5AgIiL6EqioqPDJCaQQhb44f+rUKVhYWGDlypVITk5GcnIyVq5cCUtLS5w6dao4YiQiIiIifESPm7e3N3r16oV169ZJ3XrZ2dkYMWIEvL29ce0an4tIREREVBwK3eMWExODsWPHyl2LVVVVha+vL2JiYoo0OCIiIiL6n0InbvXq1ZPGtr0pOjoaderUKVRb69atQ+3ataGvrw99fX04OTnhyJEj0vKXL1/C29sbZcqUga6uLrp164bExES5NuLi4uDm5oZSpUrBxMQE48ePR1ZWllyd8PBw1KtXD5qamrCyskJgYGCeWNasWQMLCwtoaWnB0dER58+fL9S+EBERERW3Al0qvXr1qvT/33//PUaPHo2YmBg0atQIAHDu3DmsWbMG8+fPL9TGK1asiPnz56NatWoQQmDr1q3o3LkzLl++jBo1asDHxweHDx/G3r17YWBggJEjR+Lbb7+V5ovLzs6Gm5sbTE1NcfbsWcTHx2PAgAFQV1fHvHnzAACxsbFwc3PDsGHDsH37doSGhmLQoEEoX748XF1dAQC7d++Gr68vAgIC4OjoiOXLl8PV1RW3bt2CiYlJofaJiIiIqLjIRAGesaCiogKZTPbBxzHIZDJkZ2d/UkBGRkZYtGgRunfvDmNjY+zYsQPdu3cHANy8eRPVq1dHREQEGjVqhCNHjqBjx454+PAhypUrBwAICAjAxIkT8ejRI2hoaGDixIk4fPgwrl+/Lm2jd+/eSElJQXBwMADA0dERDRo0wOrVqwEAOTk5MDc3x6hRozBp0qQCxZ2WlgYDAwOkpqZCX1//k44BFZGZBsXUbmqxNFtra61iafeaO8ed0teB38P0NShQj1tsbGxxx4Hs7Gzs3bsX6enpcHJywqVLl/Dq1Su4uLhIdWxtbVGpUiUpcYuIiECtWrWkpA0AXF1dMXz4cERFRaFu3bqIiIiQayO3zpgxYwC8fmzJpUuX4OfnJy1XUVGBi4sLIiIi3hlvRkYGMjIypPdpaWmfegiIiIiI3qtAiVvlypWLLYBr167ByckJL1++hK6uLg4cOAA7OztERkZCQ0MDhoaGcvXLlSuHhIQEAEBCQoJc0pa7PHfZ++qkpaXhxYsXSE5ORnZ2dr51bt68+c64/f39MWvWrI/aZyIiIqKP8VET8D58+BCnT59GUlIScnJy5JZ9//33hWrLxsYGkZGRSE1Nxb59++Du7o6TJ09+TFiflZ+fH3x9faX3aWlpMDc3V2BERERE9KUrdOIWGBiIoUOHQkNDA2XKlIFMJpOWyWSyQiduGhoasLKyAgA4ODjgwoULWLFiBXr16oXMzEykpKTI9bolJiZKz/IyNTXNc/dn7l2nb9Z5+07UxMRE6OvrQ1tbG6qqqlBVVc23zvueGaapqQlNTc1C7SsRERHRpyj0dCDTpk3D9OnTkZqairt37yI2NlZ6/fPPP58cUE5ODjIyMuDg4AB1dXWEhoZKy27duoW4uDg4OTkBAJycnHDt2jUkJSVJdY4dOwZ9fX3Y2dlJdd5sI7dObhsaGhpwcHCQq5OTk4PQ0FCpDhEREVFJUOget+fPn6N3795QUSl0zpeHn58f2rdvj0qVKuHp06fYsWMHwsPDERISAgMDA3h5ecHX1xdGRkbQ19fHqFGj4OTkJE1D0rZtW9jZ2aF///5YuHAhEhISMHXqVHh7e0u9YcOGDcPq1asxYcIEDBw4ECdOnMCePXtw+PBhKQ5fX1+4u7ujfv36aNiwIZYvX4709HR4enp+8j4SERERFZVCJ25eXl7Yu3dvgafJeJ+kpCQMGDAA8fHxMDAwQO3atRESEoI2bdoAAJYtWwYVFRV069YNGRkZcHV1xdq1a6X1VVVVcejQIQwfPhxOTk7Q0dGBu7s7Zs+eLdWxtLTE4cOH4ePjgxUrVqBixYrYuHGjNIcbAPTq1QuPHj3C9OnTkZCQAHt7ewQHB+e5YYGIiIhIkQo0j9ubsrOz0bFjR7x48QK1atWCurq63PKlS5cWaYDKgvMHlUCcxw0A53Gjrwe/h+lrUOgeN39/f4SEhMDGxgYA8tycQERERETFo9CJ25IlS7B582Z4eHgUQzhERERE9C6FvsNAU1MTTZo0KY5YiIiIiOg9Cp24jR49GqtWrSqOWIiIiIjoPQp9qfT8+fM4ceIEDh06hBo1auS5OWH//v1FFhwRERER/U+hEzdDQ0N8++23xRELEREREb1HoRO3LVu2FEccRERERPQBn/74AyIiIiL6LArd42Zpafne+dqK4nmlRERERJRXoRO3MWPGyL1/9eoVLl++jODgYIwfP76o4iIiIiKitxQ6cRs9enS+5WvWrMHFixc/OSAiIiIiyl+RjXFr3749fvnll6JqjoiIiIjeUuget3fZt28fjIyMiqo5oq/Otdg4RYdAREQlXKETt7p168rdnCCEQEJCAh49eoS1a9cWaXBERERE9D+FTty6dOki915FRQXGxsZo2bIlbG1tiyouIiIiInpLoRO3GTNmFEccRERERPQBnICXiIiISEkUuMdNRUXlvRPvAoBMJkNWVtYnB0VEREREeRU4cTtw4MA7l0VERGDlypXIyckpkqCIiIiIKK8CJ26dO3fOU3br1i1MmjQJv/32G/r27YvZs2cXaXBERERE9D8fNcbt4cOHGDx4MGrVqoWsrCxERkZi69atqFy5clHHR0RERET/r1CJW2pqKiZOnAgrKytERUUhNDQUv/32G2rWrFlc8RERERHR/yvwpdKFCxdiwYIFMDU1xc6dO/O9dEpERERExafAidukSZOgra0NKysrbN26FVu3bs233v79+4ssOCIiIiL6nwInbgMGDPjgdCBEREREVHwKnLgFBgYWYxhERERE9CF8cgIRERGRkmDiRkRERKQkmLgRERERKQkmbkRERERKgokbERERkZJg4kZERESkJJi4ERERESkJJm5ERERESoKJGxEREZGSUGji5u/vjwYNGkBPTw8mJibo0qULbt26JVfn5cuX8Pb2RpkyZaCrq4tu3bohMTFRrk5cXBzc3NxQqlQpmJiYYPz48cjKypKrEx4ejnr16kFTUxNWVlb5PglizZo1sLCwgJaWFhwdHXH+/Pki32ciIiKij6XQxO3kyZPw9vbGuXPncOzYMbx69Qpt27ZFenq6VMfHxwe//fYb9u7di5MnT+Lhw4f49ttvpeXZ2dlwc3NDZmYmzp49i61btyIwMBDTp0+X6sTGxsLNzQ3Ozs6IjIzEmDFjMGjQIISEhEh1du/eDV9fX8yYMQN//fUX6tSpA1dXVyQlJX2eg0FERET0ATIhhFB0ELkePXoEExMTnDx5Es2bN0dqaiqMjY2xY8cOdO/eHQBw8+ZNVK9eHREREWjUqBGOHDmCjh074uHDhyhXrhwAICAgABMnTsSjR4+goaGBiRMn4vDhw7h+/bq0rd69eyMlJQXBwcEAAEdHRzRo0ACrV68GAOTk5MDc3ByjRo3CpEmTPhh7WloaDAwMkJqaCn19/aI+NPQxZhoUU7upxdSuksVLVMLwe5i+BiVqjFtq6usfGCMjIwDApUuX8OrVK7i4uEh1bG1tUalSJURERAAAIiIiUKtWLSlpAwBXV1ekpaUhKipKqvNmG7l1ctvIzMzEpUuX5OqoqKjAxcVFqkNERESkaGqKDiBXTk4OxowZgyZNmqBmzZoAgISEBGhoaMDQ0FCubrly5ZCQkCDVeTNpy12eu+x9ddLS0vDixQskJycjOzs73zo3b97MN96MjAxkZGRI79PS0gq5x0RERESFU2J63Ly9vXH9+nXs2rVL0aEUiL+/PwwMDKSXubm5okMiIiKiL1yJSNxGjhyJQ4cOISwsDBUrVpTKTU1NkZmZiZSUFLn6iYmJMDU1leq8fZdp7vsP1dHX14e2tjbKli0LVVXVfOvktvE2Pz8/pKamSq/79+8XfseJiIiICkGhiZsQAiNHjsSBAwdw4sQJWFpayi13cHCAuro6QkNDpbJbt24hLi4OTk5OAAAnJydcu3ZN7u7PY8eOQV9fH3Z2dlKdN9vIrZPbhoaGBhwcHOTq5OTkIDQ0VKrzNk1NTejr68u9iIiIiIqTQse4eXt7Y8eOHfj111+hp6cnjUkzMDCAtrY2DAwM4OXlBV9fXxgZGUFfXx+jRo2Ck5MTGjVqBABo27Yt7Ozs0L9/fyxcuBAJCQmYOnUqvL29oampCQAYNmwYVq9ejQkTJmDgwIE4ceIE9uzZg8OHD0ux+Pr6wt3dHfXr10fDhg2xfPlypKenw9PT8/MfGCIiIqJ8KDRxW7duHQCgZcuWcuVbtmyBh4cHAGDZsmVQUVFBt27dkJGRAVdXV6xdu1aqq6qqikOHDmH48OFwcnKCjo4O3N3dMXv2bKmOpaUlDh8+DB8fH6xYsQIVK1bExo0b4erqKtXp1asXHj16hOnTpyMhIQH29vYIDg7Oc8MCERERkaKUqHnclBnnDyqBlG1eNGWLl6iE4fcwfQ1KxM0JRERERPRhTNyIiIiIlAQTNyIiIiIlUWKenEBERMrtwaQ/iqXdivObFUu7RMqIPW5ERERESoKJGxEREZGS4KVSohLC4uWOYmn3brG0SkREisDEjYiohOKYMSJ6Gy+VEhERESkJJm5ERERESoKJGxEREZGSYOJGREREpCSYuBEREREpCSZuREREREqCiRsRERGRkmDiRkRERKQkOAEvEVEJtTt2QbG0OxbFMwGvssVLpIyYuBERUZHocOVvRYdA9MXjpVIiIiIiJcHEjYiIiEhJMHEjIiIiUhJM3IiIiIiUBBM3IiIiIiXBu0qJiEoordK+ig6BiEoY9rgRERERKQn2uBERlVCtwr2LqeXoYmqXiIobe9yIiIiIlAQTNyIiIiIlwUulRERUJHr6Fc9PyrViaZVIObHHjYiIiEhJMHEjIiIiUhJM3IiIiIiUBBM3IiIiIiXBmxOIiEqo6r0fKjoEIiph2ONGREREpCSYuBEREREpCYUmbqdOnUKnTp1gZmYGmUyGoKAgueVCCEyfPh3ly5eHtrY2XFxccOfOHbk6T548Qd++faGvrw9DQ0N4eXnh2bNncnWuXr2KZs2aQUtLC+bm5li4cGGeWPbu3QtbW1toaWmhVq1a+P3334t8f4mIiIg+hUITt/T0dNSpUwdr1qzJd/nChQuxcuVKBAQE4M8//4SOjg5cXV3x8uVLqU7fvn0RFRWFY8eO4dChQzh16hSGDBkiLU9LS0Pbtm1RuXJlXLp0CYsWLcLMmTOxfv16qc7Zs2fRp08feHl54fLly+jSpQu6dOmC69evF9/OExERERWSTAghFB0EAMhkMhw4cABdunQB8Lq3zczMDGPHjsW4ceMAAKmpqShXrhwCAwPRu3dvREdHw87ODhcuXED9+vUBAMHBwejQoQMePHgAMzMzrFu3DlOmTEFCQgI0NDQAAJMmTUJQUBBu3rwJAOjVqxfS09Nx6NAhKZ5GjRrB3t4eAQEBBYo/LS0NBgYGSE1Nhb6+flEdFvoUMw2Kqd3UYmnWYtLhYmn37ny3YmmXPgMlO4drba1VLO1ecy/YsxP4PUxfgxI7xi02NhYJCQlwcXGRygwMDODo6IiIiAgAQEREBAwNDaWkDQBcXFygoqKCP//8U6rTvHlzKWkDAFdXV9y6dQvJyclSnTe3k1sndzv5ycjIQFpamtyLiIiIqDiV2OlAEhISAADlypWTKy9Xrpy0LCEhASYmJnLL1dTUYGRkJFfH0tIyTxu5y0qXLo2EhIT3bic//v7+mDVr1kfsGX0uFi93FEu7d4ulVSIiog8rsT1uJZ2fnx9SU1Ol1/379xUdEhEREX3hSmyPm6mpKQAgMTER5cuXl8oTExNhb28v1UlKSpJbLysrC0+ePJHWNzU1RWJiolyd3PcfqpO7PD+amprQ1NT8iD0jIvoyXYuNU3QIRF+8EtvjZmlpCVNTU4SGhkplaWlp+PPPP+Hk5AQAcHJyQkpKCi5duiTVOXHiBHJycuDo6CjVOXXqFF69eiXVOXbsGGxsbFC6dGmpzpvbya2Tux0iIiKikkChiduzZ88QGRmJyMhIAK9vSIiMjERcXBxkMhnGjBmDOXPm4ODBg7h27RoGDBgAMzMz6c7T6tWro127dhg8eDDOnz+PM2fOYOTIkejduzfMzMwAAN999x00NDTg5eWFqKgo7N69GytWrICvr68Ux+jRoxEcHIwlS5bg5s2bmDlzJi5evIiRI0d+7kNCRERE9E4KvVR68eJFODs7S+9zkyl3d3cEBgZiwoQJSE9Px5AhQ5CSkoKmTZsiODgYWlpa0jrbt2/HyJEj0bp1a6ioqKBbt25YuXKltNzAwABHjx6Ft7c3HBwcULZsWUyfPl1urrfGjRtjx44dmDp1KiZPnoxq1aohKCgINWvW/AxHgYiIiKhgSsw8bsqO8weVPMo2L5qyxUufgZLN46boePk9TF+DEjvGjYiIiIjkMXEjIiIiUhJM3IiIiIiUBBM3IiIiIiXBxI2IiIhISTBxIyIiIlISTNyIiIiIlAQTNyIiIiIlwcSNiIiISEkwcSMiIiJSEgp9VikREX05LF7uKJZ27xZLq0TKiT1uREREREqCiRsRERGRkmDiRkRERKQkmLgRERERKQnenEBEH+XBpD+Kpd2K85sVS7tERF8CJm5UIMX1Iw3wh5qIiKigmLhRgTwNGlJ8jc+PLr62iYiIviBM3Ijoo+yOXVAs7Y4Fe2CJiN6FiRsVSPXeDxUdAhER0VePiZuCcGA30efFf3NE9CVg4kZEH6XDlb8VHcIXj4+QIqK3MXFTkGIb7M+B/kT54pg8IvoSMHEjoq8CewiJ6EvAxI2IPoqy3bCibPESEeWHiZuC8EeEiIiICovPKiUiIiJSEkzciIiIiJQEEzciIiIiJcHEjYiIiEhJMHEjIiIiUhJM3IiIiIiUBBM3IiIiIiXBedyI6KPwOZpERJ8fe9yIiIiIlAQTt7esWbMGFhYW0NLSgqOjI86fP6/okIiIiIgA8FKpnN27d8PX1xcBAQFwdHTE8uXL4erqilu3bsHExKRIt8XLTERERFRYTNzesHTpUgwePBienp4AgICAABw+fBibN2/GpEmTFBydYhVXogkw2aTPg38sEdGXgJdK/19mZiYuXboEFxcXqUxFRQUuLi6IiIhQYGREREREr7HH7f/9999/yM7ORrly5eTKy5Urh5s3b+apn5GRgYyMDOl9amoqACAtLa1A28vJeP4J0b5bQbdfWMUVL6B8MTPe1xjva8UVL6B8MSs63tx6QohiiYOoJGDi9pH8/f0xa9asPOXm5uYKiOZ/DJYrdPMfRdliZrzFi/EWP2WLubDxPn36FAYGBsUSC5GiMXH7f2XLloWqqioSExPlyhMTE2Fqapqnvp+fH3x9faX3OTk5ePLkCcqUKQOZTFZkcaWlpcHc3Bz379+Hvr5+kbVbnJQtZsZbvBhv8VO2mIsrXiEEnj59CjMzsyJrk6ikYeL2/zQ0NODg4IDQ0FB06dIFwOtkLDQ0FCNHjsxTX1NTE5qamnJlhoaGxRafvr6+Unwhv0nZYma8xYvxFj9li7k44mVPG33pmLi9wdfXF+7u7qhfvz4aNmyI5cuXIz09XbrLlIiIiEiRmLi9oVevXnj06BGmT5+OhIQE2NvbIzg4OM8NC0RERESKwMTtLSNHjsz30qiiaGpqYsaMGXkuy5ZkyhYz4y1ejLf4KVvMyhYvUUkiE7xvmoiIiEgpcAJeIiIiIiXBxI2IiIhISTBxIyIiIlISTNzos8rOzlZ0CKRAMTExePHihaLDoC/c7t27cfr0aUWHQVQsmLjRZ3H9+nXcuHEDqqqqig6FFGTVqlVo3LgxHj9+rOhQPlpOTo6iQ6APuHPnDpYuXYoffvgB58+fV3Q4REWOiRsVuytXrqB27dr45ZdfFB0KKciPP/6I8ePHY+XKlahYsaKiwym0uLg4ZGVlQUWFX5klXbVq1TBp0iQAwKxZsxAREaHgiIiKFr+FqFhdu3YNTk5OmDFjBqZNm6bocArsS5klJ3c/MjIyFBbDzp07MXz4cOzevRu9e/dGVlaWwmL5GFeuXIGNjQ0OHDig6FCKzZdyvucOxejatSs8PT2hrq6O2bNnIzIyUrGBERUhJm5fmPddyvncX843b95Ey5Yt0b59e8yYMQOAclxqEkJAJpPh5MmTmD9/PgYMGIDQ0FA8ePBA0aEVmkwmw5EjR+Dr66uQ7W/YsAF9+/ZFhQoVEBMTAwBQU1NTmrGOV65cgZOTE3x9fdGjRw+5ZV9CspO7D2//u1TWfcvtEQ0JCcHJkydx7949hISEYNKkSbhw4YKCoyMqGkzcviA5OTnSF9eGDRswbtw4eHh4ICIiAunp6ZDJZJ/tCzkyMhIODg54+fIlnj59ipCQECm+kv6jIJPJsH//fnTu3BlRUVF49eoV3N3dMWPGDDx69EjR4RVaTEyMNNbncyZMa9euxahRo7Blyxa4u7tjz549+OGHHwAAqqqqJT6Jv3LlCho3bozRo0dj7ty5UvmFCxeQk5MDmUymwOg+Xe4fKMePH8ewYcMwY8YMnDp1CgA+63dFUZLJZAgLC0P79u1Ro0YNLF++HEuXLsV///2HGTNm4OLFi4oOkejTCfriTJw4URgbGwtvb2/RsmVLUbduXbFw4UKRkpIihBAiJyenWLcfGRkpVFVVhb+/v0hLSxMNGzYUzZs3F8HBwVKd4o7hU9y+fVtYWVmJjRs3CiGEePXqlVBTUxPTpk1TcGQfZ+fOncLExES8fPnys23z/PnzQiaTiT179gghhEhMTBQ+Pj7C0dFRzJ49W6qXnZ392WIqjH/++UdoaGiIKVOmCCH+F+fcuXNF/fr1xb179xQZXpEJDQ0VmpqaomfPnqJSpUqiRYsWYsWKFdLykvzv9F3GjBkj3Nzc5Mr27NkjateuLdq2bSsiIyMVFBlR0WDi9oXI/YLduHGjsLCwEH/99ZcQQoijR48KmUwmatasKebOnSvS0tLk6he1p0+fip49e4rJkydLZQ8fPizRyVtOTo5cLJcuXRL169cXQghx8+ZNUbFiRTFo0CBp+fXr1z9rEvQxrl69Kk6ePClevXolzp07J5ycnMQ///wjLX9zf4vyc8htKykpSVy7dk0I8TrxFUKIR48eKUXylpOTI9avXy/MzMyEt7e3VD5v3jxhaGgodw6/uY4yWrJkiVi2bJkQQojY2FgxZMgQ0ahRI7F06VKpTknft9z4oqKiRFpampg5c6ZwcnISz549k6vn7+8vNDQ0ROPGjcX58+cVESpRkWDipsT69u0r9QoJIURGRoZYvXq1WLRokRBCiF9++UUYGhqKNWvWCC8vL1GmTBnh7+8vnjx5UqxxxcXFSf+fmZkphBAiPj6+RCdvQghx4MABERsbKyIiIoS1tbWIjY0VlpaWYvDgwVJycebMGTFo0CC5JKikefjwoShfvrwwMTERVatWFZUqVRIymUyMHj1a7NmzR9y7d0/8999/4sWLF58tpg8lbyXpPBBCiNTUVLF69WpRp04dMXr0aDF//nxRtmxZceTIkTx1S1ri+T5vJjlRUVFizJgxYtu2bdLye/fuiaFDhwpHR0exfPlyRYVZaAcOHBAmJibizz//FBs3bhQmJibixIkTcnWCgoJE3bp1hbu7u9x3FJGyYeKmpJKSksTAgQOFgYGB2LFjh1T+zz//iISEBHH37l1Rq1Yt6S/nu3fvCiMjI2FhYSE2b95c5PFkZmaKlJQUcfPmzTyJYW7ylpCQIBwdHUXz5s1FSEhIifqxzr20l5sIN2vWTMhkMjFw4EC5ehMnThTNmjUTSUlJigizwO7evSuePHkiDh48KH766Schk8mEgYGBaNKkiShTpowwMDAQPXr0yNMr8SlOnTolZsyYIerWrSvq1asnpk2bJi5evCgtfzN58/X1FU5OTmL8+PFFtv2ilpycLFauXClq1KghZDKZOHr0qBDif+ezEEKMHTtWtG7dWghR8pLPd9mzZ48oXbq0MDIyEqVKlRJDhw6VWx4XFye8vb2FjY2NWLt2rYKi/LDc4/306VMxbNgwsWTJEmlZ165dRfny5cWxY8fE48ePhRBCTJo0Sfj6+krviZQVEzclFhsbK8aOHSv09PSkv5pzv8yOHz8ubGxsRHR0tBBCiLNnz4p+/fqJhQsXiqysrCKN486dO2LEiBGiVq1awsjISJiamop58+ZJ2xZCPnlr0qSJqF27tjh+/HiRxvGxrl+/LtavXy8WLFgglR06dEg0aNBAtGrVSvzzzz8iLCxMTJgwQejp6YmrV68qMNq8cj/zxMREER8fL1JTU/PUGTFihBgyZIjIysoSFy9eFKGhoeLmzZtFFkNgYKCoWrWq6Nevnxg+fLjo06ePMDExEXZ2dnK9VLnn3qNHj8TAgQPF4MGDS0TC8+TJE3H9+nWxbt06cfDgQXHr1i0hhBBpaWli1apVombNmnkSnOnTpwsdHR1x7tw5RYRcKLnHOC0tTTRp0kRs3LhRnDp1Svj6+orKlSuL6dOny9WPjY0Vvr6+IjY2VgHRvltISIg0VleI199rVapUEY0aNRJhYWFydbt16yZMTU1FzZo1RbNmzYSmpqZ0+Z5ImTFxUzKDBg0S9erVk97HxsYKHx8foaenJ7Zv3y6VBwUFiWrVqoktW7aIW7duiU6dOolhw4ZJy4sqebty5YqoVKmS8PDwEMuWLRP79u0THh4eQl1dXfTo0UNuIHDuNh8+fChcXFzE3bt3iySGT3Hv3j1Rv359oa+vL/z9/aXyFy9eiH379gknJyehq6srqlevLpycnMTly5cVF2w+cn+QDxw4IGrWrCmqVq0qjI2Nxdy5c+USs+HDh4sWLVrIrVNUAgIChKampvj555+lMZRCCLF3717RuHFjYWVlJf744w+pPPfSYkpKivT/ikzeoqOjRbt27UStWrWEtra20NHREfr6+uKnn34SQgjx7NkzsXLlSlGnTh3h5eUlhHg93k1LS0uuR7GkO3nypOjRo4fw9PSUkp+EhAQxa9YsYWtrmyd5y+0hLQmys7PF6dOnha6urkhISJDKnzx5Ipo2bSpkMpnYtWuXVDfXnj17xOLFi8WsWbOK9A8VIkVi4qZkTpw4IczNzYWrq6tUll/ylpGRIbp06SIqV64szMzMRP369aVer6L6kbxy5YooVaqUmDx5cp7xUsuXLxf6+vrC09NT7tJEbvJW1L1+Hys1NVUsWrRIVKlSRTg7O+db5/z58+Lff/8tMZdY3u4FCQ0NFVpaWmLx4sXi6NGjYv78+cLKykoMGzZM+rH69ddfRZ06deQu8xWFnTt3CplMJkJDQ4UQr3803zy/goKCRJUqVYS7u7tIT0+Xlr1ZR5FjxCIjI0XZsmWFj4+P1GMTEhIivvvuO6GmpibdYZmSkiJWrFgh6tevLypXrqw0SVvucY6Ojhbr168XxsbGwtLSUq7Ow4cPxcyZM0WtWrXE2LFjFRFmgT169EgI8bqXP3dIxuPHj0WzZs1ElSpVxI0bN4QQyjXukKiwmLgpiVOnTkn/f+bMGVGhQgXRtm1bqezN5G3r1q1CiNfJ26lTp8SJEyekRKmo/oq+c+eO0NXVFUOGDJHKcnJy5Nr39/cXMplMnD59Os/6iuphyW+7aWlpYs2aNaJKlSrC09NTKi/qRLcoDB06VFSoUEGkp6dLx3ro0KGiV69ecvW2b98uLCwspHE/QUFBwsjISCQnJxdZLGlpaaJFixbC2tpaRERESOVv36U7ceJEUaZMGfHff/8V2baLwpUrV4Surq7w8/MTQsj/2CcmJophw4YJFRUVKSlNTU0VCxcuFA0bNlSqKSUOHDggGjRoII4ePSrWr18vtLW1xffffy9XJz4+XkyYMEE4OjpKyVFJkns+ZWVliXv37gmZTCYmT54sJW9PnjwRjo6OwsbGJt+etZL0b5joUzFxUwKLFy8WDRo0kPthOX36tDAzM8s3eTMwMBA///xznnaKspfryJEjQiaTiQkTJojbt2/LLcuNMysrS1hbW4sJEyYU2XY/Re6X9+nTp8WCBQvExIkTxbFjx4QQQrx8+VKsXr1a1K5dW7ocJkTJ6RkU4vUxNzMzE9evXxdCCOmyZL9+/UTPnj2FEK+T9VzTp08XFSpUEM+fPxdpaWlyl5g+VUREhIiPjxeRkZHim2++Ec7OziIkJERa/mYSHxYWJkqVKlWixhc9efJEmJiYiObNmwsh/nduvPlvLCYmRtStW1e0adNG6lF+9uxZsd+VXRRy9+fBgweibdu2IiAgQAjx+pxZu3atMDIyEr6+vnLrJCQklMikLT/Lli0T6urqYvbs2XmSt5o1a4qoqCgFR0hUfJi4KYncH8E3/5p8V/I2duxYubvgilJSUpK4cOGCePjwoQgJCREVKlQQ33//vVzy9uZft1WqVMnzA6FI+/btE7q6uqJFixbC0dFRyGQy4ePjIxISEsSLFy/EqlWrhIODg5QIlSQnT54UZcuWFdHR0SIkJER88803Qggh5syZIwwNDaXELLencNeuXaJ27dpFeueoEK/PsQYNGojOnTuLpKQkceXKFdGhQwfRqlUrueQtNwlaunSpaN68uXj+/HmRxvEpMjIyxLRp04SmpqbYsmWLECL/XhlfX19hY2MjMjIylK7X5uTJk2LEiBGiffv2chMGp6SkiLVr14oyZcqU6Lt6hXj9h9O7jvvKlSuFTCbLk7xZW1uLhg0bFvmwAKKSgolbCfdmD8ChQ4eETCYT+/fvl8ryS97u3LkjVq5cWeSDi6OiokSTJk1EmzZtRNeuXYUQQvz0009S8nbnzh2pblZWlrh586Zo2bKl+P3334UQir9ccefOHVGpUiWxYcMGKZadO3eKMmXKiHHjxgkhXv+oLViwQDRr1kw8fPhQkeHKycnJEXfu3BF9+/YVtWrVEjKZTPzyyy9CiNeX8Fq0aCFsbGzkYh49erRwcnKSu2GgqKxfv160bNlS9OrV673J25MnT0T79u1LTILw4MEDsXv3brFr1y4RHh4uVqxYIVRUVKTkLVfu+eHj4yOaNGmigEg/3U8//SQ0NTWFtra2CA8Pl1uWkpIifvzxRyGTyaSnQ5Qkb8+zFh4eLqZNmyamTp0qgoKCpJ7wFStW5EnekpOTS9zdsERFiYlbCZbfAFsvLy+hp6cngoKCpLLTp0+LihUrinbt2uWpX1TJ2/Xr14WhoaGYPHmyuHfvnly7P//8c749bxMnThQNGzZUWAKU2zt46dIlIYQQ165dE1WqVBGRkZFySeT27duFioqKdOfj06dPS+zlsOnTpwuZTCasra2lcVY5OTni4sWLomXLlkJfX1+0bdtWtG3bVujr6xf5XbBvHrctW7aIpk2b5knenJ2dpclP3dzchIODg3S+KDJ5v3LliqhSpYqwtbUVampqws7OTmzcuFEsW7ZMyGQyaWxobowpKSmiR48e0t2Wiv7D42Ps379fmJiYiAEDBuQZ+5WcnCw2bdokTX1SUqxfv144OTlJN4sEBwcLFRUV0alTJ2FlZSVq1aolOnbsKJ1TK1euFOrq6mLSpElFOoaTqKRi4lZCvZm0TZgwQZrKQYjXc3Jpa2vLJW9nzpwRqqqqYsyYMUUey+PHj0XTpk3zDGh+V/L28OFD8cMPPwg9PT1x5cqVIo+nIHJ7B9u1aye+/fZbkZWVJS5cuCDU1dWlebfefGxVzZo1xeLFixUSa0FkZGSIrKws0b9/fzFhwgTRrVs30bRpUynZzMnJEc+fPxfLli0Tvr6+YvLkycU2/cGHkreOHTsKFxcXYWdnJ6ytraVLVoocL5h7B/SECRPEv//+K3777TfRunVr4eDgICIjI8XUqVPlkjchhJgyZYqwsrISf//9t8LiLqjcz+T+/fsiOjpa7tLo1q1bRYUKFcSoUaPyjEcticnojRs3hK2trejQoYMICQkRPXv2FKtWrRJCvJ6mZ8eOHcLBwUF07txZOqeWLFkiDA0NlWaMHtGnYOJWAr2ZtPn4+AiZTCZ0dHTkvnTzS96uXr1aLD+OUVFRomrVquLkyZN5egHfvINw27ZtolKlSsLW1laUKlVKYdMlvN07+GbMPXr0EHZ2dnI/xhkZGcLBwUGsX79eEeG+V36D5oUQ4vDhw6JTp05yyZsi4hIi/+StQYMGonHjxlLSpsg5weLi4kTZsmVFjx495Mp//PFHoaurK27duiVevXolpk2bJmQymdi3b59YtGiR0NbWLnHz9r3tzelXfvnlF1GjRg1Rrlw5Ubt2bdGpUyfp+AcGBooKFSqIMWPGyE2MXdLkxnvz5k1Rq1Yt0aFDB+Hk5CR31/Lz58/FTz/9JOrUqSPdXCSEYG8bfTWYuJUwb/4g+vj4CGNjY3H8+HFhZWWVZ1oNb29voaenJ3bu3ClXXtTJ2/bt24Wamto7kwghxP+1d+dhUdVrHMC/M8DACIEL4EYBCpdUIEFBwQRXlETEFcVQ0jQ3XEqvlwwhtfCWywUsJXAJc0lxwawU4Sq5V5dFSMRxDXADTWTf5r1/cOfEXNS8XeHMyPt5np54zjmD75lhznznd34LlZWVUX5+Ph0+fJisrKxEa2l7UuugquZTp07R8OHDyc7OjlJSUig1NZWWLVtGpqamGteyonq+jx8/TvPmzaO33npLrT9SUlIS+fr60uuvv06nT59+7GOboz4ioi1btqiFt19//VUjQhvR74MpfH191UJuUlIStWvXTlgJo7S0VLgVLZFINHqeth9++EFtBPHx48dJLpdTdHQ0nThxgrZs2UIODg5kb28vvA5fffUVGRgY0NKlSzW2437DyZkLCwupV69eJJFIhBY3leLiYurYsaPaaiea2HrIWFPg4Kah5s+fT61btxb6Z9na2grBrWFw8vf3f+LEsc/L6dOnycDAgBISEp54TGRkJA0dOpSIqEk6wz+rp7UOqvz44480efJk0tfXJxsbG+rRowelpaU1c6XPZv/+/WRsbEwzZsyg8PBweumll2jo0KHCSNGkpCQaM2YM2dvbi7L00uPCW2BgIOXn5xOR5kyncvnyZRo+fDh5eXnRxYsXqaSkhMzMzBpNVfPw4UOKjo4WJnLVRAsWLGg031poaChNmjRJ7biMjAyyt7dXGyG9d+/eRrdLNc3BgwdJKpXSjRs36Pr169SzZ09yd3dvNErew8NDo7s3MNZUOLhpCFXIUP0/ODhYbZJPV1dX2rx581Mf21Ty8/PJ3NycfH191Zapavih/d5779GSJUsaTb7a3J7WOqgKEWVlZZSTk0OFhYV08+ZNje0Xk5+fTz169KB//OMfRERUUFBAHTp0oNmzZ6sdl5iYSAEBAaKNpGv4em/evJn69OlDcXFxjfaJ7fLly+Tt7U2enp7Upk0btf6gDQOmJs+6/+OPP5KZmZkw+KOkpISI6gct9ezZs9HxkZGR1KtXL7p3716z1vln5eXl0axZs2jjxo3C345CoSAHBwdydXWlTz75hI4ePUp/+9vfSC6Xa9zACsaaAwc3DfPf/ZXq6uqorq6OXF1dhRneieqDXMNVC5r6w2bfvn2kr69PgYGBapNblpWVUUhICFlaWmrERfRZWgejoqJo6NChaoMTNNGNGzeoe/fuRFT/gda5c2e1hc4btkA877na/lcNA9qIESNo1KhR4hXzFJcvX6ZBgwaRpaUlpaamCts1KWA+zYkTJ8jCwoJyc3Np+/btNHHiRCovL6e9e/eSk5MTJSYmNppCyMrKqtH0GpooLS2NRowYQb1796bMzEy1SZwVCgU5OTmRRCIhDw8Pmjp1qkZN6MxYc5KCiUqpVAo/Z2RkwMPDA5999pnafqlUCjs7O9TW1gIAvL298ejRI0RHRwvHSaVN+1L6+fkhMjISu3btwtixYzFt2jTMmTMHkyZNwubNm3HgwAH85S9/adIanoWlpSWMjY0RHx+PmzdvCtuJSPj55s2b6NWrF2QymRgl/qHvv/8e27dvR6tWraCvr49du3ahf//+8PHxEV5zhUKB6OhonDlzBgBgaGgoZsmQSCTCc2xpaQm5XI7q6mpRa3ocW1tbxMTEoFu3bvj4449x+vRpAPX1awNPT0/Y2dnBy8sLU6ZMwYABAyCXy9G3b1+YmJggNjYWiYmJAOqvHSdOnIC5uTleeuklkSv/Y1evXkVRURF++eUX3Lt3DxKJBDo6OqitrYWNjQ0OHDgAS0tLWFlZISoqCvb29mKXzJg4xE6OLVnDb/mfffYZBQcHk1wuJ6lUSuvXr1c7NiQkhHx9fWnEiBHUtWtX0Tp+nz9/nsaNG0c9e/ak/v3709KlSzWuz4y2tA4+ztmzZ8nExITi4+OpqKiIxowZQ0ZGRjR27Fi145YuXUp9+/Z9rstYPQ+FhYXUr18/jW8NuXz5Mvn4+FDfvn3VRixqMtVghF27dpFEIqHOnTuTQqEQrgG5ubk0aNAgcnR0pK5du9KwYcPIxMREY/tvPs53331Hrq6u5O7urtZns2HL25UrV8QqjzGNICFq0BTBRPHBBx/giy++QGRkJMrLy3HixAkcPHgQy5cvx5IlSwAAy5cvx6pVq9CrVy+cOXMGenp6qK2tha6ubrPXW1dXBx0dnWb/d5+VUqlEbGws5s2bBxsbG7i5ucHAwAAFBQU4d+4cjhw5AicnJ7HLbOTGjRvYuXMnKisrsWLFCgDAqVOnEBQUBAcHB4wZMwYdO3ZEYmIitm/fjh9++AGOjo4iV91YZWUlDAwMxC7jD126dAmhoaFYu3YtXnnlFbHLaUTV2t7w+bxw4QIuXbqE0tJSbNmyBUVFRdi1axccHR2ho6ODW7duITs7G8nJyejcuTO8vb01oiX8vxERJBIJMjMzcefOHeTn5yMwMBAymQxHjx7FmjVroK+vj7CwMLi4uICIUFdXJ8r1jjGNI25uZHfu3KHevXvTtm3bhG15eXkUFhZGcrmcIiMjiah+tNvcuXOFb55iTrHQsKVQk/sGaXLrYGRkJMXHxxNRfcf4/Px86tSpExkbG9N7772nduzRo0fJz8+PzMzMyNHRkQYMGCDadCsvmoZTamiiq1ev0jvvvEP5+fm0d+9etWlKysvLydXVlezs7CgtLU2jB1U0pLpmJCQkUKdOncjd3Z2sra3Jzs6O9u7dS0REBw4coKFDh5Kvr2+jqW4Ya+k4uDWz/764FhYWkqmpaaNh7b/++iv17duXJBIJrVu3Tm2f2PNiaRNNmY5CRfXajRo1qtEo0Pj4eDIzMyMPDw/Kzs5W21dWVka3b9+moqIiYSQhe/GlpqZSmzZtaMCAASSTyYSVHVRdJSoqKqhPnz5kZ2enNgpd050/f55MTU2FL6wFBQUkkUiEL6pE9aOlXV1dacKECVRRUSFWqYxpHA5uIikvLyei+iD31ltv0fjx4xu1Bs2ZM4eGDBlCFhYWtHPnTjHK1Hqa1DqoCu3Xrl2jV155herq6ujs2bMUExMjHLNjxw7q2LEjBQcHk0KhaPRY1nKo/l5Xr15NEomE3Nzc1P4mVF8CKisr6fXXXyczMzONbInNysoSrncq27dvp5EjRxIRUU5ODllbW9Pbb78t7FcFtW+++UZt+S7GGI8qFUVsbCzs7e1RWFgIqVQKLy8vZGVlIS4uDrm5uQCAkpIS3L59GxMmTIC7uzu+/fZbVFVVqY2OZH+s4WhBMUcOqvorZWRkwNHREaNGjYJUKsUnn3yCjRs3Ii4uDgAQEBCAiIgI7N+/H9HR0bhy5QqAph81zDSP6r0ul8sRFhaGu3fvIjw8HOnp6QAAXV1d1NbWQl9fH8nJybC3txd9dHFDRISkpCQ4Ojpiz549qKysFPbl5uZCIpGguroaXl5eGDp0KGJiYgAAu3fvxqeffgoA8PHx0cj+h4yJSuTg2CJdunSJ7OzsyMXFhe7fv09ERBs3biQHBwdh8eRevXrRa6+9RkREixcvJldXV4277ceejaq1TLXQ+fvvvy/sKy8vp1GjRtEbb7yh1vK2bds2srKyounTp2vcUlysaT2pZfjYsWNkZWVFAQEBardFf/jhh+Yq7U+ZPXs2GRkZ0ZdffkllZWVEVP9esLW1JblcLkworTrv+fPn07hx40RdgYUxTcZDdJqYqqVFhYhgZ2eHb7/9Fn5+fhg8eDBSUlIwa9Ys2NnZITMzE2fPnoWXlxfCwsIAAPfu3UP37t01fjQnezypVIq8vDwMHjwYPj4++Oijj4R9CQkJMDIyQklJCbZv3w6JRIIZM2Zg6tSpqKysRFRUlEa1orCmRf8ZbXnu3DlkZWXh7t278Pf3x8svv4whQ4YgNjYWM2fOxJo1azBx4kT861//Qnh4OG7fvg1zc3ONmo+upqYGenp6+Pzzz6Gnp4e5c+dCR0cHfn5+sLS0hI+PDxITE9GtWzcAQEFBATZu3IidO3ciNTVVK+aeY0wUYifHlmL37t3Czw2XcunRowc5OztTUVFRo8fk5eVRSEgItW7dulFndaZdGi50rlpz9uOPP6ZWrVpRZmYmFRUV0dixY6l///7CclFE9aOJWcugui7s27ePWrduTd7e3tSlSxdyd3enDRs2CKtjpKSkUM+ePcnR0ZGsrKyEUaaaRnU+Z86coe+++45atWpFHTt2FAZYKBQKeuedd8jU1JQ6d+5MTk5O1LVrV62ad44xMXBwayJVVVXCbYG8vDzS09MjLy8vYb/qopaeni5cpG/fvi3sLykpoTlz5pC9vT2lp6c3a+2saagWOvf19aUZM2aQubk5HT16VNh/+/ZtmjBhAjk4OAgfbmIPqGBNr+H6vidPnqQOHToI6xLfuHGDdHV16bXXXqM1a9YI15SrV69SZmYm3bp1S7S6n8WhQ4dIV1eXIiIiKCQkhHx8fMjAwEAYTVpcXEzZ2dkUHR1NycnJlJeXJ3LFjGk+Dm5NICEhgcaMGUNOTk60atUqIqrvh2JhYUHe3t5qx96/f59cXV1JIpFQUFCQ2r6ioiKNvzCz/01ubi4NHTqU5HK52hQwqhGCBQUFNGXKFLpx44ZYJbJmsnbtWjp48CARkbAuZ3R0NM2fP5+I6sNZly5dKCgoiPz9/aljx44UGRkp+rq0z6q8vJw8PDxowYIFatvfeecdMjAwoPj4eJ7ahrE/gYPbc7Zp0yYyNjamRYsW0cKFC0kqlVJsbCwR1X+b7tixIw0bNkw4vqKigqZNm0aZmZlqgw+4peXFdeXKFfLy8iJvb286efKksF01NxcPQnnx3b9/n/z9/cnQ0JC+//57Iqp/zysUCsrJyaGysjLy8PCgadOmERHRgwcPyNTUlGxtbSkqKkrM0p9ZVVUV9enThyIiIojo979vIiIvLy+ysrKiuLi4RlOFMMaejucYeI7i4uIQHByML7/8EuvWrcP69esxYcIElJeXo6ioCG5ubvj6669x/fp19OzZE2FhYRg2bBhycnJgb28PHR0d1NXVAdCeRa/Z/65r167YsGEDiAirVq0SFjrX09MDAB6A8gJTKpUAgLZt22Lt2rUICgrCpEmTcPjwYUgkElhbW+PVV1/FpUuXUFRUhDlz5gAAbt26BRcXF3h6esLX11fMU3hmMpkMlpaW2LNnD4D6v++amhoAgK2tLe7evYuwsDBUV1eLWSZjWoeD23Ny4sQJzJw5Ex988AH8/PyE7Tk5OYiLi0OXLl0waNAgKBQKHDlyBBYWFjhz5gzatWuH1NRUSKVSKJVK/tBuIWxtbREVFQU9PT0sXrwY586dE7sk1sRUI8zz8vKQkJCAM2fOoH///pg9ezYCAwNx+PBh4f1fUlKCyspKKBQKlJeXIyEhASYmJli/fj0sLS1FPpPG6D9zzt25cwd3795FVVUVAGDp0qWoqamBv78/gN+/nBgYGODIkSNIS0uDiYmJOEUzpqV4kfnnRKFQYPr06WjTpg1CQ0PRu3dvjB07FhcuXMBHH30EY2NjLF68GEqlEsePH0f79u3VFo8Wa8F4Ji5NX+icPR+q0HbhwgWMHj0aMpkM165dg52dHfz9/VFSUoKYmBjs3LkT3t7eKC4uhr+/PxQKBXR0dPDgwQMkJSXB2dlZ7FN5ov3792PFihW4c+cORo4ciYCAAAwcOBC7d+/GqlWrIJFI8MYbb+DGjRs4dOgQLly4AFtbW7HLZkzrcHB7jhQKBebPnw8dHR08fPgQFRUV2LdvH6ysrAAAaWlp6N27N/bv36/WKkf/mbuJtUzV1dWQyWRil8GaSMPQ5ubmhnnz5mHBggVIS0tDZGQkHj16hBUrViAhIQEJCQnYvn07fHx88Ntvv+Hw4cOoqamBp6cnunbtKvapPFF2dja8vLzw7rvvQiaTYc+ePZDL5Vi4cCFGjBiBX375BZ988gnu3r0LfX19rFy5Eo6OjmKXzZhW4uD2nCkUCsyZMwc//fQTYmNjMX78eCiVSkgkEqSnpyMwMBBffPEF+vXrJ3apjLFmkpeXB2dnZwwcOFDo8wUAMTExWLJkCdLT06Gvr48VK1Zg7969+OqrrzBixAgRK352ubm52LNnD6qqqrBq1SoAQHp6OsLDw1FaWorg4GDhi2pdXR2IiO8uMPZ/4D5uz5mtrS02bdqEvn37YuvWrTh58iSkUikkEgnCwsJgbm4ONzc3sctkjDWjuro6WFtbo6qqCqdOnRK2d+nSBTKZDBUVFbCwsMDSpUsxceJEjBw5EsnJySJW/MeUSiUKCwsRFBSEdevWoaCgQNjn5OSEsLAwGBoaYtOmTYiPjwdQP/CGQxtj/x8Obk2ga9euiI6OBhFh9erVOHXqFMaOHYvLly8jKSlJGIjAGGsZrKyssGPHDlRXV2PlypXIyclBaWkpJk+ejOnTp8Pe3h5A/bVj0aJFmD9/Pl5++WWRq3481U0aqVQKMzMzhIeHw87ODj///DP++c9/Csc5OztjxYoVqKiowIEDB1BSUiJWyYy9UPhWaRNSKBRYtGgRkpKS0KVLF2RlZUFPT48HIjDWQikUCixYsADl5eW4cOECpk6divXr1wOA2lrEqnU+NdW5c+ewZcsWfPbZZ9DT00NycjJCQ0NhYWGBefPmwdPTUzj2woULaNOmjcYGUca0Dbe4NSFbW1usWbMGs2bNQnZ2Noc2xlo4W1tbREZGQkdHB8bGxhg9erSwTyr9/XKsyaFNqVQiNTUVp06dwsKFC1FTU4MhQ4YgLCwMBQUFiI6OxsmTJ4XjHR0dObQx9hxxi1sz4tDGGAOAK1euIDg4GESE0NBQrRusVFpaipiYGHz99ddwdnZGdHQ09PT0cOTIEXz88ccwMDBAeHg43N3dxS6VsRcOt7g1Iw5tjDEAsLGx0boJmK9duyb8bGRkhFmzZmHcuHFIT0/H/PnzUVNTg+HDh2PJkiWQSCQ8LyFjTYSDG2OMicDW1haffvopLCws0KlTJ7HLearc3Fz4+/tj2bJlwjZDQ0PMnj0b3t7eSExMREhICGpqajBy5Ejs378fFhYWIlbM2IuLb5UyxpiItGEC5sLCQixfvhxZWVkYNmwYQkNDhX3FxcVwdnbGgwcPEBgYiKioKJ5UnLEmxPfuGGNMRJoW2lTf5VXBS6lUCtN+rF69GocPHwYAIbzV1taib9++sLe3x5tvvqn2WMbY88ctbowxxlBQUIDOnTsLg6iOHTuGb7/9FkSEN998Ey4uLigsLERERAROnz4NFxcXzJo1C1999RV+/PFH7N27F+3atRP7NBh74XFwY4yxFi4xMRGjR49Gamoq+vfvj2+++Qb+/v7w8PBAUVERMjIysGPHDvj7+6OoqAhxcXHYsmULSktLYWBggISEBDg7O4t9Goy1CBzcGGOshVIqlZBKpSgoKEB4eDj27NmDI0eO4Ny5czA0NMTMmTPx8OFDrF69GmvXrsWXX36JgIAAVFdX47fffsP169dhbW2N9u3bi30qjLUY3MeNMcZaIFVoy8nJwb59+xASEoKKigoMHjwY3bt3R3h4OACgdevWWLlyJQBgypQpkEqlmDhxItq3b8+BjTERcHBjjLEWRhXaMjMz4eTkhIiICHTp0gXr1q1D69at8fnnn6O4uFg4Vk9PD6tWrYKOjg4CAgIgk8kwZswYkc+CsZaJgxtjjLUgqtB28eJFuLm5Yfny5Vi6dCkAwNzcHKGhoSgrK8PMmTNhbW0Nd3d3EBF0dXURHh4OfX19dOvWTeSzYKzl4j5ujDHWQqhCW3Z2NgYOHAgzMzNcvHgRgPrC9oWFhXj33Xdx4MABJCUlCeGNp/lgTHy8cgJjjLUADW+P9unTB/b29iguLsaCBQsA1C9sX1tbCwAwMzPD+vXrMXr0aIwYMQKpqakc2hjTEBzcGGOsBZBKpfj555/h4uKCv/71r0hOTkZYWBh27twphDddXV0hvJmammL9+vXw9PTE5MmTUVFRIWb5jLH/4D5ujDHWQpSXl2P27NkICwsDAPj7+wOAsAZpZGSkEN50dXVhamqKzZs3o6qqCnK5XLS6GWO/4z5ujDHWAqn6rD169Ai7d+/GsmXLEBAQgMjISADqfd4YY5qDW9wYY6wFUvVZMzY2xsSJEwHUt7zp6Ohg3bp1HNoY01Ac3BhjrIVThTepVIqZM2dCX18fERERYpfFGHsMDm6MMcZgbGyM8ePHQ09PD25ubmKXwxh7Au7jxhhjTMDztTGm2Xg6EMYYYwIObYxpNg5ujDHGGGNagoMbY4wxxpiW4ODGGGOMMaYlOLgxxhhjjGkJDm6MMcYYY1qCgxtjjDHGmJbg4MYYY4wxpiU4uDHGGGOMaQkObowxAEB4eDh69uwpdhmMMcaegoMbY1ooKCgIEokEEokEMpkMNjY2WLFiBWpra//071y8eDFSUlKeW40cBBlj7PnjReYZ01LDhw/H1q1bUVVVhe+++w5z586Fnp4eQkJC1I6rrq6GTCb7w99nZGQEIyOjpiqXMcbYc8AtboxpKX19fXTo0AGWlpaYPXs2hgwZgkOHDiEoKAh+fn746KOP0KlTJ9jZ2QEAsrKyMGjQIMjlcrRr1w4zZ85EaWmp8Pse10IWFxeHbt26wcDAAK+++io+//xztf35+fmYNGkS2rZtC0NDQ/Tu3Rvnz5/Htm3b8OGHHyIzM1NoGdy2bVtTPyWMMfbC4xY3xl4Qcrkc9+/fBwCkpKTA2NgYx44dAwCUlZVh2LBhcHNzw08//YR79+7h7bffxrx5854YqHbs2IHly5djw4YNcHJyQnp6OmbMmAFDQ0NMnToVpaWl8PT0ROfOnXHo0CF06NABaWlpUCqV8Pf3R3Z2No4cOYLk5GQAgImJSbM8D4wx9iLj4MaYliMipKSk4OjRowgODkZhYSEMDQ0RFxcn3CKNjY1FZWUl4uPjYWhoCADYsGEDRo4cib///e9o3759o98bFhaGtWvXYsyYMQAAa2trXLx4ETExMZg6dSp27tyJwsJC/PTTT2jbti0AwMbGRni8kZERdHV10aFDh6Z+ChhjrMXg4MaYljp8+DCMjIxQU1MDpVKJgIAAhIeHY+7cuXBwcFDr15aTk4PXXntNCG0A0K9fPyiVSuTm5jYKbmVlZbh69SqmT5+OGTNmCNtra2uFlrOMjAw4OTkJoY0xxljT4+DGmJYaOHAgNm7cCJlMhk6dOkFX9/e3c8OA9meo+r7FxsaiT58+avt0dHQA1N+aZYwx1rx4cAJjWsrQ0BA2NjZ45ZVX1ELb43Tr1g2ZmZkoKysTtp0+fRpSqVQYvNBQ+/bt0alTJ1y7dg02NjZq/1lbWwMAHB0dkZGRgQcPHjz235TJZKirq/s/zpAxxth/4+DGWAswefJkGBgYYOrUqcjOzsbx48cRHByMwMDAx/ZvA4APP/wQERERiIqKwuXLl5GVlYWtW7di3bp1AIBJkyahQ4cO8PPzw+nTp3Ht2jXs27cPZ8+eBQBYWVnh+vXryMjIQFFREaqqqprtfBlj7EXFwY2xFqBVq1Y4evQoHjx4ABcXF4wbNw6DBw/Ghg0bnviYt99+G3Fxcdi6dSscHBzg6emJbdu2CS1uMpkMSUlJMDc3xxtvvAEHBwesXr1auJU6duxYDB8+HAMHDoSZmRl27drVLOfKGGMvMgkRkdhFMMbEFxISgpMnT+LUqVNil8IYY+wJuMWNsRaOiHD16lWkpKSgR48eYpfDGGPsKTi4MdbCFRcXo3v37pDJZHj//ffFLocxxthT8K1SxhhjjDEtwS1ujDHGGGNagoMbY4wxxpiW4ODGGGOMMaYlOLgxxhhjjGkJDm6MMcYYY1qCgxtjjDHGmJbg4MYYY4wxpiU4uDHGGGOMaQkObowxxhhjWuLf+IRBn4Yj4qoAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Cross-tabulation of Resolution and Severity:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "resolution                                                   \n",
+            "DUPLICATE        258      3840   4864   2463   28959      776\n",
+            "FIXED            738      4735   3561   2799   58025     1821\n",
+            "INCOMPLETE         9      2578   3428   1025   10725      285\n",
+            "INVALID          129      1659   2590    989   13668      358\n",
+            "NOT_ECLIPSE       24        62     92     25     374        3\n",
+            "WONTFIX           41       232    437    461    5525      172\n",
+            "WORKSFORME       110      3851   3169   1413   15835      377\n",
+            "\n",
+            "Cross-tabulation of Project and Resolution:\n",
+            "resolution   DUPLICATE  FIXED  INCOMPLETE  INVALID  NOT_ECLIPSE  WONTFIX  \\\n",
+            "project                                                                    \n",
+            "Bugzilla           742   2375           5      597            0      156   \n",
+            "CDT                512   3982           0      317           56      101   \n",
+            "Core             10090  41299        1427     4336            0     2483   \n",
+            "Firefox          17426   8474       13584     9421            0     1742   \n",
+            "JDT               1440   1928           0      648           83      471   \n",
+            "PDE                652   2688           0      266           19      146   \n",
+            "Platform          3990   7623           0     1572          422     1489   \n",
+            "Thunderbird       6308   3310        3034     2236            0      280   \n",
+            "\n",
+            "resolution   WORKSFORME  \n",
+            "project                  \n",
+            "Bugzilla            412  \n",
+            "CDT                 161  \n",
+            "Core               7590  \n",
+            "Firefox           10425  \n",
+            "JDT                 824  \n",
+            "PDE                 379  \n",
+            "Platform           2120  \n",
+            "Thunderbird        2844  \n",
+            "\n",
+            "Percentage Distribution of Resolution Types:\n",
+            "resolution\n",
+            "FIXED          39.28\n",
+            "DUPLICATE      22.56\n",
+            "WORKSFORME     13.57\n",
+            "INVALID        10.63\n",
+            "INCOMPLETE      9.89\n",
+            "WONTFIX         3.76\n",
+            "NOT_ECLIPSE     0.32\n",
+            "Name: proportion, dtype: float64\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3XBQX5A0TrIU"
+      },
+      "source": [
+        "#Dataset used for the experiments\n",
+        "Link: https://github.com/ansymo/msr2013-bug_dataset/tree/master/data/v02/eclipse\n",
+        "\n",
+        "Citation: @inproceedings{LamkanfiMSR13,\n",
+        "\tauthor    = {Ahmed Lamkanfi and Javier Perez and Serge Demeyer},\n",
+        "\ttitle     = {The Eclipse and Mozilla Defect Tracking Dataset:\n",
+        "\t\ta Genuine Dataset for Mining Bug Information},\n",
+        "\tbooktitle = {MSR '13: Proceedings of the 10th Working Conference on Mining Software Repositories,\n",
+        "\t\tMay 18-–19, 2013. San Francisco, California, USA},\n",
+        "\tyear      = {2013},\n",
+        "}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gAzBUslDTVID"
+      },
+      "source": [
+        "\n",
+        "![Dataset_details.PNG](data:image/png;base64,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)\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zTD2MYSITRv8",
+        "outputId": "ae57a0a3-8dea-40a6-b340-19202857158e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n",
+            "Project: Bugzilla, Total number of bug reports: 4616\n",
+            "Project: CDT, Total number of bug reports: 5640\n",
+            "Project: Core, Total number of bug reports: 74292\n",
+            "Project: Firefox, Total number of bug reports: 69879\n",
+            "Project: JDT, Total number of bug reports: 10814\n",
+            "Project: PDE, Total number of bug reports: 5655\n",
+            "Project: Platform, Total number of bug reports: 24775\n",
+            "Project: Thunderbird, Total number of bug reports: 19237\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "\n",
+        "# Mount Google Drive #Skip\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def process_project(project):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Create an empty DataFrame to store bug data\n",
+        "    bug_data_df = pd.DataFrame(columns=['Project', 'Bug ID', 'Severity Label', 'Resolution Status', 'Short Description'])\n",
+        "\n",
+        "    # Load all data into the DataFrame\n",
+        "    for xml_file in ['short_desc.xml', 'severity.xml', 'resolution.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Identify the type of XML file and extract relevant information\n",
+        "            if xml_file == 'short_desc.xml':\n",
+        "                reports = root.findall('.//report')\n",
+        "            elif xml_file == 'severity.xml':\n",
+        "                severities = root.findall('.//report')\n",
+        "            elif xml_file == 'resolution.xml':\n",
+        "                resolutions = root.findall('.//report')\n",
+        "\n",
+        "    # Count bug reports for the project\n",
+        "    bug_reports_count = len(reports) if reports else 0\n",
+        "\n",
+        "    return bug_reports_count\n",
+        "\n",
+        "# Display the number of bug reports for each project\n",
+        "for project in projects:\n",
+        "    total_bug_reports = process_project(project)\n",
+        "    print(f\"Project: {project}, Total number of bug reports: {total_bug_reports}\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4jrykIkiaWfS"
+      },
+      "source": [
+        "#Deep Neural Network-Based Severity Prediction of Bug Reports\n",
+        "We reuse the dataset created by Lamkanfi et al. [31]. They\n",
+        "investigated the bug repository of Bugzilla to extract bug\n",
+        "reports from Eclipse and Mozilla projects. They collected bug\n",
+        "reports and ignored the duplicate reports and enhancement\n",
+        "reports. Both projects Eclipse and Mozilla contain four products, respectively. From the dataset, we select bug reports\n",
+        "of seven open source products. Platform, CDT, JDT, Core,\n",
+        "Firefox, Thunderbird, and Bugzilla. We ignored bug reports\n",
+        "from GEF as it contains small number of bug reports. We use\n",
+        "summary attribute that defines the bug reports and severity\n",
+        "attribute that indicates how urgent it is needed to be resolved.\n",
+        "The total number of bug reports are 59616 in which approximately 8.39%, 16.77%, 16.77%, 16.77%, 16.77%, 16.77%,\n",
+        "and 7.76% of bug reports belong to each product, respectively"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hTMlYDLZa1fM"
+      },
+      "source": [
+        "Platform, CDT, JDT, Core, Firefox, Thunderbird, and Bugzilla\n",
+        "\n",
+        "* Total Bug reports = 59616\n",
+        "* Platform, 8.39% = 5001\n",
+        "* CDT, 16.77%= 9997\n",
+        "* JDT, 17.77%= 9997\n",
+        "* Core, 16.77%= 9997\n",
+        "* Firefox, 16.77%=9997\n",
+        "* Thunderbird, 16.77%= 9997\n",
+        "* BugZilla, 7.76%= 4626\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "1.   Ignore duplicate reports and enhancement reports\n",
+        "2.   Ignore the bug reports from GEF\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fl1Xyvd5dFKy",
+        "outputId": "da7be868-92c7-4ad1-a37f-54d7ed0020a8"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Project: Bugzilla, Total number of bug reports with severity 'enhancement': 34\n",
+            "Project: CDT, Total number of bug reports with severity 'enhancement': 13\n",
+            "Project: Core, Total number of bug reports with severity 'enhancement': 60\n",
+            "Project: Firefox, Total number of bug reports with severity 'enhancement': 77\n",
+            "Project: JDT, Total number of bug reports with severity 'enhancement': 37\n",
+            "Project: PDE, Total number of bug reports with severity 'enhancement': 4\n",
+            "Project: Platform, Total number of bug reports with severity 'enhancement': 56\n",
+            "Project: Thunderbird, Total number of bug reports with severity 'enhancement': 54\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def process_project(project):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Create an empty DataFrame to store bug data\n",
+        "    bug_data_df = pd.DataFrame(columns=['Project', 'Bug ID', 'Severity Label', 'Resolution Status', 'Short Description'])\n",
+        "\n",
+        "    # Load all data into the DataFrame\n",
+        "    for xml_file in ['short_desc.xml', 'severity.xml', 'resolution.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Identify the type of XML file and extract relevant information\n",
+        "            if xml_file == 'short_desc.xml':\n",
+        "                reports = root.findall('.//report')\n",
+        "            elif xml_file == 'severity.xml':\n",
+        "                severities = root.findall('.//report')\n",
+        "            elif xml_file == 'resolution.xml':\n",
+        "                resolutions = root.findall('.//report')\n",
+        "\n",
+        "    # Filter bug reports with severity = \"enhancement\"\n",
+        "    enhancement_bug_reports = [severity for severity in severities if severity.find('.//what[last()]') is not None and severity.find('.//what[last()]').text and severity.find('.//what[last()]').text.lower() == 'enhancement']\n",
+        "    total_enhancement_bug_reports = len(enhancement_bug_reports)\n",
+        "\n",
+        "    return total_enhancement_bug_reports\n",
+        "\n",
+        "# Display the number of bug reports with severity = \"enhancement\" for each project\n",
+        "for project in projects:\n",
+        "    total_enhancement_reports = process_project(project)\n",
+        "    print(f\"Project: {project}, Total number of bug reports with severity 'enhancement': {total_enhancement_reports}\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def get_latest_update(report):\n",
+        "    \"\"\"Get the latest non-empty update value from a report\"\"\"\n",
+        "    updates = report.findall('.//update')\n",
+        "    latest_value = None\n",
+        "    latest_time = -1\n",
+        "\n",
+        "    for update in updates:\n",
+        "        when = int(update.find('when').text)\n",
+        "        what = update.find('what').text\n",
+        "\n",
+        "        if when > latest_time and what is not None and what.strip():\n",
+        "            latest_time = when\n",
+        "            latest_value = what.strip()\n",
+        "\n",
+        "    return latest_value\n",
+        "\n",
+        "def parse_xml_file(file_path):\n",
+        "    \"\"\"Parse XML file and return a dictionary of id: latest_value\"\"\"\n",
+        "    if not os.path.exists(file_path):\n",
+        "        print(f\"File not found: {file_path}\")\n",
+        "        return {}\n",
+        "\n",
+        "    try:\n",
+        "        tree = ET.parse(file_path)\n",
+        "        root = tree.getroot()\n",
+        "        bug_dict = {}\n",
+        "\n",
+        "        for report in root.findall('.//report'):\n",
+        "            bug_id = report.get('id')\n",
+        "            latest_value = get_latest_update(report)\n",
+        "\n",
+        "            if bug_id and latest_value:\n",
+        "                bug_dict[bug_id] = latest_value.upper()  # Normalize to uppercase\n",
+        "\n",
+        "        return bug_dict\n",
+        "    except ET.ParseError as e:\n",
+        "        print(f\"Error parsing {file_path}: {e}\")\n",
+        "        return {}\n",
+        "\n",
+        "def process_project(project):\n",
+        "    print(f\"\\nProcessing project: {project}\")\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Parse resolution and severity files\n",
+        "    resolution_dict = parse_xml_file(os.path.join(project_folder, 'resolution.xml'))\n",
+        "    severity_dict = parse_xml_file(os.path.join(project_folder, 'severity.xml'))\n",
+        "\n",
+        "    # Print some debug information\n",
+        "    print(f\"Total bugs with resolution: {len(resolution_dict)}\")\n",
+        "    print(f\"Total bugs with severity: {len(severity_dict)}\")\n",
+        "    print(f\"Resolution values found: {set(resolution_dict.values())}\")\n",
+        "\n",
+        "    # Create records for bugs that are fixed and have severity information\n",
+        "    records = []\n",
+        "    for bug_id in resolution_dict:\n",
+        "        if resolution_dict[bug_id] == 'FIXED' and bug_id in severity_dict:\n",
+        "            records.append({\n",
+        "                'project': project,\n",
+        "                'bug_id': bug_id,\n",
+        "                'severity': severity_dict[bug_id].lower()\n",
+        "            })\n",
+        "\n",
+        "    df = pd.DataFrame(records)\n",
+        "    print(f\"Found {len(df)} bugs with resolution='FIXED' and severity for {project}\")\n",
+        "    if not df.empty:\n",
+        "        print(\"Severity distribution:\")\n",
+        "        print(df['severity'].value_counts())\n",
+        "\n",
+        "    return df\n",
+        "\n",
+        "# Process all projects and combine data\n",
+        "dfs = []\n",
+        "for project in projects:\n",
+        "    df = process_project(project)\n",
+        "    if not df.empty:\n",
+        "        dfs.append(df)\n",
+        "\n",
+        "if dfs:\n",
+        "    all_data = pd.concat(dfs, ignore_index=True)\n",
+        "\n",
+        "    # Print data summary\n",
+        "    print(\"\\nOverall Data Summary:\")\n",
+        "    print(f\"Total number of bugs: {len(all_data)}\")\n",
+        "    print(\"\\nBugs per project:\")\n",
+        "    print(all_data['project'].value_counts())\n",
+        "    print(\"\\nSeverity levels found:\")\n",
+        "    print(all_data['severity'].value_counts())\n",
+        "\n",
+        "    # Create visualization\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    sns.countplot(data=all_data, x='project', hue='severity')\n",
+        "    plt.title('Distribution of Severity Labels for Fixed Bugs by Project')\n",
+        "    plt.xlabel('Project')\n",
+        "    plt.ylabel('Number of Fixed Bugs')\n",
+        "    plt.xticks(rotation=45)\n",
+        "    plt.legend(title='Severity', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Print summary statistics\n",
+        "    print(\"\\nSummary Statistics:\")\n",
+        "    summary = all_data.groupby(['project', 'severity']).size().unstack(fill_value=0)\n",
+        "    print(summary)\n",
+        "\n",
+        "    # Calculate percentages\n",
+        "    percentages = summary.div(summary.sum(axis=1), axis=0) * 100\n",
+        "    print(\"\\nPercentage Distribution:\")\n",
+        "    print(percentages.round(2))\n",
+        "else:\n",
+        "    print(\"\\nNo data found to visualize\")\n",
+        "    print(\"Please check:\")\n",
+        "    print(\"1. Are there any bugs marked as 'FIXED'?\")\n",
+        "    print(\"2. Do those fixed bugs have corresponding severity information?\")\n",
+        "    print(\"3. Are the bug IDs matching between resolution and severity files?\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "2_Tn57LJC509",
+        "outputId": "15842290-c90f-45e9-b441-89ac79ddd1ef"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Processing project: Bugzilla\n",
+            "Total bugs with resolution: 4616\n",
+            "Total bugs with severity: 4616\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Found 2432 bugs with resolution='FIXED' and severity for Bugzilla\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      1033\n",
+            "minor        492\n",
+            "trivial      289\n",
+            "blocker      265\n",
+            "major        253\n",
+            "critical     100\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: CDT\n",
+            "Total bugs with resolution: 5640\n",
+            "Total bugs with severity: 5640\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Found 4238 bugs with resolution='FIXED' and severity for CDT\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      3539\n",
+            "major        303\n",
+            "minor        194\n",
+            "critical      89\n",
+            "trivial       70\n",
+            "blocker       43\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Core\n",
+            "Total bugs with resolution: 74292\n",
+            "Total bugs with severity: 74292\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Found 46961 bugs with resolution='FIXED' and severity for Core\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      36960\n",
+            "critical     5834\n",
+            "major        2043\n",
+            "minor        1157\n",
+            "trivial       633\n",
+            "blocker       334\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Firefox\n",
+            "Total bugs with resolution: 69879\n",
+            "Total bugs with severity: 69879\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Found 11762 bugs with resolution='FIXED' and severity for Firefox\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      9787\n",
+            "major        670\n",
+            "minor        474\n",
+            "trivial      434\n",
+            "critical     275\n",
+            "blocker      122\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: JDT\n",
+            "Total bugs with resolution: 10814\n",
+            "Total bugs with severity: 10814\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Found 5914 bugs with resolution='FIXED' and severity for JDT\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      4508\n",
+            "major        547\n",
+            "minor        400\n",
+            "trivial      294\n",
+            "critical     127\n",
+            "blocker       38\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: PDE\n",
+            "Total bugs with resolution: 5655\n",
+            "Total bugs with severity: 5655\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Found 3968 bugs with resolution='FIXED' and severity for PDE\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      3312\n",
+            "major        303\n",
+            "minor        155\n",
+            "trivial       93\n",
+            "critical      81\n",
+            "blocker       24\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Platform\n",
+            "Total bugs with resolution: 24775\n",
+            "Total bugs with severity: 24775\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Found 13882 bugs with resolution='FIXED' and severity for Platform\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      10793\n",
+            "major        1412\n",
+            "minor         580\n",
+            "trivial       537\n",
+            "critical      418\n",
+            "blocker       142\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Thunderbird\n",
+            "Total bugs with resolution: 19237\n",
+            "Total bugs with severity: 19237\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Found 3678 bugs with resolution='FIXED' and severity for Thunderbird\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2842\n",
+            "major        287\n",
+            "minor        222\n",
+            "trivial      148\n",
+            "critical     145\n",
+            "blocker       34\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Overall Data Summary:\n",
+            "Total number of bugs: 92835\n",
+            "\n",
+            "Bugs per project:\n",
+            "project\n",
+            "Core           46961\n",
+            "Platform       13882\n",
+            "Firefox        11762\n",
+            "JDT             5914\n",
+            "CDT             4238\n",
+            "PDE             3968\n",
+            "Thunderbird     3678\n",
+            "Bugzilla        2432\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity levels found:\n",
+            "severity\n",
+            "normal      72774\n",
+            "critical     7069\n",
+            "major        5818\n",
+            "minor        3674\n",
+            "trivial      2498\n",
+            "blocker      1002\n",
+            "Name: count, dtype: int64\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Summary Statistics:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla         265       100    253    492    1033      289\n",
+            "CDT               43        89    303    194    3539       70\n",
+            "Core             334      5834   2043   1157   36960      633\n",
+            "Firefox          122       275    670    474    9787      434\n",
+            "JDT               38       127    547    400    4508      294\n",
+            "PDE               24        81    303    155    3312       93\n",
+            "Platform         142       418   1412    580   10793      537\n",
+            "Thunderbird       34       145    287    222    2842      148\n",
+            "\n",
+            "Percentage Distribution:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla       10.90      4.11  10.40  20.23   42.48    11.88\n",
+            "CDT             1.01      2.10   7.15   4.58   83.51     1.65\n",
+            "Core            0.71     12.42   4.35   2.46   78.70     1.35\n",
+            "Firefox         1.04      2.34   5.70   4.03   83.21     3.69\n",
+            "JDT             0.64      2.15   9.25   6.76   76.23     4.97\n",
+            "PDE             0.60      2.04   7.64   3.91   83.47     2.34\n",
+            "Platform        1.02      3.01  10.17   4.18   77.75     3.87\n",
+            "Thunderbird     0.92      3.94   7.80   6.04   77.27     4.02\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "M3FU8KcoFw1g"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def get_latest_update(report):\n",
+        "    \"\"\"Get the latest non-empty update value from a report\"\"\"\n",
+        "    updates = report.findall('.//update')\n",
+        "    latest_value = None\n",
+        "    latest_time = -1\n",
+        "\n",
+        "    for update in updates:\n",
+        "        when = int(update.find('when').text)\n",
+        "        what = update.find('what').text\n",
+        "\n",
+        "        if when > latest_time and what is not None and what.strip():\n",
+        "            latest_time = when\n",
+        "            latest_value = what.strip()\n",
+        "\n",
+        "    return latest_value\n",
+        "\n",
+        "def parse_xml_file(file_path):\n",
+        "    \"\"\"Parse XML file and return a dictionary of id: latest_value\"\"\"\n",
+        "    if not os.path.exists(file_path):\n",
+        "        print(f\"File not found: {file_path}\")\n",
+        "        return {}\n",
+        "\n",
+        "    try:\n",
+        "        tree = ET.parse(file_path)\n",
+        "        root = tree.getroot()\n",
+        "        bug_dict = {}\n",
+        "\n",
+        "        for report in root.findall('.//report'):\n",
+        "            bug_id = report.get('id')\n",
+        "            latest_value = get_latest_update(report)\n",
+        "\n",
+        "            if bug_id and latest_value:\n",
+        "                bug_dict[bug_id] = latest_value.upper()  # Normalize to uppercase\n",
+        "\n",
+        "        return bug_dict\n",
+        "    except ET.ParseError as e:\n",
+        "        print(f\"Error parsing {file_path}: {e}\")\n",
+        "        return {}\n",
+        "\n",
+        "def process_project(project):\n",
+        "    print(f\"\\nProcessing project: {project}\")\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Parse all relevant files\n",
+        "    status_dict = parse_xml_file(os.path.join(project_folder, 'bug_status.xml'))\n",
+        "    resolution_dict = parse_xml_file(os.path.join(project_folder, 'resolution.xml'))\n",
+        "    severity_dict = parse_xml_file(os.path.join(project_folder, 'severity.xml'))\n",
+        "\n",
+        "    # Print debug information\n",
+        "    print(f\"Total bugs with status: {len(status_dict)}\")\n",
+        "    print(f\"Status values found: {set(status_dict.values())}\")\n",
+        "    print(f\"Total bugs with resolution: {len(resolution_dict)}\")\n",
+        "    print(f\"Resolution values found: {set(resolution_dict.values())}\")\n",
+        "    print(f\"Total bugs with severity: {len(severity_dict)}\")\n",
+        "    print(f\"Severity values found: {set(severity_dict.values())}\")\n",
+        "\n",
+        "    # Create records for bugs that meet all conditions\n",
+        "    records = []\n",
+        "    for bug_id in status_dict:\n",
+        "        if (bug_id in resolution_dict and\n",
+        "            bug_id in severity_dict and\n",
+        "            status_dict[bug_id] == 'RESOLVED' and\n",
+        "            resolution_dict[bug_id] == 'FIXED'):\n",
+        "\n",
+        "            records.append({\n",
+        "                'project': project,\n",
+        "                'bug_id': bug_id,\n",
+        "                'severity': severity_dict[bug_id].lower(),\n",
+        "                'status': status_dict[bug_id],\n",
+        "                'resolution': resolution_dict[bug_id]\n",
+        "            })\n",
+        "\n",
+        "    df = pd.DataFrame(records)\n",
+        "    print(f\"\\nFound {len(df)} bugs with status='RESOLVED', resolution='FIXED' and severity for {project}\")\n",
+        "    if not df.empty:\n",
+        "        print(\"\\nSeverity distribution:\")\n",
+        "        print(df['severity'].value_counts())\n",
+        "\n",
+        "    return df\n",
+        "\n",
+        "# Process all projects and combine data\n",
+        "dfs = []\n",
+        "for project in projects:\n",
+        "    df = process_project(project)\n",
+        "    if not df.empty:\n",
+        "        dfs.append(df)\n",
+        "\n",
+        "if dfs:\n",
+        "    all_data = pd.concat(dfs, ignore_index=True)\n",
+        "\n",
+        "    # Print data summary\n",
+        "    print(\"\\nOverall Data Summary:\")\n",
+        "    print(f\"Total number of bugs: {len(all_data)}\")\n",
+        "    print(\"\\nBugs per project:\")\n",
+        "    print(all_data['project'].value_counts())\n",
+        "    print(\"\\nSeverity levels found:\")\n",
+        "    print(all_data['severity'].value_counts())\n",
+        "\n",
+        "    # Create visualization\n",
+        "    plt.figure(figsize=(15, 8))\n",
+        "    sns.countplot(data=all_data, x='project', hue='severity')\n",
+        "    plt.title('Distribution of Severity Labels for Resolved & Fixed Bugs by Project')\n",
+        "    plt.xlabel('Project')\n",
+        "    plt.ylabel('Number of Bugs')\n",
+        "    plt.xticks(rotation=45)\n",
+        "    plt.legend(title='Severity', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    # Print summary statistics\n",
+        "    print(\"\\nSummary Statistics:\")\n",
+        "    summary = all_data.groupby(['project', 'severity']).size().unstack(fill_value=0)\n",
+        "    print(summary)\n",
+        "\n",
+        "    # Calculate percentages\n",
+        "    percentages = summary.div(summary.sum(axis=1), axis=0) * 100\n",
+        "    print(\"\\nPercentage Distribution:\")\n",
+        "    print(percentages.round(2))\n",
+        "else:\n",
+        "    print(\"\\nNo data found to visualize\")\n",
+        "    print(\"Please check:\")\n",
+        "    print(\"1. Are there any bugs with status='RESOLVED'?\")\n",
+        "    print(\"2. Of those resolved bugs, are any marked as resolution='FIXED'?\")\n",
+        "    print(\"3. Do those resolved and fixed bugs have corresponding severity information?\")\n",
+        "    print(\"4. Are the bug IDs matching across all three files (status, resolution, severity)?\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "H5gxUQjQFw8G",
+        "outputId": "9ad2f1af-2436-4753-fc6f-5c17eb3a1cd8"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Processing project: Bugzilla\n",
+            "Total bugs with status: 4616\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 4616\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 4616\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 2375 bugs with status='RESOLVED', resolution='FIXED' and severity for Bugzilla\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      996\n",
+            "minor       483\n",
+            "trivial     285\n",
+            "blocker     262\n",
+            "major       251\n",
+            "critical     98\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: CDT\n",
+            "Total bugs with status: 5640\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 5640\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 5640\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'MINOR', 'NORMAL', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 3982 bugs with status='RESOLVED', resolution='FIXED' and severity for CDT\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      3368\n",
+            "major        261\n",
+            "minor        177\n",
+            "critical      79\n",
+            "trivial       63\n",
+            "blocker       34\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Core\n",
+            "Total bugs with status: 74292\n",
+            "Status values found: {'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 74292\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 74292\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 41299 bugs with status='RESOLVED', resolution='FIXED' and severity for Core\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      33990\n",
+            "critical     3956\n",
+            "major        1532\n",
+            "minor        1000\n",
+            "trivial       578\n",
+            "blocker       243\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Firefox\n",
+            "Total bugs with status: 69879\n",
+            "Status values found: {'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 69879\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 69879\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 8474 bugs with status='RESOLVED', resolution='FIXED' and severity for Firefox\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      7143\n",
+            "major        414\n",
+            "minor        342\n",
+            "trivial      316\n",
+            "critical     178\n",
+            "blocker       81\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: JDT\n",
+            "Total bugs with status: 10814\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 10814\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 10814\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 1928 bugs with status='RESOLVED', resolution='FIXED' and severity for JDT\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      1584\n",
+            "minor        185\n",
+            "trivial      120\n",
+            "major         28\n",
+            "critical      10\n",
+            "blocker        1\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: PDE\n",
+            "Total bugs with status: 5655\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 5655\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 5655\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 2688 bugs with status='RESOLVED', resolution='FIXED' and severity for PDE\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2285\n",
+            "major        167\n",
+            "minor        118\n",
+            "trivial       55\n",
+            "critical      50\n",
+            "blocker       13\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Platform\n",
+            "Total bugs with status: 24775\n",
+            "Status values found: {'CLOSED', 'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 24775\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'NOT_ECLIPSE', 'INVALID'}\n",
+            "Total bugs with severity: 24775\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'NORMAL', 'MINOR', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 7623 bugs with status='RESOLVED', resolution='FIXED' and severity for Platform\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      6044\n",
+            "major        677\n",
+            "minor        298\n",
+            "trivial      271\n",
+            "critical     249\n",
+            "blocker       84\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Processing project: Thunderbird\n",
+            "Total bugs with status: 19237\n",
+            "Status values found: {'VERIFIED', 'RESOLVED'}\n",
+            "Total bugs with resolution: 19237\n",
+            "Resolution values found: {'FIXED', 'WONTFIX', 'DUPLICATE', 'WORKSFORME', 'INCOMPLETE', 'INVALID'}\n",
+            "Total bugs with severity: 19237\n",
+            "Severity values found: {'MAJOR', 'TRIVIAL', 'MINOR', 'NORMAL', 'CRITICAL', 'BLOCKER'}\n",
+            "\n",
+            "Found 3310 bugs with status='RESOLVED', resolution='FIXED' and severity for Thunderbird\n",
+            "\n",
+            "Severity distribution:\n",
+            "severity\n",
+            "normal      2615\n",
+            "major        231\n",
+            "minor        196\n",
+            "trivial      133\n",
+            "critical     115\n",
+            "blocker       20\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Overall Data Summary:\n",
+            "Total number of bugs: 71679\n",
+            "\n",
+            "Bugs per project:\n",
+            "project\n",
+            "Core           41299\n",
+            "Firefox         8474\n",
+            "Platform        7623\n",
+            "CDT             3982\n",
+            "Thunderbird     3310\n",
+            "PDE             2688\n",
+            "Bugzilla        2375\n",
+            "JDT             1928\n",
+            "Name: count, dtype: int64\n",
+            "\n",
+            "Severity levels found:\n",
+            "severity\n",
+            "normal      58025\n",
+            "critical     4735\n",
+            "major        3561\n",
+            "minor        2799\n",
+            "trivial      1821\n",
+            "blocker       738\n",
+            "Name: count, dtype: int64\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x800 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Summary Statistics:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla         262        98    251    483     996      285\n",
+            "CDT               34        79    261    177    3368       63\n",
+            "Core             243      3956   1532   1000   33990      578\n",
+            "Firefox           81       178    414    342    7143      316\n",
+            "JDT                1        10     28    185    1584      120\n",
+            "PDE               13        50    167    118    2285       55\n",
+            "Platform          84       249    677    298    6044      271\n",
+            "Thunderbird       20       115    231    196    2615      133\n",
+            "\n",
+            "Percentage Distribution:\n",
+            "severity     blocker  critical  major  minor  normal  trivial\n",
+            "project                                                      \n",
+            "Bugzilla       11.03      4.13  10.57  20.34   41.94    12.00\n",
+            "CDT             0.85      1.98   6.55   4.45   84.58     1.58\n",
+            "Core            0.59      9.58   3.71   2.42   82.30     1.40\n",
+            "Firefox         0.96      2.10   4.89   4.04   84.29     3.73\n",
+            "JDT             0.05      0.52   1.45   9.60   82.16     6.22\n",
+            "PDE             0.48      1.86   6.21   4.39   85.01     2.05\n",
+            "Platform        1.10      3.27   8.88   3.91   79.29     3.56\n",
+            "Thunderbird     0.60      3.47   6.98   5.92   79.00     4.02\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "e_66e828k0Ss",
+        "outputId": "12a301f2-b8b6-4f85-b428-887d485f929d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
+            "Project: Bugzilla, Total number of bug reports with severity 'enhancement': 34\n",
+            "Project: CDT, Total number of bug reports with severity 'enhancement': 13\n",
+            "Project: Core, Total number of bug reports with severity 'enhancement': 60\n",
+            "Project: Firefox, Total number of bug reports with severity 'enhancement': 77\n",
+            "Project: JDT, Total number of bug reports with severity 'enhancement': 37\n",
+            "Project: PDE, Total number of bug reports with severity 'enhancement': 4\n",
+            "Project: Platform, Total number of bug reports with severity 'enhancement': 56\n",
+            "Project: Thunderbird, Total number of bug reports with severity 'enhancement': 54\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Mount Google Drive #Skip\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def process_project(project):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Create an empty DataFrame to store bug data\n",
+        "    bug_data_df = pd.DataFrame(columns=['Project', 'Bug ID', 'Severity Label', 'Resolution Status', 'Short Description'])\n",
+        "\n",
+        "    # Load all data into the DataFrame\n",
+        "    for xml_file in ['short_desc.xml', 'severity.xml', 'resolution.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Identify the type of XML file and extract relevant information\n",
+        "            if xml_file == 'short_desc.xml':\n",
+        "                reports = root.findall('.//report')\n",
+        "            elif xml_file == 'severity.xml':\n",
+        "                severities = root.findall('.//report')\n",
+        "            elif xml_file == 'resolution.xml':\n",
+        "                resolutions = root.findall('.//report')\n",
+        "\n",
+        "    # Filter bug reports with severity = \"enhancement\"\n",
+        "    enhancement_bug_reports = [severity for severity in severities if severity.find('.//what[last()]') is not None and severity.find('.//what[last()]').text and severity.find('.//what[last()]').text.lower() == 'enhancement']\n",
+        "    total_enhancement_bug_reports = len(enhancement_bug_reports)\n",
+        "\n",
+        "    return total_enhancement_bug_reports\n",
+        "\n",
+        "# Display the number of bug reports with severity = \"enhancement\" for each project\n",
+        "for project in projects:\n",
+        "    total_enhancement_reports = process_project(project)\n",
+        "    print(f\"Project: {project}, Total number of bug reports with severity 'enhancement': {total_enhancement_reports}\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "B9AmEl8ampuG",
+        "outputId": "14600c17-a9fd-46d1-b28e-ec08fff57f95"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Unique Resolution Statuses:\n",
+            "fixed\n",
+            "remind\n",
+            "incomplete\n",
+            "invalid\n",
+            "duplicate\n",
+            "not_eclipse\n",
+            "worksforme\n",
+            "later\n",
+            "wontfix\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "# Set to store unique resolution statuses\n",
+        "unique_resolution_statuses = set()\n",
+        "\n",
+        "def process_project(project):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Load all data into the DataFrame\n",
+        "    for xml_file in ['resolution.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Extract resolution statuses\n",
+        "            resolutions = root.findall('.//report/update/what')\n",
+        "            statuses = {status.text.lower() for status in resolutions if status.text is not None}\n",
+        "            unique_resolution_statuses.update(statuses)\n",
+        "\n",
+        "# Process each project to gather unique resolution statuses\n",
+        "for project in projects:\n",
+        "    process_project(project)\n",
+        "\n",
+        "# Display all unique resolution statuses\n",
+        "print(\"Unique Resolution Statuses:\")\n",
+        "for status in unique_resolution_statuses:\n",
+        "    print(status)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "RoOi_DU8nvdk",
+        "outputId": "7713b7f5-4042-4611-d0b8-572bccfdf90a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Project: Bugzilla\n",
+            "Resolution Status: Fixed, Total: 2542\n",
+            "Resolution Status: Remind, Total: 0\n",
+            "Resolution Status: Incomplete, Total: 10\n",
+            "Resolution Status: Invalid, Total: 885\n",
+            "Resolution Status: Duplicate, Total: 892\n",
+            "Resolution Status: Not_eclipse, Total: 0\n",
+            "Resolution Status: Worksforme, Total: 542\n",
+            "Resolution Status: Later, Total: 0\n",
+            "Resolution Status: Wontfix, Total: 213\n",
+            "\n",
+            "\n",
+            "Project: CDT\n",
+            "Resolution Status: Fixed, Total: 4581\n",
+            "Resolution Status: Remind, Total: 2\n",
+            "Resolution Status: Incomplete, Total: 0\n",
+            "Resolution Status: Invalid, Total: 397\n",
+            "Resolution Status: Duplicate, Total: 704\n",
+            "Resolution Status: Not_eclipse, Total: 70\n",
+            "Resolution Status: Worksforme, Total: 216\n",
+            "Resolution Status: Later, Total: 0\n",
+            "Resolution Status: Wontfix, Total: 132\n",
+            "\n",
+            "\n",
+            "Project: Core\n",
+            "Resolution Status: Fixed, Total: 50961\n",
+            "Resolution Status: Remind, Total: 0\n",
+            "Resolution Status: Incomplete, Total: 1606\n",
+            "Resolution Status: Invalid, Total: 5262\n",
+            "Resolution Status: Duplicate, Total: 11533\n",
+            "Resolution Status: Not_eclipse, Total: 0\n",
+            "Resolution Status: Worksforme, Total: 8564\n",
+            "Resolution Status: Later, Total: 0\n",
+            "Resolution Status: Wontfix, Total: 2776\n",
+            "\n",
+            "\n",
+            "Project: Firefox\n",
+            "Resolution Status: Fixed, Total: 15622\n",
+            "Resolution Status: Remind, Total: 0\n",
+            "Resolution Status: Incomplete, Total: 15731\n",
+            "Resolution Status: Invalid, Total: 12107\n",
+            "Resolution Status: Duplicate, Total: 20320\n",
+            "Resolution Status: Not_eclipse, Total: 0\n",
+            "Resolution Status: Worksforme, Total: 11646\n",
+            "Resolution Status: Later, Total: 0\n",
+            "Resolution Status: Wontfix, Total: 2256\n",
+            "\n",
+            "\n",
+            "Project: JDT\n",
+            "Resolution Status: Fixed, Total: 6451\n",
+            "Resolution Status: Remind, Total: 299\n",
+            "Resolution Status: Incomplete, Total: 0\n",
+            "Resolution Status: Invalid, Total: 1066\n",
+            "Resolution Status: Duplicate, Total: 2307\n",
+            "Resolution Status: Not_eclipse, Total: 175\n",
+            "Resolution Status: Worksforme, Total: 1346\n",
+            "Resolution Status: Later, Total: 162\n",
+            "Resolution Status: Wontfix, Total: 611\n",
+            "\n",
+            "\n",
+            "Project: PDE\n",
+            "Resolution Status: Fixed, Total: 4242\n",
+            "Resolution Status: Remind, Total: 3\n",
+            "Resolution Status: Incomplete, Total: 0\n",
+            "Resolution Status: Invalid, Total: 317\n",
+            "Resolution Status: Duplicate, Total: 849\n",
+            "Resolution Status: Not_eclipse, Total: 22\n",
+            "Resolution Status: Worksforme, Total: 455\n",
+            "Resolution Status: Later, Total: 5\n",
+            "Resolution Status: Wontfix, Total: 171\n",
+            "\n",
+            "\n",
+            "Project: Platform\n",
+            "Resolution Status: Fixed, Total: 14916\n",
+            "Resolution Status: Remind, Total: 231\n",
+            "Resolution Status: Incomplete, Total: 0\n",
+            "Resolution Status: Invalid, Total: 1948\n",
+            "Resolution Status: Duplicate, Total: 5047\n",
+            "Resolution Status: Not_eclipse, Total: 504\n",
+            "Resolution Status: Worksforme, Total: 2513\n",
+            "Resolution Status: Later, Total: 79\n",
+            "Resolution Status: Wontfix, Total: 1708\n",
+            "\n",
+            "\n",
+            "Project: Thunderbird\n",
+            "Resolution Status: Fixed, Total: 4569\n",
+            "Resolution Status: Remind, Total: 0\n",
+            "Resolution Status: Incomplete, Total: 3321\n",
+            "Resolution Status: Invalid, Total: 2698\n",
+            "Resolution Status: Duplicate, Total: 7075\n",
+            "Resolution Status: Not_eclipse, Total: 0\n",
+            "Resolution Status: Worksforme, Total: 3164\n",
+            "Resolution Status: Later, Total: 0\n",
+            "Resolution Status: Wontfix, Total: 380\n",
+            "\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def count_resolution_statuses(project, resolution_statuses):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Load all resolution data into the DataFrame\n",
+        "    for xml_file in ['resolution.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Identify the type of XML file and extract relevant information\n",
+        "            if xml_file == 'resolution.xml':\n",
+        "                resolutions = root.findall('.//report/update')\n",
+        "\n",
+        "    # Count bug reports for each specified resolution status\n",
+        "    status_counts = {}\n",
+        "    for status in resolution_statuses:\n",
+        "        filtered_reports = [\n",
+        "            resolution for resolution in resolutions if resolution.find('.//what[last()]') is not None\n",
+        "            and resolution.find('.//what[last()]').text\n",
+        "            and resolution.find('.//what[last()]').text.lower() == status.lower()\n",
+        "        ]\n",
+        "        status_counts[status] = len(filtered_reports)\n",
+        "\n",
+        "    return status_counts\n",
+        "\n",
+        "# Define the resolution statuses to count\n",
+        "resolution_statuses_to_count = ['fixed', 'remind', 'incomplete', 'invalid', 'duplicate', 'not_eclipse', 'worksforme', 'later', 'wontfix']\n",
+        "\n",
+        "# Display the number of bug reports for each specified resolution status in each project\n",
+        "for project in projects:\n",
+        "    total_resolution_statuses = count_resolution_statuses(project, resolution_statuses_to_count)\n",
+        "    print(f\"Project: {project}\")\n",
+        "    for status, count in total_resolution_statuses.items():\n",
+        "        print(f\"Resolution Status: {status.capitalize()}, Total: {count}\")\n",
+        "    print(\"\\n\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "from collections import defaultdict\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def analyze_bug_reports(project):\n",
+        "    \"\"\"\n",
+        "    Analyzes bug reports for a given project, counting fixed bugs by severity.\n",
+        "    Returns a dictionary with counts for each severity level.\n",
+        "    \"\"\"\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Dictionary to store bug_id -> severity mapping\n",
+        "    bug_severities = {}\n",
+        "    # Dictionary to store fixed bug IDs\n",
+        "    fixed_bugs = set()\n",
+        "    # Dictionary to store counts by severity\n",
+        "    severity_counts = defaultdict(int)\n",
+        "\n",
+        "    # First, load all severity data\n",
+        "    severity_file = os.path.join(project_folder, 'severity.xml')\n",
+        "    if os.path.exists(severity_file):\n",
+        "        try:\n",
+        "            tree = ET.parse(severity_file)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            for update in root.findall('.//update'):\n",
+        "                bug_id_elem = update.find('.//bug_id')\n",
+        "                what_elem = update.find('.//what[last()]')\n",
+        "\n",
+        "                if bug_id_elem is not None and bug_id_elem.text and what_elem is not None and what_elem.text:\n",
+        "                    bug_severities[bug_id_elem.text] = what_elem.text.lower()\n",
+        "        except ET.ParseError:\n",
+        "            print(f\"Warning: Could not parse severity file for {project}\")\n",
+        "\n",
+        "    # Then, process resolution data\n",
+        "    resolution_file = os.path.join(project_folder, 'resolution.xml')\n",
+        "    if os.path.exists(resolution_file):\n",
+        "        try:\n",
+        "            tree = ET.parse(resolution_file)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            for update in root.findall('.//update'):\n",
+        "                bug_id_elem = update.find('.//bug_id')\n",
+        "                what_elem = update.find('.//what[last()]')\n",
+        "\n",
+        "                if (bug_id_elem is not None and bug_id_elem.text and\n",
+        "                    what_elem is not None and what_elem.text and\n",
+        "                    what_elem.text.lower() == 'fixed'):\n",
+        "                    fixed_bugs.add(bug_id_elem.text)\n",
+        "        except ET.ParseError:\n",
+        "            print(f\"Warning: Could not parse resolution file for {project}\")\n",
+        "\n",
+        "    # Count fixed bugs by severity\n",
+        "    for bug_id in fixed_bugs:\n",
+        "        if bug_id in bug_severities:\n",
+        "            severity = bug_severities[bug_id]\n",
+        "            severity_counts[severity] += 1\n",
+        "\n",
+        "    return dict(severity_counts)\n",
+        "\n",
+        "# Process all projects and store results\n",
+        "results = {}\n",
+        "for project in projects:\n",
+        "    print(f\"Processing {project}...\")\n",
+        "    try:\n",
+        "        results[project] = analyze_bug_reports(project)\n",
+        "    except Exception as e:\n",
+        "        print(f\"Error processing {project}: {str(e)}\")\n",
+        "        results[project] = {}\n",
+        "\n",
+        "# Create a DataFrame for better visualization\n",
+        "df = pd.DataFrame(results).fillna(0)\n",
+        "df = df.astype(int)\n",
+        "\n",
+        "# Display results\n",
+        "print(\"\\nBug Reports by Project and Severity (Resolution = Fixed):\")\n",
+        "print(\"=\" * 80)\n",
+        "print(df)\n",
+        "\n",
+        "# Optional: Save to CSV\n",
+        "df.to_csv('bug_reports_by_severity.csv')\n",
+        "\n",
+        "# Print totals\n",
+        "print(\"\\nTotal fixed bugs by project:\")\n",
+        "print(\"-\" * 40)\n",
+        "for project in projects:\n",
+        "    total = sum(results[project].values())\n",
+        "    print(f\"{project}: {total}\")\n",
+        "\n",
+        "print(\"\\nTotal fixed bugs by severity:\")\n",
+        "print(\"-\" * 40)\n",
+        "total_by_severity = defaultdict(int)\n",
+        "for project_data in results.values():\n",
+        "    for severity, count in project_data.items():\n",
+        "        total_by_severity[severity] += count\n",
+        "\n",
+        "for severity, total in sorted(total_by_severity.items()):\n",
+        "    print(f\"{severity}: {total}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2TRJNSzj_qFR",
+        "outputId": "d14cb303-1210-4276-aa29-7008f249a192"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Processing Bugzilla...\n",
+            "Processing CDT...\n",
+            "Processing Core...\n",
+            "Processing Firefox...\n",
+            "Processing JDT...\n",
+            "Processing PDE...\n",
+            "Processing Platform...\n",
+            "Processing Thunderbird...\n",
+            "\n",
+            "Bug Reports by Project and Severity (Resolution = Fixed):\n",
+            "================================================================================\n",
+            "Empty DataFrame\n",
+            "Columns: [Bugzilla, CDT, Core, Firefox, JDT, PDE, Platform, Thunderbird]\n",
+            "Index: []\n",
+            "\n",
+            "Total fixed bugs by project:\n",
+            "----------------------------------------\n",
+            "Bugzilla: 0\n",
+            "CDT: 0\n",
+            "Core: 0\n",
+            "Firefox: 0\n",
+            "JDT: 0\n",
+            "PDE: 0\n",
+            "Platform: 0\n",
+            "Thunderbird: 0\n",
+            "\n",
+            "Total fixed bugs by severity:\n",
+            "----------------------------------------\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dVAha1qRsT4f",
+        "outputId": "159e2848-e129-4aa9-ec30-cc251eeaae67"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Project: Bugzilla, Total number of bug reports: 4616\n",
+            "Project: CDT, Total number of bug reports: 5640\n",
+            "Project: Core, Total number of bug reports: 74292\n",
+            "Project: Firefox, Total number of bug reports: 69879\n",
+            "Project: JDT, Total number of bug reports: 10814\n",
+            "Project: PDE, Total number of bug reports: 5655\n",
+            "Project: Platform, Total number of bug reports: 24775\n",
+            "Project: Thunderbird, Total number of bug reports: 19237\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def process_project(project):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Load all data into the DataFrame\n",
+        "    for xml_file in ['short_desc.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Identify the type of XML file and extract relevant information\n",
+        "            if xml_file == 'short_desc.xml':\n",
+        "                reports = root.findall('.//report')\n",
+        "\n",
+        "    # Count bug reports for the project\n",
+        "    bug_reports_count = len(reports) if reports else 0\n",
+        "\n",
+        "    return bug_reports_count\n",
+        "\n",
+        "# Display the number of bug reports for each project\n",
+        "for project in projects:\n",
+        "    total_bug_reports = process_project(project)\n",
+        "    print(f\"Project: {project}, Total number of bug reports: {total_bug_reports}\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "W66j1d0Hvqae",
+        "outputId": "b66b3bf8-98aa-49b9-8042-454ff609267a"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Project: Bugzilla, Total number of bug reports with severity 'normal': 2880\n",
+            "Project: CDT, Total number of bug reports with severity 'normal': 4597\n",
+            "Project: Core, Total number of bug reports with severity 'normal': 58340\n",
+            "Project: Firefox, Total number of bug reports with severity 'normal': 49027\n",
+            "Project: JDT, Total number of bug reports with severity 'normal': 8563\n",
+            "Project: PDE, Total number of bug reports with severity 'normal': 4807\n",
+            "Project: Platform, Total number of bug reports with severity 'normal': 19460\n",
+            "Project: Thunderbird, Total number of bug reports with severity 'normal': 13230\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import xml.etree.ElementTree as ET\n",
+        "import zipfile\n",
+        "import pandas as pd\n",
+        "\n",
+        "# Define paths\n",
+        "zip_file_path = '/content/drive/My Drive/test1.zip'\n",
+        "destination_directory = '/content/unzipped_data/'\n",
+        "\n",
+        "# Ensure the destination directory exists\n",
+        "os.makedirs(destination_directory, exist_ok=True)\n",
+        "\n",
+        "# Extract the ZIP file\n",
+        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall(destination_directory)\n",
+        "\n",
+        "# List of project names to process\n",
+        "projects = ['Bugzilla', 'CDT', 'Core', 'Firefox', 'JDT', 'PDE', 'Platform', 'Thunderbird']\n",
+        "\n",
+        "def count_specific_severity(project, severity_label):\n",
+        "    # Define paths for the current project\n",
+        "    project_folder = os.path.join(destination_directory, project)\n",
+        "\n",
+        "    # Load all severity data into the DataFrame\n",
+        "    for xml_file in ['severity.xml']:\n",
+        "        file_path = os.path.join(project_folder, xml_file)\n",
+        "\n",
+        "        # Check if the file exists\n",
+        "        if os.path.exists(file_path):\n",
+        "            # Parse the XML file\n",
+        "            tree = ET.parse(file_path)\n",
+        "            root = tree.getroot()\n",
+        "\n",
+        "            # Identify the type of XML file and extract relevant information\n",
+        "            if xml_file == 'severity.xml':\n",
+        "                severities = root.findall('.//report')\n",
+        "\n",
+        "    # Filter bug reports with specific severity\n",
+        "    specific_severity_bug_reports = [\n",
+        "        severity for severity in severities if severity.find('.//what[last()]') is not None\n",
+        "        and severity.find('.//what[last()]').text\n",
+        "        and severity.find('.//what[last()]').text.lower() == severity_label.lower()\n",
+        "    ]\n",
+        "\n",
+        "    total_specific_severity_bug_reports = len(specific_severity_bug_reports)\n",
+        "    return total_specific_severity_bug_reports\n",
+        "\n",
+        "# Define the severity label to count (e.g., 'trivial')\n",
+        "severity_label_to_count = 'normal'\n",
+        "\n",
+        "# Display the number of bug reports with the specific severity label for each project\n",
+        "for project in projects:\n",
+        "    total_specific_severity_reports = count_specific_severity(project, severity_label_to_count)\n",
+        "    print(f\"Project: {project}, Total number of bug reports with severity '{severity_label_to_count}': {total_specific_severity_reports}\")\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file