Detecting_phishing_websites.ipynb

{"cells":[{"cell_type":"code","source":["!pip install python-whois\n","!pip install tldextract"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"xSfsCUjbXIA7","executionInfo":{"status":"ok","timestamp":1682442002622,"user_tz":-330,"elapsed":23857,"user":{"displayName":"Aayush Pandey","userId":"14718762458990746545"}},"outputId":"5bccb390-6bc8-4ddd-ac5c-c68a0350dc99"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting python-whois\n","  Downloading python-whois-0.8.0.tar.gz (109 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m109.6/109.6 kB\u001b[0m \u001b[31m3.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: future in /usr/local/lib/python3.9/dist-packages (from python-whois) (0.18.3)\n","Building wheels for collected packages: python-whois\n","  Building wheel for python-whois (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for python-whois: filename=python_whois-0.8.0-py3-none-any.whl size=103262 sha256=092428b1b7de6189ed19a220faf8a6b469afc1b16c80679cf4f1040b211e71bf\n","  Stored in directory: /root/.cache/pip/wheels/e6/e9/d3/1e41a6c95b398de12c5a332ff28805aa44e68aa317ea60266d\n","Successfully built python-whois\n","Installing collected packages: python-whois\n","Successfully installed python-whois-0.8.0\n","Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting tldextract\n","  Downloading tldextract-3.4.0-py3-none-any.whl (93 kB)\n","\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m93.9/93.9 kB\u001b[0m \u001b[31m2.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hRequirement already satisfied: filelock>=3.0.8 in /usr/local/lib/python3.9/dist-packages (from tldextract) (3.11.0)\n","Requirement already satisfied: idna in /usr/local/lib/python3.9/dist-packages (from tldextract) (3.4)\n","Collecting requests-file>=1.4\n","  Downloading requests_file-1.5.1-py2.py3-none-any.whl (3.7 kB)\n","Requirement already satisfied: requests>=2.1.0 in /usr/local/lib/python3.9/dist-packages (from tldextract) (2.27.1)\n","Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests>=2.1.0->tldextract) (2.0.12)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests>=2.1.0->tldextract) (2022.12.7)\n","Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests>=2.1.0->tldextract) (1.26.15)\n","Requirement already satisfied: six in /usr/local/lib/python3.9/dist-packages (from requests-file>=1.4->tldextract) (1.16.0)\n","Installing collected packages: requests-file, tldextract\n","Successfully installed requests-file-1.5.1 tldextract-3.4.0\n"]}]},{"cell_type":"code","execution_count":null,"metadata":{"id":"oLLVchz3oA_3"},"outputs":[],"source":["# Load the required packages\n","\n","import pandas as pd\n","import numpy as np\n","import sys\n","import re\n","\n","from urllib.parse import urlparse,urlencode\n","# from bs4 import BeautifulSoup\n","from datetime import datetime\n","import ipaddress\n","import whois\n","import urllib\n","import urllib.request\n","import tldextract\n","\n","import pickle\n","\n","\n","class FeatureExtract:\n","\n","# This class contains the methods that extract the required features\n","# Across the entire dataset, 0 indicates legitimate url and 1 indicates phishing url\n","# Legitimate - 0; Phishing - 1\n","\n","\n","    def __init__(self):\n","        pass\n","\n","    \n","    # def rank(self,url):\n","\n","    #     # Method to check rank of the URL by connecting to the alexa rank API\n","    #     # Returns 0 if the rank is less than 100000 for the given URL else returns 1\n","        \n","    #     try:\n","            \n","    #         #Filling the whitespaces in the URL if any\n","            \n","    #         url = urllib.parse.quote(url)\n","    #         rank = BeautifulSoup(urllib.request.urlopen(\"http://data.alexa.com/data?cli=10&url=\" + url).read(), \"xml\").find(\n","    #             \"REACH\")['RANK']\n","    #         print('Hello')\n","    #         rank = int(rank)\n","    #     except TypeError:\n","    #         return 1\n","    #     if rank <100000:\n","    #         return 0\n","    #     else:\n","    #         return 1\n","        \n","\n","    def isIP(self,url):\n","        \n","        # Method to check if an IP is found in the URL\n","        # Returns 1 if IP is found in the given URL else returns 0\n","        \n","        try:\n","            ipaddress.ip_address(url)\n","            ip = 1\n","        except:\n","            ip = 0\n","        return ip\n","    \n","\n","    def isValid(self,domain_name):\n","        \n","        # Method to check the validity of the URL domain\n","        # Returns 1 if age of the domain is less than 6 else returns 0\n","        \n","        creation_date = domain_name.creation_date\n","        expiration_date = domain_name.expiration_date\n","        if (isinstance(creation_date,str) or isinstance(expiration_date,str)):\n","            try:\n","                creation_date = datetime.strptime(creation_date,'%Y-%m-%d')\n","                expiration_date = datetime.strptime(expiration_date,\"%Y-%m-%d\")\n","            except:\n","                  return 1\n","        if ((expiration_date is None) or (creation_date is None)):\n","            return 1\n","        elif ((type(expiration_date) is list) or (type(creation_date) is list)):\n","            return 1\n","        else:\n","            ageofdomain = abs((expiration_date - creation_date).days)\n","            if ((ageofdomain/30) < 6):\n","                age = 1\n","            else:\n","                age = 0\n","        return age\n","\n","\n","    def domain_reg_len(self,domain_name):\n","        \n","        # Method to check the expiration of the URL domain\n","        # Returns 1 if the domain has expired else returns 0\n","        print('hello')\n","        expiration_date = domain_name.expiration_date\n","        if isinstance(expiration_date,str):\n","            try:\n","                expiration_date = datetime.strptime(expiration_date,\"%Y-%m-%d\")\n","            except:\n","                return 1\n","        if (expiration_date is None):\n","            return 1\n","        elif (type(expiration_date) is list):\n","            return 1\n","        else:\n","            today = datetime.now()\n","            end = abs((expiration_date - today).days)\n","            if ((end/30) < 6):\n","                end = 0\n","            else:\n","                end = 1\n","        return end\n","\n","\n","    def isat(self,url):\n","        \n","        # Method to check for '@' in the URL\n","        # Returns 1 if found else returns 0\n","        \n","        if \"@\" in url:\n","            return 1    \n","        else:\n","            return 0    \n","\n","\n","    def isRedirect(self,url):\n","        \n","        # Method to check for '//' in the URL\n","        # Returns 1 if found within length of 7 for the given URL or if 'http' is found else returns 0\n","        \n","        pos = url.rfind('//')\n","        if pos > 6:\n","            if pos > 7:\n","                return 1\n","            else:\n","                return 0\n","        else:\n","            return 0\n","\n","\n","    def haveDash(self,url):\n","        \n","        # Method to check for '-' in the URL\n","        # Returns 1 if found else returns 0\n","        \n","        if '-' in urlparse(url).netloc:\n","            return 1            \n","        else:\n","            return 0   \n","    \n","\n","    def no_sub_domain(self,url):\n","        \n","        # Method to check number of subdomains in the URL\n","        # Returns 0 if number of subdomains is 1 else returns 1\n","\n","        url = str(url)\n","        url = url.replace(\"www.\",\"\")\n","        url = url.replace(\".\"+tldextract.extract(url).suffix,\"\")\n","        count = url.count(\".\")\n","        if count==1:\n","            return 0\n","        else:\n","            return 1\n","\n","\n","\n","    def httpDomain(self,url):\n","        \n","        # Method to check for 'https' in the URL\n","        # Returns 1 if found else returns 0\n","\n","        domain = urlparse(url).netloc\n","        if 'http' in domain:\n","            return 1\n","        else:\n","            return 0\n","\n","\n","    def LongURL(self,url):\n","        \n","        # Method to checks the length of the URL\n","        # Returns 0 if the length is less than 54 else returns 1\n","\n","        if len(url) < 54:\n","            return 0           \n","        else:\n","            return 1            \n","\n","\n","    def tinyURL(self,url):\n","        \n","        # Method to check if the URL belong to shortening services\n","        # Returns 1 if found else returns 0\n","        \n","        #listing shortening services\n","    \n","        shortening_services = r\"bit\\.ly|goo\\.gl|shorte\\.st|go2l\\.ink|x\\.co|ow\\.ly|t\\.co|tinyurl|tr\\.im|is\\.gd|cli\\.gs|\" \\\n","                      r\"yfrog\\.com|migre\\.me|ff\\.im|tiny\\.cc|url4\\.eu|twit\\.ac|su\\.pr|twurl\\.nl|snipurl\\.com|\" \\\n","                      r\"short\\.to|BudURL\\.com|ping\\.fm|post\\.ly|Just\\.as|bkite\\.com|snipr\\.com|fic\\.kr|loopt\\.us|\" \\\n","                      r\"doiop\\.com|short\\.ie|kl\\.am|wp\\.me|rubyurl\\.com|om\\.ly|to\\.ly|bit\\.do|t\\.co|lnkd\\.in|db\\.tt|\" \\\n","                      r\"qr\\.ae|adf\\.ly|goo\\.gl|bitly\\.com|cur\\.lv|tinyurl\\.com|ow\\.ly|bit\\.ly|ity\\.im|q\\.gs|is\\.gd|\" \\\n","                      r\"po\\.st|bc\\.vc|twitthis\\.com|u\\.to|j\\.mp|buzurl\\.com|cutt\\.us|u\\.bb|yourls\\.org|x\\.co|\" \\\n","                      r\"prettylinkpro\\.com|scrnch\\.me|filoops\\.info|vzturl\\.com|qr\\.net|1url\\.com|tweez\\.me|v\\.gd|\" \\\n","                      r\"tr\\.im|link\\.zip\\.net\"\n","        match=re.search(shortening_services,url)\n","        if match:\n","            return 1\n","        else:\n","            return 0\n","\n","\n","\n","\n","\n","class PredictURL(FeatureExtract):\n","    \n","    # This class inherits FeatureExtract class to access all its methods\n","    # The main classification of the URL is done via the methods of this class\n","    \n","    def __init__(self):\n","        pass\n","        \n","    \n","    def predict(self,url):\n","\n","        print(\"hi\")\n","        \n","        # Method to call all the methods in the FeatureExtract class to \n","        #get the features of the given URL and appends it to an np array\n","        # Returns the result of classification by calling the classify function\n","        \n","        feature = []\n","        dns = 0\n","        \n","        # URL is passed to whois API to fetch the domain name \n","        try:\n","            print(\"hi\")\n","            domain_name = whois.whois(urlparse(url).netloc)\n","            print(\"hi2\")\n","\n","        except:\n","            dns = 1\n","       \n","        #Domain based features (3)\n","        \n","        feature.append(self.rank(url))\n","        # feature.append(1 if dns == 1 else self.isValid(domain_name))\n","        # feature.append(1 if dns == 1 else self.domain_reg_len(domain_name))\n","\n","        #Address bar based features (5)\n","        feature.append(self.isIP(url))\n","        \n","        feature.append(self.isat(url))\n","  \n","\n","        feature.append(self.isRedirect(url))\n","        feature.append(self.haveDash(url))\n","        feature.append(self.no_sub_domain(url))\n","        feature.append(self.LongURL(url))\n","        feature.append(self.tinyURL(url))\n","        \n","        return self.classify(np.array(feature).reshape((1,-1)))\n","        \n","    \n","    def __getstate__(self):\n","\n","        # this method is called when you are\n","        # going to pickle the class, to know what to pickle\n","        \n","        state = self.__dict__.copy()\n","        \n","        # don't pickle the parameter fun. otherwise will raise \n","        # AttributeError: Can't pickle local object 'Process.__init__.<locals>.<lambda>'\n","        \n","        return state\n","    \n","    \n","    def __setstate__(self, state):\n","        \n","        self.__dict__.update(state)\n","\n","        \n","    def classify(self,features):\n","        \n","        #Method to classify the URL, given its features.\n","        #It loads the saved mode in the pickle file to perform the classification\n","        \n","        # Load the pickle file\n","        \n","        pick_file = open('phishing_classifier.pkl', 'rb') \n","        Pickled_sample_Model = pickle.load(pick_file)\n","        pick_file.close()\n","    \n","        # Classify the URL features using the loaded pickle file\n","        \n","        result = Pickled_sample_Model.predict(features)\n","        if result == 0:\n","            return \"Given website is a legitimate site\"\n","        else:\n","            return \"Given website is a phishing site\"\n","    \n","# Main function\n","\n","def main():\n","\n","    pass\n","\n","if __name__ == \"__main__\":\n","    main()\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":10964,"status":"ok","timestamp":1681749158953,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"WYaZJeeuJdma","outputId":"6db833d4-7ac8-4b11-fba6-a041d6def832"},"outputs":[{"output_type":"stream","name":"stdout","text":["Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Requirement already satisfied: whois in /usr/local/lib/python3.9/dist-packages (0.9.27)\n","Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Requirement already satisfied: tldextract in /usr/local/lib/python3.9/dist-packages (3.4.0)\n","Requirement already satisfied: idna in /usr/local/lib/python3.9/dist-packages (from tldextract) (3.4)\n","Requirement already satisfied: requests>=2.1.0 in /usr/local/lib/python3.9/dist-packages (from tldextract) (2.27.1)\n","Requirement already satisfied: filelock>=3.0.8 in /usr/local/lib/python3.9/dist-packages (from tldextract) (3.11.0)\n","Requirement already satisfied: requests-file>=1.4 in /usr/local/lib/python3.9/dist-packages (from tldextract) (1.5.1)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests>=2.1.0->tldextract) (2022.12.7)\n","Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests>=2.1.0->tldextract) (1.26.15)\n","Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests>=2.1.0->tldextract) (2.0.12)\n","Requirement already satisfied: six in /usr/local/lib/python3.9/dist-packages (from requests-file>=1.4->tldextract) (1.16.0)\n"]}],"source":["# Load the required packages\n","!pip install whois\n","!pip install tldextract\n","import pandas as pd\n","import numpy as np \n","import re\n","\n","\n","from sklearn.model_selection import train_test_split\n","\n","from sklearn.tree import DecisionTreeClassifier\n","from sklearn.ensemble import RandomForestClassifier\n","from sklearn.linear_model import LogisticRegression\n","from sklearn.neural_network import MLPClassifier\n","from sklearn.naive_bayes import BernoulliNB\n","from xgboost import XGBClassifier\n","from sklearn.svm import SVC\n","\n","from sklearn import metrics\n","from sklearn.metrics import r2_score\n","from sklearn.metrics import accuracy_score\n","from sklearn.metrics import confusion_matrix\n","from sklearn.metrics import cohen_kappa_score\n","from sklearn.metrics import mean_squared_error\n","from sklearn.metrics import classification_report\n","from sklearn.metrics import ConfusionMatrixDisplay\n","from sklearn.metrics import precision_recall_curve\n","from sklearn.model_selection import cross_val_score\n","from sklearn.metrics import roc_curve, roc_auc_score\n","# from sklearn.metrics import plot_precision_recall_curve\n","\n","from sklearn.model_selection import GridSearchCV\n","from sklearn.metrics import make_scorer\n","\n","# import the feature_extract file to perform feature extraction process\n","# %run /content/drive/MyDrive/Miniproj/feature_extraction.py\n","# from feature_extraction import FeatureExtract, PredictURL\n","\n","import pickle\n","\n","import seaborn as sns\n","import matplotlib.pyplot as plt\n","%matplotlib inline\n","\n","\n","import timeit\n","from math import sqrt"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29542,"status":"ok","timestamp":1681749188477,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"sYnyGXWFXN9u","outputId":"4dee73fd-9543-4681-d8d2-98696c9d5c71"},"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"markdown","metadata":{"id":"0AdJpgnFJdmi"},"source":["## Loading the phishing dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LxNtgsV1Jdmk"},"outputs":[],"source":["#Load the dataset into dataframe\n","\n","phishing_raw_df = pd.read_csv(\"/content/drive/MyDrive/Miniproj/Main_dataset.csv\", header = 0)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":996,"status":"ok","timestamp":1681722644023,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"SoRuF_PKJdml","outputId":"63f18244-2f98-4e15-a939-add90a79d229"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(72363, 12)"]},"metadata":{},"execution_count":7}],"source":["# Dropping null values, duplicates and reset the index\n","\n","phishing_raw_df = phishing_raw_df.dropna()\n","phishing_raw_df = phishing_raw_df.drop_duplicates()\n","phishing_raw_df = phishing_raw_df.reset_index(drop=True)\n","phishing_raw_df.shape"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":17,"status":"ok","timestamp":1681749190067,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"sDVvp_JIJdmn","outputId":"a1e3be54-4324-47bd-9a4f-925aabf56a93"},"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'pandas.core.frame.DataFrame'>\n","RangeIndex: 95910 entries, 0 to 95909\n","Data columns (total 12 columns):\n"," #   Column          Non-Null Count  Dtype \n","---  ------          --------------  ----- \n"," 0   domain          95910 non-null  object\n"," 1   ranking         95910 non-null  int64 \n"," 2   isIp            95910 non-null  int64 \n"," 3   valid           95910 non-null  int64 \n"," 4   activeDuration  95910 non-null  int64 \n"," 5   urlLen          95910 non-null  int64 \n"," 6   is@             95910 non-null  int64 \n"," 7   isredirect      95910 non-null  int64 \n"," 8   haveDash        95910 non-null  int64 \n"," 9   domainLen       95910 non-null  int64 \n"," 10  nosOfSubdomain  95910 non-null  int64 \n"," 11  label           95910 non-null  int64 \n","dtypes: int64(11), object(1)\n","memory usage: 8.8+ MB\n","None\n"]}],"source":["print(phishing_raw_df.info())"]},{"cell_type":"markdown","metadata":{"id":"j-PPsZ-_Jdmo"},"source":["## Data Pre-processing"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":499},"executionInfo":{"elapsed":508,"status":"ok","timestamp":1681749190565,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"24h_tsXEJdmo","outputId":"1a8c5abe-3fdb-49f2-fd86-870c8c89bd26"},"outputs":[{"output_type":"stream","name":"stdout","text":["Class Legitimate URL: 39996\n","Class Phishing URL: 55914\n","Proportion: 0.72 : 1\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Plotting a bar graph with the number of Legitimate and Phishing class urls\n","\n","target_count = phishing_raw_df.label.value_counts()\n","print('Class Legitimate URL:', target_count[0])\n","print('Class Phishing URL:', target_count[1])\n","print('Proportion:', round(target_count[0] / target_count[1], 2), ': 1')\n","\n","phishing_raw_df.label.value_counts().plot(kind='bar', title='Count (Label)');"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":516},"executionInfo":{"elapsed":567,"status":"ok","timestamp":1681749191112,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"TsJGxWB4Jdmp","outputId":"dfc2c6c2-dd4a-4a0d-de20-d207755cb99f"},"outputs":[{"output_type":"stream","name":"stdout","text":["Random under-sampling:\n","1    39996\n","0    39996\n","Name: label, dtype: int64\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Each Class count\n","\n","count_class_1, count_class_0 = phishing_raw_df.label.value_counts()\n","\n","# Divide by each class\n","\n","df_class_0 = phishing_raw_df[phishing_raw_df['label'] == 0]\n","df_class_1 = phishing_raw_df[phishing_raw_df['label'] == 1]\n","\n","# As the class 1 values are more than to class 0,\n","# Undersampling is performed to avoid bias and have same number of urls in both classes\n","\n","df_class_1_under = df_class_1.sample(count_class_0)\n","phishing_raw_df = pd.concat([df_class_1_under, df_class_0], axis=0)\n","\n","print('Random under-sampling:')\n","print(phishing_raw_df.label.value_counts())\n","\n","phishing_raw_df.label.value_counts().plot(kind='bar', title='Count (target)');"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":206},"executionInfo":{"elapsed":31,"status":"ok","timestamp":1681749191114,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"R8wZos-1Jdmr","outputId":"9af663d3-a20b-4af7-c127-b4d512ff5d88"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["                                                  domain   ranking  isIp  \\\n","18728                  ok.qqus.asia/m=weblogin/index.htm  10000000     0   \n","47052  bernweds.info/GRcntrlde/_webscr.php?nxEXEC=d2V...  10000000     0   \n","21957  mail.zrsthemovie.com/code/nbhyavwc/bhbaa/384d8...  10000000     0   \n","15157  paypal.com.update-account-information-webscrcm...  10000000     0   \n","89661                          mygreenstone.ca/security/  10000000     0   \n","\n","       valid  activeDuration  urlLen  is@  isredirect  haveDash  domainLen  \\\n","18728      0               0      33    0           0         0         12   \n","47052      0               0     137    0           0         0         13   \n","21957      1            4018     179    0           0         0         20   \n","15157      0               0     157    0           0         1        123   \n","89661      0               0      25    0           0         0         15   \n","\n","       nosOfSubdomain  label  \n","18728               2      1  \n","47052               1      1  \n","21957               2      1  \n","15157               6      1  \n","89661               1      1  "],"text/html":["\n","  <div id=\"df-9c826a13-777b-4e90-a505-6e3ba19edd06\">\n","    <div class=\"colab-df-container\">\n","      <div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>domain</th>\n","      <th>ranking</th>\n","      <th>isIp</th>\n","      <th>valid</th>\n","      <th>activeDuration</th>\n","      <th>urlLen</th>\n","      <th>is@</th>\n","      <th>isredirect</th>\n","      <th>haveDash</th>\n","      <th>domainLen</th>\n","      <th>nosOfSubdomain</th>\n","      <th>label</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>18728</th>\n","      <td>ok.qqus.asia/m=weblogin/index.htm</td>\n","      <td>10000000</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>33</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>12</td>\n","      <td>2</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>47052</th>\n","      <td>bernweds.info/GRcntrlde/_webscr.php?nxEXEC=d2V...</td>\n","      <td>10000000</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>137</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>13</td>\n","      <td>1</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>21957</th>\n","      <td>mail.zrsthemovie.com/code/nbhyavwc/bhbaa/384d8...</td>\n","      <td>10000000</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>4018</td>\n","      <td>179</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>20</td>\n","      <td>2</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>15157</th>\n","      <td>paypal.com.update-account-information-webscrcm...</td>\n","      <td>10000000</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>157</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>123</td>\n","      <td>6</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>89661</th>\n","      <td>mygreenstone.ca/security/</td>\n","      <td>10000000</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>25</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>15</td>\n","      <td>1</td>\n","      <td>1</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>\n","      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-9c826a13-777b-4e90-a505-6e3ba19edd06')\"\n","              title=\"Convert this dataframe to an interactive table.\"\n","              style=\"display:none;\">\n","        \n","  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n","       width=\"24px\">\n","    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n","    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n","  </svg>\n","      </button>\n","      \n","  <style>\n","    .colab-df-container {\n","      display:flex;\n","      flex-wrap:wrap;\n","      gap: 12px;\n","    }\n","\n","    .colab-df-convert {\n","      background-color: #E8F0FE;\n","      border: none;\n","      border-radius: 50%;\n","      cursor: pointer;\n","      display: none;\n","      fill: #1967D2;\n","      height: 32px;\n","      padding: 0 0 0 0;\n","      width: 32px;\n","    }\n","\n","    .colab-df-convert:hover {\n","      background-color: #E2EBFA;\n","      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n","      fill: #174EA6;\n","    }\n","\n","    [theme=dark] .colab-df-convert {\n","      background-color: #3B4455;\n","      fill: #D2E3FC;\n","    }\n","\n","    [theme=dark] .colab-df-convert:hover {\n","      background-color: #434B5C;\n","      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n","      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n","      fill: #FFFFFF;\n","    }\n","  </style>\n","\n","      <script>\n","        const buttonEl =\n","          document.querySelector('#df-9c826a13-777b-4e90-a505-6e3ba19edd06 button.colab-df-convert');\n","        buttonEl.style.display =\n","          google.colab.kernel.accessAllowed ? 'block' : 'none';\n","\n","        async function convertToInteractive(key) {\n","          const element = document.querySelector('#df-9c826a13-777b-4e90-a505-6e3ba19edd06');\n","          const dataTable =\n","            await google.colab.kernel.invokeFunction('convertToInteractive',\n","                                                     [key], {});\n","          if (!dataTable) return;\n","\n","          const docLinkHtml = 'Like what you see? Visit the ' +\n","            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n","            + ' to learn more about interactive tables.';\n","          element.innerHTML = '';\n","          dataTable['output_type'] = 'display_data';\n","          await google.colab.output.renderOutput(dataTable, element);\n","          const docLink = document.createElement('div');\n","          docLink.innerHTML = docLinkHtml;\n","          element.appendChild(docLink);\n","        }\n","      </script>\n","    </div>\n","  </div>\n","  "]},"metadata":{},"execution_count":9}],"source":["# Viewing sample data from dataframe\n","\n","phishing_raw_df.head()"]},{"cell_type":"markdown","metadata":{"id":"9BEJIpfQJdms"},"source":["## Data Transformation"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"xm4Hd1b9Jdms"},"outputs":[],"source":["# Object created for the features class imported from feature_extract file\n","# This class has the methods that extracts features given the URL\n","\n","feature = FeatureExtract()"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":206},"executionInfo":{"elapsed":4024,"status":"ok","timestamp":1681749195115,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"Eo3ZPJ0aJdmt","outputId":"c64df9f8-9cb8-4076-df72-d15d2941f4a9"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["   isIP  is@  isRedirect  haveDash  SubDomain  LongURL  TinyURL  Label\n","0     0    0           0         0          0        0        0      0\n","1     0    0           0         1          0        0        0      1\n","2     0    0           0         0          1        0        0      1\n","3     0    0           0         0          1        1        0      1\n","4     0    0           0         0          1        1        0      0"],"text/html":["\n","  <div id=\"df-41ba07b1-2223-4036-8021-464473b368ea\">\n","    <div class=\"colab-df-container\">\n","      <div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>isIP</th>\n","      <th>is@</th>\n","      <th>isRedirect</th>\n","      <th>haveDash</th>\n","      <th>SubDomain</th>\n","      <th>LongURL</th>\n","      <th>TinyURL</th>\n","      <th>Label</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>\n","      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-41ba07b1-2223-4036-8021-464473b368ea')\"\n","              title=\"Convert this dataframe to an interactive table.\"\n","              style=\"display:none;\">\n","        \n","  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n","       width=\"24px\">\n","    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n","    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n","  </svg>\n","      </button>\n","      \n","  <style>\n","    .colab-df-container {\n","      display:flex;\n","      flex-wrap:wrap;\n","      gap: 12px;\n","    }\n","\n","    .colab-df-convert {\n","      background-color: #E8F0FE;\n","      border: none;\n","      border-radius: 50%;\n","      cursor: pointer;\n","      display: none;\n","      fill: #1967D2;\n","      height: 32px;\n","      padding: 0 0 0 0;\n","      width: 32px;\n","    }\n","\n","    .colab-df-convert:hover {\n","      background-color: #E2EBFA;\n","      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n","      fill: #174EA6;\n","    }\n","\n","    [theme=dark] .colab-df-convert {\n","      background-color: #3B4455;\n","      fill: #D2E3FC;\n","    }\n","\n","    [theme=dark] .colab-df-convert:hover {\n","      background-color: #434B5C;\n","      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n","      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n","      fill: #FFFFFF;\n","    }\n","  </style>\n","\n","      <script>\n","        const buttonEl =\n","          document.querySelector('#df-41ba07b1-2223-4036-8021-464473b368ea button.colab-df-convert');\n","        buttonEl.style.display =\n","          google.colab.kernel.accessAllowed ? 'block' : 'none';\n","\n","        async function convertToInteractive(key) {\n","          const element = document.querySelector('#df-41ba07b1-2223-4036-8021-464473b368ea');\n","          const dataTable =\n","            await google.colab.kernel.invokeFunction('convertToInteractive',\n","                                                     [key], {});\n","          if (!dataTable) return;\n","\n","          const docLinkHtml = 'Like what you see? Visit the ' +\n","            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n","            + ' to learn more about interactive tables.';\n","          element.innerHTML = '';\n","          dataTable['output_type'] = 'display_data';\n","          await google.colab.output.renderOutput(dataTable, element);\n","          const docLink = document.createElement('div');\n","          docLink.innerHTML = docLinkHtml;\n","          element.appendChild(docLink);\n","        }\n","      </script>\n","    </div>\n","  </div>\n","  "]},"metadata":{},"execution_count":11}],"source":["# Insert a new column to the dataframe which shows if 'http' is found in the domain part of the URL.\n","\n","phishing_raw_df[\"Domain_http\"] = phishing_raw_df[\"domain\"].apply( lambda x: feature.httpDomain(x))\n","\n","# # Insert a new column to the dataframe indicating the length of the URL.\n","\n","phishing_raw_df[\"LongURL\"] = phishing_raw_df[\"domain\"].apply( lambda x: feature.LongURL(x))\n","\n","# # Insert a new column to the dataframe indicating if the URL belongs to any of the shortening services.\n","\n","phishing_raw_df[\"TinyURL\"] = phishing_raw_df[\"domain\"].apply( lambda x: feature.tinyURL(x))\n","\n","# # Alter the values in 'nosOfSubdomain' column of the dataframe.\n","# # If the number of sub domains is more than 1, then it is a phishing site.\n","\n","phishing_raw_df[\"nosOfSubdomain\"] = phishing_raw_df[\"domain\"].apply( lambda x: feature.no_sub_domain(x))\n","\n","# # Alter the values in 'activeDuration' column of the dataframe.\n","# # If the value is greater than 365 (1 year), then it is a legitimate site.\n","\n","phishing_raw_df[\"activeDuration\"] = phishing_raw_df[\"activeDuration\"].apply( lambda x: 1 if x <= 365 else 0)\n","\n","# # Alter the values in the dataframe column 'ranking'\n","# # If the value is greater than 100000, then it is a phishing site\n","\n","phishing_raw_df[\"ranking\"] = phishing_raw_df[\"ranking\"].apply( lambda x: 0 if x < 100000 else 1)\n","\n","# Remove the unwanted columns from the dataframe\n","\n","phishing_raw_df.drop(['urlLen','domainLen','domain'], inplace=True,axis=1)\n","\n","# Reorder and rename the columns in the dataframe\n","\n","Columns = ['Rank','isIP','isValid','Domain_reg_len','is@','isRedirect','haveDash','SubDomain','Label','Domain_http','LongURL','TinyURL']\n","new_columns = ['Rank','isIP','isValid','Domain_reg_len','is@','isRedirect','haveDash','SubDomain','Domain_http','LongURL','TinyURL','Label']\n","phishing_raw_df.columns = Columns\n","phishing_raw_df = phishing_raw_df.reindex(columns=new_columns)\n","phishing_raw_df1 = phishing_raw_df.copy(deep=True)\n","phishing_raw_df1.drop(['Domain_http'],inplace=True,axis=1)\n","phishing_raw_df1.drop(['isValid'],inplace=True,axis=1)\n","phishing_raw_df1.drop(['Domain_reg_len'],inplace=True,axis=1)\n","phishing_raw_df1.drop(['Rank'],inplace=True,axis=1)\n","\n","\n","# Shuffle the rows in the dataset so that when splitting the train and test set are equally distributed\n","\n","phishing_raw_df_x = phishing_raw_df1.sample(frac=1).reset_index(drop=True)\n","\n","# Save the dataframe to a csv file \n","\n","phishing_raw_df_x.to_csv('phishing_feature_engg.csv', encoding='utf-8')\n","\n","#Display the dataset after data pre-processing\n","\n","phishing_raw_df_x.head()"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":51,"status":"ok","timestamp":1681749195116,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"ksGRNGxTJdmu","outputId":"d9881491-c41e-46bb-ac67-06bd6bc212a0"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["isIP          0\n","is@           0\n","isRedirect    0\n","haveDash      0\n","SubDomain     0\n","LongURL       0\n","TinyURL       0\n","Label         0\n","dtype: int64"]},"metadata":{},"execution_count":12}],"source":["# Check for null values\n","\n","phishing_raw_df_x.isnull().sum()"]},{"cell_type":"markdown","metadata":{"id":"bCd9c5MjJdmv"},"source":["## Data Statistics"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":300},"executionInfo":{"elapsed":45,"status":"ok","timestamp":1681749195117,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"0xASNpBVJdmv","outputId":"b2d463c1-208f-4147-a8bd-de9e988de23a"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["               isIP           is@    isRedirect      haveDash     SubDomain  \\\n","count  79992.000000  79992.000000  79992.000000  79992.000000  79992.000000   \n","mean       0.000225      0.002413      0.006301      0.143289      0.549192   \n","std        0.014999      0.049061      0.079127      0.350370      0.497577   \n","min        0.000000      0.000000      0.000000      0.000000      0.000000   \n","25%        0.000000      0.000000      0.000000      0.000000      0.000000   \n","50%        0.000000      0.000000      0.000000      0.000000      1.000000   \n","75%        0.000000      0.000000      0.000000      0.000000      1.000000   \n","max        1.000000      1.000000      1.000000      1.000000      1.000000   \n","\n","            LongURL       TinyURL         Label  \n","count  79992.000000  79992.000000  79992.000000  \n","mean       0.353298      0.069932      0.500000  \n","std        0.477997      0.255034      0.500003  \n","min        0.000000      0.000000      0.000000  \n","25%        0.000000      0.000000      0.000000  \n","50%        0.000000      0.000000      0.500000  \n","75%        1.000000      0.000000      1.000000  \n","max        1.000000      1.000000      1.000000  "],"text/html":["\n","  <div id=\"df-b1bf8222-4ca5-456f-87c2-8a36a4595489\">\n","    <div class=\"colab-df-container\">\n","      <div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>isIP</th>\n","      <th>is@</th>\n","      <th>isRedirect</th>\n","      <th>haveDash</th>\n","      <th>SubDomain</th>\n","      <th>LongURL</th>\n","      <th>TinyURL</th>\n","      <th>Label</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>count</th>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","      <td>79992.000000</td>\n","    </tr>\n","    <tr>\n","      <th>mean</th>\n","      <td>0.000225</td>\n","      <td>0.002413</td>\n","      <td>0.006301</td>\n","      <td>0.143289</td>\n","      <td>0.549192</td>\n","      <td>0.353298</td>\n","      <td>0.069932</td>\n","      <td>0.500000</td>\n","    </tr>\n","    <tr>\n","      <th>std</th>\n","      <td>0.014999</td>\n","      <td>0.049061</td>\n","      <td>0.079127</td>\n","      <td>0.350370</td>\n","      <td>0.497577</td>\n","      <td>0.477997</td>\n","      <td>0.255034</td>\n","      <td>0.500003</td>\n","    </tr>\n","    <tr>\n","      <th>min</th>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","    </tr>\n","    <tr>\n","      <th>25%</th>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","    </tr>\n","    <tr>\n","      <th>50%</th>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>1.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.500000</td>\n","    </tr>\n","    <tr>\n","      <th>75%</th>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>0.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>0.000000</td>\n","      <td>1.000000</td>\n","    </tr>\n","    <tr>\n","      <th>max</th>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","      <td>1.000000</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>\n","      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-b1bf8222-4ca5-456f-87c2-8a36a4595489')\"\n","              title=\"Convert this dataframe to an interactive table.\"\n","              style=\"display:none;\">\n","        \n","  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n","       width=\"24px\">\n","    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n","    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n","  </svg>\n","      </button>\n","      \n","  <style>\n","    .colab-df-container {\n","      display:flex;\n","      flex-wrap:wrap;\n","      gap: 12px;\n","    }\n","\n","    .colab-df-convert {\n","      background-color: #E8F0FE;\n","      border: none;\n","      border-radius: 50%;\n","      cursor: pointer;\n","      display: none;\n","      fill: #1967D2;\n","      height: 32px;\n","      padding: 0 0 0 0;\n","      width: 32px;\n","    }\n","\n","    .colab-df-convert:hover {\n","      background-color: #E2EBFA;\n","      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n","      fill: #174EA6;\n","    }\n","\n","    [theme=dark] .colab-df-convert {\n","      background-color: #3B4455;\n","      fill: #D2E3FC;\n","    }\n","\n","    [theme=dark] .colab-df-convert:hover {\n","      background-color: #434B5C;\n","      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n","      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n","      fill: #FFFFFF;\n","    }\n","  </style>\n","\n","      <script>\n","        const buttonEl =\n","          document.querySelector('#df-b1bf8222-4ca5-456f-87c2-8a36a4595489 button.colab-df-convert');\n","        buttonEl.style.display =\n","          google.colab.kernel.accessAllowed ? 'block' : 'none';\n","\n","        async function convertToInteractive(key) {\n","          const element = document.querySelector('#df-b1bf8222-4ca5-456f-87c2-8a36a4595489');\n","          const dataTable =\n","            await google.colab.kernel.invokeFunction('convertToInteractive',\n","                                                     [key], {});\n","          if (!dataTable) return;\n","\n","          const docLinkHtml = 'Like what you see? Visit the ' +\n","            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n","            + ' to learn more about interactive tables.';\n","          element.innerHTML = '';\n","          dataTable['output_type'] = 'display_data';\n","          await google.colab.output.renderOutput(dataTable, element);\n","          const docLink = document.createElement('div');\n","          docLink.innerHTML = docLinkHtml;\n","          element.appendChild(docLink);\n","        }\n","      </script>\n","    </div>\n","  </div>\n","  "]},"metadata":{},"execution_count":13}],"source":["phishing_raw_df_x.describe()"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":622},"executionInfo":{"elapsed":43,"status":"ok","timestamp":1681749195118,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"bAoPtGENJdmw","outputId":"6df79ef8-20c1-4e4b-d094-0c465e522a7d"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["<Axes: >"]},"metadata":{},"execution_count":14},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x700 with 2 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Heat Map\n","\n","plt.figure(figsize=(15,7))\n","sns.heatmap(phishing_raw_df1.corr(),annot=True, linewidth=0.5)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"wUVvkA1oJdmw"},"outputs":[],"source":["# Label column was dropped and stored the feature data in X\n","X=phishing_raw_df_x.drop([\"Label\"],axis=1)\n","\n","# store the labels in y\n","Y=phishing_raw_df_x[\"Label\"]\n","\n","#split the data\n","X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size=0.2, random_state=101)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":74},"executionInfo":{"elapsed":33,"status":"ok","timestamp":1681749195121,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"qxI-Eeo0Jdmx","outputId":"ca2f2620-2b36-4bb4-fbc3-b6e4b9bc2eac"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["DecisionTreeClassifier(criterion='entropy', max_depth=5, random_state=100)"],"text/html":["<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>DecisionTreeClassifier(criterion=&#x27;entropy&#x27;, max_depth=5, random_state=100)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">DecisionTreeClassifier</label><div class=\"sk-toggleable__content\"><pre>DecisionTreeClassifier(criterion=&#x27;entropy&#x27;, max_depth=5, random_state=100)</pre></div></div></div></div></div>"]},"metadata":{},"execution_count":16}],"source":["# Fit the data with decision tree classifier to identify feature importance\n","\n","dtc = DecisionTreeClassifier(criterion = \"entropy\", random_state = 100,max_depth = 5)\n","dtc.fit(X_train,y_train)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":619},"executionInfo":{"elapsed":1780,"status":"ok","timestamp":1681749196871,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"KNi6wHzMJdmy","outputId":"0a922481-cd94-4962-a3fa-f694580d53b2"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 900x700 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAA0EAAAJaCAYAAADpm0w1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbUUlEQVR4nO3deVxV1f7/8fcBZB6MUEBDwcQpGcwBQUvtQlg2UDczG9Ry+Go5knMKqBVmWlaaZoPaYA5lZGaWYd5MuZoi3SwlJ6KrgJoBigkK+/eHP8/tBJogSLpfz8fjPPSsvfban33u/vY9b9fe61gMwzAEAAAAACZhV9sFAAAAAMDlRAgCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCoOtV0Aak5ZWZkOHTokDw8PWSyW2i4HAAAAuGSGYej48eNq0KCB7OyqNqdDCLqKHTp0SAEBAbVdBgAAAFDtfvnlF1133XVV2pcQdBXz8PCQdPYC8fT0rOVqAAAAgEtXWFiogIAA63fdqiAEXcXO3QLn6elJCAIAAMBV5VIe92BhBAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACm4lDbBaDmtU78XHZOrrVdBgAAAK4CWdN71HYJl4yZIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAABVMnfuXAUGBsrZ2VkRERHaunXrBfvPnj1bzZs3l4uLiwICAjRq1CidOnXKuj0wMFAWi6Xc64knnpAkHTt2TGPGjJEk+fr6qlGjRho+fLgKCgoqVbdDJc8TAAAAALRs2TLFx8dr/vz5ioiI0OzZsxUbG6vMzEzVr1+/XP8lS5Zo/PjxeuuttxQVFaWffvpJ/fr1k8Vi0QsvvCBJ+vbbb1VaWmrdZ+fOnYqJiVHPnj0lSYcOHVJOTo4kKS0tTceOHdPgwYN16NAhffDBBxddu8UwDONSTh5/X4WFhfLy8lLAyOWyc3Kt7XIAAABwFcia3kOSFBERofbt22vOnDmSpLKyMgUEBGjYsGEaP358uf2GDh2qXbt2KTU11dr25JNPasuWLfrmm28qPNbIkSO1evVq7dmzRxaLRdL/vuMWFBTI09NTK1as0MMPP6yioiI5OFzcHA+3wwEAAAColJKSEm3fvl3R0dHWNjs7O0VHRystLa3CfaKiorR9+3brLXP79+/XmjVrdPvtt5/3GO+++64ee+wxawCqyLkwdLEBSOJ2OAAAAACVdPToUZWWlsrX19em3dfXV7t3765wnwcffFBHjx5V586dZRiGzpw5o8GDB2vixIkV9k9JSVF+fr769et3wTqmTZumQYMGVap+ZoIAAAAA1LgNGzbo2Wef1auvvqr09HStXLlSn376qaZNm1Zh/zfffFO33XabGjRoUOH2wsJC9ejRQ61atVJSUlKlarlqQlC/fv0UFxdXa8fPysqSxWJRRkZGuW1du3bVyJEjre//uOqFq6urQkJC9MYbb9jss2HDBlksFuXn59ds4QAAAEAl+fj4yN7eXnl5eTbteXl58vPzq3CfyZMn65FHHtGAAQMUEhKie+65R88++6ySk5NVVlZm0/fnn3/Wl19+qQEDBpy3hn/+85/y8PDQRx99pDp16lSq/qsmBF1ppk6dqpycHO3cuVMPP/ywBg4cqM8++6y2ywIAAAD+kqOjo9q2bWuzyEFZWZlSU1MVGRlZ4T4nT56UnZ1t/LC3t5ck/XmttoULF6p+/frq0aNHuXEKCwutNaxatUrOzs6Vrt8UIehf//qXOnToICcnJ/n7+2v8+PE6c+aMdXvXrl01fPhwjR07Vt7e3vLz8ys3pbZ792517txZzs7OatWqlb788ktZLBalpKRUqSYPDw/5+fmpSZMmGjdunLy9vbVu3bpLOEsAAADg8omPj9frr7+uxYsXa9euXRoyZIiKior06KOPSpL69OmjCRMmWPvfeeedmjdvnpYuXaoDBw5o3bp1mjx5su68805rGJLOhqmFCxeqb9++5RY7KCws1D333CNJeuWVV1RYWKjc3Fzl5ubaLK39V676hREOHjyo22+/Xf369dPbb7+t3bt3a+DAgXJ2drYJOosXL1Z8fLy2bNmitLQ09evXT506dVJMTIxKS0sVFxenRo0aacuWLTp+/LiefPLJaqmvrKxMH330kX777Tc5Ojpe0ljFxcUqLi62vj+XkgEAAIDq1qtXLx05ckQJCQnKzc1VeHi41q5da10sITs722bmZ9KkSbJYLJo0aZIOHjyoevXq6c4779QzzzxjM+6XX36p7OxsPfbYY+WOmZ6erm3btkmS2rRpY7PtwIEDCgwMvKjar/oQ9OqrryogIEBz5syRxWJRixYtdOjQIY0bN04JCQnW/2FCQ0OVmJgoSQoODtacOXOUmpqqmJgYrVu3Tvv27dOGDRus9zg+88wziomJqXJd48aN06RJk1RcXKwzZ87I29v7gvc8Xozk5GRNmTLlksYAAAAALtbQoUM1dOjQCrdt2LDB5r2Dg4MSExOt37nP59Zbby13e9w5Xbt2VUFBgc3vBFXFVX873K5duxQZGWmztninTp104sQJ/fe//7W2hYaG2uzn7++vw4cPS5IyMzMVEBBg85BXhw4dLqmuMWPGKCMjQ+vXr1dERIRefPFFNW3a9JLGnDBhggoKCqyvX3755ZLGAwAAAK5GV/1M0MX684oSFoul3CoVF3IuhRYUFJTblp+fLy8vL5s2Hx8fNW3aVE2bNtWKFSsUEhKidu3aqVWrVlWo/iwnJyc5OTlVeX8AAADADK76maCWLVsqLS3NZkpt06ZN8vDw0HXXXXdRYzRv3ly//PKLzRKA3377rU0fb29v+fj4aPv27TbthYWF2rt3r5o1a3be8QMCAtSrVy+bB8cAAAAA1IyraiaooKCg3O/0DBo0SLNnz9awYcM0dOhQZWZmKjExUfHx8eWW6DufmJgYXX/99erbt69mzJih48ePa9KkSZJkc5tdfHy8nn32Wfn6+qpjx4769ddfNW3aNNWrV0/33nvvBY8xYsQItW7dWtu2bVO7du2s7d9//708PDys7y0Wi8LCwi6qbgAAAADlXVUhaMOGDeVWiejfv7/WrFmjMWPGKCwsTN7e3urfv781xFwMe3t7paSkaMCAAWrfvr2aNGmi559/XnfeeafNuuRjx46Vu7u7nnvuOe3bt0/e3t7q1KmTvvrqK7m4uFzwGK1atdKtt96qhIQErVmzxtp+8803l6vlj8t7AwAAAKgci3G+pRdwQZs2bVLnzp21d+9eXX/99bVdToUKCwvl5eWlgJHLZefkWtvlAAAA4CqQNb38D5heTue+417K6nBX1UxQTfroo4/k7u6u4OBg7d27VyNGjFCnTp3+tgEIAAAAQMUIQRfp+PHjGjdunLKzs+Xj46Po6GjNmjWrtssCAAAAUEmEoIvUp08f9enTp7bLAAAAAHCJrvolsgEAAADgjwhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVBxquwDUvJ1TYuXp6VnbZQAAAAB/C8wEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVh9ouADWvdeLnsnNyre0yLous6T1quwQAAAD8zTETBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQhKvW3LlzFRgYKGdnZ0VERGjr1q0X7L9ixQq1aNFCzs7OCgkJ0Zo1a2y2WyyWCl/PP/+8tU96erpiYmJUt25dXXvttRo0aJBOnDhRI+cHAACAqiEE4aq0bNkyxcfHKzExUenp6QoLC1NsbKwOHz5cYf/Nmzerd+/e6t+/v3bs2KG4uDjFxcVp586d1j45OTk2r7feeksWi0X//Oc/JUmHDh1SdHS0mjZtqi1btmjt2rX64Ycf1K9fv8txygAAALhIFsMwjNouAjWjsLBQXl5eChi5XHZOrrVdzmWRNb2HJCkiIkLt27fXnDlzJEllZWUKCAjQsGHDNH78+HL79erVS0VFRVq9erW1rWPHjgoPD9f8+fMrPFZcXJyOHz+u1NRUSdKCBQs0efJk5eTkyM7u7L8vfP/99woNDdWePXvUtGnTaj1XAAAAMzr3HbegoECenp5VGoOZIFx1SkpKtH37dkVHR1vb7OzsFB0drbS0tAr3SUtLs+kvSbGxseftn5eXp08//VT9+/e3thUXF8vR0dEagCTJxcVFkvTNN99U+XwAAABQvQhBuOocPXpUpaWl8vX1tWn39fVVbm5uhfvk5uZWqv/ixYvl4eGhe++919p2yy23KDc3V88//7xKSkr022+/WWedcnJyLuWUAAAAUI2umBDUtWtXjRw5srbLuCyysrJksViUkZFR26XgPN566y099NBDcnZ2trbdcMMNWrx4sWbNmiVXV1f5+fkpKChIvr6+NrNDAAAAqF18M6uEpKQk64pgDg4O8vHx0c0336zZs2eruLi4tsvD/+fj4yN7e3vl5eXZtOfl5cnPz6/Cffz8/C66/8aNG5WZmakBAwaU2/bggw8qNzdXBw8e1K+//qqkpCQdOXJETZo0uYQzAgAAQHUiBFXSDTfcoJycHGVnZ+urr75Sz549lZycrKioKB0/fry2y4MkR0dHtW3b1rpggXR2YYTU1FRFRkZWuE9kZKRNf0lat25dhf3ffPNNtW3bVmFhYeetwdfXV+7u7lq2bJmcnZ0VExNTxbMBAABAdbuiQlBZWZnGjh0rb29v+fn5KSkpybrthRdeUEhIiNzc3BQQEKDHH3/c+vsshYWFcnFx0WeffWYz3kcffSQPDw+dPHlSkvTLL7/o/vvvV926deXt7a27775bWVlZNvs4ODjIz89PDRo0UEhIiIYNG6Z//etf2rlzp5577jlrv3feeUft2rWTh4eH/Pz89OCDD9osz/zbb7/poYceUr169eTi4qLg4GAtXLjQ5lj79+9Xt27d5OrqqrCwsPM+pI/y4uPj9frrr2vx4sXatWuXhgwZoqKiIj366KOSpD59+mjChAnW/iNGjNDatWs1a9Ys7d69W0lJSdq2bZuGDh1qM25hYaFWrFhR4SyQJM2ZM0fp6en66aefNHfuXA0dOlTJycmqW7dujZ0rAAAAKueKCkGLFy+Wm5ubtmzZohkzZmjq1Klat26dpLOrf7388sv64YcftHjxYq1fv15jx46VJHl6euqOO+7QkiVLbMZ77733FBcXJ1dXV50+fVqxsbHy8PDQxo0btWnTJrm7u6t79+4qKSm5YF0tWrTQbbfdppUrV1rbTp8+rWnTpum7775TSkqKsrKybH4vZvLkyfrxxx/12WefadeuXZo3b558fHxsxn3qqac0evRoZWRkqFmzZurdu7fOnDlz3jqKi4tVWFho8zKrXr16aebMmUpISFB4eLgyMjK0du1a6+IH2dnZNosVREVFacmSJVqwYIHCwsL0wQcfKCUlRa1bt7YZd+nSpTIMQ717967wuFu3blVMTIxCQkK0YMECvfbaaxo+fHjNnSgAAAAq7Yr5naCuXbuqtLRUGzdutLZ16NBBt9xyi6ZPn16u/wcffKDBgwfr6NGjkqSUlBQ98sgjysvLk6urqwoLC+Xr66uPPvpI3bt317vvvqunn35au3btksVikXR2qeW6desqJSVFt956q5KSkpSSklLhggXjx4/Xyy+/bJ1V+rNt27apffv2On78uNzd3XXXXXfJx8dHb731Vrm+WVlZCgoK0htvvGFdgvnHH3/UDTfcoF27dqlFixYVHiMpKUlTpkwp127G3wkCAADA1cl0vxMUGhpq897f3996i9mXX36pf/zjH2rYsKE8PDz0yCOP6Ndff7WGkttvv1116tTRqlWrJEkffvihPD09rb8N891332nv3r3y8PCQu7u73N3d5e3trVOnTmnfvn1/WZthGNbwJEnbt2/XnXfeqUaNGsnDw0NdunSRdHYGQpKGDBmipUuXKjw8XGPHjtXmzZsveL7+/v6SZHNL3Z9NmDBBBQUF1tcvv/zyl3UDAAAAZnNFhaA6derYvLdYLCorK1NWVpbuuOMOhYaG6sMPP9T27ds1d+5cSbLeyubo6Kj77rvPekvckiVL1KtXLzk4OEiSTpw4obZt2yojI8Pm9dNPP+nBBx/8y9p27dqloKAgSVJRUZFiY2Pl6emp9957T99++60++ugjm3puu+02/fzzzxo1apQOHTqkf/zjHxo9evR5z/dcwCorKztvDU5OTvL09LR5AQAAALDlUNsFVIft27errKxMs2bNsv4ey/Lly8v1e+ihhxQTE6MffvhB69ev19NPP23dduONN2rZsmWqX79+pcPD7t27tXbtWuuD9rt379avv/6q6dOnKyAgQNLZ2+H+rF69eurbt6/69u2rm266SWPGjNHMmTMrdWwAAAAAlXNFzQSdT9OmTXX69Gm98sor2r9/v9555x3Nnz+/XL+bb75Zfn5+euihhxQUFKSIiAjrtoceekg+Pj66++67tXHjRh04cEAbNmzQ8OHD9d///tfa78yZM8rNzdWhQ4f0/fff65VXXlGXLl0UHh6uMWPGSJIaNWokR0dHaz2rVq3StGnTbGpJSEjQxx9/rL179+qHH37Q6tWr1bJlyxr6hAAAAACcc1WEoLCwML3wwgt67rnn1Lp1a7333ntKTk4u189isah379767rvv9NBDD9lsc3V11ddff61GjRrp3nvvVcuWLdW/f3+dOnXKZmbohx9+kL+/vxo1aqSuXbtq+fLlmjBhgjZu3Ch3d3dJZ2d4Fi1apBUrVqhVq1aaPn16uRkeR0dHTZgwQaGhobr55ptlb2+vpUuX1sCnAwAAAOCPrpjV4VB551bOYHU4AAAAXC1MtzocAAAAAFwqQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAU3Go7QJQ83ZOiZWnp2dtlwEAAAD8LTATBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUHGq7ANS81omfy87Jtcr7Z03vUY3VAAAAALWLmSAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCBUyty5cxUYGChnZ2dFRERo69atF+y/YsUKtWjRQs7OzgoJCdGaNWus206fPq1x48YpJCREbm5uatCggfr06aNDhw7ZjHHXXXepUaNGcnZ2lr+/vx555JFyfQAAAICLRQjCRVu2bJni4+OVmJio9PR0hYWFKTY2VocPH66w/+bNm9W7d2/1799fO3bsUFxcnOLi4rRz505J0smTJ5Wenq7JkycrPT1dK1euVGZmpu666y6bcbp166bly5crMzNTH374ofbt26f77ruvxs8XAAAAVyeLYRhGbReBmlFYWCgvLy8FjFwuOyfXKo+TNb2HJCkiIkLt27fXnDlzJEllZWUKCAjQsGHDNH78+HL79erVS0VFRVq9erW1rWPHjgoPD9f8+fMrPNa3336rDh066Oeff1ajRo0q7LNq1SrFxcWpuLhYderUqfJ5AQAA4Mpz7jtuQUGBPD09qzQGM0G4KCUlJdq+fbuio6OtbXZ2doqOjlZaWlqF+6Slpdn0l6TY2Njz9pekgoICWSwW1a1bt8Ltx44d03vvvaeoqCgCEAAAAKqEEISLcvToUZWWlsrX19em3dfXV7m5uRXuk5ubW6n+p06d0rhx49S7d+9yqX7cuHFyc3PTtddeq+zsbH388ceXcDYAAAAwsysqBHXt2lUjR46steNv2LBBFotF+fn5kqRFixadd8YClXP69Gndf//9MgxD8+bNK7d9zJgx2rFjh7744gvZ29urT58+4k5OAAAAVMUVFYJWrlypadOm/WW/fv36yWKxyGKxqE6dOgoKCtLYsWN16tSpaq2nV69e+umnn6p1zIoEBgZq9uzZNX6cC/Hx8ZG9vb3y8vJs2vPy8uTn51fhPn5+fhfV/1wA+vnnn7Vu3boK7+308fFRs2bNFBMTo6VLl2rNmjX697//fYlnBQAAADO6okKQt7e3PDw8Lqpv9+7dlZOTo/379+vFF1/Ua6+9psTExGqtx8XFRfXr1z/v9pKSkmo9Xm1ydHRU27ZtlZqaam0rKytTamqqIiMjK9wnMjLSpr8krVu3zqb/uQC0Z88effnll7r22mv/spaysjJJUnFxcVVOBQAAACZ3RYWgP94O9+qrryo4OFjOzs7y9fUtt2Syk5OT/Pz8FBAQoLi4OEVHR2vdunXW7WVlZUpOTlZQUJBcXFwUFhamDz74wGaMNWvWqFmzZnJxcVG3bt2UlZVls/3Pt8MlJSUpPDxcb7zxhoKCguTs7CxJys/P14ABA1SvXj15enrqlltu0XfffWcz1ieffKL27dvL2dlZPj4+uueee6zn/PPPP2vUqFHW2a3aEh8fr9dff12LFy/Wrl27NGTIEBUVFenRRx+VJPXp00cTJkyw9h8xYoTWrl2rWbNmaffu3UpKStK2bds0dOhQSWcD0H333adt27bpvffeU2lpqXJzc5Wbm2sNkFu2bNGcOXOUkZGhn3/+WevXr1fv3r11/fXXnzd8AQAAABfiUNsFVMW2bds0fPhwvfPOO4qKitKxY8e0cePG8/bfuXOnNm/erMaNG1vbkpOT9e6772r+/PkKDg7W119/rYcfflj16tVTly5d9Msvv+jee+/VE088oUGDBmnbtm168skn/7K2vXv36sMPP9TKlStlb28vSerZs6dcXFz02WefycvLS6+99pr+8Y9/6KeffpK3t7c+/fRT3XPPPXrqqaf09ttvq6SkxPqjoitXrlRYWJgGDRqkgQMHXvDYxcXFNrMjhYWFf1lvZfTq1UtHjhxRQkKCcnNzFR4errVr11oXP8jOzpad3f9ydVRUlJYsWaJJkyZp4sSJCg4OVkpKilq3bi1JOnjwoFatWiVJCg8PtznWV199pa5du8rV1VUrV65UYmKiioqK5O/vr+7du2vSpElycnKq1vMDAACAOVyRISg7O1tubm6644475OHhocaNG6tNmzY2fVavXi13d3edOXNGxcXFsrOzs/6+TXFxsZ599ll9+eWX1tmEJk2a6JtvvtFrr72mLl26aN68ebr++us1a9YsSVLz5s31/fff67nnnrtgbSUlJXr77bdVr149SdI333yjrVu36vDhw9Yv7TNnzlRKSoo++OADDRo0SM8884weeOABTZkyxTpOWFiYpLO3ANrb28vDw+O8z96ck5ycbDNGTRg6dKh1JufPNmzYUK6tZ8+e6tmzZ4X9AwMD/3Jxg5CQEK1fv77SdQIAAADnc0WGoJiYGDVu3FhNmjRR9+7d1b17d91zzz1ydf3fD4J269ZN8+bNU1FRkV588UU5ODjon//8p6SzszUnT55UTEyMzbglJSXWMLVr1y5FRETYbL+Y268aN25sDUCS9N133+nEiRPlnnX5/ffftW/fPklSRkbGX87yXIwJEyYoPj7e+r6wsFABAQGXPC4AAABwNbkiQ5CHh4fS09O1YcMGffHFF0pISFBSUpK+/fZb6zM6bm5uatq0qSTprbfeUlhYmN588031799fJ06ckCR9+umnatiwoc3Yl3qLlZubm837EydOyN/fv8JZknO1uri4XNIxz3FycuIWMQAAAOAvXFELI/yRg4ODoqOjNWPGDP3nP/9RVlbWeW+bsrOz08SJEzVp0iT9/vvvatWqlZycnJSdna2mTZvavM7NnLRs2VJbt261GacqSzLfeOONys3NlYODQ7lj+fj4SJJCQ0PLraL2R46OjiotLa30sQEAAACUd0WGoNWrV+vll1+2rhj29ttvq6ysTM2bNz/vPj179pS9vb3mzp0rDw8PjR49WqNGjdLixYu1b98+paen65VXXtHixYslSYMHD9aePXs0ZswYZWZmasmSJVq0aFGla42OjlZkZKTi4uL0xRdfKCsrS5s3b9ZTTz2lbdu2SZISExP1/vvvKzExUbt27Sr37FFgYKC+/vprHTx4UEePHq10DQAAAAD+54oMQXXr1tXKlSt1yy23qGXLlpo/f77ef/993XDDDefdx8HBQUOHDtWMGTNUVFSkadOmafLkyUpOTlbLli3VvXt3ffrppwoKCpIkNWrUSB9++KFSUlIUFham+fPn69lnn610rRaLRWvWrNHNN9+sRx99VM2aNdMDDzygn3/+2bqqWteuXbVixQqtWrVK4eHhuuWWW2xmoaZOnaqsrCxdf/31Ns8bAQAAAKg8i/FXy3PhilVYWCgvLy8FjFwuOyfXv97hPLKm96jGqgAAAICqO/cdt6CgQJ6enlUa44qcCQIAAACAqiIEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVQhAAAAAAUyEEAQAAADAVh9ouADVv55RYeXp61nYZAAAAwN8CM0EAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATIUQBAAAAMBUCEEAAAAATMWhtgtAzWud+LnsnFwvun/W9B41WA0AAABQu5gJAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAApkIIAgAAAGAqhCAAAAAAplLlEPTOO++oU6dOatCggX7++WdJ0uzZs/Xxxx9XW3EAAAAAUN2qFILmzZun+Ph43X777crPz1dpaakkqW7dupo9e3Z11gcAAAAA1apKIeiVV17R66+/rqeeekr29vbW9nbt2un777+vtuIAAAAAoLpVKQQdOHBAbdq0Kdfu5OSkoqKiSy4KAAAAAGpKlUJQUFCQMjIyyrWvXbtWLVu2vNSaAAAAAKDGOFRlp/j4eD3xxBM6deqUDMPQ1q1b9f777ys5OVlvvPFGddcIAAAAANWmSiFowIABcnFx0aRJk3Ty5Ek9+OCDatCggV566SU98MAD1V0jAAAAAFSbSoegM2fOaMmSJYqNjdVDDz2kkydP6sSJE6pfv35N1AcAAAAA1arSzwQ5ODho8ODBOnXqlCTJ1dWVAAQAAADgilGlhRE6dOigHTt2VHctAAAAAFDjqvRM0OOPP64nn3xS//3vf9W2bVu5ubnZbA8NDa2W4gAAAACgulUpBJ1b/GD48OHWNovFIsMwZLFYVFpaWj3VAQAAAEA1q1IIOnDgQHXXAQAAAACXRZWeCWrcuPEFX7h6zJ07V4GBgXJ2dlZERIS2bt16wf4rVqxQixYt5OzsrJCQEK1Zs8Zm+8qVK3Xrrbfq2muvlcViKfeju1lZWbJYLBW+VqxYUd2nBwAAABOq0kzQ22+/fcHtffr0qVIx+HtZtmyZ4uPjNX/+fEVERGj27NmKjY1VZmZmhSsCbt68Wb1791ZycrLuuOMOLVmyRHFxcUpPT1fr1q0lSUVFRercubPuv/9+DRw4sNwYAQEBysnJsWlbsGCBnn/+ed122201c6IAAAAwFYthGEZld7rmmmts3p8+fVonT56Uo6OjXF1ddezYsWorEFVXWFgoLy8vBYxcLjsn14veL2t6D0lSRESE2rdvrzlz5kiSysrKFBAQoGHDhmn8+PHl9uvVq5eKioq0evVqa1vHjh0VHh6u+fPn2x4jK0tBQUHasWOHwsPDL1hPmzZtdOONN+rNN9+86HMAAADA1encd9yCggJ5enpWaYwq3Q7322+/2bxOnDihzMxMde7cWe+//36VCsHfS0lJibZv367o6Ghrm52dnaKjo5WWllbhPmlpaTb9JSk2Nva8/S/G9u3blZGRof79+1d5DAAAAOCPqhSCKhIcHKzp06drxIgR1TXkX9qwYYMsFovy8/Mv2zFrisViUUpKSm2XYXX06FGVlpbK19fXpt3X11e5ubkV7pObm1up/hfjzTffVMuWLRUVFVXlMQAAAIA/qrYQJEkODg46dOjQRfc/cuSIhgwZokaNGsnJyUl+fn6KjY3Vpk2bqq2mc0HJYrHIzs5OXl5eatOmjcaOHVvu2ZPalJOTwzMvf/L7779ryZIlzAIBAACgWlVpYYRVq1bZvDcMQzk5OZozZ446dep00eP885//VElJiRYvXqwmTZooLy9Pqamp+vXXX6tS1gVlZmbK09NThYWFSk9P14wZM/Tmm29qw4YNCgkJqfbjVZafn19tl2DDx8dH9vb2ysvLs2nPy8s7b61+fn6V6v9XPvjgA508eZKFNgAAAFCtqjQTFBcXZ/O69957lZSUpNDQUL311lsXNUZ+fr42btyo5557Tt26dVPjxo3VoUMHTZgwQXfddZd1qeQ/LqGcn58vi8WiDRs22Iy1adMmhYaGytnZWR07dtTOnTvLHa9+/fry8/NTs2bN9MADD2jTpk2qV6+ehgwZYu1TVlamqVOn6rrrrpOTk5PCw8O1du1a6/ZzNS1fvlw33XSTXFxc1L59e/3000/69ttv1a5dO7m7u+u2227TkSNHrPt9++23iomJkY+Pj7y8vNSlSxelp6fb1PfH2+HOHWflypXq1q2bXF1dFRYWdknP1lSWo6Oj2rZtq9TUVGtbWVmZUlNTFRkZWeE+kZGRNv0lad26deft/1fefPNN3XXXXapXr16V9gcAAAAqUqUQVFZWZvMqLS1Vbm6ulixZIn9//4saw93dXe7u7kpJSVFxcXFVyrAaM2aMZs2apW+//Vb16tXTnXfeqdOnT19wHxcXFw0ePFibNm3S4cOHJUkvvfSSZs2apZkzZ+o///mPYmNjddddd2nPnj02+yYmJmrSpElKT0+Xg4ODHnzwQY0dO1YvvfSSNm7cqL179yohIcHa//jx4+rbt6+++eYb/fvf/1ZwcLBuv/12HT9+/II1PvXUUxo9erQyMjLUrFkz9e7dW2fOnDlv/+LiYhUWFtq8LkV8fLxef/11LV68WLt27dKQIUNUVFSkRx99VNLZpdAnTJhg7T9ixAitXbtWs2bN0u7du5WUlKRt27Zp6NCh1j7Hjh1TRkaGfvzxR0lnZ+gyMjLKPTe0d+9eff311xowYMAlnQMAAADwZ1UKQVOnTtXJkyfLtf/++++aOnXqRY3h4OCgRYsWafHixapbt646deqkiRMn6j//+U+l60lMTFRMTIxCQkK0ePFi5eXl6aOPPvrL/Vq0aCHp7MyLJM2cOVPjxo3TAw88oObNm+u5555TeHi4Zs+ebbPf6NGjFRsbq5YtW2rEiBHavn27Jk+erE6dOqlNmzbq37+/vvrqK2v/W265RQ8//LBatGihli1basGCBTp58qT+9a9/XbC+0aNHq0ePHmrWrJmmTJmin3/+WXv37j1v/+TkZHl5eVlfAQEBf/kZXEivXr00c+ZMJSQkKDw8XBkZGVq7dq118YPs7Gyb56qioqK0ZMkSLViwQGFhYfrggw+UkpJi/Y0g6eytlG3atFGPHmeX4X7ggQfUpk2bcktov/XWW7ruuut06623XtI5AAAAAH9WpRA0ZcoUnThxolz7yZMnNWXKlIse55///KcOHTqkVatWqXv37tqwYYNuvPFGLVq0qFL1/PF2K29vbzVv3ly7du36y/3O/USSxWJRYWGhDh06VO6Zpk6dOpUbKzQ01Pr3c4Hgj88V+fr6WmeXpLPPxQwcOFDBwcHy8vKSp6enTpw4oezs7AvW98fjnJth++O4fzZhwgQVFBRYX7/88ssFx78YQ4cO1c8//6zi4mJt2bJFERER1m0bNmwo979Vz549lZmZqeLiYu3cuVO33367zfZ+/frJMIxyr6SkJJt+zz77rLKzs2VnV61rdwAAAABVWxjBMAxZLJZy7d999528vb0rNZazs7NiYmIUExOjyZMna8CAAUpMTNTGjRutxzrnr25xq6xz4SYwMLBS+9WpU8f693Ofw5/bysrKrO/79u2rX3/9VS+99JIaN24sJycnRUZGqqSkpNLH+eO4f+bk5CQnJ6dKnQsAAABgNpX6Z/ZrrrlG3t7eslgsatasmby9va0vLy8vxcTE6P7777+kglq1aqWioiLrw/B/vN3qj4sk/NG///1v699/++03/fTTT2rZsuUFj/P7779rwYIFuvnmm1WvXj15enqqQYMG5Zbn3rRpk1q1alXFs/nfGMOHD9ftt9+uG264QU5OTjp69OgljQkAAACgaio1EzR79mwZhqHHHntMU6ZMkZeXl3Wbo6OjAgMDL3olsF9//VU9e/bUY489ptDQUHl4eGjbtm2aMWOG7r77brm4uKhjx46aPn26goKCdPjwYU2aNKnCsaZOnaprr71Wvr6+euqpp+Tj46O4uDibPocPH9apU6d0/Phxbd++XTNmzNDRo0e1cuVKa58xY8YoMTFR119/vcLDw7Vw4UJlZGTovffeq8zHVE5wcLDeeecdtWvXToWFhRozZoxcXFwuaUwAAAAAVVOpENS3b19JUlBQkKKiomxu16osd3d3RURE6MUXX9S+fft0+vRpBQQEaODAgZo4caKksw/H9+/fX23btlXz5s01Y8aMCh+Unz59ukaMGKE9e/YoPDxcn3zyiRwdHW36NG/eXBaLRe7u7mrSpIluvfVWxcfH2/yGzfDhw1VQUKAnn3xShw8fVqtWrbRq1SoFBwdX+Tyls0s9Dxo0SDfeeKMCAgL07LPPavTo0Zc0JgAAAICqsRh/fOimCk6dOlXu2RZPT89LKgrVo7Cw8OwqcSOXy87J9aL3y5reowarAgAAAKru3HfcgoKCKueOKi29dfLkSQ0dOlT169eXm5ubrrnmGpsXAAAAAPxdVSkEjRkzRuvXr9e8efPk5OSkN954Q1OmTFGDBg309ttvV3eNAAAAAFBtqrRE9ieffKK3335bXbt21aOPPqqbbrpJTZs2VePGjfXee+/poYcequ46AQAAAKBaVGkm6NixY2rSpImks8//HDt2TJLUuXNnff3119VXHQAAAABUsyqFoCZNmujAgQOSpBYtWmj58uWSzs4Q1a1bt9qKAwAAAIDqVqUQ9Oijj+q7776TJI0fP15z586Vs7OzRo0apTFjxlRrgQAAAABQnar0TNCoUaOsf4+Ojtbu3bu1fft2NW3aVKGhodVWHAAAAABUtyqFoD86deqUGjdurMaNG1dHPQAAAABQo6p0O1xpaammTZumhg0byt3dXfv375ckTZ48WW+++Wa1FggAAAAA1alKIeiZZ57RokWLNGPGDDk6OlrbW7durTfeeKPaigMAAACA6lalEPT2229rwYIFeuihh2Rvb29tDwsL0+7du6utOAAAAACoblUKQQcPHlTTpk3LtZeVlen06dOXXBQAAAAA1JQqhaBWrVpp48aN5do/+OADtWnT5pKLAgAAAICaUqXV4RISEtS3b18dPHhQZWVlWrlypTIzM/X2229r9erV1V0jAAAAAFSbSs0E7d+/X4Zh6O6779Ynn3yiL7/8Um5ubkpISNCuXbv0ySefKCYmpqZqBQAAAIBLVqmZoODgYOXk5Kh+/fq66aab5O3tre+//16+vr41VR8AAAAAVKtKzQQZhmHz/rPPPlNRUVG1FgQAAAAANalKCyOc8+dQBAAAAAB/d5UKQRaLRRaLpVwbAAAAAFwpKvVMkGEY6tevn5ycnCRJp06d0uDBg+Xm5mbTb+XKldVXIQAAAABUo0qFoL59+9q8f/jhh6u1GAAAAACoaZUKQQsXLqypOgAAAADgsqjSj6XiyrJzSqw8PT1ruwwAAADgb+GSVocDAAAAgCsNIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIcgEWid+rsDxn9Z2GQAAAMDfAiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQggAAAACYCiEIAAAAgKkQgkxq7ty5CgwMlLOzsyIiIrR169YL9l+xYoVatGghZ2dnhYSEaM2aNTbbDcNQQkKC/P395eLioujoaO3Zs8emT2BgoCwWi81r+vTp1X5uAAAAwIUQgkxo2bJlio+PV2JiotLT0xUWFqbY2FgdPny4wv6bN29W79691b9/f+3YsUNxcXGKi4vTzp07rX1mzJihl19+WfPnz9eWLVvk5uam2NhYnTp1ymasqVOnKicnx/oaNmxYjZ4rAAAA8GcWwzCM2i4CNaOwsFBeXl4KGLlcdk6uypreQ5IUERGh9u3ba86cOZKksrIyBQQEaNiwYRo/fny5cXr16qWioiKtXr3a2taxY0eFh4dr/vz5MgxDDRo00JNPPqnRo0dLkgoKCuTr66tFixbpgQcekHR2JmjkyJEaOXJkDZ85AAAArlbnvuMWFBTI09OzSmMwE2QyJSUl2r59u6Kjo61tdnZ2io6OVlpaWoX7pKWl2fSXpNjYWGv/AwcOKDc316aPl5eXIiIiyo05ffp0XXvttWrTpo2ef/55nTlzprpODQAAALgoDrVdQG3p16+f8vPzlZKSUtulXFZHjx5VaWmpfH19bdp9fX21e/fuCvfJzc2tsH9ubq51+7m28/WRpOHDh+vGG2+Ut7e3Nm/erAkTJignJ0cvvPDCJZ8XAAAAcLGuypmgPz98/+dXUlKSXnrpJS1atKhaj9u1a9cKb/VatGiR6tata32flJRkrcXe3l4BAQEaNGiQjh07ZrNfYGCgZs+eXa011qb4+Hh17dpVoaGhGjx4sGbNmqVXXnlFxcXFtV0aAAAATOSqnAnKycmx/n3ZsmVKSEhQZmamtc3d3V3u7u61UZrVDTfcoC+//FKlpaXatWuXHnvsMRUUFGjZsmU1elwfHx/Z29srLy/Ppj0vL09+fn4V7uPn53fB/uf+zMvLk7+/v02f8PDw89YSERGhM2fOKCsrS82bN6/K6QAAAACVdlXOBPn5+VlfXl5eslgsNm3u7u7q16+f4uLirPt07dpVw4cP19ixY+Xt7S0/Pz8lJSVZtz/22GO64447bI5z+vRp1a9fX2+++Wala3RwcJCfn58aNmyo6Oho9ezZU+vWravqKV80R0dHtW3bVqmpqda2srIypaamKjIyssJ9IiMjbfpL0rp166z9g4KC5OfnZ9OnsLBQW7ZsOe+YkpSRkSE7OzvVr1//Uk4JAAAAqJSrciaoqhYvXqz4+Hht2bJFaWlp6tevnzp16qSYmBgNGDBAN998s3JycqyzHatXr9bJkyfVq1evSzpuVlaWPv/8czk6Ol7SOMXFxTa3lhUWFlbYLz4+Xn379lW7du3UoUMHzZ49W0VFRXr00UclSX369FHDhg2VnJwsSRoxYoS6dOmiWbNmqUePHlq6dKm2bdumBQsWSDp7++HIkSP19NNPKzg4WEFBQZo8ebIaNGhgDZppaWnasmWLunXrJg8PD6WlpWnUqFF6+OGHdc0111zSeQMAAACVQQj6g9DQUCUmJkqSgoODNWfOHKWmpiomJkZRUVFq3ry53nnnHY0dO1aStHDhQvXs2bNKt9Z9//33cnd3V2lpqfW3dC51gYDk5GRNmTLlL/v16tVLR44cUUJCgnJzcxUeHq61a9daFzbIzs6Wnd3/JgmjoqK0ZMkSTZo0SRMnTlRwcLBSUlLUunVra5+xY8eqqKhIgwYNUn5+vjp37qy1a9fK2dlZkuTk5KSlS5cqKSlJxcXFCgoK0qhRoxQfH39J5wwAAABUFiHoD0JDQ23e+/v72/yA6IABA7RgwQKNHTtWeXl5+uyzz7R+/foqHat58+ZatWqVTp06pXfffVcZGRmX/MOhEyZMsAkVhYWFCggIqLDv0KFDNXTo0Aq3bdiwoVxbz5491bNnz/Me22KxaOrUqZo6dWqF22+88Ub9+9//vkD1AAAAwOVxVT4TVFV16tSxeW+xWFRWVmZ936dPH+3fv19paWl69913FRQUpJtuusm63dPTUwUFBeXGzc/Pl5eXl02bo6OjmjZtqtatW2v69Omyt7e/qFmcC3FycpKnp6fNCwAAAIAtQlAlXHvttYqLi9PChQu1aNEi6zM05zRv3lzp6enl9ktPT1ezZs0uOPakSZM0c+ZMHTp0qFprBgAAAGCL2+EqacCAAbrjjjtUWlqqvn372mwbMmSI5syZo+HDh2vAgAFycnLSp59+qvfff1+ffPLJBceNjIxUaGionn32Wc2ZM8fafvDgQWVkZNj0bdy4MYsJAAAAAFXETFAlRUdHy9/fX7GxsWrQoIHNtiZNmujrr7/W7t27FR0drYiICC1fvlwrVqxQ9+7d/3LsUaNG6Y033tAvv/xibZs5c6batGlj8/r000+r/bwAAAAAs7AYhmHUdhFXkhMnTqhhw4ZauHCh7r333tou54IKCwvl5eWlgJHLZefkqqzpPWq7JAAAAOCSnPuOW1BQUOVn4Lkd7iKVlZXp6NGjmjVrlurWrau77rqrtksCAAAAUAWEoIuUnZ2toKAgXXfddVq0aJEcHPjoAAAAgCsR3+QvUmBgoLhzEAAAALjysTACAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFMhBAEAAAAwFUIQAAAAAFNxqO0CUPN2TomVp6dnbZcBAAAA/C0wEwQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBAAAAAEyFEAQAAADAVAhBJjN37lwFBgbK2dlZERER2rp16wX7r1ixQi1atJCzs7NCQkK0Zs0am+2GYSghIUH+/v5ycXFRdHS09uzZY92elZWl/v37KygoSC4uLrr++uuVmJiokpKSGjk/AAAA4K8Qgkxk2bJlio+PV2JiotLT0xUWFqbY2FgdPny4wv6bN29W79691b9/f+3YsUNxcXGKi4vTzp07rX1mzJihl19+WfPnz9eWLVvk5uam2NhYnTp1SpK0e/dulZWV6bXXXtMPP/ygF198UfPnz9fEiRMvyzkDAAAAf2YxDMOo7SJQMwoLC+Xl5aWCggJ5enoqIiJC7du315w5cyRJZWVlCggI0LBhwzR+/Phy+/fq1UtFRUVavXq1ta1jx44KDw/X/PnzZRiGGjRooCeffFKjR4+WJBUUFMjX11eLFi3SAw88UGFdzz//vObNm6f9+/fXwFkDAADgavbn77hVwUyQSZSUlGj79u2Kjo62ttnZ2Sk6OlppaWkV7pOWlmbTX5JiY2Ot/Q8cOKDc3FybPl5eXoqIiDjvmNLZoOTt7X0ppwMAAABUGSGohnTt2lUjR46s7TKsjh49qtLSUvn6+tq0+/r6Kjc3t8J9cnNzL9j/3J+VGXPv3r165ZVX9H//939VOg8AAADgUjnUdgFXq5UrV6pOnToX3f/06dNauHChli9frl27dqm0tFRNmjTRvffeq8cff1yurq41WO3lcfDgQXXv3l09e/bUwIEDa7scAAAAmBQhqIZU5nav/fv36+6775adnZ2GDBmi0NBQubu7a/fu3Vq4cKHmzp2rzz//XM2aNatyPT4+PrK3t1deXp5Ne15envz8/Crcx8/P74L9z/2Zl5cnf39/mz7h4eE2+x06dEjdunVTVFSUFixYUOXzAAAAAC4Vt8PVkD/eDvfqq68qODhYzs7O8vX11X333WftV1BQoNjYWN1zzz3KyMjQ4MGDFRUVpdDQUN1///367LPPNHHiRN1666367bffqlyPo6Oj2rZtq9TUVGtbWVmZUlNTFRkZWeE+kZGRNv0lad26ddb+QUFB8vPzs+lTWFioLVu22Ix58OBBde3aVW3bttXChQtlZ8dlBwAAgNrDTFAN27Ztm4YPH6533nlHUVFROnbsmDZu3GjdPn36dLVt21ZTp05Vfn6+nnjiCaWmpqpJkyZ64IEH9Nlnn+mzzz7T119/rdmzZ2vKlCnnPVZxcbGKi4ut7wsLC222x8fHq2/fvmrXrp06dOig2bNnq6ioSI8++qgkqU+fPmrYsKGSk5MlSSNGjFCXLl00a9Ys9ejRQ0uXLtW2bdusMzkWi0UjR47U008/reDgYAUFBWny5Mlq0KCB4uLiJP0vADVu3FgzZ87UkSNHrPWcbwYKAAAAqEmEoBqWnZ0tNzc33XHHHfLw8FDjxo3Vpk0b6/Z33nlHa9eulSQ9+eSTOnDggD7++GMdPnxYgwYNUvPmzSVJ/fr101NPPXXBEJScnHzB7b169dKRI0eUkJCg3NxchYeHa+3atdaFDbKzs21maaKiorRkyRJNmjRJEydOVHBwsFJSUtS6dWtrn7Fjx6qoqEiDBg1Sfn6+OnfurLVr18rZ2VnS2ZmjvXv3au/evbruuuts6mF1dgAAANQGfieohnTt2lXh4eGaNm2aOnXqpJycHHXv3l3du3fXPffcI1dXVx07dkxBQUEqKCiQJNWvX18pKSmKioqSJD3zzDNat26dNmzYoB9//FH33HOPMjMzz3vMimaCAgICLmkNdQAAAODvhN8JugJ4eHgoPT1d77//vvz9/ZWQkKCwsDDl5+frzJkz1hkT6exv+bi5uVnfu7u7W/+enp6upk2bXvBYTk5O8vT0tHkBAAAAsEUIugwcHBwUHR2tGTNm6D//+Y+ysrK0fv16+fj4qKSkxLoCW+fOnTVjxgz9/vvvOnjwoF5//XVJ0ubNm/XUU08pPj6+Nk8DAAAAuCoQgmrY6tWr9fLLLysjI0M///yz3n77bZWVlal58+ays7PTXXfdpVdffVWS9NJLL2nHjh1yd3dXSEiIYmJi9K9//UuPPfaYXnrpJf3jH/+o5bMBAAAArnwsjFDD6tatq5UrVyopKUmnTp1ScHCw3n//fd1www2SpISEBHXo0EEdO3bUbbfdph9//FG5ubm65pprVFZWpqeeeko+Pj61fBYAAADA1YOFEf4GvvjiCz3wwAN6+OGHNXDgQGtA+v777zVz5kzVq1dPL7zwQqXHrY6HxgAAAIC/ExZGuErceuut2r59u44fP66bbrpJjo6OcnR01G233abrrrtOSUlJtV0iAAAAcNVgJuhvpqysTHl5ebKzs7P+fk9VMRMEAACAq011fMflmaC/GTs7O/n7+9d2GQAAAMBVi9vhAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIQgAAACAqRCCAAAAAJgKIchE5s6dq8DAQDk7OysiIkJbt269YP8VK1aoRYsWcnZ2VkhIiNasWWOz3TAMJSQkyN/fXy4uLoqOjtaePXts+jzzzDOKioqSq6ur6tatW92nBAAAAFQaIcgkli1bpvj4eCUmJio9PV1hYWGKjY3V4cOHK+y/efNm9e7dW/3799eOHTsUFxenuLg47dy509pnxowZevnllzV//nxt2bJFbm5uio2N1alTp6x9SkpK1LNnTw0ZMqTGzxEAAAC4GBbDMIzaLgI1o7CwUF5eXiooKFBMTIzat2+vOXPmSJLKysoUEBCgYcOGafz48eX27dWrl4qKirR69WprW8eOHRUeHq758+fLMAw1aNBATz75pEaPHi1JKigokK+vrxYtWqQHHnjAZrxFixZp5MiRys/Pr7kTBgAAwFXvj99xPT09qzQGM0EmUFJSou3btys6OtraZmdnp+joaKWlpVW4T1pamk1/SYqNjbX2P3DggHJzc236eHl5KSIi4rxjAgAAAH8HhKAa1rVrV40cObJWa/j1119VWloqX19fm3ZfX1/l5uZWuE9ubu4F+5/7szJjAgAAAH8HhKAatnLlSk2bNu0v+/Xr109xcXE27y0WiywWixwdHdW0aVNNnTpVZ86cqcFqAQAAgKsfIaiGeXt7y8PDo0r7du/eXTk5OdqzZ4+efPJJJSUl6fnnn6/0ONdee63s7e2Vl5dn056Xlyc/P78K9/Hz87tg/3N/VmZMAAAA4O+AEFTD/ng73Kuvvqrg4GA5OzvL19dX99133wX3dXJykp+fnxo3bqwhQ4YoOjpaq1atqnQNjo6Oatu2rVJTU61tZWVlSk1NVWRkZIX7REZG2vSXpHXr1ln7BwUFyc/Pz6ZPYWGhtmzZct4xAQAAgL8Dh9ouwCy2bdum4cOH65133lFUVJSOHTumjRs3VmoMFxcX/frrr+fdXlxcrOLiYuv7wsJC69/j4+PVt29ftWvXTh06dNDs2bNVVFSkRx99VJLUp08fNWzYUMnJyZKkESNGqEuXLpo1a5Z69OihpUuXatu2bVqwYIEkyWKxaOTIkXr66acVHBysoKAgTZ48WQ0aNLC5rS87O1vHjh1Tdna2SktLlZGRIUlq2rSp3N3dK3X+AAAAQHUgBF0m2dnZcnNz0x133CEPDw81btxYbdq0uah9DcNQamqqPv/8cw0bNuy8/ZKTkzVlypQKt/Xq1UtHjhxRQkKCcnNzFR4errVr11oXNsjOzpad3f8mBqOiorRkyRJNmjRJEydOVHBwsFJSUtS6dWtrn7Fjx6qoqEiDBg1Sfn6+OnfurLVr18rZ2dnaJyEhQYsXL7a+P3fOX331lbp27XpR5w8AAABUJ34nqIZ17dpV4eHhmjZtmjp16qScnBx1795d3bt31z333CNXV1dJZxdCyM/PV0pKivX9u+++K2dnZ50+fVplZWV68MEH9eqrr8rNza3CY1U0ExQQEHBJa6gDAAAAfyf8TtAVxMPDQ+np6Xr//ffl7++vhIQEhYWFXfDHQ7t166aMjAzt2bNHv//+uxYvXnzeACSdfYbI09PT5gUAAADAFiHoMnJwcFB0dLRmzJih//znP8rKytL69evP29/NzU1NmzZVo0aN5ODAnYsAAABAdeCb9WWyevVq7d+/XzfffLOuueYarVmzRmVlZWrevHltlwYAAACYCiHoMqlbt65WrlyppKQknTp1SsHBwXr//fd1ww031HZpAAAAgKmwMMJVrDoeGgMAAAD+TlgYAQAAAAAqiRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRAEAAAAwFQcarsA1BzDMCRJhYWFtVwJAAAAUD3Ofbc99123KghBV7Fff/1VkhQQEFDLlQAAAADV6/jx4/Ly8qrSvoSgq5i3t7ckKTs7u8oXCHA+hYWFCggI0C+//CJPT8/aLgdXGa4v1CSuL9Q0rrGaZRiGjh8/rgYNGlR5DELQVczO7uwjX15eXvwfIGqMp6cn1xdqDNcXahLXF2oa11jNudR/4GdhBAAAAACmQggCAAAAYCqEoKuYk5OTEhMT5eTkVNul4CrE9YWaxPWFmsT1hZrGNfb3ZzEuZW05AAAAALjCMBMEAAAAwFQIQQAAAABMhRAEAAAAwFQIQQAAAABMhRB0hZs7d64CAwPl7OysiIgIbd269YL9V6xYoRYtWsjZ2VkhISFas2bNZaoUV6LKXF+vv/66brrpJl1zzTW65pprFB0d/ZfXI8ytsv/9Omfp0qWyWCyKi4ur2QJxRavs9ZWfn68nnnhC/v7+cnJyUrNmzfj/kbigyl5js2fPVvPmzeXi4qKAgACNGjVKp06dukzVohwDV6ylS5cajo6OxltvvWX88MMPxsCBA426desaeXl5FfbftGmTYW9vb8yYMcP48ccfjUmTJhl16tQxvv/++8tcOa4Elb2+HnzwQWPu3LnGjh07jF27dhn9+vUzvLy8jP/+97+XuXJcCSp7fZ1z4MABo2HDhsZNN91k3H333ZenWFxxKnt9FRcXG+3atTNuv/1245tvvjEOHDhgbNiwwcjIyLjMleNKUdlr7L333jOcnJyM9957zzhw4IDx+eefG/7+/saoUaMuc+U4hxB0BevQoYPxxBNPWN+XlpYaDRo0MJKTkyvsf//99xs9evSwaYuIiDD+7//+r0brxJWpstfXn505c8bw8PAwFi9eXFMl4gpWlevrzJkzRlRUlPHGG28Yffv2JQThvCp7fc2bN89o0qSJUVJScrlKxBWustfYE088Ydxyyy02bfHx8UanTp1qtE6cH7fDXaFKSkq0fft2RUdHW9vs7OwUHR2ttLS0CvdJS0uz6S9JsbGx5+0P86rK9fVnJ0+e1OnTp+Xt7V1TZeIKVdXra+rUqapfv7769+9/OcrEFaoq19eqVasUGRmpJ554Qr6+vmrdurWeffZZlZaWXq6ycQWpyjUWFRWl7du3W2+Z279/v9asWaPbb7/9stSM8hxquwBUzdGjR1VaWipfX1+bdl9fX+3evbvCfXJzcyvsn5ubW2N14spUlevrz8aNG6cGDRqUC95AVa6vb775Rm+++aYyMjIuQ4W4klXl+tq/f7/Wr1+vhx56SGvWrNHevXv1+OOP6/Tp00pMTLwcZeMKUpVr7MEHH9TRo0fVuXNnGYahM2fOaPDgwZo4ceLlKBkVYCYIQLWbPn26li5dqo8++kjOzs61XQ6ucMePH9cjjzyi119/XT4+PrVdDq5CZWVlql+/vhYsWKC2bduqV69eeuqppzR//vzaLg1XiQ0bNujZZ5/Vq6++qvT0dK1cuVKffvqppk2bVtulmRYzQVcoHx8f2dvbKy8vz6Y9Ly9Pfn5+Fe7j5+dXqf4wr6pcX+fMnDlT06dP15dffqnQ0NCaLBNXqMpeX/v27VNWVpbuvPNOa1tZWZkkycHBQZmZmbr++utrtmhcMary3y9/f3/VqVNH9vb21raWLVsqNzdXJSUlcnR0rNGacWWpyjU2efJkPfLIIxowYIAkKSQkREVFRRo0aJCeeuop2dkxL3G58YlfoRwdHdW2bVulpqZa28rKypSamqrIyMgK94mMjLTpL0nr1q07b3+YV1WuL0maMWOGpk2bprVr16pdu3aXo1RcgSp7fbVo0ULff/+9MjIyrK+77rpL3bp1U0ZGhgICAi5n+fibq8p/vzp16qS9e/daw7Uk/fTTT/L39ycAoZyqXGMnT54sF3TOhW7DMGquWJxfba/MgKpbunSp4eTkZCxatMj48ccfjUGDBhl169Y1cnNzDcMwjEceecQYP368tf+mTZsMBwcHY+bMmcauXbuMxMRElsjGeVX2+po+fbrh6OhofPDBB0ZOTo71dfz48do6BfyNVfb6+jNWh8OFVPb6ys7ONjw8PIyhQ4camZmZxurVq4369esbTz/9dG2dAv7mKnuNJSYmGh4eHsb7779v7N+/3/jiiy+M66+/3rj//vtr6xRMj9vhrmC9evXSkSNHlJCQoNzcXIWHh2vt2rXWB/Wys7Nt/tUhKipKS5Ys0aRJkzRx4kQFBwcrJSVFrVu3rq1TwN9YZa+vefPmqaSkRPfdd5/NOImJiUpKSrqcpeMKUNnrC6iMyl5fAQEB+vzzzzVq1CiFhoaqYcOGGjFihMaNG1dbp4C/ucpeY5MmTZLFYtGkSZN08OBB1atXT3feeaeeeeaZ2joF07MYBnNwAAAAAMyDf2YDAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAAAACmQggCAAAAYCqEIAAALqBr164aOXJkbZcBAKhGhCAAQJX169dPFoul3Gvv3r3VMv6iRYtUt27dahmrqlauXKlp06bVag0XsmHDBlksFuXn59d2KQBwxXCo7QIAAFe27t27a+HChTZt9erVq6Vqzu/06dOqU6dOpffz9vaugWqqx+nTp2u7BAC4IjETBAC4JE5OTvLz87N52dvbS5I+/vhj3XjjjXJ2dlaTJk00ZcoUnTlzxrrvCy+8oJCQELm5uSkgIECPP/64Tpw4IensDMejjz6qgoIC6wxTUlKSJMlisSglJcWmjrp162rRokWSpKysLFksFi1btkxdunSRs7Oz3nvvPUnSG2+8oZYtW8rZ2VktWrTQq6++esHz+/PtcIGBgXr66afVp08fubu7q3Hjxlq1apWOHDmiu+++W+7u7goNDdW2bdus+5yb0UpJSVFwcLCcnZ0VGxurX375xeZY8+bN0/XXXy9HR0c1b95c77zzjs12i8WiefPm6a677pKbm5sGDhyobt26SZKuueYaWSwW9evXT5K0du1ade7cWXXr1tW1116rO+64Q/v27bOOde4zWrlypbp16yZXV1eFhYUpLS3N5pibNm1S165d5erqqmuuuUaxsbH67bffJEllZWVKTk5WUFCQXFxcFBYWpg8++OCCnycA/C0YAABUUd++fY277767wm1ff/214enpaSxatMjYt2+f8cUXXxiBgYFGUlKStc+LL75orF+/3jhw4ICRmppqNG/e3BgyZIhhGIZRXFxszJ492/D09DRycnKMnJwc4/jx44ZhGIYk46OPPrI5npeXl7Fw4ULDMAzjwIEDhiQjMDDQ+PDDD439+/cbhw4dMt59913D39/f2vbhhx8a3t7exqJFi857jl26dDFGjBhhfd+4cWPD29vbmD9/vvHTTz8ZQ4YMMTw9PY3u3bsby5cvNzIzM424uDijZcuWRllZmWEYhrFw4UKjTp06Rrt27YzNmzcb27ZtMzp06GBERUVZx125cqVRp04dY+7cuUZmZqYxa9Ysw97e3li/fr21jySjfv36xltvvWXs27fPyMrKMj788ENDkpGZmWnk5OQY+fn5hmEYxgcffGB8+OGHxp49e4wdO3YYd955pxESEmKUlpbafEYtWrQwVq9ebWRmZhr33Xef0bhxY+P06dOGYRjGjh07DCcnJ2PIkCFGRkaGsXPnTuOVV14xjhw5YhiGYTz99NNGixYtjLVr1xr79u0zFi5caDg5ORkbNmw47+cJAH8HhCAAQJX17dvXsLe3N9zc3Kyv++67zzAMw/jHP/5hPPvsszb933nnHcPf3/+8461YscK49tprre8XLlxoeHl5let3sSFo9uzZNn2uv/56Y8mSJTZt06ZNMyIjI89bU0Uh6OGHH7a+z8nJMSQZkydPtralpaUZkoycnBzreUgy/v3vf1v77Nq1y5BkbNmyxTAMw4iKijIGDhxoc+yePXsat99+u815jxw50qbPV199ZUgyfvvtt/Oeg2EYxpEjRwxJxvfff28Yxv8+ozfeeMPa54cffjAkGbt27TIMwzB69+5tdOrUqcLxTp06Zbi6uhqbN2+2ae/fv7/Ru3fvC9YCALWNZ4IAAJekW7dumjdvnvW9m5ubJOm7777Tpk2b9Mwzz1i3lZaW6tSpUzp58qRcXV315ZdfKjk5Wbt371ZhYaHOnDljs/1StWvXzvr3oqIi7du3T/3799fAgQOt7WfOnJGXl1elxg0NDbX+3dfXV5IUEhJSru3w4cPy8/OTJDk4OKh9+/bWPi1atFDdunW1a9cudejQQbt27dKgQYNsjtOpUye99NJL5z2nC9mzZ48SEhK0ZcsWHT16VGVlZZKk7OxstW7dusJz8ff3t9bdokULZWRkqGfPnhWOv3fvXp08eVIxMTE27SUlJWrTps1F1QgAtYUQBAC4JG5ubmratGm59hMnTmjKlCm69957y21zdnZWVlaW7rjjDg0ZMkTPPPOMvL299c0336h///4qKSm5YAiyWCwyDMOmraJFAs4FsnP1SNLrr7+uiIgIm37nnmG6WH9cYMFisZy37VzwqE5/PKcLufPOO9W4cWO9/vrratCggcrKytS6dWuVlJTY9LtQ3S4uLucd/9zn+emnn6phw4Y225ycnC6qRgCoLYQgAECNuPHGG5WZmVlhQJKk7du3q6ysTLNmzZKd3dl1epYvX27Tx9HRUaWlpeX2rVevnnJycqzv9+zZo5MnT16wHl9fXzVo0ED79+/XQw89VNnTuWRnzpzRtm3b1KFDB0lSZmam8vPz1bJlS0lSy5YttWnTJvXt29e6z6ZNm9SqVasLjuvo6ChJNp/Tr7/+qszMTL3++uu66aabJEnffPNNpWsODQ1VamqqpkyZUm5bq1at5OTkpOzsbHXp0qXSYwNAbSIEAQBqREJCgu644w41atRI9913n+zs7PTdd99p586devrpp9W0aVOdPn1ar7zyiu68805t2rRJ8+fPtxkjMDBQJ06cUGpqqsLCwuTq6ipXV1fdcsstmjNnjiIjI1VaWqpx48Zd1PLXU6ZM0fDhw+Xl5aXu3buruLhY27Zt02+//ab4+Pia+igknZ1xGTZsmF5++WU5ODho6NCh6tixozUUjRkzRvfff7/atGmj6OhoffLJJ1q5cqW+/PLLC47buHFjWSwWrV69WrfffrtcXFx0zTXX6Nprr9WCBQvk7++v7OxsjR8/vtI1T5gwQSEhIXr88cc1ePBgOTo66quvvlLPnj3l4+Oj0aNHa9SoUSorK1Pnzp1VUFCgTZs2ydPT0ybMAcDfDUtkAwBqRGxsrFavXq0vvvhC7du3V8eOHfXiiy+qcePGkqSwsDC98MILeu6559S6dWu99957Sk5OthkjKipKgwcPVq9evVSvXj3NmDFDkjRr1iwFBATopptu0oMPPqjRo0df1DNEAwYM0BtvvKGFCxcqJCREXbp00aJFixQUFFT9H8CfuLq6aty4cXrwwQfVqVMnubu7a9myZdbtcXFxeumllzRz5kzdcMMNeu2117Rw4UJ17dr1guM2bNhQU6ZM0fjx4+Xr66uhQ4fKzs5OS5cu1fbt29W6dWuNGjVKzz//fKVrbtasmb744gt999136tChgyIjI/Xxxx/LweHsv6FOmzZNkydPVnJyslq2bKnu3bvr008/vSyfJwBcCovx55uqAQBAtVq0aJFGjhyp/Pz82i4FACBmggAAAACYDCEIAAAAgKlwOxwAAAAAU2EmCAAAAICpEIIAAAAAmAohCAAAAICpEIIAAAAAmAohCAAAAICpEIIAAAAAmAohCAAAAICpEIIAAAAAmAohCAAAAICp/D+2MYbnYlJUTQAAAABJRU5ErkJggg==\n"},"metadata":{}}],"source":["# Get the feature importance for all the features, from the decision tree classifier\n","\n","importances = dtc.feature_importances_\n","indices = np.argsort(importances)\n","plt.figure(figsize=(9,7))\n","n_features = X_train.shape[1]\n","plt.barh(range(n_features), importances[indices], align='center')\n","plt.yticks(np.arange(n_features), X_train.columns[indices])\n","for index, value in enumerate(importances[indices]):\n","    plt.text(value, index, str(round(value,3)))\n","plt.xlabel(\"Feature importance\")\n","plt.ylabel(\"Feature\")\n","plt.show()\n"]},{"cell_type":"code","execution_count":null,"metadata":{"executionInfo":{"elapsed":25,"status":"ok","timestamp":1681749196873,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"},"user_tz":-330},"id":"Jw5SkppYJdmy","colab":{"base_uri":"https://localhost:8080/","height":206},"outputId":"0997e73f-f77c-4ee0-dbf1-6f8772da9fa7"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["   isIP  is@  isRedirect  haveDash  SubDomain  LongURL  TinyURL  Label\n","0     0    0           0         0          0        0        0      0\n","1     0    0           0         1          0        0        0      1\n","2     0    0           0         0          1        0        0      1\n","3     0    0           0         0          1        1        0      1\n","4     0    0           0         0          1        1        0      0"],"text/html":["\n","  <div id=\"df-a4405862-d47c-4e7c-a810-5cc500ca2a0f\">\n","    <div class=\"colab-df-container\">\n","      <div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>isIP</th>\n","      <th>is@</th>\n","      <th>isRedirect</th>\n","      <th>haveDash</th>\n","      <th>SubDomain</th>\n","      <th>LongURL</th>\n","      <th>TinyURL</th>\n","      <th>Label</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>\n","      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-a4405862-d47c-4e7c-a810-5cc500ca2a0f')\"\n","              title=\"Convert this dataframe to an interactive table.\"\n","              style=\"display:none;\">\n","        \n","  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n","       width=\"24px\">\n","    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n","    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n","  </svg>\n","      </button>\n","      \n","  <style>\n","    .colab-df-container {\n","      display:flex;\n","      flex-wrap:wrap;\n","      gap: 12px;\n","    }\n","\n","    .colab-df-convert {\n","      background-color: #E8F0FE;\n","      border: none;\n","      border-radius: 50%;\n","      cursor: pointer;\n","      display: none;\n","      fill: #1967D2;\n","      height: 32px;\n","      padding: 0 0 0 0;\n","      width: 32px;\n","    }\n","\n","    .colab-df-convert:hover {\n","      background-color: #E2EBFA;\n","      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n","      fill: #174EA6;\n","    }\n","\n","    [theme=dark] .colab-df-convert {\n","      background-color: #3B4455;\n","      fill: #D2E3FC;\n","    }\n","\n","    [theme=dark] .colab-df-convert:hover {\n","      background-color: #434B5C;\n","      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n","      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n","      fill: #FFFFFF;\n","    }\n","  </style>\n","\n","      <script>\n","        const buttonEl =\n","          document.querySelector('#df-a4405862-d47c-4e7c-a810-5cc500ca2a0f button.colab-df-convert');\n","        buttonEl.style.display =\n","          google.colab.kernel.accessAllowed ? 'block' : 'none';\n","\n","        async function convertToInteractive(key) {\n","          const element = document.querySelector('#df-a4405862-d47c-4e7c-a810-5cc500ca2a0f');\n","          const dataTable =\n","            await google.colab.kernel.invokeFunction('convertToInteractive',\n","                                                     [key], {});\n","          if (!dataTable) return;\n","\n","          const docLinkHtml = 'Like what you see? Visit the ' +\n","            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n","            + ' to learn more about interactive tables.';\n","          element.innerHTML = '';\n","          dataTable['output_type'] = 'display_data';\n","          await google.colab.output.renderOutput(dataTable, element);\n","          const docLink = document.createElement('div');\n","          docLink.innerHTML = docLinkHtml;\n","          element.appendChild(docLink);\n","        }\n","      </script>\n","    </div>\n","  </div>\n","  "]},"metadata":{},"execution_count":18}],"source":["# Drop the features with least importance and assign the input and output\n","# variables from the dataset\n","\n","# phishing_raw_df_x.drop([\"isIP\",\"Domain_http\",\"is@\"],inplace=True,axis=1)\n","\n","phishing_raw_df_x.head()\n","\n","\n","# X = phishing_raw_df_x.iloc[:, :8]\n","# Y = phishing_raw_df_x[\"Label\"]"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"dV09Ul_7Jdmz"},"outputs":[],"source":["# Split the data for training and testing \n","\n","X_train, X_test, y_train, y_test = train_test_split(X.values,Y.values, test_size=0.3, random_state=101)"]},{"cell_type":"markdown","metadata":{"id":"wtuNQIi6Jdmz"},"source":["## Model Development"]},{"cell_type":"markdown","metadata":{"id":"UNT2TLcOJdm0"},"source":["### XGBoost"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"I-e7j0wJJdm0"},"outputs":[],"source":["def XG_Boost_classifier():\n","    \n","    # Funtion for XGBoost model\n","    \n","    global XGB_model\n","    \n","    XGB_model = XGBClassifier(random_state=100)\n","    \n","    train_start = timeit.default_timer()\n","    XGB_model.fit(X_train, y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_XGB_test = XGB_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","    \n","    pred_XGB_train = XGB_model.predict(X_train)\n","    kappa_XGB = cohen_kappa_score(y_test, pred_XGB_test)\n","    \n","    # Print the classification report\n","\n","    print('\\n---------- XGBoost ----------\\n')\n","    print('Classification Report:\\n', classification_report(y_test, pred_XGB_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_XGB_test),display_labels=['0','1'])\n","    print('\\nConfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(XGB_model, X_test, y_test, name = 'XGBoost')\n","    \n","    return (('XGBoost',accuracy_score(y_train,pred_XGB_train),accuracy_score(y_test,pred_XGB_test),kappa_XGB, train_time,test_time))\n"]},{"cell_type":"markdown","metadata":{"id":"E4XZlAQCJdm1"},"source":["## Decision Tree"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"YSmUxg5RJdm1"},"outputs":[],"source":["def Decision_Tree_classifier():\n","    \n","    # Funtion for Decision Tree model\n","    \n","    global DTC_model\n","    \n","    DTC_model = DecisionTreeClassifier(criterion = \"entropy\", random_state = 100,max_depth = 5)\n","    \n","    train_start = timeit.default_timer()\n","    DTC_model.fit(X_train,y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_dtc_test = DTC_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","    \n","    pred_dtc_train = DTC_model.predict(X_train)\n","    kappa_dtc = cohen_kappa_score(y_test, pred_dtc_test)\n","    \n","    # Print the classification report\n","    \n","    print('\\n---------- Decision Tree ----------\\n')\n","    print('Classification Report :\\n', classification_report(y_test, pred_dtc_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_dtc_test),display_labels=['0','1'])\n","    print('\\nConfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(DTC_model, X_test, y_test, name = 'Decision Tree')\n","    \n","    return (('Decision Tree',accuracy_score(y_train,pred_dtc_train),accuracy_score(y_test,pred_dtc_test), kappa_dtc, train_time,test_time))"]},{"cell_type":"markdown","metadata":{"id":"O03R5hJpJdm1"},"source":["## Neural Network"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"4VD09eTWJdm2"},"outputs":[],"source":["def Neural_Network_classifier():\n","    \n","    # Funtion for Neural Network model\n","    # The neural network is trained with 3 layers \n","    global MLP_model\n","\n","    MLP_model = MLPClassifier(hidden_layer_sizes=(12,12,12), activation='relu', solver='adam', max_iter=500)\n","    \n","    train_start = timeit.default_timer()  \n","    MLP_model.fit(X_train,y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_NN_test = MLP_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","    \n","    pred_NN_train = MLP_model.predict(X_train)\n","    kappa_NN = cohen_kappa_score(y_test, pred_NN_test)\n","    \n","    # Print the classification report\n","    \n","    print('\\n---------- Neural Network ----------\\n')\n","    print('Classification Report:\\n', classification_report(y_test, pred_NN_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_NN_test),display_labels=['0','1'])\n","    print('\\nconfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(MLP_model, X_test, y_test, name = 'Neural Network')\n","    \n","    return (('Neural Network',accuracy_score(y_train,pred_NN_train),accuracy_score(y_test,pred_NN_test), kappa_NN, train_time,test_time))"]},{"cell_type":"markdown","metadata":{"id":"iyAZv2xjJdm2"},"source":["# SVM"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"OFQ0h-ooJdm3"},"outputs":[],"source":["def Svm_classifier():\n","    \n","    # Funtion for SVM model\n","    \n","    global SVM_model\n","    \n","    SVM_model = SVC(kernel='poly', degree=9, random_state=12)\n","    \n","    train_start = timeit.default_timer()\n","    SVM_model.fit(X_train, y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_svm_test = SVM_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","    \n","    pred_svm_train = SVM_model.predict(X_train)\n","    kappa_svm = cohen_kappa_score(y_test, pred_svm_test)\n","    \n","    # Print the classification report\n","    \n","    print('\\n---------- SVM ----------\\n')\n","    print('Classification Report:\\n', classification_report(y_test, pred_svm_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_svm_test),display_labels=['0','1'])\n","    print('\\nconfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(SVM_model, X_test, y_test, name = 'SVM')\n","    \n","    return (('SVM',accuracy_score(y_train,pred_svm_train),accuracy_score(y_test,pred_svm_test), kappa_svm, train_time,test_time))"]},{"cell_type":"markdown","metadata":{"id":"Oif-k1SyJdm3"},"source":["# Naive Bayes"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"UZ6o-6xKJdm3"},"outputs":[],"source":["def Naive_Bayes_classifier():\n","    \n","    # Funtion for Naive Bayes model\n","    \n","    global NBC_model\n","    \n","    NBC_model = BernoulliNB()\n","    \n","    train_start = timeit.default_timer()\n","    NBC_model.fit(X_train,y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_nb_test = NBC_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","    \n","    pred_nb_train = NBC_model.predict(X_train)\n","    kappa_nb = cohen_kappa_score(y_test, pred_nb_test)\n","    \n","    # Print the classification report\n","    \n","    print('\\n---------- Naive Bayes ----------\\n')\n","    print('Classification Report:\\n', classification_report(y_test, pred_nb_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_nb_test),display_labels=['0','1'])\n","    print('\\nconfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(NBC_model, X_test, y_test, name = 'Naive Bayes')\n","    \n","    return (('Naive Bayes',accuracy_score(y_train,pred_nb_train),accuracy_score(y_test,pred_nb_test),kappa_nb, train_time,test_time))"]},{"cell_type":"markdown","metadata":{"id":"7_kWcLzBJdm4"},"source":["# Logistic Regression"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"2yQ0N8rkJdm4"},"outputs":[],"source":["def Logistic_Regression_classifier():\n","    \n","    # Funtion for Logistic Regression model\n","    \n","    global LOG_model\n","\n","    LOG_model = LogisticRegression(random_state=100)\n","    \n","    train_start = timeit.default_timer()\n","    LOG_model.fit(X_train,y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_logreg_test = LOG_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","   \n","    pred_logreg_train = LOG_model.predict(X_train)\n","    kappa_lg =  cohen_kappa_score(y_test, pred_logreg_test)\n","    \n","    # Print the classification report\n","    \n","    print('\\n---------- Logistic Regression ----------\\n')\n","    print('Classification Report:\\n', classification_report(y_test, pred_logreg_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_logreg_test),display_labels=['0','1'])\n","    print('\\nconfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(LOG_model, X_test, y_test, name = 'Logistic Regression')\n","    \n","    return (('Logistic Regression',accuracy_score(y_train,pred_logreg_train),accuracy_score(y_test,pred_logreg_test),kappa_lg, train_time,test_time))"]},{"cell_type":"markdown","metadata":{"id":"TydTK5R_Jdm5"},"source":["# RandomForest"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"rYtoewnWJdm5"},"outputs":[],"source":["def Random_Forest_classifier():\n","    \n","    # Funtion for Random Forest model\n","    \n","    global RFC_model\n","    \n","    RFC_model = RandomForestClassifier(criterion='entropy',random_state=100)\n","    \n","    train_start = timeit.default_timer()\n","    RFC_model.fit(X_train, y_train)\n","    train_time = timeit.default_timer() - train_start\n","    \n","    test_start = timeit.default_timer()\n","    pred_RF_test = RFC_model.predict(X_test)\n","    test_time = timeit.default_timer() - test_start\n","    \n","    pred_RF_train = RFC_model.predict(X_train)\n","    kappa_rf = cohen_kappa_score(y_test, pred_RF_test)\n","    \n","    # Print the classification report\n","    \n","    print('\\n---------- Random Forest ----------\\n')\n","    print('Classification Report:\\n', classification_report(y_test, pred_RF_test, target_names=['0','1']))\n","    \n","    # Print the Confusion matrix\n","    \n","    disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix(y_test, pred_RF_test),display_labels=['0','1'])\n","    print('\\nconfusion matrix:\\n',disp.plot())\n","    \n","    # Print the precision-recall graph\n","    \n","    # plot_precision_recall_curve(RFC_model, X_test, y_test, name = 'Random Forest')\n","    \n","    return (('Random Forest',accuracy_score(y_train,pred_RF_train),accuracy_score(y_test,pred_RF_test),kappa_rf, train_time, test_time))"]},{"cell_type":"markdown","metadata":{"id":"AJOGXvu3Jdm6"},"source":["## Evaluation Metrics"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"i9U1eu2VJdm6"},"outputs":[],"source":["\n","def Roc_curves():\n","    \n","    # Function to display the ROC curves for the models\n","    plt.figure()\n","    \n","    # Add the models to the list that you want to view on the ROC plot\n","    models = [\n","    {\n","        'label': 'Logistic Regression',\n","        'model': LogisticRegression(random_state=100),\n","    },\n","    {\n","        'label': 'SVM',\n","        'model': SVC(kernel='linear', C=1.0, random_state=100,probability=True),\n","    },\n","    {\n","        'label': 'NaiveBayes',\n","        'model': BernoulliNB(),\n","    },\n","    {\n","        'label': 'Decision Tree',\n","        'model': DecisionTreeClassifier(criterion = \"entropy\", random_state = 100,max_depth = 5),\n","    },\n","    {\n","        'label': 'RandomForest',\n","        'model': RandomForestClassifier(criterion='entropy',random_state=100)\n","    },\n","    {\n","        'label': 'XGBoost',\n","        'model': XGBClassifier(random_state=100),\n","    },\n","    {\n","        'label': 'Neural Network',\n","        'model': MLPClassifier(hidden_layer_sizes=(12,12,12), activation='relu', solver='adam', max_iter=500)\n","    }\n","    ]\n","\n","    # Below for loop iterates through your models list\n","    \n","    for m in models: \n","        model = m['model']                # select the model\n","        model.fit(X_train, y_train)       # train the model\n","        y_pred=model.predict(X_test)      # predict the test data\n","    \n","    # Compute False postive rate, and True positive rate\n","    \n","        fpr, tpr, thresholds = metrics.roc_curve(y_test, model.predict_proba(X_test)[:,1])\n","    \n","    # Calculate Area under the curve to display on the plot\n","    \n","        auc = metrics.roc_auc_score(y_test,model.predict(X_test))\n","    # Now, plot the computed values\n","    \n","        plt.plot(fpr, tpr, label='%s ROC (area = %0.2f)' % (m['label'], auc))\n","        \n","    # Custom settings for the plot \n","    \n","    plt.plot([0, 1], [0, 1],'r--')\n","    plt.xlim([0.0, 1.0])\n","    plt.ylim([0.0, 1.05])\n","    plt.xlabel('1-Specificity(False Positive Rate)')\n","    plt.ylabel('Sensitivity(True Positive Rate)')\n","    plt.title('Receiver Operating Characteristic')\n","    plt.legend(loc=\"lower right\")\n","    plt.show()   "]},{"cell_type":"code","execution_count":null,"metadata":{"id":"iCG0UyE_Jdm7"},"outputs":[],"source":["def call_ml_models():\n","    \n","    # Function to invoke all the proposed ML models and consolidates the performace of each model\n","    \n","    kappa_list = []\n","    ML_Model = []\n","    acc_train = []\n","    acc_test = []\n","    train_time = []\n","    test_time = []\n","    model_list = [Logistic_Regression_classifier,Naive_Bayes_classifier,Svm_classifier,Decision_Tree_classifier,Random_Forest_classifier,XG_Boost_classifier,Neural_Network_classifier]\n","    \n","    # Below loop iterates to invoke each models in the model_list\n","    \n","    for model in model_list: \n","        res = model()\n","        ML_Model.append(res[0])\n","        acc_train.append(res[1])\n","        acc_test.append(res[2])\n","        kappa_list.append(res[3]) \n","        train_time.append(res[4])\n","        test_time.append(res[5])\n","        \n","    # Call to display the ROC curves of all the models\n","    \n","    Roc_curves()\n","        \n","    return ML_Model,acc_train,acc_test,kappa_list,train_time,test_time  \n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"wT-0F0DEJdm7","executionInfo":{"status":"error","timestamp":1681749801118,"user_tz":-330,"elapsed":268856,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"}},"outputId":"b96817a2-a723-4b4b-bea6-fa8ef6236bdb"},"outputs":[{"metadata":{"tags":null},"name":"stdout","output_type":"stream","text":["\n","---------- Logistic Regression ----------\n","\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0abfda9a0>\n","\n","---------- Naive Bayes ----------\n","\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0ab441ca0>\n","\n","---------- SVM ----------\n","\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0ab366730>\n","\n","---------- Decision Tree ----------\n","\n","Classification Report :\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","Confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0ab2c05e0>\n","\n","---------- Random Forest ----------\n","\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0ab248d30>\n","\n","---------- XGBoost ----------\n","\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","Confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0ab1e97f0>\n","\n","---------- Neural Network ----------\n","\n","Classification Report:\n","               precision    recall  f1-score   support\n","\n","           0       0.72      0.85      0.78     11846\n","           1       0.83      0.68      0.74     12152\n","\n","    accuracy                           0.76     23998\n","   macro avg       0.77      0.76      0.76     23998\n","weighted avg       0.77      0.76      0.76     23998\n","\n","\n","confusion matrix:\n"," <sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay object at 0x7ff0ab0fe9a0>\n"]},{"output_type":"error","ename":"KeyboardInterrupt","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m<ipython-input-29-be86de3cca1f>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Invoke the call models function to display the model performance statistics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mML_Model\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0macc_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0macc_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mkappa_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtrain_time\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcall_ml_models\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# Create the dataframe with the consolidated accuracies and timings of all models\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-28-b9ef0474f5e9>\u001b[0m in \u001b[0;36mcall_ml_models\u001b[0;34m()\u001b[0m\n\u001b[1;32m     24\u001b[0m     \u001b[0;31m# Call to display the ROC curves of all the models\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m     \u001b[0mRoc_curves\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mML_Model\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0macc_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0macc_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mkappa_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtrain_time\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtest_time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-27-ed9bf095dea2>\u001b[0m in \u001b[0;36mRoc_curves\u001b[0;34m()\u001b[0m\n\u001b[1;32m     45\u001b[0m     \u001b[0;31m# Compute False postive rate, and True positive rate\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m         \u001b[0mfpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mthresholds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_proba\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m     \u001b[0;31m# Calculate Area under the curve to display on the plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.9/dist-packages/sklearn/svm/_base.py\u001b[0m in \u001b[0;36mpredict_proba\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m    869\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sparse_predict_proba\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sparse\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dense_predict_proba\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    870\u001b[0m         )\n\u001b[0;32m--> 871\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mpred_proba\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    872\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    873\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mavailable_if\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_check_proba\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.9/dist-packages/sklearn/svm/_base.py\u001b[0m in \u001b[0;36m_dense_predict_proba\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m    909\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    910\u001b[0m         \u001b[0msvm_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLIBSVM_IMPL\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_impl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 911\u001b[0;31m         pprob = libsvm.predict_proba(\n\u001b[0m\u001b[1;32m    912\u001b[0m             \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    913\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msupport_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAgwAAAGxCAYAAAAOOu45AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABN5UlEQVR4nO3deVxVdf7H8ddlR+GCGyCJhlkqZZpaSotlkZTU6GjTWFbkkr8KKzWXnNJcKkvHTMulsqQanbKpLLVU0tRMcqEwV8q01BS0EG6YbPee3x/EzZsm4LmIet7Px+M88p7zPd/zPQzD+dzPdzk2wzAMRERERE7Cp6YbICIiImc+BQwiIiJSIQUMIiIiUiEFDCIiIlIhBQwiIiJSIQUMIiIiUiEFDCIiIlIhBQwiIiJSIb+aboAZLpeL/fv3Exoais1mq+nmiIhIFRmGwa+//kp0dDQ+PtX3HbawsJDi4mLT9QQEBBAUFOSFFp19zuqAYf/+/cTExNR0M0RExKS9e/fSqFGjaqm7sLCQ2CYhZB90mq4rKiqK3bt3WzJoOKsDhtDQUAB+/Op87CHqXZFz098valXTTRCpNqWUsIaP3X/Pq0NxcTHZB538mHE+9tBTf1Y4fnXRpN0PFBcXVypgWL16NZMmTSIjI4MDBw7wwQcf0L17d/dxwzB48sknefXVV8nLy+Oqq65i5syZXHjhhe4yubm5PPTQQyxcuBAfHx969uzJ1KlTCQkJcZf55ptvSElJYcOGDTRo0ICHHnqI4cOHe7Tl3XffZdSoUfzwww9ceOGFPPfcc3Tt2rVK939WBwzl3RD2EB9TvwQiZzI/m39NN0Gk+vz+NqPT0a0cEmojJPTUr+OiauceOXKE1q1b07dvX3r06HHc8YkTJzJt2jTeeOMNYmNjGTVqFImJiWzbts0dkPTu3ZsDBw6QlpZGSUkJffr0YcCAAcybNw8Ah8NBly5dSEhIYNasWWzevJm+ffsSHh7OgAEDAFi7di133HEHEyZM4JZbbmHevHl0796dr776iksuuaTS92M7m18+5XA4CAsL4/C3TRUwyDkrMbpNTTdBpNqUGiWs5EPy8/Ox2+3Vco3yZ8XBrCamMwwRzX88pbbabDaPDINhGERHR/Poo48ydOhQAPLz84mMjCQ1NZVevXqxfft24uLi2LBhA+3btwdgyZIldO3alX379hEdHc3MmTN5/PHHyc7OJiAgAIDHHnuMBQsWsGPHDgD++c9/cuTIERYtWuRuT8eOHWnTpg2zZs2q9D3oKSsiIpbgwjC9QVkAcuxWVFRU5bbs3r2b7OxsEhIS3PvCwsLo0KED6enpAKSnpxMeHu4OFgASEhLw8fFh3bp17jKdOnVyBwsAiYmJZGVlcfjwYXeZY69TXqb8OpWlgEFERKQKYmJiCAsLc28TJkyoch3Z2dkAREZGeuyPjIx0H8vOziYiIsLjuJ+fH3Xr1vUoc6I6jr3GX5UpP15ZZ/UYBhERkcpy4cJl8nwom9FxbJdEYGCgyZadHRQwiIiIJTgNA6eJYXvl59rtdtPjLaKiogDIycmhYcOG7v05OTm0adPGXebgwYMe55WWlpKbm+s+PyoqipycHI8y5Z8rKlN+vLLUJSEiInKaxcbGEhUVxfLly937HA4H69atIz4+HoD4+Hjy8vLIyMhwl1mxYgUul4sOHTq4y6xevZqSkhJ3mbS0NJo3b06dOnXcZY69TnmZ8utUlgIGERGxBG8NeqysgoICMjMzyczMBMoGOmZmZrJnzx5sNhuDBg3iqaee4qOPPmLz5s3cc889REdHu2dStGzZkptuuon77ruP9evX88UXXzBw4EB69epFdHQ0AHfeeScBAQH069ePrVu38s477zB16lSGDBnibscjjzzCkiVLmDx5Mjt27GDMmDFs3LiRgQMHVul+1CUhIiKW4MLAWcWH/p/Pr4qNGzfSuXNn9+fyh3hycjKpqakMHz6cI0eOMGDAAPLy8rj66qtZsmSJx6JQc+fOZeDAgdxwww3uhZumTZvmPh4WFsayZctISUmhXbt21K9fn9GjR7vXYAC48sormTdvHk888QT/+te/uPDCC1mwYEGV1mAArcMgcsbTOgxyLjud6zDs3tGQUBPPil9/dRHb4kC1tvVMpgyDiIhYwql0K/z5fCtTwCAiIpbgrVkSVqU8voiIiFRIGQYREbEE1++bmfOtTAGDiIhYgtPkLAkz554LFDCIiIglOI2yzcz5VqYxDCIiIlIhZRhERMQSNIbBHAUMIiJiCS5sOLGZOt/K1CUhIiIiFVKGQURELMFllG1mzrcyBQwiImIJTpNdEmbOPReoS0JEREQqpAyDiIhYgjIM5ihgEBERS3AZNlyGiVkSJs49F6hLQkRERCqkDIOIiFiCuiTMUcAgIiKW4MQHp4nEutOLbTkbKWAQERFLMEyOYTA0hkFERETk5JRhEBERS9AYBnMUMIiIiCU4DR+chokxDBZfGlpdEiIiIlIhZRhERMQSXNhwmfie7MLaKQYFDCIiYgkaw2COuiRERESkQsowiIiIJZgf9KguCRERkXNe2RgGEy+fUpeEiIiIyMkpwyAiIpbgMvkuCc2SEBERsQCNYTBHAYOIiFiCCx+tw2CCxjCIiIhIhRQwiIiIJTgNm+mtqn799VcGDRpEkyZNCA4O5sorr2TDhg3u44ZhMHr0aBo2bEhwcDAJCQl89913HnXk5ubSu3dv7HY74eHh9OvXj4KCAo8y33zzDddccw1BQUHExMQwceLEU/shnYQCBhERsQTn74MezWxV1b9/f9LS0njrrbfYvHkzXbp0ISEhgZ9++gmAiRMnMm3aNGbNmsW6deuoXbs2iYmJFBYWuuvo3bs3W7duJS0tjUWLFrF69WoGDBjgPu5wOOjSpQtNmjQhIyODSZMmMWbMGF555RXzP7Rj2Azj7B3F4XA4CAsL4/C3TbGHKvaRc1NidJuaboJItSk1SljJh+Tn52O326vlGuXPitSvW1Mr1PeU6/ntVyf3Xrap0m09evQooaGhfPjhhyQlJbn3t2vXjptvvpnx48cTHR3No48+ytChQwHIz88nMjKS1NRUevXqxfbt24mLi2PDhg20b98egCVLltC1a1f27dtHdHQ0M2fO5PHHHyc7O5uAgAAAHnvsMRYsWMCOHTtO+X7/TE9ZERGxBJfhY3qDsgDk2K2oqOiE1ystLcXpdBIUFOSxPzg4mDVr1rB7926ys7NJSEhwHwsLC6NDhw6kp6cDkJ6eTnh4uDtYAEhISMDHx4d169a5y3Tq1MkdLAAkJiaSlZXF4cOHvfPDQwGDiIhYhLe6JGJiYggLC3NvEyZMOOH1QkNDiY+PZ/z48ezfvx+n08l//vMf0tPTOXDgANnZ2QBERkZ6nBcZGek+lp2dTUREhMdxPz8/6tat61HmRHWUH/MWTasUERGpgr1793p0SQQGBv5l2bfeeou+ffty3nnn4evrS9u2bbnjjjvIyMg4HU31KmUYRETEElyYmynh+r0eu93usZ0sYLjgggtYtWoVBQUF7N27l/Xr11NSUkLTpk2JiooCICcnx+OcnJwc97GoqCgOHjzocby0tJTc3FyPMieqo/yYtyhgEBERSyhfuMnMdqpq165Nw4YNOXz4MEuXLqVbt27ExsYSFRXF8uXL3eUcDgfr1q0jPj4egPj4ePLy8jwyEitWrMDlctGhQwd3mdWrV1NSUuIuk5aWRvPmzalTp84pt/nPFDCIiIhUk6VLl7JkyRJ2795NWloanTt3pkWLFvTp0webzcagQYN46qmn+Oijj9i8eTP33HMP0dHRdO/eHYCWLVty0003cd9997F+/Xq++OILBg4cSK9evYiOjgbgzjvvJCAggH79+rF161beeecdpk6dypAhQ7x6LxrDICIilmD+XRJVPzc/P5+RI0eyb98+6tatS8+ePXn66afx9/cHYPjw4Rw5coQBAwaQl5fH1VdfzZIlSzxmVsydO5eBAwdyww034OPjQ8+ePZk2bZr7eFhYGMuWLSMlJYV27dpRv359Ro8e7bFWgzdoHQaRM5zWYZBz2elch2FaRkeCQ079e/LRglIebvdltbb1TKYMg4iIWEJNZBjOJda+exEREakUZRhERMQSTvV9EMeeb2UKGERExBJchg3XKbxx8tjzrcza4ZKIiIhUijIMIiJiCS6TXRJmFm46FyhgEBERSzj2jZOner6VWfvuRUREpFKUYRAREUtwYsPJqQ9cNHPuuUABg4iIWIK6JMyx9t2LiIhIpSjDICIiluDEXLeC03tNOSspYBAREUtQl4Q5ChhERMQS9PIpc6x99yIiIlIpyjCIiIglGNhwmRjDYGhapYiIyLlPXRLmWPvuRUREpFKUYRAREUvQ663NUcAgIiKW4DT5tkoz554LrH33IiIiUinKMIiIiCWoS8IcBQwiImIJLnxwmUismzn3XGDtuxcREZFKUYZBREQswWnYcJroVjBz7rlAAYOIiFiCxjCYo4BBREQswTD5tkpDKz2KiIiInJwyDCIiYglObDhNvEDKzLnnAgUMIiJiCS7D3DgEl+HFxpyF1CUhIiIiFVKG4Ry2+cvavDsjgu821yI3x58nX9vNlTfnV+s1P5pTn//NjCD3kB9N447y4FM/0eKy344rZxjwxF1N2fiZ/bS0S6zjkg4F/OPBQ1zY6jfqRZUypu/5pC8Jcx9fun/TCc97dXxD/jczgshGxdw5OIc2VxVQp0EJv+T4s+L9Ovx3agSlJWXfsSIbFfPm+u3H1fHILc3Y8VXt6rkxMc1lctCjmXPPBWfE3U+fPp3zzz+foKAgOnTowPr162u6SeeEwt98aHrxUQY+s88r9S17py7Dejb7y+MrPwznlbHR9B6SzfSlWTSNO8rjdzYl7+fj49IPXm2AzdrdgVJNgmq52LU1iJf+1eiEx3u1jvPYJg+OweWCNYvLgoqYZoX4+BhMHdGIAZ2b8/KYaJLu/oU+I7OPq2vE7U096vrum1rVem9ijgub6c3KajxgeOeddxgyZAhPPvkkX331Fa1btyYxMZGDBw/WdNPOepdf/yv3jsjmqr/49l5cZOOVsdHc2TaOv13QioeTLmTT2pBTvt77rzTgpjt/IbFXLk0uKuLh5/YRGOxi6X/repT7fksw773cgCHP7znla4n8lY2f2XljYkPWHpNVONbhQ/4eW3xiPpu+CCF7T2DZ+SvtTB7cmK9WhZK9J5Avl4Xxv1kNTvj/I8dhP4+6nKXWfqCIJ6fTyahRo4iNjSU4OJgLLriA8ePHYxh/DIYwDIPRo0fTsGFDgoODSUhI4LvvvvOoJzc3l969e2O32wkPD6dfv34UFBR4lPnmm2+45pprCAoKIiYmhokTJ3r9fmo8YHj++ee577776NOnD3FxccyaNYtatWrx+uuv13TTznnTH2/E9oxajJz5I7OWZ3HNLXk83rspP+0KqHJdJcU2vvumFm2v+eOX2McHLrumgG0Zf6RoC3+z8WxKE1Ke3kfdiFKv3IfIqQqvX8IVNzhY+nbdk5arHerk1zzf4/aPTd3NO99sZfKC7+jYRd1qZ7rylR7NbFXx3HPPMXPmTF566SW2b9/Oc889x8SJE3nxxRfdZSZOnMi0adOYNWsW69ato3bt2iQmJlJYWOgu07t3b7Zu3UpaWhqLFi1i9erVDBgwwH3c4XDQpUsXmjRpQkZGBpMmTWLMmDG88sor5n9ox6jRMQzFxcVkZGQwcuRI9z4fHx8SEhJIT0+vwZad+w7u82fZO3X5z4at1Isqe3D/44FDbPzMztJ36tF35IEq1efI9cXltBHeoMRjf536JezdGej+/PKY84hrf4Qrb3KYvwkRk268/TBHC3xZ8/GJsxEA0ecX0a3vz7w6Ltq97+hvPrw8JpqtG2phuGxcnZTHk6//wNi+5/Plsr+uS2rW6R7DsHbtWrp160ZSUhIA559/Pv/973/d3e6GYfDCCy/wxBNP0K1bNwDefPNNIiMjWbBgAb169WL79u0sWbKEDRs20L59ewBefPFFunbtyr///W+io6OZO3cuxcXFvP766wQEBHDxxReTmZnJ888/7xFYmFWjAcPPP/+M0+kkMjLSY39kZCQ7duw4rnxRURFFRUXuzw6HHjqnaveOYFxOG32vbumxv6TYB3udsgDi4D5/7ruuhfuY02nDWWKjW7NW7n29Hs7hjocr132UvtRO5hehzFiW5YU7EDEvsVcuKz4Ip6ToxA+CelElPD13F6sXhfPJvHru/Y5cP95/pYH787ebalEvspR/PHBIAYMF/PnZExgYSGBg4HHlrrzySl555RW+/fZbLrroIjZt2sSaNWt4/vnnAdi9ezfZ2dkkJCS4zwkLC6NDhw6kp6fTq1cv0tPTCQ8PdwcLAAkJCfj4+LBu3Tr+/ve/k56eTqdOnQgI+CM7nJiYyHPPPcfhw4epU6eOV+77rJolMWHCBMaOHVvTzTgnHD3ig4+vwUtLvsXH13NycXBtF1D2x3JG2h8P9y8+DmfNx2GMeOlH977QcCcA9rpOfHwN8g75e9R1+Gd/6jQoC0AyvwjlwA8B9GjRyqPM+PvO55IOR5j03k7v3aBIBS65ooCYZkU8c3+TEx6vG1nCxHd3sm1jbaYOO/EAymPt+LoWl3X61dvNFC9yYfJdEr8PeoyJifHY/+STTzJmzJjjyj/22GM4HA5atGiBr68vTqeTp59+mt69ewOQnV02kPZEX5rLj2VnZxMREeFx3M/Pj7p163qUiY2NPa6O8mPnRMBQv359fH19ycnJ8difk5NDVFTUceVHjhzJkCFD3J8dDsdx/8NJ5TS75Cgup428X/xo1eHICcv4+sF5scXuz+H1SwkMMjz2lfMPMLjw0t/4ek2Ie4qkywWZa0L4270/A/DPgTncfOcvHuf93/Ut+L8xP9Gxi7JFcnol3pHLt5uC2bUt+Lhj9aLKgoXvNtdi8uAYjEo8ZC64+Ci5B/0rLCc1xzA508H4/dy9e/dit9vd+0+UXQCYP38+c+fOZd68ee5ugkGDBhEdHU1ycvIpt6Om1GjAEBAQQLt27Vi+fDndu3cHwOVysXz5cgYOHHhc+b9K+8iJHT3iw/7df/y8svcG8P2WYELDS2l0QRHX98hl0sONGfDkfppdcpS8X/zIXBNCbMtCOiRU/QHeY8Ah/j2oMRe1/o3ml/3GB682oPA3H7r0ygWgbkTpCQc6RpxXQlTj44MQkVMRVMtJ9DFBbVRMMU0vPsqveb4c+qksZVsrxEmnW/N5ZWzD486vF1XCpP/t5OBPAbw6Lpqwen/8zh7+PYOW8I9cSktsfL+lLNi46uZ8uvTK5YWh+gJzJvPW2yrtdrtHwPBXhg0bxmOPPUavXr0AaNWqFT/++CMTJkwgOTnZ/cU4JyeHhg3/+F3MycmhTZs2AERFRR03a7C0tJTc3Fz3+VFRUSf84l1+zFtqvEtiyJAhJCcn0759e6644gpeeOEFjhw5Qp8+fWq6aWe9bzfVYvhtf6yb8PKY8wC48fZchr6wh0en7GHeC1G8MjaaX7L9sdd10rLtkVMKFgCu65ZH/i9+vDmpIYcP+dH04qM8PXeXu0tC5HS4qPVRJr33vfvz/WP3A7DsnTpMHtwYgGu75YHN4LMFx6dq23b6lfOaFnNe02LmfbXN41hidGv3v+8clENkoxKcpbB3ZxDP3N+ENYvDvX9Dctb67bff8PHxHB/j6+uLy1XW7RsbG0tUVBTLly93BwgOh4N169bxwAMPABAfH09eXh4ZGRm0a9cOgBUrVuByuejQoYO7zOOPP05JSQn+/mVBbVpaGs2bN/dadwSAzTh2QmgNeemll5g0aRLZ2dm0adOGadOmuX8QJ+NwOAgLC+Pwt02xh9b4DFGRapEY3aammyBSbUqNElbyIfn5+ZX61n4qyp8Vf0/rg3/tqk8bL1dypJgPbpxT6bbee++9fPrpp7z88stcfPHFfP311wwYMIC+ffvy3HPPAWVTL5999lneeOMNYmNjGTVqFN988w3btm0jKCgIgJtvvpmcnBxmzZpFSUkJffr0oX379sybNw+A/Px8mjdvTpcuXRgxYgRbtmyhb9++TJky5dyZJVFu4MCBJ+yCEBER8RZvdUlU1osvvsioUaN48MEHOXjwINHR0fzf//0fo0ePdpcZPnw4R44cYcCAAeTl5XH11VezZMkSd7AAMHfuXAYOHMgNN9yAj48PPXv2ZNq0ae7jYWFhLFu2jJSUFNq1a0f9+vUZPXq0V4MFOEMyDKdKGQaxAmUY5Fx2OjMM3Zb1NZ1h+LDL69Xa1jPZGZFhEBERqW5m3wdh9XdJKGAQERFLON1dEuca5fFFRESkQsowiIiIJSjDYI4CBhERsQQFDOaoS0JEREQqpAyDiIhYgjIM5ihgEBERSzAwNzXyrF20yEsUMIiIiCUow2COxjCIiIhIhZRhEBERS1CGwRwFDCIiYgkKGMxRl4SIiIhUSBkGERGxBGUYzFHAICIilmAYNgwTD30z554L1CUhIiIiFVKGQURELMGFzdTCTWbOPRcoYBAREUvQGAZz1CUhIiIiFVKGQURELEGDHs1RwCAiIpagLglzFDCIiIglKMNgjsYwiIiISIWUYRAREUswTHZJWD3DoIBBREQswQAMw9z5VqYuCREREamQMgwiImIJLmzYtNLjKVPAICIilqBZEuaoS0JEREQqpAyDiIhYgsuwYdPCTadMAYOIiFiCYZicJWHxaRLqkhAREZEKKcMgIiKWoEGP5ijDICIillAeMJjZquL888/HZrMdt6WkpABQWFhISkoK9erVIyQkhJ49e5KTk+NRx549e0hKSqJWrVpEREQwbNgwSktLPcqsXLmStm3bEhgYSLNmzUhNTTX1c/orChhERMQSyt9WaWarig0bNnDgwAH3lpaWBsA//vEPAAYPHszChQt59913WbVqFfv376dHjx7u851OJ0lJSRQXF7N27VreeOMNUlNTGT16tLvM7t27SUpKonPnzmRmZjJo0CD69+/P0qVLvfAT86QuCRERkWrQoEEDj8/PPvssF1xwAddeey35+fm89tprzJs3j+uvvx6AOXPm0LJlS7788ks6duzIsmXL2LZtG59++imRkZG0adOG8ePHM2LECMaMGUNAQACzZs0iNjaWyZMnA9CyZUvWrFnDlClTSExM9Or9KMMgIiKWUD5Lwsx2qoqLi/nPf/5D3759sdlsZGRkUFJSQkJCgrtMixYtaNy4Menp6QCkp6fTqlUrIiMj3WUSExNxOBxs3brVXebYOsrLlNfhTcowiIiIJZQ99M0Meiz7r8Ph8NgfGBhIYGDgSc9dsGABeXl53HvvvQBkZ2cTEBBAeHi4R7nIyEiys7PdZY4NFsqPlx87WRmHw8HRo0cJDg6u9P1VRBkGERGRKoiJiSEsLMy9TZgwocJzXnvtNW6++Waio6NPQwurhzIMIiJiCd6aVrl3717sdrt7f0XZhR9//JFPP/2U999/370vKiqK4uJi8vLyPLIMOTk5REVFucusX7/eo67yWRTHlvnzzIqcnBzsdrtXswugDIOIiFiE4YUNwG63e2wVBQxz5swhIiKCpKQk97527drh7+/P8uXL3fuysrLYs2cP8fHxAMTHx7N582YOHjzoLpOWlobdbicuLs5d5tg6ysuU1+FNChhERESqicvlYs6cOSQnJ+Pn90dSPywsjH79+jFkyBA+++wzMjIy6NOnD/Hx8XTs2BGALl26EBcXx913382mTZtYunQpTzzxBCkpKe4g5f7772fXrl0MHz6cHTt2MGPGDObPn8/gwYO9fi/qkhAREUuoiZUeP/30U/bs2UPfvn2POzZlyhR8fHzo2bMnRUVFJCYmMmPGDPdxX19fFi1axAMPPEB8fDy1a9cmOTmZcePGucvExsayePFiBg8ezNSpU2nUqBGzZ8/2+pRKAJthnL2v03A4HISFhXH426bYQ5UskXNTYnSbmm6CSLUpNUpYyYfk5+d7jAvwpvJnRdM3/oVvraBTrsf5WyG7kp+p1raeyZRhEBERazCZYUDvkhARERE5OWUYRETEEsyu1nj2duB7hwIGERGxBL3e2hx1SYiIiEiFlGEQERFrMGzmBi5aPMOggEFERCxBYxjMUZeEiIiIVEgZBhERsYZjXwhxqudbWKUCho8++qjSFf7tb3875caIiIhUF82SMKdSAUP37t0rVZnNZsPpdJppj4iIiJyBKhUwuFyu6m6HiIhI9bN4t4IZpsYwFBYWEhR06i/yEBEROV3UJWFOlWdJOJ1Oxo8fz3nnnUdISAi7du0CYNSoUbz22mteb6CIiIhXGF7YLKzKAcPTTz9NamoqEydOJCAgwL3/kksuYfbs2V5tnIiIiJwZqhwwvPnmm7zyyiv07t0bX19f9/7WrVuzY8cOrzZORETEe2xe2KyrymMYfvrpJ5o1a3bcfpfLRUlJiVcaJSIi4nVah8GUKmcY4uLi+Pzzz4/b/7///Y/LLrvMK40SERGRM0uVMwyjR48mOTmZn376CZfLxfvvv09WVhZvvvkmixYtqo42ioiImKcMgylVzjB069aNhQsX8umnn1K7dm1Gjx7N9u3bWbhwITfeeGN1tFFERMS88rdVmtks7JTWYbjmmmtIS0vzdltERETkDHXKCzdt3LiR7du3A2XjGtq1a+e1RomIiHibXm9tTpUDhn379nHHHXfwxRdfEB4eDkBeXh5XXnklb7/9No0aNfJ2G0VERMzTGAZTqjyGoX///pSUlLB9+3Zyc3PJzc1l+/btuFwu+vfvXx1tFBERkRpW5QzDqlWrWLt2Lc2bN3fva968OS+++CLXXHONVxsnIiLiNWYHLmrQY9XExMSccIEmp9NJdHS0VxolIiLibTajbDNzvpVVuUti0qRJPPTQQ2zcuNG9b+PGjTzyyCP8+9//9mrjREREvEYvnzKlUhmGOnXqYLP9kYo5cuQIHTp0wM+v7PTS0lL8/Pzo27cv3bt3r5aGioiISM2pVMDwwgsvVHMzREREqpnGMJhSqYAhOTm5utshIiJSvTSt0pRTXrgJoLCwkOLiYo99drvdVINERETkzFPlQY9Hjhxh4MCBREREULt2berUqeOxiYiInJE06NGUKgcMw4cPZ8WKFcycOZPAwEBmz57N2LFjiY6O5s0336yONoqIiJingMGUKgcMCxcuZMaMGfTs2RM/Pz+uueYannjiCZ555hnmzp1bHW0UERE5K/3000/cdddd1KtXj+DgYFq1auWxLIFhGIwePZqGDRsSHBxMQkIC3333nUcdubm59O7dG7vdTnh4OP369aOgoMCjzDfffMM111xDUFAQMTExTJw40ev3UuWAITc3l6ZNmwJl4xVyc3MBuPrqq1m9erV3WyciIuItp/n11ocPH+aqq67C39+fTz75hG3btjF58mSP7vuJEycybdo0Zs2axbp166hduzaJiYkUFha6y/Tu3ZutW7eSlpbGokWLWL16NQMGDHAfdzgcdOnShSZNmpCRkcGkSZMYM2YMr7zyivmf2TGqPOixadOm7N69m8aNG9OiRQvmz5/PFVdcwcKFC90voxIRETnTnO6VHp977jliYmKYM2eOe19sbKz734Zh8MILL/DEE0/QrVs3AN58800iIyNZsGABvXr1Yvv27SxZsoQNGzbQvn17AF588UW6du3Kv//9b6Kjo5k7dy7FxcW8/vrrBAQEcPHFF5OZmcnzzz/vEViYVeUMQ58+fdi0aRMAjz32GNOnTycoKIjBgwczbNgwrzVMRETkbPbRRx/Rvn17/vGPfxAREcFll13Gq6++6j6+e/dusrOzSUhIcO8LCwujQ4cOpKenA5Cenk54eLg7WABISEjAx8eHdevWuct06tSJgIAAd5nExESysrI4fPiw1+6nyhmGwYMHu/+dkJDAjh07yMjIoFmzZlx66aVea5iIiIhXeWkdBofD4bE7MDCQwMDA44rv2rWLmTNnMmTIEP71r3+xYcMGHn74YQICAkhOTiY7OxuAyMhIj/MiIyPdx7Kzs4mIiPA47ufnR926dT3KHJu5OLbO7Oxsr81gNLUOA0CTJk1o0qSJN9oiIiJyxouJifH4/OSTTzJmzJjjyrlcLtq3b88zzzwDwGWXXcaWLVuYNWvWWbkgYqUChmnTplW6wocffviUGyMiIlJdbJgcw/D7f/fu3euxSOGJsgsADRs2JC4uzmNfy5Ytee+99wCIiooCICcnh4YNG7rL5OTk0KZNG3eZgwcPetRRWlpKbm6u+/yoqChycnI8ypR/Li/jDZUKGKZMmVKpymw2mwIGERE5p9nt9kqtanzVVVeRlZXlse/bb791Z+VjY2OJiopi+fLl7gDB4XCwbt06HnjgAQDi4+PJy8sjIyODdu3aAbBixQpcLhcdOnRwl3n88ccpKSnB398fgLS0NJo3b+7VBRUrFTDs3r3baxesDl2G98HPP6immyFSLdpsyKzpJohUm+ICH1Zed5oudppfPjV48GCuvPJKnnnmGW6//XbWr1/PK6+84p7uaLPZGDRoEE899RQXXnghsbGxjBo1iujoaPebn1u2bMlNN93Efffdx6xZsygpKWHgwIH06tWL6OhoAO68807Gjh1Lv379GDFiBFu2bGHq1KmV/rJfWabHMIiIiJwVTvPLpy6//HI++OADRo4cybhx44iNjeWFF16gd+/e7jLDhw/nyJEjDBgwgLy8PK6++mqWLFlCUNAfX4Lnzp3LwIEDueGGG/Dx8aFnz54eQwXCwsJYtmwZKSkptGvXjvr16zN69GivTqkEsBmGcdYudulwOAgLC+Py7uOVYZBzVpsRmTXdBJFqU1xQwmvXzSc/P7/aXl5Y/qxoMuFpfIJO/VnhKizkx5GPV2tbz2TKMIiIiDXo9damKGAQERFLON0rPZ5rqrzSo4iIiFjPKQUMn3/+OXfddRfx8fH89NNPALz11lusWbPGq40TERHxGr3e2pQqBwzvvfceiYmJBAcH8/XXX1NUVARAfn6+ezUrERGRM44CBlOqHDA89dRTzJo1i1dffdW9QASULVDx1VdfebVxIiIicmao8qDHrKwsOnXqdNz+sLAw8vLyvNEmERERr9OgR3OqnGGIiopi586dx+1fs2YNTZs29UqjREREvK58pUczm4VVOWC47777eOSRR1i3bh02m439+/czd+5chg4d6l77WkRE5IyjMQymVLlL4rHHHsPlcnHDDTfw22+/0alTJwIDAxk6dCgPPfRQdbRRREREaliVAwabzcbjjz/OsGHD2LlzJwUFBcTFxRESElId7RMREfEKjWEw55RXegwICDjuPd8iIiJnLC0NbUqVA4bOnTtjs/31wI8VK1aYapCIiIiceaocMLRp08bjc0lJCZmZmWzZsoXk5GRvtUtERMS7THZJKMNQRVOmTDnh/jFjxlBQUGC6QSIiItVCXRKmeO3lU3fddRevv/66t6oTERGRM4jXXm+dnp5OUFCQt6oTERHxLmUYTKlywNCjRw+Pz4ZhcODAATZu3MioUaO81jARERFv0rRKc6ocMISFhXl89vHxoXnz5owbN44uXbp4rWEiIiJy5qhSwOB0OunTpw+tWrWiTp061dUmEREROcNUadCjr68vXbp00VspRUTk7KN3SZhS5VkSl1xyCbt27aqOtoiIiFSb8jEMZjYrq3LA8NRTTzF06FAWLVrEgQMHcDgcHpuIiIiceyo9hmHcuHE8+uijdO3aFYC//e1vHktEG4aBzWbD6XR6v5UiIiLeYPEsgRmVDhjGjh3L/fffz2effVad7REREakeWofBlEoHDIZR9pO69tprq60xIiIicmaq0rTKk72lUkRE5EymhZvMqVLAcNFFF1UYNOTm5ppqkIiISLVQl4QpVQoYxo4de9xKjyIiInLuq1LA0KtXLyIiIqqrLSIiItVGXRLmVDpg0PgFERE5q6lLwpRKL9xUPktCRERErKfSGQaXy1Wd7RAREaleyjCYUuWloUVERM5Gp/tdEmPGjMFms3lsLVq0cB8vLCwkJSWFevXqERISQs+ePcnJyfGoY8+ePSQlJVGrVi0iIiIYNmwYpaWlHmVWrlxJ27ZtCQwMpFmzZqSmpp7qj+ikFDCIiIg11MDbKi+++GIOHDjg3tasWeM+NnjwYBYuXMi7777LqlWr2L9/Pz169HAfdzqdJCUlUVxczNq1a3njjTdITU1l9OjR7jK7d+8mKSmJzp07k5mZyaBBg+jfvz9Lly6temMrUKVZEiIiIlJ5fn5+REVFHbc/Pz+f1157jXnz5nH99dcDMGfOHFq2bMmXX35Jx44dWbZsGdu2bePTTz8lMjKSNm3aMH78eEaMGMGYMWMICAhg1qxZxMbGMnnyZABatmzJmjVrmDJlComJiV69F2UYRETEGmogw/Ddd98RHR1N06ZN6d27N3v27AEgIyODkpISEhIS3GVbtGhB48aNSU9PByA9PZ1WrVoRGRnpLpOYmIjD4WDr1q3uMsfWUV6mvA5vUoZBREQswVvrMDgcDo/9gYGBBAYGHle+Q4cOpKam0rx5cw4cOMDYsWO55ppr2LJlC9nZ2QQEBBAeHu5xTmRkJNnZ2QBkZ2d7BAvlx8uPnayMw+Hg6NGjBAcHn/L9/pkCBhERkSqIiYnx+Pzkk08yZsyY48rdfPPN7n9feumldOjQgSZNmjB//nyvPshPFwUMIiJiDV6aVrl3717sdrt794myCycSHh7ORRddxM6dO7nxxhspLi4mLy/PI8uQk5PjHvMQFRXF+vXrPeoon0VxbJk/z6zIycnBbrd7PSjRGAYREbEEb02rtNvtHltlA4aCggK+//57GjZsSLt27fD392f58uXu41lZWezZs4f4+HgA4uPj2bx5MwcPHnSXSUtLw263ExcX5y5zbB3lZcrr8CYFDCIiItVg6NChrFq1ih9++IG1a9fy97//HV9fX+644w7CwsLo168fQ4YM4bPPPiMjI4M+ffoQHx9Px44dAejSpQtxcXHcfffdbNq0iaVLl/LEE0+QkpLiDlLuv/9+du3axfDhw9mxYwczZsxg/vz5DB482Ov3oy4JERGxhtO80uO+ffu44447+OWXX2jQoAFXX301X375JQ0aNABgypQp+Pj40LNnT4qKikhMTGTGjBnu8319fVm0aBEPPPAA8fHx1K5dm+TkZMaNG+cuExsby+LFixk8eDBTp06lUaNGzJ492+tTKkEBg4iIWMVpDhjefvvtkx4PCgpi+vTpTJ8+/S/LNGnShI8//vik9Vx33XV8/fXXVWvcKVCXhIiIiFRIGQYREbEE2++bmfOtTAGDiIhYg95WaYoCBhERsQRvrfRoVRrDICIiIhVShkFERKxBXRKmKGAQERHrsPhD3wx1SYiIiEiFlGEQERFL0KBHcxQwiIiINWgMgynqkhAREZEKKcMgIiKWoC4JcxQwiIiINahLwhR1SYiIiEiFlGEQERFLUJeEOQoYRETEGtQlYYoCBhERsQYFDKZoDIOIiIhUSBkGERGxBI1hMEcBg4iIWIO6JExRl4SIiIhUSBkGERGxBJthYDNOPU1g5txzgQIGERGxBnVJmKIuCREREamQMgwiImIJmiVhjgIGERGxBnVJmKIuCREREamQMgwiImIJ6pIwRwGDiIhYg7okTFHAICIilqAMgzkawyAiIiIVUoZBRESsQV0SpihgEBERy7B6t4IZ6pIQERGpZs8++yw2m41Bgwa59xUWFpKSkkK9evUICQmhZ8+e5OTkeJy3Z88ekpKSqFWrFhEREQwbNozS0lKPMitXrqRt27YEBgbSrFkzUlNTq+UeFDCIiIg1GIb57RRs2LCBl19+mUsvvdRj/+DBg1m4cCHvvvsuq1atYv/+/fTo0cN93Ol0kpSURHFxMWvXruWNN94gNTWV0aNHu8vs3r2bpKQkOnfuTGZmJoMGDaJ///4sXbr01H5GJ6GAQURELKF8loSZraoKCgro3bs3r776KnXq1HHvz8/P57XXXuP555/n+uuvp127dsyZM4e1a9fy5ZdfArBs2TK2bdvGf/7zH9q0acPNN9/M+PHjmT59OsXFxQDMmjWL2NhYJk+eTMuWLRk4cCC33XYbU6ZM8crP7FgKGERERKpJSkoKSUlJJCQkeOzPyMigpKTEY3+LFi1o3Lgx6enpAKSnp9OqVSsiIyPdZRITE3E4HGzdutVd5s91JyYmuuvwJg16FBERa/DSLAmHw+GxOzAwkMDAwOOKv/3223z11Vds2LDhuGPZ2dkEBAQQHh7usT8yMpLs7Gx3mWODhfLj5cdOVsbhcHD06FGCg4Mrf38VUIZBREQsweYyvwHExMQQFhbm3iZMmHDctfbu3csjjzzC3LlzCQoKOs13Wj2UYbCY7ldvo/tV22hY71cAdh+oQ+qStny5vTEA0fUdDOz2Ja0uyCbAz8m67TFM+d+VHP611nF1+fs5eWXIAi5s9Av3PteDnT/Vdx+7osVe+nXNIDbqMEWlvmzaGcVLC+LJzg09PTcqlmU4DXJfceJY4sT5C/jVh9BbfKnbzxebzYZRavDLTCdHvnBR8pOBTwjUusKH+gP98Gtgc9fjzDc4NKmUI2tcYIOQ631o8KgfPrVsx12zeK/BnruKsfnABZ8d/01Tzi179+7Fbre7P58ou5CRkcHBgwdp27ate5/T6WT16tW89NJLLF26lOLiYvLy8jyyDDk5OURFRQEQFRXF+vXrPeotn0VxbJk/z6zIycnBbrd7NbsAyjBYzqG82sxaeAX9JvWg/6S/89W30Uy4bxmxUbkEBZQw5cHFGMAjL97CA1O64efr5LkBS7GdYLTPg39bx8/5xwcSDes6mHDfMjK+jebeiT15dEZXwkKKeLrfstNwh2J1h990kveek4hhfjSZH0C9h/w4/JaT/HecALgKoXCHi7r9fGn8lj8NJ/pT/KPB/kdLPOrJHlVC0S6D817yJ3qKP0e/Nsh5pvS46xmlBtmPlxDcRn9Oz3iGFzbAbrd7bCcKGG644QY2b95MZmame2vfvj29e/d2/9vf35/ly5e7z8nKymLPnj3Ex8cDEB8fz+bNmzl48KC7TFpaGna7nbi4OHeZY+soL1NehzfV6G/46tWrufXWW4mOjsZms7FgwYKabI4lfLGlCV9ua8y+Q2HsPRTOK4uv4GiRP3HnH6RV0xyi6hbw9Nzr2HWgLrsO1OXp/3SmRcwh2l34k0c9HVvu4fIW+5j+YcfjrtG88c/4+rh4dfHl7P/Zzrf76vP2iku58Lxf8PVxna5bFYs6+o1ByLU+1L7aF/9oG6E3+FKrgw+FW8v+2vuG2Gg0PYDQG30JON+H4FY+RAzzo2i7QUl2WZni3S5+SzeIfMKPoEt8CG7jQ4OhfhQsc1F6yDN4/mWmk4DzbYQmKGA4053OWRKhoaFccsklHlvt2rWpV68el1xyCWFhYfTr148hQ4bw2WefkZGRQZ8+fYiPj6djx7K/q126dCEuLo67776bTZs2sXTpUp544glSUlLcQcr999/Prl27GD58ODt27GDGjBnMnz+fwYMHe/3nV6O/4UeOHKF169ZMnz69JpthWT42Fze03UlQYAlbf4gkwM+JYUBJqa+7THGpLy7DxqUXZLv31Qn9jeF3fM74tzpTWHx8r1bWnvq4DBtdO2ThY3NRO6iYxMu/Y+O35+F06Y+qVK/gS238tsFF8Y9lwWnRty4KN7modeVf/+65CgAb+ISUfT662cAnFILi/jin1hU28IHCLX8Evb9tcPHrp04aDFfv7lmhhtZh+CtTpkzhlltuoWfPnnTq1ImoqCjef/9993FfX18WLVqEr68v8fHx3HXXXdxzzz2MGzfOXSY2NpbFixeTlpZG69atmTx5MrNnzyYxMdGrbYUaHsNw8803c/PNN9dkEyypacNcZg1ZQICfk6NF/vxrdhd+yK5DXkEQhcV+PPC3dby88ApsNoP7b12Pn69BPftvv59t8HjvVXy4piVZexsQVffX4+o/kGtnyIyujLt3OcP++Tl+vgabd0cybNZNp/dGxZLqJPviKoAf/1FS9pXIBfUe8MV+s+8Jy7uKDH5+qZTQLj74hpSNT3D+YuBbx3Osgs3Phq8dSn8p++zMM8gZW0LUOH/3eSIns3LlSo/PQUFBTJ8+/aRfmps0acLHH3980nqvu+46vv76a2808aTOqrC4qKiIoqIi9+c/T22RytlzMIw+z/UkJLiY69rs5vG7VvLQtFv5IbsOo+bcyNDbP+e2TltwGTY+/eoCsvaWZQwAbuu0lVqBxbyV1uYv668b+hsjen3OJ+sv5NOvmlErsIT+XTfyVN9PGTS9K6A/rlJ9Cj518esSJ1FP+RHQ1EbRtwaHni/Fr4EN+y2eQYNRapA9shQMaPBY1f4c5jxdSmiiL8FtlTU7W+j11uacVQHDhAkTGDt2bE0346xX6vTlp5/DAMja24CWjQ/xj2s3M+mdTmzY0Yh/jruDsNqFOF02Co4G8uFTb7H/5wsAaHvRT1wce5AVz7/mUefsoR+QtrEZT8/tTI9rtlJwNICZH/0xvmHcW535YNw8Lj7/IFt/8JwzLOJNP08tpU6yH6FdyoKDwGZQesAgN9XpETAYpQYHRpZSkm3QaIZnlsC3ng3nYc+ng1Fq4HSAX72yz0c3ujjyORye6/y9AOCC7zoWEfEvP8L+duKMhtQgva3SlLMqYBg5ciRDhgxxf3Y4HMTExNRgi84NNpuBv5/nYMT8I2Xzhtte+BN1Qo6yZksTAKa+dxWvLr7cXa5+2G9MefBjnky9gW0/RgAQFFB6XFef6/exCyeabSHiTa4ijh+d5YPHH3t3sLDH4LxZ/viGe2a9glvZcP0KhdtdBLUsq+y3jQa4IOiSss8xr/tjOP8458hqF4ffdNJotj9+EcqiybnnrAoY/mo1Lam8/7t1PV9uiyHncAi1Aku4sf1OLmu2nyEzuwLQtUMWP+aEc7ggmEvOz+GRnmuZv7IVew+GA5BzOMSjvqNF/gD89LOdQ3llx9Zubczt123m3psy+DSjrEvi/25dz4FfQvh2X31EqlPtq304PKcU/ygIaOpDUZaLvHlO7L9/4zdKDQ6MKKVoh4voKf7ghNKff59BEQY2fxsBsT7Uirdx8OlSIkb6YZTCoUmlhHTxca/VEBDrGZUUbTfABoHN1EVxplKXhDlnVcAg5tUJOcoTd31GvbDfOHI0gO/312PIzK5szGoEQOOIPP7v1vXYaxWRnRvKm8su453PWlXpGl99dx5j37yeO2/YxJ03bKKo2I8tP0Ty6MyuFJfoV06qV8QwP36Z5eTgc6U4D5ct3GTv4Uu9/mUBQ+nBsmwAwJ7enmsvnDfLn1rtygKCqPH+HJxUyr4HS7CVL9w0VL+/ZzWzMx28PEvibGMzjJr7CRQUFLBz504ALrvsMp5//nk6d+5M3bp1ady4cYXnOxwOwsLCuLz7ePz8z42lN0X+rM2IzJpugki1KS4o4bXr5pOfn++xeqI3lT8rOnYdZ+pZUVpSyJcfj67Wtp7JajRc3rhxI507d3Z/Lh+fkJycTGpqag21SkREzkXqkjCnRgOG6667jhpMcIiIiJVoloQpGp0jIiIiFdIIHhERsQR1SZijgEFERKzBZZRtZs63MAUMIiJiDRrDYIrGMIiIiEiFlGEQERFLsGFyDIPXWnJ2UsAgIiLWoJUeTVGXhIiIiFRIGQYREbEETas0RwGDiIhYg2ZJmKIuCREREamQMgwiImIJNsPAZmLgoplzzwUKGERExBpcv29mzrcwdUmIiIhIhZRhEBERS1CXhDkKGERExBo0S8IUBQwiImINWunRFI1hEBERkQopwyAiIpaglR7NUcAgIiLWoC4JU9QlISIiIhVShkFERCzB5irbzJxvZQoYRETEGtQlYYq6JERERKRCyjCIiIg1aOEmU5RhEBERSyhfGtrMVhUzZ87k0ksvxW63Y7fbiY+P55NPPnEfLywsJCUlhXr16hESEkLPnj3JycnxqGPPnj0kJSVRq1YtIiIiGDZsGKWlpR5lVq5cSdu2bQkMDKRZs2akpqae8s/oZBQwiIiIVINGjRrx7LPPkpGRwcaNG7n++uvp1q0bW7duBWDw4MEsXLiQd999l1WrVrF//3569OjhPt/pdJKUlERxcTFr167ljTfeIDU1ldGjR7vL7N69m6SkJDp37kxmZiaDBg2if//+LF261Ov3YzOMs3cUh8PhICwsjMu7j8fPP6immyNSLdqMyKzpJohUm+KCEl67bj75+fnY7fZquUb5s6Jzu5H4+Z36s6K0tJDPMiaYamvdunWZNGkSt912Gw0aNGDevHncdtttAOzYsYOWLVuSnp5Ox44d+eSTT7jlllvYv38/kZGRAMyaNYsRI0Zw6NAhAgICGDFiBIsXL2bLli3ua/Tq1Yu8vDyWLFlyyvd6IsowiIiINRiAy8Rm4uu10+nk7bff5siRI8THx5ORkUFJSQkJCQnuMi1atKBx48akp6cDkJ6eTqtWrdzBAkBiYiIOh8OdpUhPT/eoo7xMeR3epEGPIiJiCd56vbXD4fDYHxgYSGBg4AnP2bx5M/Hx8RQWFhISEsIHH3xAXFwcmZmZBAQEEB4e7lE+MjKS7OxsALKzsz2ChfLj5cdOVsbhcHD06FGCg4NP7WZPQBkGERGRKoiJiSEsLMy9TZgw4S/LNm/enMzMTNatW8cDDzxAcnIy27ZtO42t9R5lGERExBoMTC7cVPafvXv3eoxh+KvsAkBAQADNmjUDoF27dmzYsIGpU6fyz3/+k+LiYvLy8jyyDDk5OURFRQEQFRXF+vXrPeorn0VxbJk/z6zIycnBbrd7NbsAyjCIiIhVlK/0aGYD9zTJ8u1kAcOfuVwuioqKaNeuHf7+/ixfvtx9LCsriz179hAfHw9AfHw8mzdv5uDBg+4yaWlp2O124uLi3GWOraO8THkd3qQMg4iISDUYOXIkN998M40bN+bXX39l3rx5rFy5kqVLlxIWFka/fv0YMmQIdevWxW6389BDDxEfH0/Hjh0B6NKlC3Fxcdx9991MnDiR7OxsnnjiCVJSUtxByv33389LL73E8OHD6du3LytWrGD+/PksXrzY6/ejgEFERKzBBdhMnl8FBw8e5J577uHAgQOEhYVx6aWXsnTpUm688UYApkyZgo+PDz179qSoqIjExERmzJjhPt/X15dFixbxwAMPEB8fT+3atUlOTmbcuHHuMrGxsSxevJjBgwczdepUGjVqxOzZs0lMTDRxoyemdRhEznBah0HOZadzHYYbLhmOn2/luw/+rNRZxPItE6u1rWcyjWEQERGRCqlLQkRErEGvtzZFAYOIiFiDAgZT1CUhIiIiFVKGQURErEEZBlMUMIiIiDWc5mmV5xoFDCIiYgneevmUVWkMg4iIiFRIGQYREbEGjWEwRQGDiIhYg8sAm4mHvsvaAYO6JERERKRCyjCIiIg1qEvCFAUMIiJiESYDBqwdMKhLQkRERCqkDIOIiFiDuiRMUcAgIiLW4DIw1a2gWRIiIiIiJ6cMg4iIWIPhKtvMnG9hChhERMQaNIbBFAUMIiJiDRrDYIrGMIiIiEiFlGEQERFrUJeEKQoYRETEGgxMBgxea8lZSV0SIiIiUiFlGERExBrUJWGKAgYREbEGlwswsZaCy9rrMKhLQkRERCqkDIOIiFiDuiRMUcAgIiLWoIDBFHVJiIiISIWUYRAREWvQ0tCmKGAQERFLMAwXhok3Tpo591yggEFERKzBMMxlCTSGQURERLxtwoQJXH755YSGhhIREUH37t3JysryKFNYWEhKSgr16tUjJCSEnj17kpOT41Fmz549JCUlUatWLSIiIhg2bBilpaUeZVauXEnbtm0JDAykWbNmpKamev1+FDCIiIg1lM+SMLNVwapVq0hJSeHLL78kLS2NkpISunTpwpEjR9xlBg8ezMKFC3n33XdZtWoV+/fvp0ePHu7jTqeTpKQkiouLWbt2LW+88QapqamMHj3aXWb37t0kJSXRuXNnMjMzGTRoEP3792fp0qXmf2bHsBnG2ZtjcTgchIWFcXn38fj5B9V0c0SqRZsRmTXdBJFqU1xQwmvXzSc/Px+73V4t1yh/VtwQ2hs/W8Ap11NqFLP817mn3NZDhw4RERHBqlWr6NSpE/n5+TRo0IB58+Zx2223AbBjxw5atmxJeno6HTt25JNPPuGWW25h//79REZGAjBr1ixGjBjBoUOHCAgIYMSIESxevJgtW7a4r9WrVy/y8vJYsmTJKd/vnynDICIichrk5+cDULduXQAyMjIoKSkhISHBXaZFixY0btyY9PR0ANLT02nVqpU7WABITEzE4XCwdetWd5lj6ygvU16Ht2jQo4iIWINhclrl7wl5h8PhsTswMJDAwMCTnupyuRg0aBBXXXUVl1xyCQDZ2dkEBAQQHh7uUTYyMpLs7Gx3mWODhfLj5cdOVsbhcHD06FGCg4OrcJN/TRkGERGxBMPlMr0BxMTEEBYW5t4mTJhQ4bVTUlLYsmULb7/9dnXfZrVRhkFERKQK9u7d6zGGoaLswsCBA1m0aBGrV6+mUaNG7v1RUVEUFxeTl5fnkWXIyckhKirKXWb9+vUe9ZXPoji2zJ9nVuTk5GC3272WXQBlGERExCq8NEvCbrd7bH8VMBiGwcCBA/nggw9YsWIFsbGxHsfbtWuHv78/y5cvd+/Lyspiz549xMfHAxAfH8/mzZs5ePCgu0xaWhp2u524uDh3mWPrKC9TXoe3KMMgIiLW4DLAdvoWbkpJSWHevHl8+OGHhIaGuscchIWFERwcTFhYGP369WPIkCHUrVsXu93OQw89RHx8PB07dgSgS5cuxMXFcffddzNx4kSys7N54oknSElJcQcq999/Py+99BLDhw+nb9++rFixgvnz57N48eJTv9cTUIZBRESkGsycOZP8/Hyuu+46GjZs6N7eeecdd5kpU6Zwyy230LNnTzp16kRUVBTvv/+++7ivry+LFi3C19eX+Ph47rrrLu655x7GjRvnLhMbG8vixYtJS0ujdevWTJ48mdmzZ5OYmOjV+1GGQURErMEwABPvg6hihqEyyxwFBQUxffp0pk+f/pdlmjRpwscff3zSeq677jq+/vrrKrWvqhQwiIiIJRguA8NEl8RZvM6hVyhgEBERazBcmMswWPttlRrDICIiIhVShkFERCxBXRLmKGAQERFrUJeEKWd1wFAe7TlLCmu4JSLVp7igpKabIFJtio+U/X6fjm/vpZSYepVEKdb+/+JZ/Xrrffv2ERMTU9PNEBERk/bu3euxbLI3FRYWEhsb6144yYyoqCh2795NUFCQF1p2djmrAwaXy8X+/fsJDQ3FZrPVdHMsweFwEBMTc9xa6iLnAv1+n36GYfDrr78SHR2Nj0/1jcMvLCykuLjYdD0BAQGWDBbgLO+S8PHxqbaIVE6ufA11kXORfr9Pr7CwsGq/RlBQkGUf9N6iaZUiIiJSIQUMIiIiUiEFDFIlgYGBPPnkkxW+/13kbKTfb5G/dlYPehQREZHTQxkGERERqZACBhEREamQAgYRERGpkAIGqbTp06dz/vnnExQURIcOHVi/fn1NN0nEK1avXs2tt95KdHQ0NpuNBQsW1HSTRM44ChikUt555x2GDBnCk08+yVdffUXr1q1JTEzk4MGDNd00EdOOHDlC69atmT59ek03ReSMpVkSUikdOnTg8ssv56WXXgLKluWOiYnhoYce4rHHHqvh1ol4j81m44MPPqB79+413RSRM4oyDFKh4uJiMjIySEhIcO/z8fEhISGB9PT0GmyZiIicLgoYpEI///wzTqeTyMhIj/2RkZFeefubiIic+RQwiIiISIUUMEiF6tevj6+vLzk5OR77c3JyiIqKqqFWiYjI6aSAQSoUEBBAu3btWL58uXufy+Vi+fLlxMfH12DLRETkdPGr6QbI2WHIkCEkJyfTvn17rrjiCl544QWOHDlCnz59arppIqYVFBSwc+dO9+fdu3eTmZlJ3bp1ady4cQ22TOTMoWmVUmkvvfQSkyZNIjs7mzZt2jBt2jQ6dOhQ080SMW3lypV07tz5uP3Jycmkpqae/gaJnIEUMIiIiEiFNIZBREREKqSAQURERCqkgEFEREQqpIBBREREKqSAQURERCqkgEFEREQqpIBBREREKqSAQURERCqkgEHEpHvvvZfu3bu7P1933XUMGjTotLdj5cqV2Gw28vLy/rKMzWZjwYIFla5zzJgxtGnTxlS7fvjhB2w2G5mZmabqEZGapYBBzkn33nsvNpsNm81GQEAAzZo1Y9y4cZSWllb7td9//33Gjx9fqbKVeciLiJwJ9PIpOWfddNNNzJkzh6KiIj7++GNSUlLw9/dn5MiRx5UtLi4mICDAK9etW7euV+oRETmTKMMg56zAwECioqJo0qQJDzzwAAkJCXz00UfAH90ITz/9NNHR0TRv3hyAvXv3cvvttxMeHk7dunXp1q0bP/zwg7tOp9PJkCFDCA8Pp169egwfPpw/v47lz10SRUVFjBgxgpiYGAIDA2nWrBmvvfYaP/zwg/uFR3Xq1MFms3HvvfcCZa8PnzBhArGxsQQHB9O6dWv+97//eVzn448/5qKLLiI4OJjOnTt7tLOyRowYwUUXXUStWrVo2rQpo0aNoqSk5LhyL7/8MjExMdSqVYvbb7+d/Px8j+OzZ8+mZcuWBAUF0aJFC2bMmFHltojImU0Bg1hGcHAwxcXF7s/Lly8nKyuLtLQ0Fi1aRElJCYmJiYSGhvL555/zxRdfEBISwk033eQ+b/LkyaSmpvL666+zZs0acnNz+eCDD0563XvuuYf//ve/TJs2je3bt/Pyyy8TEhJCTEwM7733HgBZWVkcOHCAqVOnAjBhwgTefPNNZs2axdatWxk8eDB33XUXq1atAsoCmx49enDrrbeSmZlJ//79eeyxx6r8MwkNDSU1NZVt27YxdepUXn31VaZMmeJRZufOncyfP5+FCxeyZMkSvv76ax588EH38blz5zJ69Giefvpptm/fzjPPPMOoUaN44403qtweETmDGSLnoOTkZKNbt26GYRiGy+Uy0tLSjMDAQGPo0KHu45GRkUZRUZH7nLfeesto3ry54XK53PuKioqM4OBgY+nSpYZhGEbDhg2NiRMnuo+XlJQYjRo1cl/LMAzj2muvNR555BHDMAwjKyvLAIy0tLQTtvOzzz4zAOPw4cPufYWFhUatWrWMtWvXepTt16+fcccddxiGYRgjR4404uLiPI6PGDHiuLr+DDA++OCDvzw+adIko127du7PTz75pOHr62vs27fPve+TTz4xfHx8jAMHDhiGYRgXXHCBMW/ePI96xo8fb8THxxuGYRi7d+82AOPrr7/+y+uKyJlPYxjknLVo0SJCQkIoKSnB5XJx5513MmbMGPfxVq1aeYxb2LRpEzt37iQ0NNSjnsLCQr7//nvy8/M5cOAAHTp0cB/z8/Ojffv2x3VLlMvMzMTX15drr7220u3euXMnv/32GzfeeKPH/uLiYi677DIAtm/f7tEOgPj4+Epfo9w777zDtGnT+P777ykoKKC0tBS73e5RpnHjxpx33nke13G5XGRlZREaGsr3339Pv379uO+++9xlSktLCQsLq3J7ROTMpYBBzlmdO3dm5syZBAQEEB0djZ+f56977dq1PT4XFBTQrl075s6de1xdDRo0OKU2BAcHV/mcgoICABYvXuzxoIaycRnekp6eTu/evRk7diyJiYmEhYXx9ttvM3ny5Cq39dVXXz0ugPH19fVaW0Wk5ilgkHNW7dq1adasWaXLt23blnfeeYeIiIjjvmWXa9iwIevWraNTp05A2TfpjIwM2rZte8LyrVq1wuVysWrVKhISEo47Xp7hcDqd7n1xcXEEBgayZ8+ev8xMtGzZ0j2As9yXX35Z8U0eY+3atTRp0oTHH3/cve/HH388rtyePXvYv38/0dHR7uv4+PjQvHlzIiMjiY6OZteuXfTu3btK1xeRs4sGPYr8rnfv3tSvX59u3brx+eefs3v3blauXMnDDz/Mvn37AHjkkUd49tlnWbBgATt27ODBBx886RoK559/PsnJyfTt25cFCxa465w/fz4ATZo0wWazsWjRIg4dOkRBQQGhoaEMHTqUwYMH88Ybb/D999/z1Vdf8eKLL7oHEt5///189913DBs2jKysLObNm0dqamqV7vfCCy9kz549vP3223z//fdMmzbthAM4g4KCSE5OZtOmTXz++ec8/PDD3H777URFRQEwduxYJkyYwLRp0/j222/ZvHkzc+bM4fnnn69Se0TkzKaAQeR3tWrVYvXq1TRu3JgePXrQsmVL+vXrR2FhoTvj8Oijj3L33XeTnJxMfHw8oaGh/P3vfz9pvTNnzuS2227jwQcfpEWLFtx3330cOXIEgPPOO4+xY8fy2GOPERkZycCBAwEYP348o0aNYsKECbRs2ZKbbrqJxYsXExsbC5SNK3jvvfdYsGABrVu3ZtasWTzzzDNVut+//e1vDB48mIEDB9KmTRvWrl3LqFGjjivXrFkzevToQdeuXenSpQuXXnqpx7TJ/v37M3v2bObMmUOrVq249tprSU1NdbdVRM4NNuOvRmuJiIiI/E4ZBhEREamQAgYRERGpkAIGERERqZACBhEREamQAgYRERGpkAIGERERqZACBhEREamQAgYRERGpkAIGERERqZACBhEREamQAgYRERGpkAIGERERqdD/A9OrZvffAyR7AAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Invoke the call models function to display the model performance statistics\n","\n","ML_Model,acc_train,acc_test,kappa_list,train_time,test_time = call_ml_models()\n","\n","# Create the dataframe with the consolidated accuracies and timings of all models\n","\n","results = pd.DataFrame({ 'ML Model': ML_Model, \n","    'Train Accuracy': acc_train,\n","    'Test Accuracy': acc_test, 'Kappa Score': kappa_list,\n","    'Training Time': train_time, 'Testing Time': test_time})\n","\n","results # Display results"]},{"cell_type":"markdown","metadata":{"id":"HUE5waqKJdm8"},"source":["## Hyper parameter tunning"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"jEF_hQYhJdm8"},"outputs":[],"source":["# Assign the XGBoost parameters to the parameter grid \n","\n","param_grid = [\n","  {\n","    'n_estimators': [200, 250],\n","    'max_depth': [5,6]\n","  }\n","]\n","\n","scoring = {'AUC':'roc_auc', 'Accuracy':make_scorer(accuracy_score)}"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TfS_1Md7Jdm8","outputId":"d79626fc-bcbd-4ed6-b09b-bc9d5382cc6e","colab":{"base_uri":"https://localhost:8080/","height":134},"executionInfo":{"status":"ok","timestamp":1681749918070,"user_tz":-330,"elapsed":107228,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Fitting 5 folds for each of 4 candidates, totalling 20 fits\n"]},{"output_type":"execute_result","data":{"text/plain":["GridSearchCV(cv=5,\n","             estimator=XGBClassifier(base_score=None, booster=None,\n","                                     callbacks=None, colsample_bylevel=None,\n","                                     colsample_bynode=None,\n","                                     colsample_bytree=None,\n","                                     early_stopping_rounds=None,\n","                                     enable_categorical=False, eval_metric=None,\n","                                     feature_types=None, gamma=None,\n","                                     gpu_id=None, grow_policy=None,\n","                                     importance_type=None,\n","                                     interaction_constraints=None,\n","                                     learning_rate=None,...\n","                                     max_delta_step=None, max_depth=None,\n","                                     max_leaves=None, min_child_weight=None,\n","                                     missing=nan, monotone_constraints=None,\n","                                     n_estimators=100, n_jobs=None,\n","                                     num_parallel_tree=None, predictor=None,\n","                                     random_state=100, ...),\n","             n_jobs=-1,\n","             param_grid=[{'max_depth': [5, 6], 'n_estimators': [200, 250]}],\n","             refit='AUC',\n","             scoring={'AUC': 'roc_auc',\n","                      'Accuracy': make_scorer(accuracy_score)},\n","             verbose=1)"],"text/html":["<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GridSearchCV(cv=5,\n","             estimator=XGBClassifier(base_score=None, booster=None,\n","                                     callbacks=None, colsample_bylevel=None,\n","                                     colsample_bynode=None,\n","                                     colsample_bytree=None,\n","                                     early_stopping_rounds=None,\n","                                     enable_categorical=False, eval_metric=None,\n","                                     feature_types=None, gamma=None,\n","                                     gpu_id=None, grow_policy=None,\n","                                     importance_type=None,\n","                                     interaction_constraints=None,\n","                                     learning_rate=None,...\n","                                     max_delta_step=None, max_depth=None,\n","                                     max_leaves=None, min_child_weight=None,\n","                                     missing=nan, monotone_constraints=None,\n","                                     n_estimators=100, n_jobs=None,\n","                                     num_parallel_tree=None, predictor=None,\n","                                     random_state=100, ...),\n","             n_jobs=-1,\n","             param_grid=[{&#x27;max_depth&#x27;: [5, 6], &#x27;n_estimators&#x27;: [200, 250]}],\n","             refit=&#x27;AUC&#x27;,\n","             scoring={&#x27;AUC&#x27;: &#x27;roc_auc&#x27;,\n","                      &#x27;Accuracy&#x27;: make_scorer(accuracy_score)},\n","             verbose=1)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(cv=5,\n","             estimator=XGBClassifier(base_score=None, booster=None,\n","                                     callbacks=None, colsample_bylevel=None,\n","                                     colsample_bynode=None,\n","                                     colsample_bytree=None,\n","                                     early_stopping_rounds=None,\n","                                     enable_categorical=False, eval_metric=None,\n","                                     feature_types=None, gamma=None,\n","                                     gpu_id=None, grow_policy=None,\n","                                     importance_type=None,\n","                                     interaction_constraints=None,\n","                                     learning_rate=None,...\n","                                     max_delta_step=None, max_depth=None,\n","                                     max_leaves=None, min_child_weight=None,\n","                                     missing=nan, monotone_constraints=None,\n","                                     n_estimators=100, n_jobs=None,\n","                                     num_parallel_tree=None, predictor=None,\n","                                     random_state=100, ...),\n","             n_jobs=-1,\n","             param_grid=[{&#x27;max_depth&#x27;: [5, 6], &#x27;n_estimators&#x27;: [200, 250]}],\n","             refit=&#x27;AUC&#x27;,\n","             scoring={&#x27;AUC&#x27;: &#x27;roc_auc&#x27;,\n","                      &#x27;Accuracy&#x27;: make_scorer(accuracy_score)},\n","             verbose=1)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: XGBClassifier</label><div class=\"sk-toggleable__content\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n","              colsample_bylevel=None, colsample_bynode=None,\n","              colsample_bytree=None, early_stopping_rounds=None,\n","              enable_categorical=False, eval_metric=None, feature_types=None,\n","              gamma=None, gpu_id=None, grow_policy=None, importance_type=None,\n","              interaction_constraints=None, learning_rate=None, max_bin=None,\n","              max_cat_threshold=None, max_cat_to_onehot=None,\n","              max_delta_step=None, max_depth=None, max_leaves=None,\n","              min_child_weight=None, missing=nan, monotone_constraints=None,\n","              n_estimators=100, n_jobs=None, num_parallel_tree=None,\n","              predictor=None, random_state=100, ...)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBClassifier</label><div class=\"sk-toggleable__content\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n","              colsample_bylevel=None, colsample_bynode=None,\n","              colsample_bytree=None, early_stopping_rounds=None,\n","              enable_categorical=False, eval_metric=None, feature_types=None,\n","              gamma=None, gpu_id=None, grow_policy=None, importance_type=None,\n","              interaction_constraints=None, learning_rate=None, max_bin=None,\n","              max_cat_threshold=None, max_cat_to_onehot=None,\n","              max_delta_step=None, max_depth=None, max_leaves=None,\n","              min_child_weight=None, missing=nan, monotone_constraints=None,\n","              n_estimators=100, n_jobs=None, num_parallel_tree=None,\n","              predictor=None, random_state=100, ...)</pre></div></div></div></div></div></div></div></div></div></div>"]},"metadata":{},"execution_count":32}],"source":["# Using Grid search to find the hyper parameters of XGBoost\n","\n","XGB_grid = GridSearchCV(XGB_model,param_grid=param_grid,cv=5,scoring=scoring,refit='AUC',verbose=1,n_jobs=-1)\n","XGB_grid.fit(X_train, y_train)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"i23eQmvhJdm9","outputId":"1f653e04-8805-4aae-e3b2-3a5c86ccbe34","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1681749925887,"user_tz":-330,"elapsed":7827,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Kappa:  0.5284963048466387\n","Train accuracy:  0.7610994035075187\n","Test accuracy:  0.7637303108592383\n"]}],"source":["# Check for accuracy changes using the fine tuned XGB Model parameters \n","XGB_model_best = XGB_grid.best_estimator_\n","\n","\n","XGB_model_best.fit(X_train, y_train)\n","pred_RF_test = XGB_model_best.predict(X_test)\n","pred_RF_train = XGB_model_best.predict(X_train)\n","\n","kappa_rf = cohen_kappa_score(y_test, pred_RF_test)\n","train_acc = accuracy_score(y_train,pred_RF_train)\n","test_acc = accuracy_score(y_test,pred_RF_test)\n","\n","print('Kappa: ',kappa_rf)\n","print('Train accuracy: ',train_acc)\n","print('Test accuracy: ',test_acc)"]},{"cell_type":"markdown","metadata":{"id":"tlZdDyuaJdm9"},"source":["## Save the model"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"QzQW-du4Jdm9"},"outputs":[],"source":["def save_model(model):\n","    \n","    # Function to save the required model using pickle\n","    \n","    with open('phishing_classifier.pkl', 'wb') as f:\n","        pickle.dump(model, f, -1)\n","        f.close()\n","\n","\n","        \n","save_model(XGB_model_best)"]},{"cell_type":"markdown","metadata":{"id":"S77TFIJyJdm-"},"source":["## Perform the classification using the saved model"]},{"cell_type":"code","source":["# Load the required packages\n","\n","import pandas as pd\n","import numpy as np\n","import sys\n","import re\n","\n","from urllib.parse import urlparse,urlencode\n","from bs4 import BeautifulSoup\n","from datetime import datetime\n","import ipaddress\n","import whois\n","import urllib\n","import urllib.request\n","import tldextract\n","\n","import pickle\n","\n","\n","class FeatureExtract:\n","\n","# This class contains the methods that extract the required features\n","# Across the entire dataset, 0 indicates legitimate url and 1 indicates phishing url\n","# Legitimate - 0; Phishing - 1\n","\n","\n","    def __init__(self):\n","        pass\n","\n","    \n","    # def rank(self,url):\n","\n","    #     # Method to check rank of the URL by connecting to the alexa rank API\n","    #     # Returns 0 if the rank is less than 100000 for the given URL else returns 1\n","        \n","    #     try:\n","            \n","    #         #Filling the whitespaces in the URL if any\n","            \n","    #         url = urllib.parse.quote(url)\n","    #         rank = BeautifulSoup(urllib.request.urlopen(\"http://data.alexa.com/data?cli=10&url=\" + url).read(), \"xml\").find(\n","    #             \"REACH\")['RANK']\n","    #         print('Hello')\n","    #         rank = int(rank)\n","    #     except TypeError:\n","    #         return 1\n","    #     if rank <100000:\n","    #         return 0\n","    #     else:\n","    #         return 1\n","        \n","\n","    def isIP(self,url):\n","        \n","        # Method to check if an IP is found in the URL\n","        # Returns 1 if IP is found in the given URL else returns 0\n","        \n","        try:\n","            ipaddress.ip_address(url)\n","            ip = 1\n","        except:\n","            ip = 0\n","        return ip\n","    \n","\n","    def isValid(self,domain_name):\n","        \n","        # Method to check the validity of the URL domain\n","        # Returns 1 if age of the domain is less than 6 else returns 0\n","        \n","        creation_date = domain_name.creation_date\n","        expiration_date = domain_name.expiration_date\n","        if (isinstance(creation_date,str) or isinstance(expiration_date,str)):\n","            try:\n","                creation_date = datetime.strptime(creation_date,'%Y-%m-%d')\n","                expiration_date = datetime.strptime(expiration_date,\"%Y-%m-%d\")\n","            except:\n","                  return 1\n","        if ((expiration_date is None) or (creation_date is None)):\n","            return 1\n","        elif ((type(expiration_date) is list) or (type(creation_date) is list)):\n","            return 1\n","        else:\n","            ageofdomain = abs((expiration_date - creation_date).days)\n","            if ((ageofdomain/30) < 6):\n","                age = 1\n","            else:\n","                age = 0\n","        return age\n","\n","\n","    def domain_reg_len(self,domain_name):\n","        \n","        # Method to check the expiration of the URL domain\n","        # Returns 1 if the domain has expired else returns 0\n","        print('hello')\n","        expiration_date = domain_name.expiration_date\n","        if isinstance(expiration_date,str):\n","            try:\n","                expiration_date = datetime.strptime(expiration_date,\"%Y-%m-%d\")\n","            except:\n","                return 1\n","        if (expiration_date is None):\n","            return 1\n","        elif (type(expiration_date) is list):\n","            return 1\n","        else:\n","            today = datetime.now()\n","            end = abs((expiration_date - today).days)\n","            if ((end/30) < 6):\n","                end = 0\n","            else:\n","                end = 1\n","        return end\n","\n","\n","    def isat(self,url):\n","        \n","        # Method to check for '@' in the URL\n","        # Returns 1 if found else returns 0\n","        \n","        if \"@\" in url:\n","            return 1    \n","        else:\n","            return 0    \n","\n","\n","    def isRedirect(self,url):\n","        \n","        # Method to check for '//' in the URL\n","        # Returns 1 if found within length of 7 for the given URL or if 'http' is found else returns 0\n","        \n","        pos = url.rfind('//')\n","        if pos > 6:\n","            if pos > 7:\n","                return 1\n","            else:\n","                return 0\n","        else:\n","            return 0\n","\n","\n","    def haveDash(self,url):\n","        \n","        # Method to check for '-' in the URL\n","        # Returns 1 if found else returns 0\n","        \n","        if '-' in urlparse(url).netloc:\n","            return 1            \n","        else:\n","            return 0   \n","    \n","\n","    def no_sub_domain(self,url):\n","        \n","        # Method to check number of subdomains in the URL\n","        # Returns 0 if number of subdomains is 1 else returns 1\n","\n","        url = str(url)\n","        url = url.replace(\"www.\",\"\")\n","        url = url.replace(\".\"+tldextract.extract(url).suffix,\"\")\n","        count = url.count(\".\")\n","        if count==1:\n","            return 0\n","        else:\n","            return 1\n","\n","\n","\n","    def httpDomain(self,url):\n","        \n","        # Method to check for 'https' in the URL\n","        # Returns 1 if found else returns 0\n","\n","        domain = urlparse(url).netloc\n","        if 'http' in domain:\n","            return 1\n","        else:\n","            return 0\n","\n","\n","    def LongURL(self,url):\n","        \n","        # Method to checks the length of the URL\n","        # Returns 0 if the length is less than 54 else returns 1\n","\n","        if len(url) < 54:\n","            return 0           \n","        else:\n","            return 1            \n","\n","\n","    def tinyURL(self,url):\n","        \n","        # Method to check if the URL belong to shortening services\n","        # Returns 1 if found else returns 0\n","        \n","        #listing shortening services\n","    \n","        shortening_services = r\"bit\\.ly|goo\\.gl|shorte\\.st|go2l\\.ink|x\\.co|ow\\.ly|t\\.co|tinyurl|tr\\.im|is\\.gd|cli\\.gs|\" \\\n","                      r\"yfrog\\.com|migre\\.me|ff\\.im|tiny\\.cc|url4\\.eu|twit\\.ac|su\\.pr|twurl\\.nl|snipurl\\.com|\" \\\n","                      r\"short\\.to|BudURL\\.com|ping\\.fm|post\\.ly|Just\\.as|bkite\\.com|snipr\\.com|fic\\.kr|loopt\\.us|\" \\\n","                      r\"doiop\\.com|short\\.ie|kl\\.am|wp\\.me|rubyurl\\.com|om\\.ly|to\\.ly|bit\\.do|t\\.co|lnkd\\.in|db\\.tt|\" \\\n","                      r\"qr\\.ae|adf\\.ly|goo\\.gl|bitly\\.com|cur\\.lv|tinyurl\\.com|ow\\.ly|bit\\.ly|ity\\.im|q\\.gs|is\\.gd|\" \\\n","                      r\"po\\.st|bc\\.vc|twitthis\\.com|u\\.to|j\\.mp|buzurl\\.com|cutt\\.us|u\\.bb|yourls\\.org|x\\.co|\" \\\n","                      r\"prettylinkpro\\.com|scrnch\\.me|filoops\\.info|vzturl\\.com|qr\\.net|1url\\.com|tweez\\.me|v\\.gd|\" \\\n","                      r\"tr\\.im|link\\.zip\\.net\"\n","        match=re.search(shortening_services,url)\n","        if match:\n","            return 1\n","        else:\n","            return 0\n","\n","\n","\n","\n","\n","class PredictURL(FeatureExtract):\n","    \n","    # This class inherits FeatureExtract class to access all its methods\n","    # The main classification of the URL is done via the methods of this class\n","    \n","    def __init__(self):\n","        pass\n","        \n","    \n","    def predict(self,url):\n","\n","        print(\"hi\")\n","        \n","        # Method to call all the methods in the FeatureExtract class to \n","        #get the features of the given URL and appends it to an np array\n","        # Returns the result of classification by calling the classify function\n","        \n","        feature = []\n","        dns = 0\n","        \n","        # URL is passed to whois API to fetch the domain name \n","        # try:\n","        #     print(\"hi\")\n","        #     domain_name = whois.whois(urlparse(url).netloc)\n","        #     print(\"hi2\")\n","\n","        # except:\n","        #     dns = 1\n","       \n","        #Domain based features (3)\n","        \n","        # feature.append(self.rank(url))\n","        # feature.append(1 if dns == 1 else self.isValid(domain_name))\n","        # feature.append(1 if dns == 1 else self.domain_reg_len(domain_name))\n","\n","        #Address bar based features (5)\n","        feature.append(self.isIP(url))\n","        \n","        feature.append(self.isat(url))\n","\n","        feature.append(self.isRedirect(url))\n","        feature.append(self.haveDash(url))\n","        feature.append(self.no_sub_domain(url))\n","        feature.append(self.LongURL(url))\n","        feature.append(self.tinyURL(url))\n","\n","        \n","        return self.classify(np.array(feature).reshape((1,-1)))\n","        \n","       \n","    \n","    def __getstate__(self):\n","\n","        # this method is called when you are\n","        # going to pickle the class, to know what to pickle\n","        \n","        state = self.__dict__.copy()\n","        \n","        # don't pickle the parameter fun. otherwise will raise \n","        # AttributeError: Can't pickle local object 'Process.__init__.<locals>.<lambda>'\n","        \n","        return state\n","    \n","    \n","    def __setstate__(self, state):\n","        \n","        self.__dict__.update(state)\n","\n","        \n","    def classify(self,features):\n","        \n","        #Method to classify the URL, given its features.\n","        #It loads the saved mode in the pickle file to perform the classification\n","        \n","        # Load the pickle file\n","        \n","        pick_file = open('/content/phishing_classifier.pkl', 'rb') \n","        Pickled_sample_Model = pickle.load(pick_file)\n","        pick_file.close()\n","    \n","        # Classify the URL features using the loaded pickle file\n","        \n","        result = Pickled_sample_Model.predict(features)\n","        if result == 0:\n","            return \"Given website is a legitimate site\"\n","        else:\n","            return \"Given website is a phishing site\"\n","    \n","# Main function\n","\n","def main():\n","\n","    pass\n","\n","if __name__ == \"__main__\":\n","    main()\n"],"metadata":{"id":"xx0KQnYehjd-"},"execution_count":null,"outputs":[]},{"cell_type":"code","execution_count":null,"metadata":{"id":"xEjkRmWZJdm-"},"outputs":[],"source":["classification = PredictURL()"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"QyucZlEOJdm-","outputId":"5ea8439b-ede2-4aca-d93f-afc3ca5c17ce","colab":{"base_uri":"https://localhost:8080/","height":88},"executionInfo":{"status":"ok","timestamp":1681750229908,"user_tz":-330,"elapsed":1753,"user":{"displayName":"Advait Khandare","userId":"17595074583096159597"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["hi\n","CPU times: user 25.2 ms, sys: 0 ns, total: 25.2 ms\n","Wall time: 25.4 ms\n"]},{"output_type":"execute_result","data":{"text/plain":["'Given website is a legitimate site'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":41}],"source":["%%time\n","# classification.predict('https://www.google.com')\n","classification.predict('https://www.facebook.com')\n","\n","# classification.predict('https://obcontest-1.github.io/osoter/index.html')\n","#\n","# classification.predict('https://client-bourso.servehttp.com/conformité/\t')"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"bD1jComDJdm-"},"outputs":[],"source":[]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.5"}},"nbformat":4,"nbformat_minor":0}