diff --git a/log-analysis/HTTP.ipynb b/log-analysis/HTTP.ipynb index 35942bd..a2d100b 100644 --- a/log-analysis/HTTP.ipynb +++ b/log-analysis/HTTP.ipynb @@ -9,13 +9,20 @@ "\n", "Because as far as I can tell, there isn't a good one that exists?\n", "\n", - "This Notebook ingests a given log file and produces useful statistics about the recorded traffic." + "This Notebook ingests a given log file and produces useful statistics about the recorded traffic.\n", + "\n", + "## Instructions\n", + "\n", + "1. Run the first and second cells\n", + "2. Upload the file you want to parse\n", + "3. Click on the third cell, then click `Run -> Run Selected Cell and All Below`\n", + "4. Enjoy your data!" ] }, { "cell_type": "code", "execution_count": 1, - "id": "9e51fd41-fb2d-45d4-a625-08fd60fd52d6", + "id": "1ce288a4-d9d8-4b51-9a3d-9194161e37da", "metadata": {}, "outputs": [ { @@ -34,26 +41,67 @@ "import pandas as pd\n", "import plotly.express as px\n", "import altair as alt\n", - "import numpy\n", + "import numpy as np\n", "import re\n", + "import ipywidgets as widgets\n", + "from IPython.display import display\n", "# Allow Altair to handle large datasets\n", "alt.data_transformers.disable_max_rows()" ] }, + { + "cell_type": "markdown", + "id": "bc020c2d-0ba9-4cff-a500-9735fb425eb8", + "metadata": {}, + "source": [ + "The first thing we need to do is get a file to analyze! Drop that file!" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "id": "04021b75-fa2c-422a-8ad6-6dff420a44d2", "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f5768708231741a5af91402cb7749b26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FileUpload(value={}, accept='.log,.txt', description='Upload', multiple=True)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "upload = widgets.FileUpload(\n", + " accept=\".log,.txt\", # Accepted file extension e.g. '.txt', '.pdf', 'image/*', 'image/*,.pdf'\n", + " multiple=True # True to accept multiple files upload else False\n", + ")\n", + "display(upload)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "32b0c18f-a554-4716-b71d-ce440a91c7df", + "metadata": {}, "outputs": [], "source": [ - "with open(\"samples/access.log\") as f:\n", - " raw_rows = [l.strip() for l in f.readlines()]" + "# Extract values\n", + "raw_rows = []\n", + "for f in upload.value:\n", + " raw_rows += upload.value[f][\"content\"].decode().split(\"\\n\")" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 19, "id": "a2faa922-0df2-4f6f-af5f-a2c25314e4e2", "metadata": {}, "outputs": [], @@ -66,7 +114,18 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 20, + "id": "22b268a1-535e-4208-b8e1-98b60a0b2aa5", + "metadata": {}, + "outputs": [], + "source": [ + "# Parser for log lines\n", + "row_parser = r\"(?P[0-9\\.]+) (?P\\w+|-) (?P\\w+|-) \\[(?P.*?)\\] \\\"(?P.*?) (?P\\/.*) (?PHTTP/[\\d\\.]+)\\\" (?P\\d{3}) (?P\\d+) \\\"(?P.*)\\\" \\\"(?P.*)\\\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 21, "id": "27edf20b-07fd-436c-bf2c-f972a0a6566d", "metadata": {}, "outputs": [], @@ -75,32 +134,14 @@ " \"\"\"\n", " Ingests a row of HTTP log and returns a dict with structured data\n", " \"\"\"\n", - " src_ip = re.search(\"^([0-9]{1,3}\\.){3}[0-9]{1,3}\", row)\n", - " timestamp = re.search(\"\\[(.+)\\]\", row)\n", - " http_method = re.search(\"\\] \\\"([A-Z]+) /\", row)\n", - " uri = re.search(\"[A-Z]+ (/.+) HTTP\", row)\n", - " http_status = re.search(\"HTTP/[12.]*\\\" ([0-9]{3}) \", row)\n", - " response_size = re.search(\"[0-9]{3} ([0-9]+) \\\"\", row)\n", - " referrer = re.search(\"[0-9]+ \\\"(.*)\\\" \\\"\", row)\n", - " user_agent = re.search(\"\\\" \\\"(.+)\\\"\", row)\n", + " matches = re.search(row_parser, row)\n", " \n", - "\n", - " res = {\n", - " \"src_ip\": src_ip.group(0) if src_ip else \"\",\n", - " \"timestamp\": timestamp.group(1) if timestamp else \"\",\n", - " \"http_method\": http_method.group(1) if http_method else \"\",\n", - " \"uri\": uri.group(1) if uri else \"\",\n", - " \"http_status\": http_status.group(1) if http_status else \"\",\n", - " \"response_size\": response_size.group(1) if response_size else \"\",\n", - " \"referrer\": referrer.group(1) if referrer else \"\",\n", - " \"user_agent\": user_agent.group(1) if user_agent else \"\",\n", - " }\n", - " return res" + " return matches.groupdict() if matches else {}" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "id": "e6281ae6-40de-4bf7-a287-53885c176ba6", "metadata": {}, "outputs": [], @@ -111,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 23, "id": "f5028f7a-1631-43b5-9a0c-6ab0d09e7dde", "metadata": {}, "outputs": [], @@ -122,14 +163,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "id": "68f34c95-0657-47e5-b1da-6400bf2c88b7", "metadata": {}, "outputs": [], "source": [ "# Make a proper datetime object\n", "# Reference: 17/May/2015:10:05:03 +0000\n", - "df[\"_time\"] = pd.to_datetime(df[\"timestamp\"], format=\"%d/%b/%Y:%H:%M:%S %z\")" + "df[\"_time\"] = pd.to_datetime(df[\"date\"], format=\"%d/%b/%Y:%H:%M:%S %z\")\n", + "df.sort_values(by=\"_time\", ascending=False, inplace=True)" ] }, { @@ -144,17 +186,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "id": "ee02d32b-11ca-4c3e-8edf-1d91507509fe", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(10000, 9)" + "(10001, 12)" ] }, - "execution_count": 8, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -166,19 +208,20 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "id": "de52d82a-aab1-4b5f-9d9b-16339d2af940", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['src_ip', 'timestamp', 'http_method', 'uri', 'http_status',\n", - " 'response_size', 'referrer', 'user_agent', '_time'],\n", + "Index(['ip', 'remote_log_name', 'userid', 'date', 'request_method', 'path',\n", + " 'request_version', 'status', 'length', 'referrer', 'user_agent',\n", + " '_time'],\n", " dtype='object')" ] }, - "execution_count": 9, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -198,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 27, "id": "d0f40868-dd2c-4301-86f0-93473fe5ef27", "metadata": {}, "outputs": [ @@ -223,17 +266,23 @@ " \n", " \n", " \n", - " timestamp\n", - " http_method\n", - " uri\n", - " http_status\n", - " response_size\n", + " remote_log_name\n", + " userid\n", + " date\n", + " request_method\n", + " path\n", + " request_version\n", + " status\n", + " length\n", " referrer\n", " user_agent\n", " _time\n", " \n", " \n", - " src_ip\n", + " ip\n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -247,14 +296,17 @@ " \n", " \n", " 66.249.73.135\n", - " 482\n", - " 482\n", - " 482\n", - " 482\n", - " 482\n", - " 482\n", - " 482\n", - " 482\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", + " 432\n", " \n", " \n", " 46.105.14.53\n", @@ -266,28 +318,23 @@ " 364\n", " 364\n", " 364\n", + " 364\n", + " 364\n", + " 364\n", " \n", " \n", " 130.237.218.86\n", - " 357\n", - " 357\n", - " 357\n", - " 357\n", - " 357\n", - " 357\n", - " 357\n", - " 357\n", - " \n", - " \n", - " 75.97.9.59\n", - " 273\n", - " 273\n", - " 273\n", - " 273\n", - " 273\n", - " 273\n", - " 273\n", - " 273\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", + " 293\n", " \n", " \n", " 50.16.19.13\n", @@ -299,6 +346,23 @@ " 113\n", " 113\n", " 113\n", + " 113\n", + " 113\n", + " 113\n", + " \n", + " \n", + " 209.85.238.199\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", + " 102\n", " \n", " \n", " ...\n", @@ -310,9 +374,15 @@ " ...\n", " ...\n", " ...\n", + " ...\n", + " ...\n", + " ...\n", " \n", " \n", - " 41.249.219.90\n", + " 67.225.29.201\n", + " 1\n", + " 1\n", + " 1\n", " 1\n", " 1\n", " 1\n", @@ -323,7 +393,10 @@ " 1\n", " \n", " \n", - " 41.99.29.14\n", + " 206.161.220.42\n", + " 1\n", + " 1\n", + " 1\n", " 1\n", " 1\n", " 1\n", @@ -334,7 +407,10 @@ " 1\n", " \n", " \n", - " 42.156.136.43\n", + " 157.56.92.142\n", + " 1\n", + " 1\n", + " 1\n", " 1\n", " 1\n", " 1\n", @@ -345,7 +421,10 @@ " 1\n", " \n", " \n", - " 46.105.125.31\n", + " 157.56.92.141\n", + " 1\n", + " 1\n", + " 1\n", " 1\n", " 1\n", " 1\n", @@ -356,7 +435,10 @@ " 1\n", " \n", " \n", - " 54.215.54.10\n", + " 54.242.167.99\n", + " 1\n", + " 1\n", + " 1\n", " 1\n", " 1\n", " 1\n", @@ -368,54 +450,54 @@ " \n", " \n", "\n", - "

1753 rows × 8 columns

\n", + "

1674 rows × 11 columns

\n", "" ], "text/plain": [ - " timestamp http_method uri http_status response_size \\\n", - "src_ip \n", - "66.249.73.135 482 482 482 482 482 \n", - "46.105.14.53 364 364 364 364 364 \n", - "130.237.218.86 357 357 357 357 357 \n", - "75.97.9.59 273 273 273 273 273 \n", - "50.16.19.13 113 113 113 113 113 \n", - "... ... ... ... ... ... \n", - "41.249.219.90 1 1 1 1 1 \n", - "41.99.29.14 1 1 1 1 1 \n", - "42.156.136.43 1 1 1 1 1 \n", - "46.105.125.31 1 1 1 1 1 \n", - "54.215.54.10 1 1 1 1 1 \n", + " remote_log_name userid date request_method path \\\n", + "ip \n", + "66.249.73.135 432 432 432 432 432 \n", + "46.105.14.53 364 364 364 364 364 \n", + "130.237.218.86 293 293 293 293 293 \n", + "50.16.19.13 113 113 113 113 113 \n", + "209.85.238.199 102 102 102 102 102 \n", + "... ... ... ... ... ... \n", + "67.225.29.201 1 1 1 1 1 \n", + "206.161.220.42 1 1 1 1 1 \n", + "157.56.92.142 1 1 1 1 1 \n", + "157.56.92.141 1 1 1 1 1 \n", + "54.242.167.99 1 1 1 1 1 \n", "\n", - " referrer user_agent _time \n", - "src_ip \n", - "66.249.73.135 482 482 482 \n", - "46.105.14.53 364 364 364 \n", - "130.237.218.86 357 357 357 \n", - "75.97.9.59 273 273 273 \n", - "50.16.19.13 113 113 113 \n", - "... ... ... ... \n", - "41.249.219.90 1 1 1 \n", - "41.99.29.14 1 1 1 \n", - "42.156.136.43 1 1 1 \n", - "46.105.125.31 1 1 1 \n", - "54.215.54.10 1 1 1 \n", + " request_version status length referrer user_agent _time \n", + "ip \n", + "66.249.73.135 432 432 432 432 432 432 \n", + "46.105.14.53 364 364 364 364 364 364 \n", + "130.237.218.86 293 293 293 293 293 293 \n", + "50.16.19.13 113 113 113 113 113 113 \n", + "209.85.238.199 102 102 102 102 102 102 \n", + "... ... ... ... ... ... ... \n", + "67.225.29.201 1 1 1 1 1 1 \n", + "206.161.220.42 1 1 1 1 1 1 \n", + "157.56.92.142 1 1 1 1 1 1 \n", + "157.56.92.141 1 1 1 1 1 1 \n", + "54.242.167.99 1 1 1 1 1 1 \n", "\n", - "[1753 rows x 8 columns]" + "[1674 rows x 11 columns]" ] }, - "execution_count": 10, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Group data by src_ip\n", - "df.groupby(\"src_ip\").count().sort_values(by=\"timestamp\", ascending=False)" + "df.groupby(\"ip\").count().sort_values(by=\"_time\", ascending=False)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 28, "id": "9abacfd7-23a1-424c-afce-cbc83446d8da", "metadata": {}, "outputs": [ @@ -507,7 +589,7 @@ "data": [ { "alignmentgroup": "True", - "hovertemplate": "src_ip=%{x}
http_status=%{y}", + "hovertemplate": "ip=%{x}
status=%{y}", "legendgroup": "", "marker": { "color": "#636efa", @@ -525,26 +607,26 @@ "66.249.73.135", "46.105.14.53", "130.237.218.86", - "75.97.9.59", "50.16.19.13", "209.85.238.199", + "75.97.9.59", "68.180.224.225", - "100.43.83.137", + "198.46.149.143", "208.115.111.72", - "198.46.149.143" + "208.115.113.88" ], "xaxis": "x", "y": [ - 482, + 432, 364, - 357, - 273, + 293, 113, 102, 99, - 84, - 83, - 82 + 95, + 82, + 73, + 66 ], "yaxis": "y" } @@ -1387,7 +1469,7 @@ 9.5 ], "title": { - "text": "src_ip" + "text": "ip" }, "type": "category" }, @@ -1400,20 +1482,20 @@ ], "range": [ 0, - 507.36842105263156 + 454.7368421052632 ], "title": { - "text": "http_status" + "text": "status" }, "type": "linear" } } }, - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA58AAAFoCAYAAADQGU/0AAAAAXNSR0IArs4c6QAAIABJREFUeF7s3Qm4TdX/x/GvIWmQpBIRkQwZogxNUmmiEiWpqAyFZiEpKkVCmo0ZMiVKSZSiNMjUJDKUsYxJQmWIe//Pd/nt+z/3ONO669xz7zn7fZ7n//z+uWefc/Zrr33O/uy11nflSU9PTxceCCCAAAIIIIAAAggggAACCGSjQB7CZzbq8tIIIIAAAggggAACCCCAAAJGgPBJQ0AAAQQQQAABBBBAAAEEEMh2AcJnthPzBggggAACCCCAAAIIIIAAAoRP2gACCCCAAAIIIIAAAggggEC2CxA+s52YN0AAAQQQQAABBBBAAAEEECB80gYQQAABBBBAAAEEEEAAAQSyXYDwme3EvAECCCCAAAIIIIAAAggggADhkzaAAAIIIIAAAggggAACCCCQ7QKEz2wn5g0QQAABBBBAAAEEEEAAAQQIn7QBBBBAAAEEEEAAAQQQQACBbBcgfGY7MW+AAAIIIIAAAggggAACCCBA+KQNIIAAAggggAACCCCAAAIIZLsA4TPbiXkDBBBAAAEEEEAAAQQQQAABwidtAAEEEEAAAQQQQAABBBBAINsFCJ/ZTswbIIAAAggggAACCCCAAAIIED5pAwgggAACCCCAAAIIIIAAAtkuQPjMdmLeAAEEEEAAAQQQQAABBBBAgPBJG0AAAQQQQAABBBBAAAEEEMh2AcJnthPzBggggAACCCCAAAIIIIAAAoRP2gACCCCAAAIIIIAAAggggEC2CxA+s52YN0AAAQQQQAABBBBAAAEEECB80gYQQAABBBBAAAEEEEAAAQSyXYDwme3EvAECCCCAAAIIIIAAAggggADhkzaAAAIIIIAAAggggAACCCCQ7QKEz2wn5g0QQAABBBBAAAEEEEAAAQQIn7QBBBBAAAEEEEAAAQQQQACBbBcgfGY7MW+AAAIIIIAAAggggAACCCBA+KQNIIAAAggggAACCCCAAAIIZLsA4TPbiXkDBBBAAAEEEEAAAQQQQAABwidtAAEEEEAAAQQQQAABBBBAINsFCJ/ZTswbIIAAAggggAACCCCAAAIIED5pAwgggAACCCCAAAIIIIAAAtkuQPjMdmLeAAEEEEAAAQQQQAABBBBAgPBJG0AAAQQQQAABBBBAAAEEEMh2AcJnthPzBggggAACCCCAAAIIIIAAAoRP2gACCCCAAAIIIIAAAggggEC2CxA+s53Yv2+wY+du6djtBWl2bX1p2rBeRIgpM76QydPmyKC+D0mRwoX8i8aeI4AAAggggAACCCCQogJJGz4HDpssIyZMj3pYGjWoK706t5aCBQtEfW48n7B3737pOWCk1K1ZOWzw8sLZj8vXZLz1011bRw1q+uRFi1fIHQ/0zfSRA7fVMNej38jDdqnNLY2k013NrHbVs65WqaxVOCR8WjHzZAQQQAABBBBAAAEEUlogacNn8FFZs36T3N31eenTvZ3Uql4xxw+aF/7ChUkvmNWqUSkjDHr70OH2xjEFUC/g/rbx98NCob7/4DemytB+D0vZ0iWMh/f6NaqWjzmQe5/zuELHyFcLl8jol7rF7Ev4zPFmyAdAAAEEEEAAAQQQQCDXCBA+43wogntkw4XPcMNMbYaf2oZP3VWvxzTWEKnP795nuAn1A4dMksCwHI2O8BlNiL8jgAACCCCAAAIIIOAfAV+Ez1DDW4PDV2Cvox7+wCGrsQa1wGYTqRfTC436/OAhwTbhMCvh06Z3NfhzDhozVRZ9vzzs0Nvgob5VK5WV7X/ulOCe3FDH48LaVWXX7n8yvbYGeX2/gU/eIy8MnyzTZ82XEsWKZvTmep9P/917hAr7wTcEQg0fjuU5sbQj/RyxvJZ/vmLYUwQQQAABBBBAAAEEDgmkfPgMFba8gBcYVLznbdq6XQL/3SYMxho+Qw259bbNSjiMdditvofN6wc/N5KFBq4PZ88POcw3MHx6r3n1ZXUzzT31gmZgwSEvxAUGzmCnwNcJ5Rr8uqGCfyzPidRmAvcvltfiywcBBBBAAAEEEEAAAT8KpHT4jNTDGDwnMlwoi/QakRpMpJCXk+HT652MpTc32CicRbj5tqGG3Wo42/L79sN6fEMNNw4VSD3zSK/jzXUtcnwhU2031FDhmXMWycV1q8ueffuiPkffU4tHnXJy0cOKNQV+Rn1etPdLdOErP36psc8IIIAAAggggAACuVMgpcNnpDmHwb14kcJipBAU7rDmxvDp7XMsFW/DBc1QhYxC/Zu6BPtHCt024TPScQ0MwlUrlDWhUYflhpt7Gzh0N9xzIhWz8ubEamGnEsVOjPp+ufNrgE+FAAIIIIAAAggggED2C6R0+IwUAIP/Fum5NkWAvEOWG8JnqKVWYunx1H0IHIYcqhkGBrVw4Tw4JNoah3vdaJ9NP6+3n6HmhQYP4432nFDL2gSaRJuHGmrYcPaf2rwDAggggAACCCCAAAK5SyClw2du7fnMyYJDsTa/cMEv1GcPF87D9Xw2u7b+YUvJxKvnM9r+ecH1xBMKhy2cFPycHX/tzvIyPrG8X7TPzN8RQAABBBBAAAEEEEgFgZQOn/Gc8xlqvl+kBhCtsE9OLbUSS6ONNDxWtw+eNxquEFFw+Ix2PCZPmxOy2m1gESJ9/1jn4er7L1m+VurVrZZptwOHCeu80FieE24uZ+ALx/J+3pqrsRwHnoMAAggggAACCCCAQCoJpHT41AMVqrpqrJVLdftQVVxjaQDRwmeogBdtm+D3zcpSK7F89mgVfoM/e6gwGG4uZajX9v4teAmUSHNtPasaVctnKl6k79t/8ES5tWkDCVVwKPizhio4FGp/ws2XVYtnXxkvj953q6ENDqmxBuVYjgvPQQABBBBAAAEEEEAgmQVSPnzqwYllfcZw8whDrQkZ6YAHr/HoPTfU68TyucK9V6h5iIHzMMMVAYrWWCMF2sBtwy0p4q25qfMc+3RvJwOHTJLgYbbBn10LIJUpWUxi7fn0PkeouZr6t8CCSqGOa3DBpVieE64d6b+HW7LH+5yxFHiKdlz4OwIIIIAAAggggAACyS6QMuHT9UDY9jq6vh/bI4AAAggggAACCCCAAAJ+EiB8/u9oEz791OzZVwQQQAABBBBAAAEEEEi0AOGT8JnoNsf7IYAAAggggAACCCCAgA8FCJ8+POjsMgIIIIAAAggggAACCCCQaAHCZ6LFeT8EEEAAAQQQQAABBBBAwIcChE8fHnR2GQEEEEAAAQQQQAABBBBItADhM9HivB8CCCCAAAIIIIAAAggg4EMBwqcPDzq7jAACCCCAAAIIIIAAAggkWoDwmWhx3g8BBBBAAAEEEEAAAQQQ8KEA4dOHB51dRgABBBBAAAEEEEAAAQQSLUD4TLQ474cAAggggAACCCCAAAII+FCA8OnDg84uI4AAAggggAACCCCAAAKJFiB8Jlqc90MAAQQQQAABBBBAAAEEfChA+PThQWeXEUAAAQQQQAABBBBAAIFECxA+Ey3O+yGAAAIIIIAAAggggAACPhQgfPrwoLPLCCCAAAIIIIAAAggggECiBQifiRbn/RBAAAEEEEAAAQQQQAABHwoQPn140NllBBBAAAEEEEAAAQQQQCDRAoTPRIvzfggggAACCCCAAAIIIICADwUInz486OwyAggggAACCCCAAAIIIJBoAcJnosV5PwQQQAABBBBAAAEEEEDAhwKETx8edHYZAQQQQAABBBBAAAEEEEi0AOEz0eK8HwIIIIAAAggggAACCCDgQwHCpw8POruMAAIIIIAAAggggAACCCRagPCZaHHeDwEEEEAAAQQQQAABBBDwoQDh04cHnV1GAAEEEEAAAQQQQAABBBItQPhMtDjvhwACCCCAAAIIIIAAAgj4UIDw6cODzi4jgAACCCCAAAIIIIAAAokWIHwmWpz3QwABBBBAAAEEEEAAAQR8KED49OFBZ5cRQAABBBBAAAEEEEAAgUQLED4TLc77IYAAAggggAACCCCAAAI+FCB8+vCgs8sIIIAAAggggAACCCCAQKIFCJ+JFuf9EEAAAQQQQAABBBBAAAEfChA+fXjQ2WUEEEAAAQQQQAABBBBAINEChM9Ei/N+CCCAAAIIIIAAAggggIAPBQifPjzo7DICCCCAAAIIIIAAAgggkGgBwmeixXk/BBBAAAEEEEAAAQQQQMCHAoRPHx50dhkBBBBAAAEEEEAAAQQQSLQA4TPR4rwfAggggAACCCCAAAIIIOBDAcKnDw86u4wAAggggAACCCCAAAIIJFqA8Jlocd4PAQQQQAABBBBAAAEEEPChAOHThwedXUYAAQQQQAABBBBAAAEEEi1A+Ey0OO+HAAIIIIAAAggggAACCPhQgPDpw4POLiOAAAIIIIAAAggggAACiRYgfCZanPdDAAEEEEAAAQQQQAABBHwoQPj04UFnlxFAAAEEEEAAAQQQQACBRAsQPhMtzvshgAACCCCAAAIIIIAAAj4UIHz68KCzywgggAACCCCAAAIIIIBAogUIn4kW5/0QQAABBBBAAAEEEEAAAR8KED59eNDZZQQQQAABBBBAAAEEEEAg0QKET0fxTdv3OL4CmyOAAAIIIIAAAggggEAyCJQoelQyfMxc+xkJn46HhvDpCMjmCCCAAAIIIIAAAggkiQDh0+1AET7d/ITw6QjI5ggggAACCCCAAAIIJIkA4dPtQBE+3fwIn45+bI4AAggggAACCCCAQLIIED7djhTh082P8Onox+YIIIAAAggggAACCCSLAOHT7UgRPt38CJ+OfmyOAAIIIIAAAggggECyCBA+3Y4U4dPNj/Dp6MfmCCCAAAIIIIAAAggkiwDh0+1IET7d/CKHz3THF0/mzfMk84fnsyOAAAIIIIAAAgggcLgA4dOtVRA+3fwihs/t20VmfZrP8R2Sb/NmTQ9KXv/tdvIdKD4xAggggAACCCCAgJUA4dOK67AnEz7d/KKGz9Fj88vOXY5vkkSbV6qQLs1vJHwm0SHjoyKAAAIIIIAAAgjEKED4jBEqzNMIn25+hM8gP8KnY4NicwQQQAABBBBAAIFcK0D4dDs0hE83P8In4dOxBbE5AggggAACCCCAQLIIED7djhTh082P8En4dGxBbI4AAggggAACCCCQLAKET7cjRfh08yN8Ej4dWxCbI4AAAggggAACCCSLAOHT7Uj5LnwOHDZZFn2/XAb1fUiKFC5k9Hbs3C0du70gPy5fY/579EvdpFb1ihmyU2Z8IT36jTT/3ahBXenVubUULFjA/Pem7XvCHgGtdkvBIbcGytYIIIAAAggggAACCOQWAcKn25HwVfjU4DliwnSpVqlsRvjcu3e/9BwwUurWrCxNG9aTNes3Sfe+r0ufbm2lbOkSsmjxChk4ZFLG8/U19NHprmaEzxBtj4JDbickWyOAAAIIIIAAAgjkXgHCp9ux8U341N7LdRu2ykV1qmYKkxo2+w+eKH0ebWd6QoPDqIbNMiWLmWCqj+AwSs9n5gZI+HQ7IdkaAQQQQAABBBBAIPcKED7djo0vwqcGz/nfLTPDZZesXJMpfAaHSeX0ejc7tmqcqVdU/xbcM0r4JHy6nYJsjQACCCCAAAIIIJAsAoRPtyOV8uFTw+XkaXMy5mkGh83gv4cKn82urZ8xBzQ4fP6xa1/YI7D193QZ+UY+2bnL7SAl09ba83lL8zQ54og8yfSx+awIIIAAAggggAACCEQVOPG4I6M+hyeEF0j58BlYLCiQwZv3uWrdxkw9oaHCpzcfVP8WHD73/5cWVnftbwdk2Kg8vgufbVrmlaML5uW8QwABBBBAAAEEEEAgpQQKHME1rssBTfnwGYwT3PPJnE+X5nP4tsz5jK8nr4YAAggggAACCCCQewQYdut2LHwfPql269aAgrcmfMbXk1dDAAEEEEAAAQQQyD0ChE+3Y+H78Kl8rPPp1ogCtyZ8xs+SV0IAAQQQQAABBBDIXQKET7fj4bvw6cZ1+NZUu81sQviMdwvj9RBAAAEEEEAAAQRyiwDh0+1IED7d/ITwSfh0bEJsjgACCCCAAAIIIJAkAoRPtwNF+HTzI3wG+dHz6dig2BwBBBBAAAEEEEAg1woQPt0ODeHTzY/wSfh0bEFsjgACCCCAAAIIIJAsAoRPtyNF+HTzI3wSPh1bEJsjgAACCCCAAAIIJIsA4dPtSBE+3fwIn4RPxxbE5ggggAACCCCAAALJIkD4dDtShE83P8In4dOxBbE5AggggAACCCCAQLIIED7djhTh082P8En4dGxBbI4AAggggAACCCCQLAKET7cjRfh08yN8xjl87v8vj+MRSc7NCxyRnpwfnE+NAAIIIIAAAgj4SIDw6XawCZ9ufoTPOIfPNWvzyNfz/BVAq1UVqVY1zbElsjkCCCCAAAIIIIBAdgsQPt2ECZ9ufoTPbAifo8fmczwqybX5jU3SCJ/Jdcj4tAgggAACCCDgUwHCp9uBJ3y6+RE+CZ+OLUiE8OlMyAsggAACCCCAAAIJESB8ujETPt38CJ+ET8cWRPh0BuQFEEAAAQQQQACBBAkQPt2gCZ9ufoRPwqdjCyJ8OgPyAggggAACCCCAQIIECJ9u0IRPNz/CJ+HTsQURPp0BeQEEEEAAAQQQQCBBAoRPN2jCp5sf4ZPw6diCCJ/OgLwAAggggAACCCCQIAHCpxs04dPNj/BJ+HRsQYRPZ0BeAAEEEEAAAQQQSJAA4dMNmvDp5kf4JHw6tiDCpzMgL4AAAggggAACCCRIgPDpBk34dPMjfBI+HVsQ4dMZkBdAAAEEEEAAAQQSJED4dIMmfLr5ET4Jn44tiPDpDMgLIIAAAggggAACCRIgfLpBEz7d/AifhE/HFkT4dAbkBRBAAAEEEEAAgQQJED7doAmfbn6ET8KnYwsifDoD8gIIIIAAAggggECCBAifbtCETzc/wifh07EFET6dAXkBBBBAAAEEEEAgQQKETzdowqebH+GT8OnYggifzoC8AAIIIIAAAgggkCABwqcbNOHTzY/wSfh0bEGET2dAXgABBBBAAAEEEEiQAOHTDZrw6eZH+CR8OrYgwqczIC+AAAIIIIAAAggkSIDw6QZN+HTzI3wSPh1bEOHTGZAXQAABBBBAAAEEEiRA+HSD9kX4nDLjC+nRb2SG1NNdW0vThvUy/nvHzt3SsdsL8uPyNebfRr/UTWpVr5jx98DtGzWoK706t5aCBQuYv2/avifsEdi+XWT02Pyyc5fbQUqmrStVSJfmNx6UvPmy9qnXrM0jo8dmceOsvWWOb3VjkzSpVjUtxz8HHwABBBBAAAEEEEAgsgDh062FpHz43Lt3vwwaM1XubH6VFClcSLyg2an9TSZg6t97DhgpdWtWNoF0zfpN0r3v69KnW1spW7qELFq8QgYOmSSD+j5kth84bLIR73RXM8JniLZH+LQ/IQmf9mZsgQACCCCAAAII5IQA4dNNPeXDZzBPqLDZf/BE6fNoOxMug/+uYbNMyWIZPaXBYZSez8zChE/7E5LwaW/GFggggAACCCCAQE4IED7d1H0XPrVn8+6uz0uf7u1Mz2dwmFROr3ezY6vGmXpF9W/BPaNb/twb9gj88YfIqLH5fDfs9uZmaZIviyNnV63RocpZ3NjtXMixrZs1SZPq1dJz7P15YwQQQAABBBBAAIHYBE45oWBsT+RZIQV8Ez4D53UGzvnU8Dl52pxM8ziDw2eza+tnzAENDp9p6eFDw6p1/8nQkXl8Fz7b3Z5Xjj3aPkCmpaXLoh8PyIjReXx1uja/IV0uPj+/5M/nr/321UFmZxFAAAEEEEAgJQTy5uF6zeVA+iZ8ekjBw2pdez4Zdpu5+THs1v50ZNitvRlbIIAAAggggAACOSHAsFs3dd+FT+XS6rXrNmw1RYO0J5M5n26NKHBrwqe9pVP4TBfZ958/78AdWYChyvatjS0QQAABBBBAwEWA8OmiJ5Ly4VOH24566yPR+Zu6PIo3/FaH0mp1W6rdujWg4K0Jn/aeruFz+sy8sv0P+/dN5i2uvjJNTjopmfeAz44AAggggAACyShA+HQ7aikfPpVH53COmDA9Q4p1Pt0aTaStCZ/2tvEInwsW5rV/4yTdokABkbvbHCB8Junx42MjgAACCCCQzAKET7ej54vw6UYUeWvmfGb2IXzatzbCp50Z4dPOi2cjgAACCCCAQPwECJ9ultkaPrXHccvv200lWX30HDBSps+aLyWKFZWh/R6WsqVLuH36XLA14ZPw6doMCZ92goRPOy+ejQACCCCAAALxEyB8ullmW/j05lZ2an9Txnqa3pImS1auOWx5E7fdyLmtCZ+ET9fWR/i0EyR82nnxbAQQQAABBBCInwDh080yW8Nn92eHS5cON5seTm/tzFAVZt12IWe3JnwSPl1bIOHTTpDwaefFsxFAAAEEEEAgfgKETzfLbAufXhVZrSp7RplTpWO3FySwF3TgkEkyqO9DUqRwIbc9yOGtCZ+ET9cmSPi0EyR82nnxbAQQQAABBBCInwDh080y28KnfixdQ/Purs/Lpq3bpc0tjcy6mt5w3Fo1Kpn/TvYH4ZPw6dqGCZ92goRPOy+ejQACCCCAAALxEyB8ullma/h0+2jJsTXhk/Dp2lIJn3aChE87L56NAAIIIIAAAvETIHy6WRI+3fyE8En4dGxCQvi0EyR82nnxbAQQQAABBBCInwDh080y28KnN7z2x+VrQn7CapXKMufT7djlyq1Z59P+sBA+7cwIn3ZePBsBBBBAAAEE4idA+HSzzLbwGe5jaSGi/oMnyq1NG7DOp9uxy5VbEz7tDwvh086M8GnnxbMRQAABBBBAIH4ChE83y4SHT/24U2Z8Ies2bKXgkNuxy5VbEz7tDwvh086M8GnnxbMRQAABBBBAIH4ChE83yxwJn1oFV3s/+zzajqVW3I5frtua8Gl/SAifdmaETzsvno0AAggggAAC8RMgfLpZEj7d/Cg4FORH+LRvUIRPOzPCp50Xz0YAAQQQQACB+AkQPt0scyR8Dhw22Xxq1vl0O3i5cWvCp/1RIXzamRE+7bx4NgIIIIAAAgjET4Dw6WaZbeEzUrXbRg3qSq/OraVgwQJunz4XbM1SK5kPAuHTvlESPu3MCJ92XjwbAQQQQAABBOInQPh0s8zW8Nn92eHSpcPNh1W1XbR4hUyeNiclAijhk/DpdgoK63xaAhI+LcF4OgIIIIAAAgjETYDw6UaZI+GTgkNuBy03b03Pp/3RoefTzozwaefFsxFAAAEEEEAgfgKETzfLHAmfutTK/O+W0fPpduxy5daET/vDQvi0MyN82nnxbAQQQAABBBCInwDh080y7uFTezXv7vq8bNq6PewnK1GsqAzt9/Bhw3HddiVntmbYbWZ3wqd9OyR82pkRPu28eDYCCCCAAAIIxE+A8OlmGffw6X0cLTgUbs6n20fOXVsTPgmfri2S8GknSPi08+LZCCCAAAIIIBA/AcKnm2W2hU+3j5U8WxM+CZ+urZXwaSdI+LTz4tkIIIAAAgggED8BwqebJeHTzU8In4RPxyZEtVtLQMKnJRhPRwABBBBAAIG4CRA+3SgJn25+hM8gP+Z82jcoej7tzAifdl48GwEEEEAAAQTiJ0D4dLPM1vAZqfhQtUplZVDfh6RI4UJue5DDW9PzSc+naxMkfNoJEj7tvHg2AggggAACCMRPgPDpZplt4XPv3v3Sc8BIqVuzspx91hkyfsos6dLhZilYsIAMHDZZLqpTVWpVr+j26XPB1oRPwqdrMyR82gkSPu28eDYCCCCAAAIIxE+A8OlmmW3hM7DarX7E/oMnSp9H25mezkWLV8jkaXNY59Pt2OXKrRl2a39YCJ92ZoRPOy+ejQACCCCAAALxEyB8ulkmJHwWOb6QPPvKeHn0vltN+NThuIFh1G0Xom+tPa0jJkzPeOLTXVtL04b1Mv5bg3LHbi/Ij8vXmH8b/VK3TL2yU2Z8IT36jTR/a9SgbqbQTM9nZn/CZ/T2GPwMwqedGeHTzotnI4AAAggggED8BAifbpbZFj4Dh91q0NMAWKZkMRP6NMzN/25ZQno+9XMMGjNV7mx+VUbwvbvr89KnezsTMIM/pwbj7n1flz7d2krZ0iVML+3AIZMy5qfqfuij013NzP8SPgmfbqegUO3WEpDwaQnG0xFAAAEEEEAgbgKETzfKbAufwR8rsHexRLGiMrTfwybcJfoRKmwG9sJGCs36WYPDKOGT8Onahun5tBMkfNp58WwEEEAAAQQQiJ8A4dPNMtvCZ+Ccz+CQmZNzPr0Q3Kn9TabnMzhMKqfXu9mxVeOMokneMN3gnlHCJ+HT7RSk59PWj/BpK8bzEUAAAQQQQCBeAoRPN8kcCZ+JnvMZSBQ8bDZUEA4On82urZ8xBzQ4fB5MSw97BFav/0+GjswjO3e5HaRk2lrnfLZrlVeOOTqf9cdOS0uXb348ICPeyGO9bTJv0PyGdKl3Xn7Jn89+v/f/d1DGv50m8xfab5usZho+7737oFQoe2Sy7gKfGwEEEEAAAQSSVCBfXv9cc2XHIcqR8JnIOZ/BwXPL79szzTV17fncumNv2OOy7Q+RUWPy+S58tmiWJvnyZ6G5pov8skZk9Fj74JqFd8s1mzRrkiZnVw9/EyPiB01Pl/c/zCsLFubNNfuT3R9Ew2f7NgekWDG+/LPbmtdHAAEEEEAAgcwCxYoUhMRBIO7hU3sGtaDPpq3bw36snJjzqb2ZwcFTP2BwLyxzPh1ak4hQ7dbejzmfdmYMu7Xz4tkIIIAAAgggED8Bht26WcY9fHofJ9KcT7ePbL918FDbwFeg2q29Z6QtCJ/2noRPOzPCp50Xz0YAAQQQQACB+AkQPt0ssy18un2s+G0dvIan98qB63Wyzmf8vAmf9paETzszwqedF89GAAEEEEAAgfgJED7dLFM+fLrxRN+aareZjQif0dtM8DMIn3ZmhE87L56NAAIIIIAAAvETIHw1DjUcAAAgAElEQVS6WRI+3fyE8En4dGxCQvi0EyR82nnxbAQQQAABBBCInwDh080yW8NnYJEf/Zg9B4yU6bPmS04UHHJjCr814ZPw6dq2CJ92goRPOy+ejQACCCCAAALxEyB8ullmW/j05lF2an+TWSMzcD3NJSvXyORpczIteeK2Gzm3NeGT8Ona+gifdoKETzsvno0AAggggAAC8RMgfLpZZmv47P7scOnS4WYpW7qEBFacDV7exG0XcnZrwifh07UFEj7tBAmfdl48GwEEEEAAAQTiJ0D4dLPMtvDpLWHS7Nr6ckaZU6VjtxcksBd04JBJMqjvQ1KkcCG3PcjhrQmfhE/XJkj4tBMkfNp58WwEEEAAAQQQiJ8A4dPNMtvCp34s7eG8u+vzsmnrdmlzSyPpdFcz8Ybj1qpRyfx3sj8In4RP1zZM+LQTJHzaefFsBBBAAAEEEIifAOHTzTJbw6fbR0uOrQmfhE/Xlkr4tBMkfNp58WwEEEAAAQQQiJ8A4dPNkvDp5sdSK0F+rPNp36AIn3ZmhE87L56NAAIIIIAAAvETIHy6WRI+3fwIn4RPxxYkrPNpKUj4tATj6QgggAACCCAQNwHCpxsl4dPNj/BJ+HRsQYRPW0DCp60Yz0cAAQQQQACBeAkQPt0kCZ9ufoRPwqdjCyJ82gISPm3FeD4CCCCAAAIIxEuA8OkmSfh08yN8Ej4dWxDh0xaQ8GkrxvMRQAABBBBAIF4ChE83ScKnmx/hk/Dp2IIIn7aAhE9bMZ6PAAIIIIAAAvESIHy6SRI+3fwIn4RPxxZE+LQFJHzaivF8BBBAAAEEEIiXAOHTTZLw6eZH+CR8OrYgwqctIOHTVoznI4AAAggggEC8BAifbpKETzc/wifh07EFET5tAQmftmI8HwEEEEAAAQTiJUD4dJMkfLr5ET4Jn44tiPBpC0j4tBXj+QgggAACCCAQLwHCp5sk4dPNj/BJ+HRsQYRPW0DCp60Yz0cAAQQQQACBeAkQPt0kCZ9ufoRPwqdjCyJ82gISPm3FeD4CCCCAAAIIxEuA8OkmSfh08yN8Ej4dWxDh0xaQ8GkrxvMRQAABBBBAIF4ChE83ScKnmx/hk/Dp2IIIn7aAhE9bMZ6PAAIIIIAAAvESIHy6SRI+3fwIn4RPxxZE+LQFJHzaivF8BBBAAAEEEIiXAOHTTZLw6eZH+CR8OrYgwqctIOHTVoznI4AAAggggEC8BAifbpKETzc/wifh07EFET5tAQmftmI8HwEEEEAAAQTiJUD4dJMkfLr5ET4Jn44tiPBpC+gePvPYvmUKPT89hfaFXUEAAQQQQCDxAoRPN3Nfhc8pM76QdRu2Sqe7mmVS27Fzt3Ts9oL8uHyN+ffRL3WTWtUrZjxHt+vRb6T570YN6kqvzq2lYMEC5r83bd8T9ghs3y4yemx+2bnL7SAl09aVKqRL8xsPSt58WfvUa9bmkdFjs7hx1t4yx7e6sUmaVKualrXPkS4yfWZeWbAwb9a2T8KtXMPnzp15ZPWhU91Xj4oV0uXoo321y+wsAggggAACcRcgfLqR+iJ8Llq8Qu54oK+RanNLo0zhc+/e/dJzwEipW7OyNG1YT9as3yTd+74ufbq1lbKlS4huO3DIJBnU9yEpUriQDBw22byOF2AJn5kbIOHT/oQkfNqZxSN8jnszr2z93T89oKeXTpfmzQ4SPu2aGs9GAAEEEEDgMAHCp1uj8EX49IhC9Xxq2Ow/eKL0ebSdCZfBYVTDZpmSxUww1UdwGCV8Ej7dTkGG3dr6ET5txUQIn/ZmbIEAAggggEAoAcKnW7vwffgMDpPK6fVudmzVOFOvqP4tuGeU8En4dDsFCZ+2foRPWzG38Omf/uHDXdN1iqyfAeybGlsggAACKS9A+HQ7xITPxStk8rQ5meZxBofPZtfWz5gDGhw+9+4/GPYIrN9wQIaNyuu7OZ+tb8sjRxW0n4OYnp4uP/x0UEa8Yb+t22mQs1s3b5om59fJJ/ny2l/l/ncgTd56N13mL7TfNmf3OuvvruHznrsOSrnSR2TpRTZtPSgjxojvht3ecZtI0eOzNp965eoDsnipf9qYNqxjjkqXKy/NJ/nz2+/3gQP+LeyUFa8snchshAACCOSQQMECWfstzaGPm+velvAZNKfTtufzz937wx7UzVvTZOQb+XwXPm9rni5HFLC/YJN0keW/pMuoMf4Kn82apsm5NfJIniyQpaWly3sf5PFd+OzQ9qCcWiJr7eSP7enyxvg8vguft7ZIl+OOzUIjE5H1v6XJa0P99WN71eVpUv8ikbxZuCmk5+WcL3Pd7322f6ByZdOldKmsnZfZ/uF4AwQQQCBOAicUOlR0lEfWBHwfPpnzmbWGE24rCg7Ze1JwyM6MYbd2XvpslzmfGlc3b8kjg4b5K3xe2SBNLjgvLWvDbtNF5s7LKzNn+SuIdbzroBQ/JV3vI1o//v1X5J9/rDdL+g0KFMgjhQtnRSzpd50dQCBpBRh263bofB8+qXbr1oCCtyZ82nsSPu3MCJ92XoRPey/dgvBp7+YaPt+anE82bs5a77z9p835LYocny63tUgjfOb8oeATIGAlQPi04jrsyb4In4FLrXgCgWt5ss6nWyMK3JrwaW9J+LQzI3zaeRE+7b0In1kzi0f4XLveP+Gz2MmEz6y1NLZCIGcFCJ9u/r4In25Ekbem2m1mH8KnfWsjfNqZET7tvAif9l6Ez6yZET7t3Aifdl48G4HcIkD4dDsShE83PyF8Ej4dm5AQPu0ECZ92XoRPey/CZ9bMCJ92bs7h089TRf3TQW7XqHh2QgQIn27MhE83P8JnkB89n/YNivBpZ0b4tPMifNp7ET6zZkb4tHNzDZ/btoksW+GvolYqfPGFWSwEZnd4eDYCYQUIn26Ng/Dp5kf4JHw6tiCh59NSkPBpCUa1W3swCg5lyYzwaccWj/A5dER+2R9+xTe7D5QEz65TO00aXUn4TIJDldIfkfDpdngJn25+hE/Cp2MLInzaAhI+bcVYasVejGq3WTEjfNqpET7tvPTZhE97M7aIvwDh082U8OnmR/gkfDq2IMKnLSDh01aM8GkvRvjMihnh006N8GnnFY/wudyHw5SPPDJdyp7u5wnC9u0s2haEz2hCkf9O+HTzI3wSPh1bEOHTFpDwaStG+LQXI3xmxYzwaadG+LTzikf4/HFJXnn7XX/Nk72j5UHCp31Ti7gF4dMNlPDp5kf4JHw6tiDCpy0g4dNWjPBpL0b4zIoZ4dNOjfBp50X4tPfSLVzCZ9pBkb//9mdp4eMKh+8tJnxmrS16WxE+3fwIn4RPxxZE+LQFJHzaihE+7cUIn1kxI3zaqRE+7bwIn/Ze8Qifb72dT3b8lbX3Ttatmt94UIoWDf/pCZ9uR5bw6eZH+CR8OrYgwqctIOHTVozwaS9G+MyKGeHTTo3waedF+LT3ilf4XL7SP72fhY/T3uIDhM+sNbeYtiJ8xsQU/kmbtu8J+8ft20VGj80vO3c5vkkSbc46n/YHi3U+7cwIn3Ze+uzTS6dL82YH5eij7bfVS47NW/LIoGH57DdO4i2ubJAmF5yXxSUd0kXmzssrM2f5a24Z4dOuwRM+7bwIn/ZehE97M8KnvZntFoRPW7Gg5xM+M4MQPu0bFOHTzozwaedF+LT30i0In/ZuhE87M8KnnRfh096L8GlvRvi0N7PdgvBpK0b4jChG+LRvUIRPOzPCp50X4dPei/CZNTPCp50b4dPOi/Bp70X4tDcjfNqb2W5B+LQVI3wSPh3bTPDmhE87UMKnnRfh096L8Jk1M8KnnRvh086L8GnvRfi0NyN82pvZbkH4tBUjfBI+HdsM4dMNkPBp78ecT3szht3amxE+7cwIn3ZehE97L8KnvRnh097MdgvCp60Y4ZPw6dhmCJ9ugIRPez/Cp70Z4dPejPBpZ0b4tPMifNp7ET7tzQif9ma2WxA+bcUIn4RPxzZD+HQDJHza+xE+7c0In/ZmhE87M8KnnRfh096L8GlvRvi0N7PdgvBpK0b4JHw6thnCpxsg4dPej/Bpb0b4tDcjfNqZET7tvAif9l6ET3szwqe9me0WhE9bMcIn4dOxzRA+3QAJn/Z+hE97M8KnvRnh086M8GnnRfi09yJ82psRPu3NbLcgfNqKET4Jn45thvDpBkj4tPcjfNqbET7tzQifdmaETzsvwqe9F+HT3ozwaW9muwXh01aM8En4dGwzhE83QMKnvR/h096M8GlvRvi0MyN82nkRPu29CJ/2ZoRPezPbLQiftmKET8KnY5shfLoBEj7t/Qif9maET3szwqedGeHTzovwae9F+LQ3I3zam9luQfi0FSN8Ej4d2wzh0w2Q8GnvR/i0NyN82psRPu3MCJ92XoRPey/Cp70Z4dPezHYLwqetGOGT8OnYZgifboCET3s/wqe9GeHT3ozwaWdG+LTzInzaexE+7c0In/ZmtlsQPm3FCJ+ET8c2Q/h0AyR82vsRPu3NCJ/2ZoRPOzPCp50X4dPei/Bpb0b4tDez3YLwaStG+CR8OrYZwqcbIOHT3o/waW9G+LQ3I3zamRE+7bwIn/ZehE97M8KnvZntFoTPGMSmzPhCevQbaZ7ZqEFd6dW5tRQsWMD896bte8K+wvbtIqPH5pedu2J4kxR5SqUK6dL8xoOSN1/WdmjN2jwyemwWN87aW+b4Vjc2SZNqVdOy9jnSRabPzCsLFubN2vZJuBXh0/6gET7tzQif9maETzszwqedF+HT3ovwaW9G+LQ3s92C8BlFbNHiFTJwyCQZ1PchKVK4kAwcNtls0emuZoTPEHaET9tTUITwaWdG+LTz0mcTPu3NCJ/2ZoRPOzPCp50X4dPei/Bpb0b4tDez3YLwGUVMw2aZksWkacN65pnBYZSez8yAhE/bU5DwaStG+LQVI3zai4kQPu3VCJ92ZoRPOy/Cp70X4dPejPBpb2a7BeEzgtjevful54CRUrdm5YzwuWb9June93Xp062tlC1dgmG3QX6ET9tTkPBpK0b4tBUjfNqLET6zYkb4tFMjfNp5ET7tvQif9maET3sz2y0InzGEz2bX1pda1SuaZwaHz0jgv6zbLx98ZHtIkv/57Vrlk2OPtp+3mZaWLgsX/yfzFiS/gc0eVK0sUv+CIyR/vjw2m5nn7tt/UMZOPii7d1tvmtQbXNUgXSqdcWSW9uHXTf/JO++nZ2nbZN7olmZ5pFjRI7K0Cz+u2Cez59i3zyy9WS7ZqHQpkWuuyC8FjrCfT73/vzT54OMDsv63XLIzCfoYl9VPl2oVs3Zebt3+n0yY7L/z8obr8shpJbJ2Xi5ftU8+muWv87JQIZGWzfLJkQXsrzEOHEyXOXP/kyXLEnRC5JK3Oa+OSO3qR0jevPZt5e9/D8rwMQdzyZ4k7mNcc5VI+TKHarvwiL8A4TOG8Bmp5zP+h4RXRAABBBBAAAEEEEAAAQRST4DwGeWYRpvzmXpNgj1CAAEEEEAAAQQQQAABBOIvQPiMYhqt2m38DwmviAACCCCAAAIIIIAAAgikngDhM4ZjGmmdzxg25ykIIIAAAggggAACCCCAgO8FCJ++bwIAIIAAAggggAACCCCAAALZL0D4zH5j3gEBBBDIJLD7nz2y7tfNclaF07NUgdCPnL9u3Cr//XdQypQqJvny2Ve69JvZ0hVrZeEPK6TF9ZfKUQWzVoHWb2bsLwLZLXDw4EFZsepXOaloETmpaGHJk8e+Am12f8bc9vp79+2Xlat/kzIlT5HCxx2T2z4enycLAoTPLKAlyybp6emy9tfN8uWCH81HPr9WFSlX+lQudpPlACbJ5/z7nz3yx5875ZSTT5BVazfKmeVKSYEj8ifJp8+Zj6lD+fu+OkHOrVZB7m3dVCqVP42LkAiHYs/efTL5g8/ls7nfy1+7/pYeD7aUmlXPzJmDlyTvqmZj3/5Ypn0yTx5sd6NcVKca52WUY7fl9z9NG9v9z79Sp2ZlqVKhDDc6opit/W2LnHhCYflr527JmzevnHrKiUlyhuTMx1y/Yau89f6n8sX8H6XiGadJ9/tulROKHJczHyZJ3nXxstXy/sy5MmfeD3L1JXWk4x2N5eijCibJp+djhhIgfKZou9C7a8PGfSBfLVwitzS5TI48soBMmf6FCQiP3HuLHFkga+uKpShXpt1Su6Ur18k70z+XZT+vl+ef6CilSxbzw65naR81DLw66l2ZPG2OXFm/lvTq3FoKFmR9rHCYv236XR7tM1weve8WOXAwTQYOnSTly5aUDq0aS1EuQqK2wZ9X/yY9B4ySng/dLpXPLB31+X5/wsYtf8iICdNl9fpN0qXDzXJWhTLc6AhqFHqj9v2Pv5bXJ0yXljdcLsVOOkE+/nyR7Nj5tzzzSBs54fhCfm9GIfdf3b5etFSeeWmcbN+xU15++n6pe05lrGIQ0HXN3/3wS/liwWJ55pG2UuiYo2LYyt9P2f/fARk65n35Z89e6dKhOTeGkrg5ED6T+OCF++j6g/DeR1+ZIVeP3X+bHPu/LzUNVXqXslzpElx8BOHpD8Eva3+T9z485Hb1pXXkn3/3yF+7/pFH77uVHoMYegw69xosXTreLNUrl0vBsyo+u6Tn4KDRUyVvvrzS8fbG5jzUH9QZs+dLsZOKyHnnnBWfN0rxVwleAivFd9d59w6mpcn4KbPkmx9WSO9H23GhGyQ6/9tlMuqtD+WpzneaG7T60N9RDeynlzqFi9wILVCdJrw7W1at28hvpeWZumPnbun+7HBzU6hs6RKWW/vz6WvWb5L+gydKn0fbSZHC3BRK1lZA+EzWIxfhc+vJ+dATr5n5ZD+tXCvnnXuWtG91nRx/3LEpuLfuu7Rz1z/y+HMj5PTSxeXay88zQ5M3btlmeqe6338bvStRiPXiY8SbM2TPnn1mOEzgfDztedf5GjqEjTu7YoLmh58uMD0s2tZaNbtSCh6ZuZd47979sm//f3LsMQW56A3R9n7/4y/p8vRgaXfrNXJh7armGf/8u1cOHDgohY49mmkFQWabtm6Xvq+MN//a7b5bpUSxorL1jx0y5+sf5Lorzvf9fFCdMtD5qUGmt3P9xq1yykknSNd7WhinwIf+TmzYss2EUYb8/b+MjuTo8dwI6dnp9kwBSm+0bdm2Q/Lny2vmN+bNy9zG4K+zuQuXyOAx78vAJ++Rk088XvQm+O6//5X8+fPJMUczrDTYS681psw41Fv87KPtzHmo7ezvf/aa0XyMuHK/Hk7UKxA+EyWdwPcZNm6apKeL3HXbNeZ/dWjH90t/kccfaJlxcm7fsUsmfzBHvlqwRE4/7RS5/qqLpEaV8r78gdALsT4vj5OTih5vhj4ef9wxpnfqqKOOlDYtGmb0Em/YtE3GvzvLWKpV04YXyRllTvV9L7IOTVa/Z7u3k1IlTs5o6f/9d0B+WLbKtLGZcxZJ65uvlhsa1SNQiYjOx3tt1Htm+JDXs64/rB9+tlCeH/JWxo0i7YmpUvH0BH575M63Uptt23eai45REz+UaxqcZ77f9DHm7Y9lzOSZxuyE44+Tp7rcKSWLn5Q7dySBn0pvdEyfNU9GTvxQ2re8Vq6+tK75fvduFunf9uzdb25MNrysrm9Hd+jwWq2L0OOh2+WI/PnMMFLtJTbDbf83DF57Rp8a+IZcULuK6M3d+uedLbc2beD77zK98O8/+C0z5zPwt1JHWD3e93UpXOhQcRjteQ/sVU7gaZDr3krNVq/fLB988rVMnz1fej/S1gxV/nPHLnliwGhZ+9tmcyPtqktqm3Mz+OZkrtuhBHwgvZb4aeU6c8267Od1MqBnRylXpoQZyaft7N89e2XX3//K3bddyzVGAo5HPN6C8BkPxVz0Gtpr8vSLY6R540ukWqVDwx+Dh3bo8JhHnhkqza6tL5ddWNNc1A0ZM1UuqF1Vml93SS7am8R9FL3jOHfREnll5Lum+MuvG383d9a8IVh68dH75XFyf+umck61M+XnNRtk8JipcnfL6+T8c/07VFIvcJ99ZbxUqXC6CePhKvdpUaInnx8tl9c718wL9dtDz8ttf/6VKZzrTQ/94XzsgZZSptQpom3slVFT5JmubeT004qbioiDRr9nehT04s5vjz//2i0zP1so879fJj8sXWWCwOUXnSPXXXGBnFr8UFETnV7wyeffmKBQ5PhCZo77R58tlB4PtvLtXXANl3qhpkPTQs0lDrxZpD0H+j32y5oNprfvrDPL+K2ZiQ7h1sJCV1x86HtJz9WeA0aa38da1SuaUQj63aUFmxpeWsf0tLw2+j2pUO40X36XBTYQLQTz6sgp0rtbO9Nzpw/vN0Hnr3dodZ0pQqRFnPTc1J53Pxaj03Pus6+/lwXfLTNVW6tVLmduoF16YU0zIkjD09MvjpUzSpeQO5pfJQfT0uW1Ue+aWhNNG9bz3Tmp59h3S36Rz+ctloXfLxedt35u9QrGok7NSiaQb9v+l3Tv+7o0vuICadSgrhn98syLY+X6qy5k3nEStBjCZxIcJJuPqHeI+rwyXhpeVsf8cOpD79TqXdve3dqaoQk6x6BJw3pycd3qGUM79AdDT3i/l+Tftfsf6fL0EBM+H3/gNlMhWOf96LCiTu1vkqoVymZc1GrvlQ4x9eOP6YLvlpu2s3PX3zL+3dkmqEcrga6VN7f9uVM63dXMpkmnxHP14uOF4ZPliU63Z/TK6b8NGDJR+na/W9LS0uThpwaZeaB6E0gf2r6ee+1NaXXjFb6bD6R3/gcOmyRfLlgiT3W+Q6pWLCtHBFVQVr+e/UeaHvfyp5c0Ztp7oN9/jz1wmy/nA+mIFg2Ty39eb3rUg4sLecFAC+jcc0eTjJ7Q5b/8KkcVLGBuevjtoSOF9OaOd5Gvw3Af7TNM7mvTNOMGrj5HL3hb3niFucGmN4q08qbOcc+XN6+vyHT48efzF5ubrv0GvSmXXXhOphAeah6jmvZ9ZYI89qD/zkutoHx/j1ek7GnF5YG2N5jh3YFDkL05szqiqleXOzOGdGsb+/rbn3z5e7ly9a9yV5fnTZDUMK6jWgJvbHs97npO3te6ScYIhLc/+NzY+jGwJ9uXEOEz2Y5YDJ930eIV8trId+XBds3kuEJHy4DBb0nVSmWl3a2NZPSkmWbYgs7B+3D2fKl0Zhlz8jKH5RCs3mmb8uEX8lC7ZmZ42qnFTzI9ezocS4fyaUVEnSfl9yFXeidy1MQZxkOHDV1+8bmHtUy9EfLS6++YNqg/uDrPsWenVuamiPY0r/tts1miRQstpHrPnrYlbVsvjXjHjC4oevxxMnrSR3LjNRdL4ysvMEMj1SKwgp/OpXr6hbHy9COtpdiJRWI481PrKRqUdDikVlK++pLa5sLfuznmhSgd9q7VvL0LE+0hHfP2THm6axspeOQRoqFKbx5VrXi6lClVPOWnFejUgG+X/CxXXHxuyBuJXmE1HfKt88q63XtrRo9VarWe2PdGlyN7vN8IaXfLNXLG6afKyDdnmN5O7T3X0Qna/jRw6TqzTz58h5Q69WTp0W+ENL7yQnPu+u3hnZcvDn9bShU/Sfo+dpcc97/htWqhaxh37zPcDMM9u8oZhkfPSw3wzz1+tymAqOZ6A7NyhTK+WM5GA/nE9z6V2V99ZwLoBbWqZnwXedXPA+tL6O+FrlZw9FFHmu89PW+XrlwjP61YJ+eeXcEXS+Z5VbrV54G2N2a6kaY97v0HTZQBPTtkjE7Tdvn0C29Ig4vOlYvPq25G/OlyNnqTnJoTue9bivCZ+45JXD6RNz9RL/B1mNplF50jOvSxW+9h0rn9TWYtRr17pJPd9e5R4HyNuHyAJHwRveB4YdhkM5/HKxevvcZ9X33TDOvTYUU6POaZF8eZLzc/Dh8NPKze8L7nh04yw9F0mFrwQ3tiXn79HTmnegXT0669o4HLAOnc2bnfLDXFYzRgpPqC2/qD+PHn35ghQ7rGZ+0alcy6lXpe6lqM3tIh3sXHzt1/y8N33+TruWWB61V2v/9WUxFYz0u9KaQh0xsa7118VD6zjDS56iLz902/bzfD23T47hllS8q9dzbx5UiF4PPSW+ZBpxrod5vfbz56NRC+XbxSLr2gplx/9YWyf/8B6frMEDP3Tntg9CbGw08Oklo1Kpq1Bv1aI8FrS955+c3in+XprneaG4ze47slP5vfTZ2KUa9udbM8RsXyp0mL6y8TvTnea+AYaXtLI9m67U/56ed1ph6F1lxI9Ydel2lvsT4ee7Cluamoaz7rNJ7gG49dnx5i5snqtdrUmXNl0vufyW03XC7Lf1lv5jd27Xhzyp+3gVMIKpQrZb6/taic3tTW9hJ843HAkLdM8SYtcvVI76GmXoLeoNTpGW1aNGI4bi46wQifuehgZPdH0Qu21yfMMEPSvEpq+kOg6zOGW5tRT369e6QXyPXqVvPdUDb10Tllj9zTIiMA6I/Fug1bfTkcJlQb1Yv+/aY661HmQkIfgXPHAg11/o+Zp/fFt/JM19ZmHp8OS9KCRbr+rB8XKA91Xv6ydoOpttyrS2uqLf+v0emF2559+8wQ21DnpVaOHPTGVLMur85rHzlxhjz32N3mIkXbaO8Xx5oeeq9CbnZ/3+am19eeu5/X/Ca1zj40FUMfOkS5W5/h0u3eFmGHdfu5YmmoJR1mfLpAlq5Y4/sbQoFtW6uzag+dTkHRmxp58oi5iajhdO6ipeb6QufjeRVdXxkxxQQIHU6pDzOv74fl5vc0sFJ6bjp/4vlZ1OjH5avNfE5dKkTnHJ9T9UxzQ1sfes5p7QmtEq+BVNeCNvUSLjrHzBH1hunq8FIN83546Pf34mWrzLQnfeiNxZuvv1QqlT+0zrN2CvTsP8rcENJAqkOY9VpXe9p1Tq1eY/R9dYJZvcCbm+wHt9y8j4TP3Hx04vzZdImCZ14cY05A7S3wqh7++deusD+m3km/6PsVZojl3S2vNcON/Bhbk0IAACAASURBVFI2XRe0H67DRR9qZX4wveF+Z5YtGfaLX4cdfTHvB1NUQOdt1D//bF/c1dXmqvurxasef6iVuePo/VDq0jXag7d+w1bp+szQTKFKL0x6vzRO2t7S0HdzG9Vsw+Zt0ufl8aaN6XnpFZ/Q9XgjjUjQ3oWDB9PkiPz5Zftfu+SS82v45rzUi7c3Js2UJzvfaS4utCdZ73Q3v+5SMyIh1A0inXOsN938OB/IG1qqveva467hQMO6Vgru93j7kPO1/V6xVAO7Dq9t36pxxg2gT7/6Tj6aszDszVo9n/16XmpoennEFFN87tILa0iePHlNkSGd6/5IxxYZvU76b+9/PNcMYdYe96Ur1sq4dz4xUzL82AOvw5GPOfqojF48/Q198fW3pX+P9hkF6t58b7Zs3bYjY36jtsNFP6yQLh1b+OY737sc9uqa6Ag1DezeuvZaaM77LtNrXV0+r0vH5uZmpd4g6fXCGGl3SyPTk8wj5wUInzl/DBL2CfQk1QCpPU+3XH+ZrFj9q8z64lt5/smOJihEe3jVxdrc3NA3wxe8IaJqdf2VF5o5aOs2bMnoUQll5lXO1UBR/vRTfbWou7YxXapgwNBJUqFsKVMyXu1e7HWvWR9Ph+gWLnSsWSbDG2KrhWN0/pDOHdJCKH57eOel9hDUrlFRvl+6SvTmhs4NinQx5hWX0aWUBj5xT8adcz/4eeflDz+tMnOBdDmfqy+rY4ozae+JXsBNmvaZucDV+Wga6PViRIOnH3s+tU1ob7De5DmpaGHT46IjWrQAljfFILDdULH0kIYGSf1uuvGa+nLUkQXMPG1dmzfSlAs/n5e678PHf2CGiOo0Fq1M+nD75mYkzOp1m+Tx516XCmecJn/t/FvKli5ubsxqTYomV19khjan+rSLUN/Nel2lhdN02LIWL5z37TLzvaVV9bXS67OvTpDaZ1cUHQ2jw711/VntLe3S4WbfXIcFu2lb0orUeqNDe9j1v5/p1laKnXi89Bs0UTZv3W56lvVmt84XnfbxXPlr9z/S48GWvrzBkRuvCQifufGoZPNn0iEIWvr86KMLWg2l1Yvk54dMMj8afuo90P3WngMNnlqA6IJaVaJWBTYVE58dbkKWV3U4mw9rrnp5HTKkJeX37dtvlnvQi10t3tHjuZHS46GWGXd0vap1+vfAQJqrdiZBH0bPS+3R06HHlcqXiemOtvbwffvjz75cWkTPS724WPbLeqlcvrS52PAuXrVdTftknkx4d7bc2KieuRD+Yv5isz5ctKrMCTrcOfI26rJy9QbRucSnlyqeMV82+MPEUrFUTbXXPdVHwejF7ewvv5NNW/+QSy6oEdPazn4+L0M1bO/mjy5XoyFTTXVpkeInn2CCvf6vH4OnZ6U3e35cttr00GmRJv091N67zr20Avr1JmSam//PDjdzknX6QKoX6Yv2BaltSH/79KFBXYvRaQ/xj8vXmJCp/60dLbqOr45e0OWU/DCsO5pbbvk74TO3HIkc/Bx6EffW+5+ZynW6tEi4HwEdgqqBStcdrF750Bqifn3oj8Ubkz4yXsFr43lDTbVKW2ARAbXyLv7+2bNHKp5R2gwZ9MtD51DpMD+dP+tVLdW5e3pDI3CIUaCHemklWK00qUMqtZhMql/sBu6/Dkn7ZvFKM78leLFxDat6PuodcK9QkV/aUrj91Payd99/GXPa9aJ37qKfpO+rOqz59rC9w36ujKjDvt+fOVduadrALGmgj2gVS/XGpc7d03O6a8cWUrLESb5qelk5L/1YsdRrFKFuZmjhnMFvTDVLwOmUFh6ZBULNOdb5sZ/O/c4UaApeego/MT3CZQLWRtUpPTp0XucXe+ve45Q7BAifueM45Oin0IvYh554Ve5ofvVhw4n0TtySFWvlg0/myYLvl0nn9s1N9b/ggKoXK1q5ruxpJXwRDlas+lU69xpsfjiDg7j+aOjix326tc00h1EvhHXS++bf1am4LPxhhfkR0bt2fngEz8PQdte97/CISxboBZv20uiSGePe/ljKlSkh99zZ5LAglop+3lqXe/buN2s2Bq4nqyFr0OipZrc73tE4446uVx1Ql3TRIVu6PJAu7aKViP2whq8O4e4/eKLcfdu1UuGMUrL+t61mzpkO7/OG5Aa3FS284+fKiOOnzDK9wsFzPyNVLFVDb3qBDnPT0SBasbpokeNS8VTMtE9ZOS/1BfxasdS76apTLsqVPtVUwPXWSh02fpq88OS9MY1G0NFE+htaqsTJvugl9YroNLnqwoy1n7VHfdHilWZYrq7ZHuqh12pbtv1p/q41AVo2u8I3a9EGzyfWNtP5qUFyf9sbpGbV0NdZ+j026q0PTUfA79v/MtdsWr2fR/YKED6z1zdpXj2wSp3ODXpl5BSzNpfekdTFpOufX0NqVi2f6aJfh1Z+t+QXM79jyYo1cuzRR8mrfR7IGFKZNDufxQ8aaOa9hDeMVH8gA8uAe8va6Jdht3tvMY56oTzizekZRVOy+DGSajO9oNXhVqZIzo6dJiTc0KheTMNh9MdYq/5dcXEtaXDROUm131n9sBom09PlsBs6Xsh69tF2mYZO6lxHvfv76H23SPXKZ8g/e/bK+Hc+kROLFpYbG12c1Y+RVNtpVdzX35wueoOoSOFjpeUNV0jdc84Ke1NM26TfKyPq95M3JC2WiqWBDUJHgUyfNc+MUGjf8lq5+tK6KX8D0va81CHKfq9YqhXzB41+T3bs/FuKFytqpv7oVItrLz8/7PeL3tSe981SeWvqZ2bOshaLGdCjQ0xhNam+tMJ82E1bt0u/196U4wsfa8Lk19/8lLFWdrj90/NR6wBo4b8Xe93nq1Fq3nQL/T7Ste2146TEyUXNzduCBQuEbRI6hFcLP3361fe+uobNyXOE8JmT+rnwvfWurp6EH362UJ7qfIcpXR3Yy+n1rGgxD70A1uGAF9aqagoxBAeuXLh72faRtMjO0pVr5cyypWT8u7NEQ0HgnAwNBRrodRkIb11CnQP53KsTpMdDrXy1hI1Wq9N9L1zoGKvhVvrD8txrb0rFM07z1Zxjr9Fq+NbeTq3wN+XDL6VW9QqZHHRecqcnXzP/dk61ClKhXEkTKMJdKGfbyZBkL0xlxP8/YLFWLA08xF4PqN700HVY/TbHPdp56VlRsVTMd5GO/Nmw6XfTwxRq3qK2wUU/rJQJ786SXbv/McPBq1YsK31fmyBNr67nq8Jq2nb0/NL12rWieSxTdbxVDHRd9/taN4npxm6SfWVH/bh602LFqvVS9PjjpEyp4lFvhnkF1rSAkdczH/VNeIKTAOHTiS81N9Yvr183/i7PD3nL7GDgnB4dUvrUwDfk4fY3mR8Eb/iMDlvQwKXrNnpflnrXSZeLqFT+tJT/AtQfzK8WLjXDaptcfaFZIsPrSdCLE52bd2X92pmGc+j8jRmz55uFpPWunA6T1LvBbX0yfM07e2KZc6xtSue66ByhAT07yOmnFRddCmHgsEmmlLoOBfdDAQYNSjpU7dvFK2XgU4cqCOtD258Oa9Me9cvrnSsffrrAVEfUdUL9sHh7LN/EwXMb9byMpTKi387LSBVLg531ubqw+z//7PHl3E/PI9x5qX+PpWKpn2sBBJ+XeqN2xMQZZukpvaGtDwo4ZT7zIs051u99XdP46Ufa+GYUWrTv/2jXGLrs1Ph3Z5trWD8XpIvmGM+/Ez7jqZlirxU4p+fO5leZHhXv33QR5BbXXyoXn3e2PDVwdMYdSf0R1SFss7/8Vlo0ucwUS9He1MceuM0seZDqDx2+oesJ6ppcXe9pYYbKaGGFV0e9K326/f8Xm96Ze+zZ4XLVpXVMINX/1jL0OnRZK7jp3beWN17hi3l64eYca7GA1es3mmU0ps+eL8VOKpJRtl/bkfag6tyWed/8JG9O/dTMObs6xHzkVGtz3ugDDd66bqMWUgiuJKzPmTLjS+On66tS5U8keG5jLJUR/XxeRjpvAofatr75amnU4LxMc5JT7ZyLZX9CnZexVCz1ey2A4PPSa1tvvvep6bkrV+ZUeazv65kKq+nvrG6nv7Val6Je3epy123XmhvdqV41N9KcY68HT5fOC5z24/Wg+nVuY6S6JnoTu+szQ+SWJg0O61XXzpZJ0+ZI1Yqnm+uye1s39eVycLF8/9k+h/BpK+bD5+sXvc7v1PLf3kP/TedhjH3nYzOn4JlH2pj1k7Qibs8Bo8x/6xeg/iAPG/eBHFfoaGlx/WW+0QucQ6UVXT//erHpLfZ+GLX4hPZ6ekU+Au/spku6+VHVpSL0TlyViqenvFvgPDO9C6kFm3S+cZ0alcxacWefVd6sTxjuwsKr/Provbf4ZhHpQDP9kdSh7zqf2FsbVNudrh3aq3PriPNdUr5xBexg4HkZS2VEv5+XwW3DC1ha1EmXUOrQqnHUIkM6z13XY9V53jWrnZnyFb6Dz0u16vNou4zfz8CKpVq5e/CY98XvtQACz0uvzWmvuv4O6neY3ozVG216E03D+jMvjjPz2PWG4zFHFTQ1J8a984mppO6HETDBUyk8P+011ory4Xrw/Dy3MfC8DPTT73gdpRdc1E/boT5Pl255csAoc4NNR7Sl+s2NRF0PED4TJZ2C76MX/FrxtUCB/GaOWftW15lFuYMvePXH9tslP0unu5qloEL0XdJArhU3n+rcWk4+8XgT0HUYbrf7bjHzo/Tu+L2PvSSNLqsjLZo0yOhB0AsSHUZ5rI+WY9Ef0emzF5iFyrW3veFldcNWttUfBq3mlz9/PjMEV9dE63B7Y1PVTgs1aLEZP1R41Rao+//EgFFyz53Xm2HIsa6fSmXEuaZypAb24MqInJeZv9u0aI4Oe//ki2/MVAGt0h3tQkxvgPTsN8pMRdDHrC+/kycevv2w5amif4sm5zOiVSz9fskv1AKIcGi1roQulXHM0QXNyKtrLz/P3Mz+fukqub3ZFVLhjNMywmaoAJucrcbuU+vcTi1mpfMVv1iwWG5vdlXYebGR5jbqSCK/LN+i1649+4+S+udXlxmzF0j3+28Lu1zZ4mWr5dWRU6R3t3bm+s17aJhNT09jVJFdc814NuEzi3B+38yb1L5nzz6z1EOePHnNpG7tgXn2lfGmguupp5yYMRdN5274qeczsH2o1UefLZRBb0w1YUiLKGgPlRaO8S7evDlDa9dvlqe63GmWyPDzwxu+rL2/XTveLBfUqnpY0QBdR/XhpwabxaN/27zNLFR+qJLwkTJx6mzRYVvhtk1FW29pjBpVzpA1v242u6jL/USa80llxHmmUmu4yoicl5nPFL1A1UcsF6kavB5/boRcVKeaXH/Vhea7Tiuoj5vyifTqcmdGD30qnouB+xSuYqmuDx1LLYBU9wm3f15Q0iGPTa6+yFT9XrV2gxlZpd/rerNozOSPzTJS111xftQbIans6A1V1t7fh9s3l7o1K4csshNubqPevOzWZ6gpMKk3wP2w/rh3jfHF/B/l8QdbSoVypQ5rQ16F/csuPOewZQg1lGrof7DtjXJh7SqEUMsTjPBpCcbTDwnoXZ/vl/4iJYufKMVOOiGDRYOWVn59acQUaXBRTSl2YhGZOPVT6dejfcjJ7/o6/x04EHbNqlTy3rt3v/y+fYecXLRIyGGQ3jy9H376RXo8dLvv51DpsddlM/oNelPOPbuiWacx+KF3MAePmWqGw5x2arFMf9ZttRiKLnDepcPNclaFMil/gaLh4Oc1v5kAXqZUsag/iFRGFDPfOlJlRM7LrH0L63nX/dnh5tzTyqb68GuF71AVS2OpBZA1+dTYSgPVou+XS7WzzsgIQzoM9989+8wSLXozQ28OPTFgpDzUrplvpltEOro6VFmXb9MhonpzI/ARbm6j9/226IcVUrZ0cTPdx0/zuPU6QefCtm7R0HSYBD5mzlkkMz6dL8880jZTIPdCaYWypcyNXi2a5ZdrjHh9uxA+4yXp89fRLzAd/qHz9PShF8EaTrWapN61DJ787nHp2l3deg+TW5s28F3RCr340MJE9c8/O6P1qEe/1ybKc4/f5avlVyKdPt7wFn2OriWo68J5y9Xov+ncPe391PU/gx/eHDXtjW9Q7xxp1exK3yy47VlkpTKiBrLvfvzZ3Bg6+6wzfDGPyvPK6nm5et0meXH422Zd5GuuON8XvQeeWXDFUv13vdmmQ8GvrF9LLrmghgkLugi8zrHyagT4+WczlloAwT46tFS/A3/duFWaX3epVD6zTNRlJFLJWL/r69aoJOfXqmJ2S9tYzwEjTe+n35b4ieW4xjK3UUcQ9XhuhDz2YEszZUMDrN7Q1VFt2iPol6krnqc3N1QddGTCvXc2OWytVA2ls7/61kzZUJ+fVq4Tndut17o6yoNHdAHCZ3QjnhGDgPZAde87XFo0vszMBdIFpfVCTBeTfqDtDRGHWHlfdlpNTOeFhhpiGcNHSLqnaNDs/uzr0vH2xmYIblpamik+oXfVIlUo9WsFNv0hfe+jr0TnKXpDk712d3/rG+TsKmcc1ga8oTX6Y6HFncqVOdQD45dHViojrvttizz0xKty3rlnmdEKWu3vwbY3mMrWfnhk9bzUC+Ftf/5llrnRuY2PP3ibqUTsh0dwxVJvn3XI6XOvTTBVvC+9sKYZBaMXaFrh2++PaLUAQvnohfHO3X/L8l9+lXFvf2y+z+65s0nYefGpZjzj0wWmZoK3fqXOCX36hTfCjqzS/ffr76XueyxzG/XcHTN5pjz2QEu5sPah6S36W6s9z1qt328P7V1fv3GrHKFrZItIlw7NM40g0k6Wx557Xf7bf8DMFS1Z4tAUKb0xpEPDtQYFj+gChM/oRjwjRgENkbow9NxFS83doGbXXCwN6p0b8/BRb4hlnrx55PEHWvpifUK9OOv7yviMOXoa1qPN0/NzBTZvqR9dTzV/vnxm3s9tN1xuhmEFLicS2OOpc85uv+lK393B9U5bm8qI3nqhWoCnQ6vrjKneGX/25UPzuAMLLsT4tZCUT8vKeRm4ozq3auLUz6RP93a+6QENLPiiyyQVPPII0370nN24ZZsMHTvNzHfv/Wh4Ez+tqRpLLYBIJ4839E9HfDS46JykPM9sP7Tusy7zpoGyTKlTZNaX38r9bW6IOOfTz7+X6hvL3Ebv2iuWzgLbY5Zsz/euHXS6j95w1VF7wb2/3nWI9sT7ZYm3eB9Hwme8RXm9LAt4PaDag6Dhs2DBAll+rWTa0BuyrF9oxx5TMOo8Pd23cBXYkmm/XT6rXuj+/c9ec5dWqwEHVt302tEvazYwDyMIOVplxFDD2DRI9H5pnLS9pWHG3D2XY5cs22blvPT2TYfuDhj8lgx4ooPvhs9rb7sOQdMpGDc0rGd6At798Ev5fP5iM3fq9FKnhGwCfl1TNVotgHDni34HPvfam1LxjNNMJVi/PPS83LZ9p2zY/LuUK32qFD4u+vrhfv+91LYRPLcxuDqwd/41u6a+6QH1+8Mr4qThXdcADb6Jqz7a8z5gyETp2/1u39yYjVe7IHzGS5LXCSugX2rPvDBGLr/43JB3aDV0ffb192aYrjfR/Yj8+WTCu7NNT+oNjS42pfoD1xlNdW5dnmb67Hny2P0tD/txjVSBLdVdIu1fVha+X/vrZrnv8ZfN8PC7br3GLBmkgTaVH5EqI+oFyaDRU6Vw4WPltqaXGwsd5tb3tQn8wP7vYuPVUe9K9/tuzRhuFdxW9OaHzjEuV7qE6ZHXR//Bb5k5tC2aXCZXXVI75XvhtY3N+uIbmfzB56bn5YJaVcwFXNEix4U9tVhT9RBNtN9LfY7+Zn469zuz9M2Anh3k9NOKi84h7fzUYKl1dkW5u+W1Zp3taEvhpMr3nIaAcOclv5eHH2W94aFeOmrIq5/g3cyoUrGs6UmO9ghcNzPac1Ph79rbPn32fDNNyhtlpQXUHu/7uhmyrD3x0R5+XQ4olAvhM1pr4e/OAloc4eURU+SeO643P5KBD2+4h/5b144tMl3Q6Z2mHTv/lo8/XyTTPvlaenVu7Ys5e/oFpUP29EdTw3jgcFJ1CleBLdBVh6N+ueBHU4TBm5PgfCBz8QvoGoQvDJssm7b8Id3uu1VKFCsa86dV71/WbjRttG7NSqb4VbB5zC+WRE8MVxlR52vrhcnmrdvN/LxZX3xrzluvwmQS7WLcP+onn39jLvI73XVTxsgMbT/aE/Pj8tUy7eN55n9b3niFubDTdXq9sLBt+w6ZMuNL8/deXVr7YlpBrAeANVX/Xyrc76WOQFi9fqN8tWCJuQgudlIRs6xGYFVTLfSntROGjJkqN19/6EaHHx6hzktvv2P5vdTAr7+XZUqeIpXKn5byoV2vrd7/+GuZNO0zeaLTHeZGxbxvlsoro96V/mFWJlDPg2lpMmjUe/Lb5t/NtdnVl9T2Ta+7Xo/pdJ8jCxQwRYiOOupIGTrmfflz52559L5bw04v0xoCfV4eJ6VLniIbN/8hz3ZvF/EmnB/OV91HwqdfjnQu289Y1nEM/MhaaGDBd8vMcNxY1pjLZbvr/HFiqcCmpdTnzPtBps78SnTom4aHp7u2kbrnVHZ+fz+8gBZneKzv69LjoVYx3cVMNRM9JzV0FzgivxlipIFKL07mfP2DvNr7gUwVhlNt37OyP3rBqnNhP5/3g5xV4XSpU7OS1Dq7glQ6o3TY7yh1HTbuA8mTR+Su267Nytsm9Ta6/2+9/5mUKn6SqVga2DMXaU1VvZn2w0+r5Ij8+aVmtTN9M49WD7bOH+7e93UzjLlOjUqmnZ19Vnk5qWjhsCFJK1zrzTQNErEMS03qRhXiw8fye6lhYtEPK0171CJOv2/bIR1ub+ybMOXNbRw4bJIs+G65Waqsd7c2UrPqmRGbg9rq74IWVnv+iY6+qoSuIzpmzJ4vr4ycYoo5aSVvvSY9IcKIDsXUa7HOvQbLDY3q+aZ9RftOIXxGE+LvcRfQITKP9B5qhmLpHSSdsxfqoevEac+B/p8OwdX1C/0aPiNVYFuyfI2pkrtv337Ta1enZmX56LOFsnTl2oh35OJ+YHPpC+qPrC4FoevRarAK99DCOo8/N0Ke6nynL8PnmLc/ltXrNsqdza+W44492tzIGPvOJ+ac0wrW4R5afXjLtj9NZcSDB9OkZbMrfLGcjQ656v3iWMOiPVCnnXpy2DCwbftfUvi4YyVf3jxmCO4JxxfKCJ/aW6VufpjjrhdsWkn5juZXH7ZouzqGWlNVe5p79htlpl7oQysJP/Hw7YetY5hLv36cPpb2qk+fvUCGj/9A7mx+lTS8rG5MlW1/WLpKXh75jrzw5L2+DJ+Rfi/Xb9hqil+t37BFbrzmYrn0gpqydMUaGf/ubHn20XYZXn6tXhrt99KbG9r06nqmSj8Pkb379pslanTEVaih7jqNasqHusRU5vVC/WxH+PTz0c+hfdcvNz1ZNVRGmpMyedocGfTGe1Ki2IkmoOpwynDFKnJoVxL2tuEqsOlQrB79RsjZVcrLzY0vNeEqeN2uhH3IXPpGOq/z3sdekrtbXhdyLova/rrxd3nu1QlSuUKZjCqverdSe9m1jf6182+zAHcqz6HSO9rzv/1Jxr7zsRlSpYVM2rZoFHXYtt4N1oIyOtTvxV73HbYmWi5tFnH5WN55qQV2ypctKR1aNT5sSJWGyyFj35f3Z841vQTaw/DIPS2kyPGFzNC3gUMnmTvnZU8rbkKszZDxuOxEgl8kcK5YtDVV9YaG3hDSitW6fp6efxqsxk35RHp1uTPiEl4J3q1sfbtYRwqp7ZIVa6Tfa2+aYOWZZeuHy4UvHu730lt6Sj/yPXc0kWOOLig6YkjXc7y1yWVyQe2q5tpk+LgP5O3pn5vf0+pnnWHmeEfr3cqFDFn6SNF+L6fOnCtfL1pqbtIG3jDTYnY6QkHnkK5au1HOLFcq5pUOsvRBc9FGajJs3DR5rc+Dh924/vN/64XqTd3gUWh+u8YIPGSEz1zUgP3+UfSHMz09LdN8Ox1y9NPP66RNi4a+mIcXrQ0EV2DT53sXJvO+XWbWP/ti/o8mrKtZpLCkF8V+GMKsZitWrTfzWnQJEW1n2qu+cvVvZii3luvXiwwtmR64NJC2Ow2kOofq6a6tGS4TpnHqhd6IN2eIXnx46+9Fa8ep9nfvvNR1aJ977G456cTjzS7my5vX/K8aaUDXYc2Nr7zA/Jv2xj/yzFBTrKLymaVNYScdktv9fv9c6EZbU3XX3/9K92eHm6rVZUsfWqNXe5z1vNTh8X4qQmfazKZtoktAnHt2RWl14xVmbUEdHq8hft63P5l6AKVLFpP2La+TuueclVE8Tdvf5t//NEMG3/7gc7m/TVPTi5rqj1C/l96/vfnep6YOxdZtf8ryVb9mjBLSwld6o6h/zw5StEhhmf3lt2YUSI8HW/lidELw72VgG9GRCzp8tEvHmw+7yejVCtBOAx2OqjU6/DCaQ330ekLnc55VoUymay4973TUnn7PhZoX6udrDMJnqn/7JtH+6fAqnXvgrS+oH11P2oFDJ2caDhNpl/xcTWzjlj9k0Oj3ZN43P8krve8389DCPfRub7c+Q6VGlfLSokkD38yh0nk+PfuPMsNLNWjq/msPX5HCx4YdLqMVl/s97s+5U177iVR9+Ze1G8zw06cfaSOlSpyc0eT0QuXBJ16VU046wRTgUetUrySsPSv58uWVaZ/ME72507ThRRntav63y2Tqx3PlyYfvMEOU//xrt6mU2LlDcxOs9ELl+SGT5LxzKpseGL88Iq2pqlU5nxgwylzMXnJBDWP51cIlogHhmUfa+KbnM7AteDdpt+/YLZ2efM2cU7oeYY0qZ0j500uauaHeQ3uidArGB7PmSYVypaRqxbKiN0i06EngueqXtha4nxoYdHjuG5NnSv/H25v2tW/ff9JzwEjRIaVeL5Vfl5ryrPSa6t89+8wNbb3JuGfPPul4x/9XfI019MtrNwAAGuNJREFUnPqpjemN2AIFjjA3Nno8N0J6dro97DJl+tvqx2sMwqefzohcvq8aDJ5+cawce/RRZuL/UQULyGuj3pO09DR5+O6bwvZ86g9sz34jzXIZK1b9anqpvLvkuXyX4/rxvAu1E4sWFv3/77mziZlbFvzw5lUt+mGFGUqqF8reEjeR5kTG9cPm0It5BQP0gqP5dZeYXqjgBaS9j+YNx9IehuDhMvq3DVu2mWHg2puayo9I1ZfVU5cV0V5lXYw7uKddA5hWEh467n2pWO40UzHXD5WEdY6nzms//1xdYuQy2bN3v3HSubMtrr9MVq/bJLO/+lY+nfu9qSTc48GWoiFMe0J1OGmkG0ep2NYiramqLs+9NsH8Llx6YU2ZOPVTU4W54aV1UpEi5n3yRrx8+NlCUztBhyZ739/qOXLih7L4p1Wm6m3NqnrjJ2/EczXmN06RJ3rLSv2xY6fZIx0WqdcQTz4/Wq6qXztjPqPtchopwpOxG1oI7OkXxpghyjpaI9yNC28ETKRwmmo24fZHb/BMnzVPtLKcFgkLNwot3DWGXr/N+HS+lCtzqlSpUCYlfzMJn345G5JkP7NaTUwnwT/Rf6ScXqp42LtySUKQ5Y8Z66T24DmhOlF+8Jip5o7m4w+2TPk1CBU42hyqSMNltAfrqYFvyAW1q4iu/VX/vLN9szxL4N1wDZFqoYWKAgt1hGrA+iPb9Zkhcs+d10u1SuWy3MaTaUOvjY166yOzbJKuc6nDkrdu22GGrnW6q5nUrlFJho6bZob2FT+5qLRqdqWpZprKc4tjPYba41TwyCPMhZf29m3css0Uitm1+x/p/Wg734zWiOblfX//smaDGZ6sQ//+O3BQxkyeKXMXLTU3bvXfdFRRLOdqtPdLlb9r4UOdq63fXd5al7pvOgKr/6C3zJDcC2tXEZ3P9/3SX6THQ7f7Zg5j8DHW82/uoiUyZMz75ubZFfVrHWahnrqkSHA41d9SvTY5+cQiojfltAc1UgG7VGlf3nn577/7zNqgwUveRbrG0CHM+tuqa/nqjUqdX1ulYviRbMloRvhMxqPmw88crQJbuB8S/bLbtftfKVOqWErePQpsCnqxq3Okip1YxPzz7r//NT0uJ/9v/pn33PFTZpkLE51rdmHtqmbYlvpq8NfhgLrOnN4l10JPqT5MUudQ6ZqW2vOrBRK8R7iiTbqeqN4Z114G7XnRu+evjX5PKpQ7LWT1zlQ8VXVIkRpUqXC6fLFgsdze7KqQVQ/VRocG6pIQGrgefmqQPHJvC9+Ez3DHXoeMrlm/WR5uf5MJmXrj7KnnR5uhydUr+yOYRzsvdPiyBgMdQnpDw3qSP38+M2f28/mLTcVIvxaeC+fmFdgZ984n0unumzK+8/X7rf+QiWaJGv0tbH1zw4gVSrXYjs6F1/UuU32JFv29U5NTTznxMFYNDpM/mGPm0Or0gZefuc+sme33h15jqEm9OtUyFWDyRsDob0LgVAPPy5urrMWwXuvzkJnj7oeHd15qewquDBxrYUgdzdf3lfGHTWtJdj/CZ7IfQZ98/kgV2HSIwtMvjjF305o2rJchogsifzxnkUz58Ev5bePvcn/bG8xwmlQPVAqgF/5avEQL6gx86t7Dht96PwY6zOiBtjdkDB3VcKUXx7p8xr9798lj999mXP3QE6M/oDPnLJTaZ1cULUYRrmiTVrXTSs0aFtRF71BqQQotwuAVmEn109Ir2qEXu1qhtW7NyoedVzrfpfuzr8vO3f+Y9qjnpg5B9cOw20jHX+csfvL5N/LYgy0z1lTVuZ46BD7w+yv4Ndb+tsVUy/1r525zcyjURXMqtTttY7O++EYmf/C5GamgS3Np73HRKGvqpZJBPPZFL4C19/3VkVOkfavrTO+6fn+FeixettoU29Hvs6svqWNGEaX6tALPYfZX35lRPzrnWr/XNTDoUPkypU7JVIci2M3PFUu1N/1QxeC/D1uqJtDJG+KsN5H8MvUi1PkV6zVG4LY6AqRb72HS6qYrUuoGCOEzHt/uvEa2C0SqwBbLhG39Ien76gTT0+dVm8z2D53Db6AFiDSYlytzqEpkcDEmb72uZtfUNy7BD10PrdfAN6T97del1JdeuMOiQ4u+/XGlDHpjqrnAf7XPg5ku8NVDe0l1CKn2DmvhmFKnnmyWuml85YW+aVeBfnpejXhzujRqcJ5Zd9EruOPdrNDhpgOHTZZbmzQwcxt5iBmC+9yrb5r5Zbro+LoNW8x/9+rSOmyPgAYIXd7gmZfGyfYdO+Xlp+8/bB4ytgiEEtCeO11KRG8yHpE/nymwFu0GkP7eDh3zvvyzZ6906dA86vNTQd67Ibvm180mcOvNM52rp2tnR/Lyc8VSvcYYNXGGWTKq9yNt5fKLzw3ZFMKNTEuFdmOzD9GuMbzXUtf+gybK5fXOMUU3l65Ya6qop9JyP4RPm5bDc3ONgN4J1wtcrU6nP6yhisIEf1i9eHtv5le+KgHuGWgI1eB02w2XZ8xv0TD63GtvSpWKZUOuf6nbanEPLfih89P88ggsxd+7WxtTQdKbs3jVJbXN2nmr12+Sh58cJLVqVDQ9BH6o5Brt+Guv+YDBb8lN19U3ZvrwKrjqkObrrjg/2kv45u+Ba6oec9RR0rpFQ6lU/rSIIwyile33DR47aiWgwyS1uvfdLa+1CpE6n12HPvd5tJ1vlrTxCl8dOHhQjjryyJiXConlBrjVQUuiJ3tDS58fOslMRWl2bf1Mn16vPbSCsI6OiTSyI4l22fmjhrrGCHxRNdVRCDpFqsX1l5oq1am2LB7h07kZ8QI5IaBDHV8ZOUVKnHKiGR4Zag0l/Vw6vC1P3jxyZtmS8vKIKeaur1d57Oc1G2TV2g2Z1nbMiX1JxHvql5nenZw07TN5otMdpjrpvG+Wyiuj3pX+PdpnlN3XQPruh19JyeInSdETjjNV7m5terlv5jMGHguvXLpWkAx1ITbj0wWydMWaiJWYtZdLh0uWPOWklJ9DpXZ6XvZ+eVzGcG3tFdARB70635lpTm0i2nwyvocOY9PhtMHFKXRfvDlCwWX7Nchu275DDhxMk1NOKmIVMJLRiM/sJqBLjGhPSp2alcMW0PEqouucbi3Io8NRdf1oLYRSr24134RRT1qrvOrw2nOqVThsekGkquhuRyq5ttZAtX//f+Z6LPARayFE3UbXqtUb3l3a3xzyOzC5RKJ/Wu8aQ0ckfPz5NyagB8611lFD51Q9M+I87WS9xiB8Rm8fPCOXCnjVJLUS3X2tbwjZc+ANpdHhkTq0VH88NEx4E+R/XLZa0tLTTc/eBbUOFd9J1Yd3h3LgsEmm8uFppxYT7dmrWfXMjF32nvPS62/L2VXKy0V1qkqVCmVT2iWW460XGDq8tn2rxhlDIz/96jv5aM7CsD3pOlxGe0drVC0vWq5ei17pkgipPodKz7kBQ96Sz77+Xo4/7ljpdu8toj3Gfpg3HEtbCvccHR55T/cXM+bGBnrpTaH+g98ycz4Dy/b/uWOXPDFgtOzc/becXLSIrP1tswkLgcWzXD4T26aegFa81Xmdr/Z+IFOVV91TXRrpp5XrTLGdZT+vkwE9O5ppG/p7uXjZKln0/QpzE1N7UXWqQSr/XnpHXqcS9Bv0pik8FFxlOdbRCHqDaN/+/b6oJK9u+nv3+oQPpOGldU0lfV3GJni5slBnlldVt9+giXLZhTVNXQU/zPHW7/fBY943I6x0eLwG+GjTotQvma8xCJ+p99viuz3Si93vf/rFDPn4v/buPd6mMo/j+M9MObogk0tuHTFiIk0uJSKXNHJJTRIlRQgzDSZkTqgojkKaiXKvF51CSXIpQ5SME7mX6xBCuaR0eYnXq17z+j5ae/Y59jln730Oe5+9PutP1tprrfd6zt7r9zzP7/eo2uu3x3/IkF+mP1BNX3i0V4fANJrgaTKqCqsfF20DH77XypS61FeG6tHVphw0b9MIVvq6Le6LkKDhtMq6zTts7KQ3rG2rRnZBUkF7eda7rnjHnxrVCdle/jVljltoWgUWtM1ZuMI06pDVml++anTcbEgBLSNSqFDSGSNSmoKlgjFPD+wWqGTqraunKeBaJ1SdGhrRmpy2wJXmT/RqpTSh6AT0oqvfyWJFC7s6AOs273RLYaxev9WUa1b7miquA0RL/oQqTKQKsSmpk+3B9i3CCiiiu8r4OkpVgLV8TeFMo3rZVSzV3+eRr4/b4g/W2JsLPjCNck145hFfrEGue9934LCNfmmmnTh5ylJTukcURMp74dJ0VyjLL2uQ6561CsGCJeluCS7Nqqrw6xrQWXVY5+d3DILP+PqO42pyKaAAYdy0ufZk/85u6qi2DZ/+11ShdOSgh1zpfvUu9Rv2orVuVs9aN7vBBVfqcdMIarnSxa1Uid/l8iry1+FaDHn5qo32WO+ObqRKm6aUqlLuoN73JVyuQW6ejkbbl65YZwcPHbXG9a9105ezCs710qEXOk0JV8EKdYJMe32Rpfyto6sQyIZAdgL6ntLSIvVqV3OdY01vrJWho8PLpVKOlbcMhKZgaZrzA+2a++IllxaUO4Htu/ZZ9/6jXR77A3c3d9//OXU2enncOVVnzt2Vxe/ROVUs1d+t1md8Y/4HllzuMru9eX1bs3G7/fLzL75bg9wbyZw2c5HrECtfpmTYD1a/tXpv+/a7H7NMqwr7w/LRjkePHXdpPklJBe0PlZOzXVs2P79jEHzmo0bJpeYsoB/Gd5ettomvzrc2t9R31cEmTJ9n3TtqmlB99wHq7V27aYdbn1F/3JoKmTlPIeczJc4e8tDI8Pwl6a5YzIkTJy3traU2dEBnX1S5ze2TzJwPpKmQ41+Za/sOHHF5ehr5bFK/pivbn1yulK9LzefW2k/H6yV3xceb3Gh7+dIlLPWx7lak8EUBAk2RHDkuzWrWqOJmfWhTe3t81DRXOVedbwpQvzz8tZuuq443NgQyC2i0c0raAtd2endta9WqVMg2AN2x6wtX5E+5x1qXVr+5Kmqk9pbTsYmgn13FUk3NHfLsNLur1U1W/7rqbjaCKr0O/+cMG5HSLRB8aQaM6lEoJaNSctmEn74sswIFzLWrnHKO1Z70fvbkmFfc4ICm3moEnpzj/+cch/OOUaDAb1wnuYpyxuM69wSfifBtyD2cIaAvOCVwa4pQ7RpV3DSGzPkpXjn5EydPZls0xi+8egnRunonfjplDetek2P1Tb+4ZHefmfOBkgqe74JM5an07HSbHfv2e+s/9EUrWaKYtbq5npum5uUcL12x1uYtXuk+vnnj6+2Wm2r7JieIthO+gJfb/snGHTZsQOcMMzNUzErLIWltWo1evf3eSvvuhx9dDvviD9e6aW831KpmKvzUrEEt63pvq2x70sO/KvZMJAEv11/VbatUKu86ZIM7OpSasnnb527954/Xb7F+Pe4O5HEraO0/7CXTeoSVksu4/wtVMCuRvHQvoSqWen+rq9Zuce8UlSuWczMRrq56RYZKrwpSVVxHAaiqhAfP1Eo0p8z3k13OsZbuUo7ozt37bcBfOrjluzxrco5P5xyH847x298UcDmkK1dvdqsZKH/7kR7tMtT3iHU7I/iM9RPg/OdMQEuGKB/0qiuTA+fUVMhnxr1uIwd1910Fv3MGn+AnCs4HUqdHyohJ1r9n+8C0R037njHn3za0f2fXE66pkcPGTndBgAox6Mdk7rsfueVbhg3oQgCa4O0l2ttTAHDhBUluCnfwSIJegrU+7TuLV9maDVttfGpfN1KggKBP17auw0P7jJkwyy0JlFWOcrTXxXGJI+AVFrq6SkXb/9URV1Fe318aNdf070b1rrWaV1cO5IIGF8Lq3P5WtxatisVoxEr58KFyRhNH6/SdBFdF9+5NdSiemzTbtDZ0yeLFXBGwUDnYCvo/Wr3ZXpv7fpb7JJpXcM6xd29eID/19UU55nj6Pec4nHeMPV985WbAPPXog260XQWgNEumT7e2EU19Ppttj+DzbOry2XElsGbjNhs39S0b1LeTy9Xzyslv+GynDe57PyMCcfW08ufF6Ef06bHTrcmNNQPl0VUE5rmJs23U4z2tyMUXuh5JLVnQq1Mbu6RoYTci760vx9TI/Pncz/VVazmCn3/+xe5s2dB1XqhC6YgXXrV2rRu79VQ/2bTdZr+zPEMlZgUG6eu3+mrN3nP9XBLlfJrRoXy7RctW25P9HnCdFqFyQVUISyPvo4b0DBT50+jfmg3bA7M8EsUk0vtwtSWGjne5/t3ubWXt2zQNOb320NFvLGX4JFdzoWJymUhPk+/316yMkS+kWdnSJdyoeU7Vbck5zv4dQ4XE1FH5WOpkl25WveoVgfW21RGpVR/iYSP4jIenwDWcEwEvl0DrEF5b7fduiZX1m3fa6Cd6uWCUDYG8ENBUyGfGpVm92tXdcjYz337fata40lW53bR1t3tZ63B7U1dlUvl4yp26ovxleXFqPsMnAt70PlWDVIVcrWOsF7d6daq7IOGz7Z+7wmsjUrq7ERd9902cMd/lXemFhA2BnASCK5Zq3wG9OpwxnVbLQahgnWoG9Livtd3apG7C5y/m5Ob9/5yFH7qpypp+qy24roT+Pie9usBaNL3eVq751BTsD+7TKVCNP9xzJMJ++i5Tyk/Fy8uE1XYy5xwngkGk95DVO4YqAy/7zwabNW+ZyfX8886z4SndTGaqHRDcSRTpOfN6f4LPvBbl8+JeQNMkt+/6wk6ePOVyMtRTxIZAXgpoBFTL1SjXos4fq/46cmD2/OQ3rVSJYi741KZ99OKm6TEsjZGXT8Dfn+UVEdOLyEMdW7u29fTzM2xI306sAervphHx3Qevvdj57uYZche9D1MOY0rqJOvSvkXcjKxEfKN5eICKganabc0ala1KpcvP+GSZqiLuivRN1rFtM6t4eWk3nZ4ttEB2Ocd+NQv1jrF52+nOba3soPxrpfNMeW2hK7bZomldK3tZ8bjhIviMm0fBhSCAQCILqPKoihG1v72Jq7KsLVT+RiIbcG9nX0CBp/ciq6BA5fhnzltmzRrWtoe73MFL7tl/BAl5Bo2kqONWnbValiy5bClXTd7bFGztO3iYad0hnr4ChSUr1trNDWoF0ntC/R4kZMOJ8qY0XTmnnOMoPzphD9No+579hwJ/g14aULObasddpxDBZ8I2Q24MAQTiSUBBwegJs1z1ZeWEalPOlCqSjhrSy0oWvySeLpdryYcCKiyh9tTj/jZWoVwpFyy8Mus9FyxodL3EpbSxfPhY4+qS9T2mKdyq5N27651uOqmKqGmJEX2vecv+xNVFx/hi5PPU2BlWqUIZt3SIis2pY0hL1vzjr/cwGyHT8wk35zjGjzXuTq/iYNPfXGxP9OtshS+6wC0rqA7vq66sEHLGQixvgOAzlvqcGwEEfCWwa89BGzJqqjVvdJ0VLXKxW4O26z0t3TIZOS3u7isobjYqAW/JjDETZ9nH67a6YkTtbmtsPTrdZpcUuTiqz+QgBDILaEQlza0NvcrlGW/dudetJTu4z32uojfbmQIqMvfCtLdMBehUc2L5qo3W8ua6bkkuptye6RVOzjHtLKOAl26hehJ33NrA9h44ZAuXptuzg3vETZVb74oJPmm9CCCAwDkU0PQ1FZk48OURa3B9DVclksDzHD4AToUAAnkicPTYcdu996AlJRV0qQQa0WPLWkAB1ZeHj9ne/V+5ziDlg2Zefxy/jALh5BxjllHAW7O9UKEkt354PNY1Ifik1SKAAAIIIIAAAggggEBcCgTnHMflBXJREQkQfEbExc4IIIAAAggggAACCCCAAALRCBB8RqPGMQgggAACCCCAAAIIIIAAAhEJEHxGxMXOCCCAAAIIIIAAAggggAAC0QgQfEajxjEIIIAAAggggAACCCCAAAIRCRB8RsTFzggggAACCCCAAAIIIIAAAtEIEHxGo8YxCCCAAAIIIIAAAggggAACEQkQfEbExc4IIIAAAggggAACCCCAAALRCBB8RqPGMQgggAACCCCAAAIIIIAAAhEJEHxGxMXOCCCAAAIIIIAAAggggAAC0QgQfEajxjEIIIAAAggggAACCCCAAAIRCRB8RsTFzggggAACCCCAAAIIIIAAAtEIEHxGo8YxCCCAAAIIIIAAAggggAACEQkQfEbExc4IIIAAAggggAACCCCAAALRCBB8RqPGMQgggAACCCCAAAIIIIAAAhEJEHxGxMXOCCCAAAIIIIAAAggggAAC0QgQfEajxjEIIIAAAggggAACCCCAAAIRCRB8RsTFzggggAACCCCAAAIIIIAAAtEIEHxGo8YxCCCAAAK+EZiz8EOb/c5yG5/a14oVLeyb++ZGEUAAAQQQyGsBgs+8FuXzEEAAAQQQQAABBBBAAAEEzhAg+KRRIIAAAgggkI2ARj7T122xof26uL2GjJpqdWteZXv2H7IpaQvcvz14T0v7e/e7cEQAAQQQQACBbAQIPmkeCCCAAAIIRBh8LliSbi8/P9DqXFPVvjn+vfUa+Jzd1bqR/blFQywRQAABBBBAIAsBgk+aBgIIIIAAAhEGnxr5DA40g0dHCxUqiCcCCCCAAAIIhBAg+KRZIIAAAgggkMvgc83GbTbmpVkUJaIlIYAAAgggkI0AwSfNAwEEEEAAAYJP2gACCCCAAAJnXYDg86wTcwIEEEAAgfwskFXBIabd5uenyrUjgAACCMRCgOAzFuqcEwEEEEAg3wjkFHzu3nvQHhow2oandHMFiNgQQAABBBBAILQAwSctAwEEEEAAgWwEQgWfqnYbvHmVb4FEAAEEEEAAgawFCD5pHQgggAACCIQp8NNPpwLrfLKsSpho7IYAAggggMCvAgSfNAUEEEAAAQTCFCD4DBOK3RBAAAEEEAghQPBJs0AAAQQQQCBMAYLPMKHYDQEEEEAAAYJP2gACCCCAAAIIIIAAAggggEAsBBj5jIU650QAAQQQQAABBBBAAAEEfCZA8OmzB87tIoAAAggggAACCCCAAAKxECD4jIU650QAAQQQQAABBBBAAAEEfCZA8OmzB87tIoAAAggggAACCCCAAAKxECD4jIU650QAAQQQQAABBBBAAAEEfCZA8OmzB87tIoAAAggggAACCCCAAAKxECD4jIU650QAAQQQQAABBBBAAAEEfCZA8OmzB87tIoAAAggggAACCCCAAAKxEPgfkpLcEDlqWacAAAAASUVORK5CYII=", "text/html": [ - "
" ], "text/plain": [ "alt.Chart(...)" ] }, - "execution_count": 21, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -3012,58 +3450,258 @@ "source": [ "alt.Chart(top_10_visits) \\\n", ".mark_line() \\\n", - ".encode(x=\"_time:T\", y=\"count(http_status):Q\", color=\"src_ip:N\")" + ".encode(x=\"_time:T\", y=\"count(status):Q\", color=\"ip:N\")" ] }, { "cell_type": "markdown", - "id": "ef7fee9f-721e-4146-9de3-f01115c6b6a5", + "id": "3dc84a01-9a58-4115-bad3-cf940017b57d", "metadata": {}, "source": [ - "## Indicators of Attack" + "### Significantly Noisy IPs" ] }, { "cell_type": "markdown", - "id": "b0a8d73c-9047-4b8d-8f6a-78c143faa743", + "id": "8d510d7d-b407-456a-a80d-f8f789728c50", "metadata": {}, "source": [ - "### Big Missers\n", + "Is there any reason to be concerned about any of these IPs? How can we tell?\n", "\n", - "Source IPs where the response was `401`, `403`, or `404`." + "Through the power of ***MATH***" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "6f76b08a-2aaa-4be4-a681-c0c6b525c1c3", - "metadata": {}, + "execution_count": 34, + "id": "37b968a5-1a45-474a-9c59-9387dbd015eb", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, "outputs": [], "source": [ - "fails = [\"404\", \"403\", \"401\"]\n", - "fail_visits = df[df.http_status.apply(lambda s: s in fails)]" + "# Aggregate top 10 visitors\n", + "top_10_counts = top_10_visits.groupby(\"ip\").count()" ] }, { "cell_type": "code", - "execution_count": 17, - "id": "62cc2a50-9c21-417d-ba5b-8fee635611c2", - "metadata": {}, + "execution_count": 35, + "id": "b75fee34-3b5e-4ac3-b18c-818a966a391b", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, "outputs": [ { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "alignmentgroup": "True", - "hovertemplate": "src_ip=%{x}
http_status=%{y}", - "legendgroup": "", - "marker": { - "color": "#636efa", - "pattern": { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average visits per IP: 171.9\n", + "Standard Deviation: 129.57\n" + ] + } + ], + "source": [ + "# Calculate the average visits\n", + "# counts_df = df.groupby(\"ip\").count()\n", + "counts_df = top_10_counts\n", + "avg_visits = round(np.mean(counts_df._time), 2)\n", + "# Calculate the standard deviation\n", + "visits_std = round(np.std(counts_df._time), 2)\n", + "\n", + "print(f\"Average visits per IP: {avg_visits}\")\n", + "print(f\"Standard Deviation: {visits_std}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "5d930017-a553-49bd-8a35-e8b91bd7d72e", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Calculate significance threshold\n", + "n_sigmas = 1.2\n", + "alpha = avg_visits + (visits_std * n_sigmas)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "f8edabe4-7728-40e8-bce3-e70e47d33542", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
remote_log_nameuseriddaterequest_methodpathrequest_versionstatuslengthreferreruser_agent_time
ip
46.105.14.53364364364364364364364364364364364
66.249.73.135432432432432432432432432432432432
\n", + "
" + ], + "text/plain": [ + " remote_log_name userid date request_method path \\\n", + "ip \n", + "46.105.14.53 364 364 364 364 364 \n", + "66.249.73.135 432 432 432 432 432 \n", + "\n", + " request_version status length referrer user_agent _time \n", + "ip \n", + "46.105.14.53 364 364 364 364 364 364 \n", + "66.249.73.135 432 432 432 432 432 432 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Look for any values that exceed our alpha threshold\n", + "significant = top_10_counts[top_10_counts._time >= alpha]\n", + "significant" + ] + }, + { + "cell_type": "markdown", + "id": "ef7fee9f-721e-4146-9de3-f01115c6b6a5", + "metadata": { + "tags": [] + }, + "source": [ + "## Indicators of Attack" + ] + }, + { + "cell_type": "markdown", + "id": "b0a8d73c-9047-4b8d-8f6a-78c143faa743", + "metadata": {}, + "source": [ + "### Big Missers\n", + "\n", + "Source IPs where the response was `401`, `403`, or `404`. This can indicate brute force browsing with tools like Gobuster or ZAP/Burp." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "6f76b08a-2aaa-4be4-a681-c0c6b525c1c3", + "metadata": {}, + "outputs": [], + "source": [ + "fails = [\"404\", \"403\", \"401\"]\n", + "fail_visits = df[df.status.apply(lambda s: s in fails)]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "62cc2a50-9c21-417d-ba5b-8fee635611c2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "alignmentgroup": "True", + "hovertemplate": "ip=%{x}
status=%{y}", + "legendgroup": "", + "marker": { + "color": "#636efa", + "pattern": { "shape": "" } }, @@ -3086,22 +3724,32 @@ "131.107.160.94", "14.140.163.52", "14.160.65.22", + "144.76.194.187", + "144.76.95.39", "157.55.34.93", + "173.236.32.219", "176.92.75.62", "183.91.14.219", + "184.154.137.213", + "185.38.249.133", "188.165.243.45", "190.250.238.82", "192.185.81.134", "192.185.83.181", "193.244.33.47", "194.186.207.105", + "195.211.162.22", "195.250.34.144", + "198.143.145.210", "198.245.61.43", "199.102.67.16", "199.116.117.212", + "199.168.96.66", "199.189.248.95", "200.31.173.106", "204.62.56.3", + "207.241.237.104", + "207.241.237.220", "208.115.113.88", "208.43.251.181", "208.50.255.30", @@ -3120,6 +3768,7 @@ "50.87.144.128", "59.163.27.11", "61.140.183.41", + "62.225.70.202", "62.24.122.25", "63.140.98.80", "66.147.244.126", @@ -3128,10 +3777,13 @@ "67.215.172.14", "69.171.237.10", "69.171.237.9", + "69.175.14.230", + "69.175.87.242", "74.208.16.115", "74.208.180.23", "75.67.42.229", "75.97.9.59", + "76.164.234.106", "78.173.140.106", "79.171.127.34", "80.108.25.232", @@ -3145,9 +3797,10 @@ "89.107.177.18", "89.107.180.34", "90.175.31.133", - "91.236.75.25", + "94.153.9.168", "94.242.255.188", "95.78.54.93", + "96.127.149.186", "98.130.2.118" ], "xaxis": "x", @@ -3164,22 +3817,32 @@ 1, 1, 1, + 2, + 14, + 1, 1, 5, 1, + 1, + 1, 3, 1, 1, 1, 2, 1, + 1, 3, + 1, 3, 1, 1, + 2, 1, 1, 2, + 1, + 1, 3, 1, 1, @@ -3201,6 +3864,7 @@ 1, 1, 1, + 1, 8, 2, 1, @@ -3209,7 +3873,10 @@ 1, 1, 1, + 1, + 1, 6, + 1, 3, 1, 1, @@ -3223,9 +3890,10 @@ 2, 1, 1, - 8, + 1, 1, 3, + 1, 1 ], "yaxis": "y" @@ -3237,9 +3905,6 @@ "legend": { "tracegroupgap": 0 }, - "margin": { - "t": 60 - }, "template": { "data": { "bar": [ @@ -4057,6 +4722,9 @@ } } }, + "title": { + "text": "Failed browsers" + }, "xaxis": { "anchor": "y", "autorange": true, @@ -4066,10 +4734,10 @@ ], "range": [ -0.5, - 74.5 + 89.5 ], "title": { - "text": "src_ip" + "text": "ip" }, "type": "category" }, @@ -4085,17 +4753,17 @@ 63.1578947368421 ], "title": { - "text": "http_status" + "text": "status" }, "type": "linear" } } }, - "image/png": "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", + "image/png": "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", "text/html": [ - "
" + ], + "text/plain": [ + "alt.Chart(...)" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "alt.Chart(post_df) \\\n", + ".mark_bar() \\\n", + ".encode(x=\"_time:T\", y=\"count(status):Q\", color=\"ip:N\")" + ] + }, + { + "cell_type": "markdown", + "id": "677688de-a1d3-42f0-9c8b-9f60d5f5c187", + "metadata": {}, + "source": [ + "## User Agents\n", + "\n", + "User Agents may indicate scanning data, or uncommon agents in your org." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "016a6f3e-dc68-481d-b569-edbc279e35cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ipremote_log_nameuseriddaterequest_methodpathrequest_versionstatuslengthreferrer_time
user_agent
&as_qdr=all11111111111
Mozilla/5.0 (Linux; U; Android 4.3; en-gb; GT-I9300 Build/JSS15J) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30 GSA/3.2.17.1009776.arm11111111111
Mozilla/5.0 (Linux; U; Android 4.3; en-nz; GT-I9505 Build/JSS15J) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.3011111111111
Mozilla/5.0 (Linux; U; Android 4.3; en-us; GT-I9300 Build/JSS15J) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.3011111111111
Mozilla/5.0 (Linux; U; Android 4.3; en-us; HTC_One Build/JSS15J) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.3011111111111
Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8L1 Safari/6533.18.511111111111
Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) AppleWebKit/537.51.1 (KHTML, like Gecko) CriOS/32.0.1700.21 Mobile/11B554a Safari/9537.5311111111111
Mozilla/5.0 (Linux;u;Android 2.3.7;zh-cn;HTC Desire Build) AppleWebKit/533.1 (KHTML,like Gecko) Version/4.0 Mobile Safari/533.111111111111
Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) GSA/3.2.1.25875 Mobile/11B554a Safari/8536.2511111111111
Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10B329 Safari/8536.2511111111111
Mozilla/5.0 (iPad; CPU OS 6_0_1 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A523 Safari/8536.2511111111111
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:11.0) Gecko/20100101 Firefox/11.011111111111
Mozilla/5.0 (compatible; theoldreader.com; 2 subscribers; feed-id=2e78188bde2b643b822a26d6)11111111111
Mozilla/5.0 (Linux; U; Android 4.2.2; fa-ir; GT-I8190 Build/JDQ39) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.3011111111111
Mozilla/5.0 (compatible; theoldreader.com)11111111111
Mozilla/5.0 (compatible; MojeekBot/0.6; http://www.mojeek.com/bot.html)11111111111
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8) AppleWebKit/534.50.2 (KHTML, like Gecko) Version/5.0.6 Safari/533.22.311111111111
Mozilla/5.0 (compatible; MSIE or Firefox mutant; not on Windows server; + http://tab.search.daum.net/aboutWebSearch.html) Daumoa/3.011111111111
Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; MALC)11111111111
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.1111111111111
\n", + "
" + ], + "text/plain": [ + " ip remote_log_name \\\n", + "user_agent \n", + "&as_qdr=all 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-gb; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-nz; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; HTC_... 1 1 \n", + "Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Linux;u;Android 2.3.7;zh-cn;HTC De... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_0_1 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com; 2 su... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.2.2; fa-ir; GT... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com) 1 1 \n", + "Mozilla/5.0 (compatible; MojeekBot/0.6; http://... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8) ... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE or Firefox mutant... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) ... 1 1 \n", + "\n", + " userid date \\\n", + "user_agent \n", + "&as_qdr=all 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-gb; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-nz; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; HTC_... 1 1 \n", + "Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Linux;u;Android 2.3.7;zh-cn;HTC De... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_0_1 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com; 2 su... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.2.2; fa-ir; GT... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com) 1 1 \n", + "Mozilla/5.0 (compatible; MojeekBot/0.6; http://... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8) ... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE or Firefox mutant... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) ... 1 1 \n", + "\n", + " request_method path \\\n", + "user_agent \n", + "&as_qdr=all 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-gb; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-nz; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; HTC_... 1 1 \n", + "Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Linux;u;Android 2.3.7;zh-cn;HTC De... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_0_1 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com; 2 su... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.2.2; fa-ir; GT... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com) 1 1 \n", + "Mozilla/5.0 (compatible; MojeekBot/0.6; http://... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8) ... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE or Firefox mutant... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) ... 1 1 \n", + "\n", + " request_version status \\\n", + "user_agent \n", + "&as_qdr=all 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-gb; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-nz; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; GT-I... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; HTC_... 1 1 \n", + "Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Linux;u;Android 2.3.7;zh-cn;HTC De... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_0_1 like Mac OS X) ... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com; 2 su... 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.2.2; fa-ir; GT... 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com) 1 1 \n", + "Mozilla/5.0 (compatible; MojeekBot/0.6; http://... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8) ... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE or Firefox mutant... 1 1 \n", + "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6... 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) ... 1 1 \n", + "\n", + " length referrer _time \n", + "user_agent \n", + "&as_qdr=all 1 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-gb; GT-I... 1 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-nz; GT-I... 1 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; GT-I... 1 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.3; en-us; HTC_... 1 1 1 \n", + "Mozilla/5.0 (iPad; U; CPU OS 4_3_5 like Mac OS ... 1 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 1 \n", + "Mozilla/5.0 (Linux;u;Android 2.3.7;zh-cn;HTC De... 1 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 7_0_4 like Mac OS X) ... 1 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) ... 1 1 1 \n", + "Mozilla/5.0 (iPad; CPU OS 6_0_1 like Mac OS X) ... 1 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv... 1 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com; 2 su... 1 1 1 \n", + "Mozilla/5.0 (Linux; U; Android 4.2.2; fa-ir; GT... 1 1 1 \n", + "Mozilla/5.0 (compatible; theoldreader.com) 1 1 1 \n", + "Mozilla/5.0 (compatible; MojeekBot/0.6; http://... 1 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8) ... 1 1 1 \n", + "Mozilla/5.0 (compatible; MSIE or Firefox mutant... 1 1 1 \n", + "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6... 1 1 1 \n", + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) ... 1 1 1 " + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Group by User Agent\n", + "agents = df.groupby(\"user_agent\").count()\n", + "# Look at rare UAs\n", + "agents.sort_values(by=\"ip\", ascending=True).head(20)" + ] + }, + { + "cell_type": "markdown", + "id": "b6938024-ff6e-45a6-a653-0669268b9476", + "metadata": {}, + "source": [ + "### Short UAS\n", + "\n", + "Short User Agents may indicate programmatic access, like by scanners." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "3c1b9825-07d4-40f8-bb97-307b413f24ae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ipremote_log_nameuseriddaterequest_methodpathrequest_versionstatuslengthreferrer_time
user_agent
-175175175175175175175175175175175
Feedbin - 1 subscribers5050505050505050505050
Twitterbot/1.01414141414141414141414
portscout/0.8.177777777777
Embedly +support@embed.ly55555555555
Python-urllib/2.744444444444
Wget/1.14 (linux-gnu)44444444444
fetch libfetch/2.044444444444
MAXX_MAUI WAP Browser33333333333
Ruby33333333333
Googlebot-Image/1.022222222222
binlar_2.6.3 test@mgmt.mic22222222222
Opera 9.611111111111
Robosourcer/1.011111111111
Wget/1.12 (linux-gnu)11111111111
Wget/1.13.4 (linux-gnu)11111111111
YisouSpider11111111111
ZDM/4.0; Windows Mobile 8.011111111111
nutch-1.4/Nutch-1.411111111111
&as_qdr=all11111111111
\n", + "
" + ], + "text/plain": [ + " ip remote_log_name userid date \\\n", + "user_agent \n", + "- 175 175 175 175 \n", + "Feedbin - 1 subscribers 50 50 50 50 \n", + "Twitterbot/1.0 14 14 14 14 \n", + "portscout/0.8.1 7 7 7 7 \n", + "Embedly +support@embed.ly 5 5 5 5 \n", + "Python-urllib/2.7 4 4 4 4 \n", + "Wget/1.14 (linux-gnu) 4 4 4 4 \n", + "fetch libfetch/2.0 4 4 4 4 \n", + "MAXX_MAUI WAP Browser 3 3 3 3 \n", + "Ruby 3 3 3 3 \n", + "Googlebot-Image/1.0 2 2 2 2 \n", + "binlar_2.6.3 test@mgmt.mic 2 2 2 2 \n", + "Opera 9.6 1 1 1 1 \n", + "Robosourcer/1.0 1 1 1 1 \n", + "Wget/1.12 (linux-gnu) 1 1 1 1 \n", + "Wget/1.13.4 (linux-gnu) 1 1 1 1 \n", + "YisouSpider 1 1 1 1 \n", + "ZDM/4.0; Windows Mobile 8.0 1 1 1 1 \n", + "nutch-1.4/Nutch-1.4 1 1 1 1 \n", + "&as_qdr=all 1 1 1 1 \n", "\n", - " }) }; });
" + " request_method path request_version status \\\n", + "user_agent \n", + "- 175 175 175 175 \n", + "Feedbin - 1 subscribers 50 50 50 50 \n", + "Twitterbot/1.0 14 14 14 14 \n", + "portscout/0.8.1 7 7 7 7 \n", + "Embedly +support@embed.ly 5 5 5 5 \n", + "Python-urllib/2.7 4 4 4 4 \n", + "Wget/1.14 (linux-gnu) 4 4 4 4 \n", + "fetch libfetch/2.0 4 4 4 4 \n", + "MAXX_MAUI WAP Browser 3 3 3 3 \n", + "Ruby 3 3 3 3 \n", + "Googlebot-Image/1.0 2 2 2 2 \n", + "binlar_2.6.3 test@mgmt.mic 2 2 2 2 \n", + "Opera 9.6 1 1 1 1 \n", + "Robosourcer/1.0 1 1 1 1 \n", + "Wget/1.12 (linux-gnu) 1 1 1 1 \n", + "Wget/1.13.4 (linux-gnu) 1 1 1 1 \n", + "YisouSpider 1 1 1 1 \n", + "ZDM/4.0; Windows Mobile 8.0 1 1 1 1 \n", + "nutch-1.4/Nutch-1.4 1 1 1 1 \n", + "&as_qdr=all 1 1 1 1 \n", + "\n", + " length referrer _time \n", + "user_agent \n", + "- 175 175 175 \n", + "Feedbin - 1 subscribers 50 50 50 \n", + "Twitterbot/1.0 14 14 14 \n", + "portscout/0.8.1 7 7 7 \n", + "Embedly +support@embed.ly 5 5 5 \n", + "Python-urllib/2.7 4 4 4 \n", + "Wget/1.14 (linux-gnu) 4 4 4 \n", + "fetch libfetch/2.0 4 4 4 \n", + "MAXX_MAUI WAP Browser 3 3 3 \n", + "Ruby 3 3 3 \n", + "Googlebot-Image/1.0 2 2 2 \n", + "binlar_2.6.3 test@mgmt.mic 2 2 2 \n", + "Opera 9.6 1 1 1 \n", + "Robosourcer/1.0 1 1 1 \n", + "Wget/1.12 (linux-gnu) 1 1 1 \n", + "Wget/1.13.4 (linux-gnu) 1 1 1 \n", + "YisouSpider 1 1 1 \n", + "ZDM/4.0; Windows Mobile 8.0 1 1 1 \n", + "nutch-1.4/Nutch-1.4 1 1 1 \n", + "&as_qdr=all 1 1 1 " ] }, + "execution_count": 45, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "px.scatter(visits_208_91_156_11, x=\"_time\", y=\"uri\")" + "pd.set_option(\"display.max_rows\",100)\n", + "agent_clean = df.dropna(subset=[\"user_agent\"])\n", + "not_moz = agent_clean[~agent_clean.user_agent.str.contains(\"Mozilla\")]\n", + "short_agents = not_moz[not_moz.user_agent.str.len() <= 30]\n", + "short_agents.groupby(\"user_agent\").count().sort_values(by=\"ip\", ascending=False).head(100)" ] } ],