From 14554660446426501ba86e767f80633386ce360c Mon Sep 17 00:00:00 2001 From: AntonWirsing Date: Mon, 18 Aug 2025 13:22:25 +0200 Subject: [PATCH] add functionality --- analysis.ipynb | 339 ++++++++++++++++++++++++++++++++++++++--- durationEstimate.ipynb | 316 ++++++++++++++++++++++++++++++++++++++ main.py | 145 ++++++++++++++++++ plot.py | 97 ++++++++++++ 4 files changed, 874 insertions(+), 23 deletions(-) create mode 100644 durationEstimate.ipynb create mode 100644 main.py create mode 100644 plot.py diff --git a/analysis.ipynb b/analysis.ipynb index 7a3e9d9..4330647 100644 --- a/analysis.ipynb +++ b/analysis.ipynb @@ -4,61 +4,354 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true, "ExecuteTime": { - "end_time": "2025-08-17T13:06:41.263897Z", - "start_time": "2025-08-17T13:06:40.939099Z" + "end_time": "2025-08-13T09:04:47.365323Z", + "start_time": "2025-08-13T09:04:46.211866Z" } }, "outputs": [], "source": [ - "import pandas as pd" + "import pandas as pd\n", + "import json\n", + "import re\n", + "import unicodedata\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2025-08-13T09:05:06.879965Z", + "start_time": "2025-08-13T09:05:06.803852Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " totalPrice totalPriceLow totalPriceHigh \\\n", + "0 145 145 145 \n", + "\n", + " ZusatzInfo complete confidence \\\n", + "0 Bitte bestätigen Sie, dass die Oberlichten als... False 0.8 \n", + "\n", + " missverständliche Aspekte \\\n", + "0 Der Ausdruck \"Oberlichten\" ist nicht eindeutig... \n", + "\n", + " Zu erbringende Leistungen: \\\n", + "0 4 Altbau‑Doppelfenster (je 25 €), 2 Neubaufens... \n", + "\n", + " Rechenweg \\\n", + "0 4×25 € + 2×15 € + 1×15 € = 100 € + 30 € + 15 €... \n", + "\n", + " Kommentare \n", + "0 Die Kosten basieren ausschließlich auf den in ... \n", + "Index(['id', 'product_id', 'product_name', 'price', 'currency', 'duration',\n", + " 'requirements_textual', 'street', 'zipcode', 'city', 'country',\n", + " 'coordinate', 'comment_price', 'comment_key', 'comment_important',\n", + " 'comment_restrict', 'comment_other', 'inquired',\n", + " 'quotation_info_request', 'quotation_state', 'quotation_ts',\n", + " 'quotation_comment', 'completed', 'customer_id', 'name', 'response',\n", + " 'n_Images', 'resp_totalPrice', 'resp_totalPriceLow',\n", + " 'resp_totalPriceHigh', 'resp_ZusatzInfo', 'resp_complete',\n", + " 'resp_confidence', 'resp_missverständliche Aspekte',\n", + " 'resp_Zu erbringende Leistungen', 'resp_Rechenweg', 'resp_Kommentare',\n", + " 'resp_Zu erbringen Leistungen', 'diff_price'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "#Get Data\n", + "from extractResponse import data_expanded\n", + "print(data_expanded.columns)\n", + "columns=[\"price\",\"resp_totalPrice\",\"diff_price\",\"duration\",\"requirements_textual\",\"inquired\",\"resp_ZusatzInfo\",\"resp_complete\",\"resp_confidence\",\"comment_price\",\"comment_important\",\"comment_important\",\"resp_missverständliche Aspekte\",\"resp_Zu erbringende Leistungen\",\"resp_Rechenweg\",\"resp_Kommentare\",\"response\" ]\n", + "\n", + "data = data_expanded[columns]\n", + "#print(data_expanded)" ] }, { "cell_type": "code", "execution_count": 3, - "outputs": [], - "source": [ - "data = pd.read_csv(\"./quotationsSampleWithResponse.csv\", on_bad_lines='skip',sep=\";\")\n" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "start_time": "2025-08-13T09:05:06.803852Z", - "end_time": "2025-08-13T09:05:06.879965Z" + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_656/1294317036.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " data[\"inquired\"] = data[\"inquired\"].apply(np.datetime64)\n" + ] } - } + ], + "source": [ + "data[\"inquired\"] = data[\"inquired\"].apply(np.datetime64)" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, + "metadata": {}, "outputs": [], - "source": [], + "source": [ + "# Search for bad positives and good negatives\n", + "\n", + "positives = data_expanded\n", + "\n", + "positives = positives.loc[positives[\"resp_totalPrice\"]>0]\n", + "positives = positives.loc[positives[\"n_Images\"]==0]\n", + "\n", + "#data_expanded[\"price\"]\n", + "positives[\"resp_totalPrice\"]\n", + "\n", + "positives[\"diff_price\"].describe()\n", + "\n", + "positives = positives.loc[positives[\"resp_complete\"]==True]\n", + "positives = positives.loc[positives[\"resp_totalPrice\"]<=1000]\n", + "\n", + "\n", + "\n", + "\n", + "negatives = data_expanded\n", + "\n", + "negatives = negatives.loc[negatives[\"resp_totalPrice\"]>=0]\n", + "negatives = negatives.loc[negatives[\"n_Images\"]==0]\n", + "\n", + "\n", + "#negatives[\"diff_price\"].describe()\n", + "\n", + "negatives = negatives.loc[negatives[\"resp_complete\"]==False]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Choose the Data to procede with\n", + "data = negatives" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": { - "collapsed": false - } + "scrolled": true + }, + "outputs": [], + "source": [ + "\n", + "\n", + "\n", + "\n", + "outliers = data.loc[( abs(data[\"diff_price\"]) <10)]\n", + "\n", + "if (False):\n", + " for o in outliers.index:\n", + " #print(data_expanded.iloc[0])\n", + " #print(data_expanded.iloc[columns,o])\n", + " \n", + " for c in columns:\n", + " print(f\"\\n#####{c}########\") \n", + " print(outliers.loc[o, c]) \n", + " print(\"#############\") \n", + " print(outliers.loc[o, ])\n", + " #print(o)\n", + " print(\"\\n\\n\\n\\n####################################################\\n####################################################\\n\\n\") \n", + " \n", + " #data_expanded[columns]\n", + " #data_expanded.index[351]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[skip] confidence == 100: no rows\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "confidence == 100: 0 rows\n", + "100 > confidence ≥ 90: 6 rows\n", + "90 > confidence ≥ 80: 29 rows\n", + "80 > confidence ≥ 50: 176 rows\n", + "50 > confidence: 96 rows\n" + ] + } + ], + "source": [ + "from plot import plotPriceConfidence, histPriceDiff\n", + "\n", + "plotPriceConfidence(data)\n", + "histPriceDiff(data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from plot import plotVariables\n", + "\n", + "plotVariables(data[\"duration\"],data[\"price\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 30.000000\n", + "1 48.333333\n", + "5 32.000000\n", + "6 50.000000\n", + "7 34.000000\n", + " ... \n", + "985 39.000000\n", + "988 46.666667\n", + "992 34.000000\n", + "996 34.285714\n", + "998 33.333333\n", + "Length: 307, dtype: float64\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[1. , 0.06179235],\n", + " [0.06179235, 1. ]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rate = data[\"price\"]/data[\"duration\"]*60\n", + "print(rate)\n", + "np.corrcoef(data[\"duration\"],rate)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.11" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } diff --git a/durationEstimate.ipynb b/durationEstimate.ipynb new file mode 100644 index 0000000..2427816 --- /dev/null +++ b/durationEstimate.ipynb @@ -0,0 +1,316 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "ce5cf325-1b49-462b-b5cc-2564a3ae356b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " duration ZusatzInfo complete \\\n", + "0 25 Bitte geben Sie an, ob zusätzlich Fensterreini... 0 \n", + "\n", + " confidence missverständliche Aspekte \\\n", + "0 0.3 Nicht spezifiziert, ob die 50 qm die gesamte R... \n", + "\n", + " Zu erbringende Leistungen: \\\n", + "0 Reinigung aller Räume (Boden, Oberflächen), Gr... \n", + "\n", + " Rechenweg \\\n", + "0 Annahme 5 Minuten pro 10 qm → 50 qm / 10 = 5 E... \n", + "\n", + " Kommentare \n", + "0 Beschreibung unvollständig; weitere Angaben zu... \n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import json\n", + "import re\n", + "import unicodedata\n", + "import numpy as np\n", + "data = pd.read_csv(\"./umzugQuotationsSampleWithResponse.csv\", on_bad_lines='skip',sep=\";\")\n", + "#imagecount = pd.read_csv(\"./quotationsSample.csv\", on_bad_lines='skip',sep=\";\")['n_Images']\n", + "#data['n_Images'] = imagecount\n", + "data[\"inquired\"] = data[\"inquired\"].apply(np.datetime64)\n", + "\n", + "import re, json\n", + "def normalize_col(name: str) -> str:\n", + " s = unicodedata.normalize(\"NFKC\", str(name)) # unify unicode\n", + " s = s.replace(\"\\xa0\", \" \") # NBSP -> space\n", + " s = re.sub(r\"\\s+\", \" \", s).strip() # collapse spaces\n", + " s = re.sub(r\":+\\s*$\", \"\", s) # drop trailing colons\n", + "\n", + " return s\n", + "def extract_json_from_response(raw: str) -> dict | None:\n", + " \"\"\"\n", + " Extract the JSON object that appears in content='...'.\n", + " Returns a dict or None if not found / invalid.\n", + " \"\"\"\n", + " if not isinstance(raw, str):\n", + " return None\n", + "\n", + " # 1) Prefer: content=' {...} ' or content=\" {...} \"\n", + " m = re.search(r\"content=(?P['\\\"])(?P\\{.*?\\})(?P=q)\", raw, flags=re.DOTALL)\n", + " if m:\n", + " json_str = m.group(\"body\")\n", + " try:\n", + " # --- minimal normalization: collapse backslash runs before a quote to \\\" ---\n", + " json_str = re.sub(r'\\\\+\"', r'\\\"', json_str) # <-- CHANGED\n", + " return json.loads(json_str) # <-- CHANGED (removed early return of raw string)\n", + " except json.JSONDecodeError:\n", + " pass # fall through to brace-balanced fallback\n", + "\n", + " # 2) Fallback: find the first '{' after 'content=' and parse a balanced JSON object\n", + " m2 = re.search(r\"content=([\\'\\\"])?.*?(\\{)\", raw, flags=re.DOTALL)\n", + " if not m2:\n", + " return None\n", + "\n", + " start = m2.start(2) # index of first '{'\n", + " # Walk to matching closing '}' while tracking nesting\n", + " depth = 0\n", + " i = start\n", + " in_string = False\n", + " esc = False\n", + " while i < len(raw):\n", + " ch = raw[i]\n", + " if in_string:\n", + " if esc:\n", + " esc = False\n", + " elif ch == '\\\\':\n", + " esc = True\n", + " elif ch == '\"':\n", + " in_string = False\n", + " else:\n", + " if ch == '\"':\n", + " in_string = True\n", + " elif ch == '{':\n", + " depth += 1\n", + " elif ch == '}':\n", + " depth -= 1\n", + " if depth == 0:\n", + " json_str = raw[start:i+1]\n", + " try:\n", + " # --- same minimal normalization here ---\n", + " json_str = re.sub(r'\\\\+\"', r'\\\"', json_str) # <-- CHANGED\n", + " return json.loads(json_str) # <-- CHANGED (removed print/early return)\n", + " except json.JSONDecodeError:\n", + " return None\n", + " i += 1\n", + " return None\n", + "\n", + "# --- Example: single row ---\n", + "raw = data.loc[1, \"response\"]\n", + "parsed = extract_json_from_response(raw)\n", + "if parsed is None:\n", + " raise ValueError(\"Could not extract valid JSON from response cell.\")\n", + "df_one = pd.DataFrame([parsed])\n", + "print(df_one)\n", + "\n", + "# --- Expand ALL rows into columns ---\n", + "parsed_rows = [extract_json_from_response(x) or {} for x in data[\"response\"]]\n", + "expanded = pd.DataFrame(parsed_rows)\n", + "\n", + "# Normalize column names\n", + "expanded.columns = [normalize_col(c) for c in expanded.columns]\n", + "\n", + "# Coalesce duplicate columns (row-wise first non-null)\n", + "def coalesce_dupe_cols(df: pd.DataFrame) -> pd.DataFrame:\n", + " out = {}\n", + " for col in dict.fromkeys(df.columns): # preserves original order\n", + " same = [c for c in df.columns if c == col]\n", + " if len(same) == 1:\n", + " out[col] = df[same[0]]\n", + " else:\n", + " out[col] = df[same].bfill(axis=1).iloc[:, 0] # pick first non-null per row\n", + " return pd.DataFrame(out, index=df.index)\n", + "\n", + "expanded = coalesce_dupe_cols(expanded)\n", + "\n", + "# (optional) If you’d rather just drop duplicates and keep the first:\n", + "# expanded = expanded.loc[:, ~expanded.columns.duplicated()]\n", + "\n", + "# Prefix to avoid collisions with original data\n", + "expanded = expanded.add_prefix(\"resp_\")\n", + "\n", + "data_expanded = pd.concat(\n", + " [data.reset_index(drop=True), expanded.reset_index(drop=True)], axis=1\n", + ")\n", + "\n", + "\n", + "data_expanded = pd.DataFrame(data_expanded)\n", + "data_expanded = data_expanded.loc[data_expanded[\"resp_duration\"].notna()]\n", + "data_expanded = data_expanded.loc[data_expanded[\"resp_duration\"]!=\"0\"]\n", + "\n", + "data_expanded[\"resp_duration\"] = pd.to_numeric(data_expanded[\"resp_duration\"])\n", + "data_expanded[\"diff_duration\"] = data_expanded[\"duration\"] - data_expanded[\"resp_duration\"]#-50.88\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d098d74e-0bad-49ea-a770-74501358c40f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb4a7f8c-784e-4c50-866a-da19625950cc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5281345-9528-49ff-8e34-741ddeebbbba", + "metadata": {}, + "outputs": [], + "source": [ + "data_expanded[\"diff_duration\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "539a367a-dd9a-441f-9a6b-5563422b99d1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHFCAYAAAAT5Oa6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdBFJREFUeJzt3XlYlOX+P/D3sA2LMLIEA4pAqSnhvuK+gVouZaVpkZWnrFyytMXT8YiVWnZSO/bLym9HSzI7nbTUCMUsl8QllRQhs8ItQVQQZF/m/v1BMzEwyzPDMOv7dV1eNc9z88x9PzAzn/ncm0wIIUBERETkwtxsXQEiIiIiW2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQERkZ5KTkyGTybSORUdH45FHHtE6duLECQwdOhQKhQIymQyrV68GAHz77bfo3bs3/Pz8IJPJ8OWXX1qn4tBdd7IsXb/fDRs2QCaT4dy5c0Z/ftiwYRg2bFiL15PI0XjYugJEZNzWrVsREBCgdeyxxx5DWVkZNm/ejMDAQERHR0MIgcmTJ6Njx47Ytm0b/Pz8cPvtt1utnn/7298wZswYqz2fq9H3+62trUVGRgbCw8NtXUUih8WAiMgB9OjRo8mxrKwsPP744xg7dqzm2B9//IHCwkLcc889GDlypNXqV15eDl9fX7Rt2xZt27a12vO6msuXL+v9/d5yyy02qhWRc2CXGZENff311+jevTvkcjliYmLwr3/9S2e5hl1m6u6R2tparF27FjKZDDKZDMnJyZpg5MUXX4RMJkN0dLSkepw7dw4ymQwrVqzA0qVL0a5dO3h7e6N379749ttvtcqqu8WOHz+O++67D4GBgbjtttu0zjW2adMmxMfHo1WrVmjVqhW6d++ODz/8UKvM7t27MXLkSAQEBMDX1xcDBw5s8tyNXb16FV5eXli0aFGTcz///DNkMhn+/e9/A6gP2hYsWICYmBh4e3sjKCgIvXv3xqeffirpHjVWVVWFV155BZ07d4a3tzeCg4MxfPhwHDx4UFOmsrISCxcuRExMDLy8vNCmTRvMmjULN27c0LpWdHQ0xo0bh7S0NPTs2RM+Pj7o1KkT/vOf/2jKGPr96uoyE0JgxYoViIqKgre3N3r27IlvvvlGZ1tKSko090Zdz3nz5qGsrEyrnEwmw+zZs7Fx40Z07twZvr6+6NatG3bs2NHkmj///DOmTp2KsLAwyOVytGvXDg8//DCqqqo0ZfLz8zFz5ky0bdsWXl5eiImJwZIlS1BbWyvpd0BkUYKIbGL37t3C3d1dDBo0SGzZskV8/vnnok+fPqJdu3ai8UszKipKTJ8+XQghREFBgcjIyBAAxH333ScyMjJERkaGuHjxotiyZYsAIObMmSMyMjLE8ePHJdUlNzdXABCRkZFi0KBB4osvvtDUx9PTUxw8eFBTdvHixQKAiIqKEi+++KJIT08XX375pda5hhYtWiQAiEmTJonPP/9c7Nq1S6xcuVIsWrRIU2bjxo1CJpOJu+++W2zZskVs375djBs3Tri7u4vdu3cbrPs999wjIiMjRV1dndbxF154QXh5eYlr164JIYSYOXOm8PX1FStXrhTfffed2LFjh3j99dfFmjVrJN2jhmpqasTw4cOFh4eHWLBggUhNTRXbtm0Tf//738Wnn34qhBBCpVKJ0aNHCw8PD7Fo0SKxa9cu8a9//Uv4+fmJHj16iMrKSs31oqKiRNu2bUVsbKz4+OOPxc6dO8X9998vAIi9e/cKIYTB3+/69esFAJGbm6u5pvp3MWPGDPHNN9+IDz74QLRp00YolUoxdOhQTbmysjLRvXt3ERISIlauXCl2794t3n77baFQKMSIESOESqXSlAUgoqOjRd++fcV///tfkZqaKoYNGyY8PDzEb7/9pimXmZkpWrVqJaKjo8V7770nvv32W5GSkiImT54sSkpKhBBC5OXlicjISBEVFSXef/99sXv3bvHqq68KuVwuHnnkEZN/J0TNxYCIyEb69esnIiIiREVFheZYSUmJCAoKMhgQqQEQs2bN0jqmDmzefPNNk+qi/jl99Rk1apTmmPqD9p///GeT6zQOiH7//Xfh7u4uHnzwQb3PXVZWJoKCgsT48eO1jtfV1Ylu3bqJvn37Gqz7tm3bBACxa9cuzbHa2loREREh7r33Xs2xuLg4cffddxu8llQff/yxACDWrVunt0xaWpoAIFasWKF1/LPPPhMAxAcffKA5FhUVJby9vcX58+c1xyoqKkRQUJCYOXOm5pi+32/jgKioqEh4e3uLe+65R6vcDz/8IABoBUTLly8Xbm5u4ujRo1pl//e//wkAIjU1VXMMgAgLC9MENUIIkZ+fL9zc3MTy5cs1x0aMGCFat24tCgoK9N6fmTNnilatWmm1WQgh/vWvfwkA4vTp03p/lqglsMuMyAbKyspw9OhRTJo0Cd7e3prj/v7+GD9+vM3qpa8++/btQ11dnVbZe++91+j10tPTUVdXh1mzZuktc/DgQRQWFmL69Omora3V/FOpVBgzZgyOHj3apOumobFjx0KpVGL9+vWaYzt37sTly5fx2GOPaY717dsX33zzDV566SV8//33qKioMFp/fb755ht4e3trXb+xPXv2AECT2YH3338//Pz8mnQHdu/eHe3atdM89vb2RseOHXH+/HmT65eRkYHKyko8+OCDWscHDBiAqKgorWM7duxAXFwcunfvrnX/R48eDZlMhu+//16r/PDhw+Hv7695HBYWhtDQUE09y8vLsXfvXkyePNnguKYdO3Zg+PDhiIiI0Hpe9Zi4vXv3mtxuoubgoGoiGygqKoJKpYJSqWxyTtcxa9FXn+rqapSWlkKhUGiOS5nRdPXqVQAwOND6ypUrAID77rtPb5nCwkL4+fnpPOfh4YGkpCSsWbMGN27cQOvWrbFhwwaEh4dj9OjRmnL//ve/0bZtW3z22Wd444034O3tjdGjR+PNN99Ehw4djLalcbsiIiLg5qb/O+X169fh4eHRJCiQyWRQKpW4fv261vHg4OAm15DL5WYFbuprS/n7unLlCn799Vd4enrqvNa1a9dMqmdRURHq6uqMDq6/cuUKtm/fLvl5iVoaAyIiGwgMDIRMJkN+fn6Tc7qOWYu++nh5eaFVq1Zax6WsN6QOBi5duoTIyEidZUJCQgAAa9asQf/+/XWWCQsLM/g8jz76KN58801s3rwZU6ZMwbZt2zBv3jy4u7tryvj5+WHJkiVYsmQJrly5oskWjR8/Hj///LPRtjRu14EDB6BSqfQGRcHBwaitrcXVq1e1giIhBPLz89GnTx+TntMU6qBF3++z4WD7kJAQ+Pj4aA3gbkj9+5EqKCgI7u7uuHTpksFyISEh6Nq1K5YuXarzfEREhEnPS9Rc7DIjsgE/Pz/07dsXW7ZsQWVlpeb4zZs3sX37dpvVS199Bg8erBVcSJWYmAh3d3esXbtWb5mBAweidevWyM7ORu/evXX+8/LyMvg8nTt3Rr9+/bB+/Xps2rQJVVVVePTRR/WWDwsLwyOPPIKpU6fizJkzKC8vN6ldY8eORWVlJTZs2KC3jHpafEpKitbxL774AmVlZS26LEL//v3h7e2NTz75ROv4wYMHm3TBjRs3Dr/99huCg4N13nupMxXVfHx8MHToUHz++ecGszzjxo1DVlYWbrvtNp3Py4CIrI0ZIiIbefXVVzFmzBgkJCRg/vz5qKurwxtvvAE/Pz8UFhbapE7u7u5ISEjAc889B5VKhTfeeAMlJSVYsmSJWdeLjo7G3//+d7z66quoqKjA1KlToVAokJ2djWvXrmHJkiVo1aoV1qxZg+nTp6OwsBD33XcfQkNDcfXqVfz000+4evWqwYBK7bHHHsPMmTNx+fJlDBgwoMmClP369cO4cePQtWtXBAYGIicnBxs3bkR8fDx8fX0BAB9//DEee+wx/Oc//8HDDz+s97mmTp2K9evX48knn8SZM2cwfPhwqFQqHD58GJ07d8YDDzyAhIQEjB49Gi+++CJKSkowcOBAnDx5EosXL0aPHj2QlJRk1j2VIjAwEAsWLMBrr72Gv/3tb7j//vtx8eJFJCcnN+kymzdvHr744gsMGTIEzz77LLp27QqVSoULFy5g165dmD9/Pvr162fS869cuRKDBg1Cv3798NJLL6F9+/a4cuUKtm3bhvfffx/+/v545ZVXkJ6ejgEDBmDu3Lm4/fbbUVlZiXPnziE1NRXvvfce17Qiq2JARGQjCQkJ+PLLL/GPf/wDU6ZMgVKpxNNPP42KigqzA5Dmmj17NiorKzF37lwUFBTgjjvuwNdff42BAweafc1XXnkFHTp0wJo1a/Dggw/Cw8MDHTp0wNy5czVlHnroIbRr1w4rVqzAzJkzcfPmTYSGhqJ79+5NBiXr88ADD2DevHm4dOkSFi9e3OT8iBEjsG3bNqxatQrl5eVo06YNHn74Ybz88suaMiqVCnV1dVCpVAafy8PDA6mpqVi+fDk+/fRTrF69Gv7+/ujWrZtmpW71thrJyclYv349li5dipCQECQlJWHZsmWQy+WS2mWuV155BX5+fnj33XexceNGdOrUCe+9916Tta78/Pywf/9+vP766/jggw+Qm5sLHx8ftGvXDqNGjTI5QwQA3bp1w5EjR7B48WIsXLgQN2/ehFKpxIgRIzTZvvDwcPz444949dVX8eabb+LSpUvw9/dHTEwMxowZg8DAQEvcBiLJZEIIYetKEJFtnTt3DjExMXjzzTexYMECW1eHiMjqOIaIiIiIXB67zIicnLFtEAxNHScichUMiIicmLorzJDFixcjOTkZ7D0nIlfGgIjIiUVERODo0aNGyxARuToOqiYiIiKXx8EDRERE5PLYZSaRSqXC5cuX4e/vL2nLAiIiIrI9IQRu3rxpdP9BBkQSXb58We9eTERERGTfLl68aHD1cwZEEvn7+wOov6EBAQE2ro10NTU12LVrFxITE/XuKu3oXKGNANvpbNhO5+EKbQQct50lJSWIjIzUfI7rw4BIInU3WUBAgMMFRL6+vggICHCoP2BTuEIbAbbT2bCdzsMV2gg4fjuNDXfhoGoiIiJyeQyIiIiIyOUxICIiIiKXx4CIiIiIXB4DIiIiInJ5DIiIiIjI5TEgIiIiIpfHgIiIiIhcHgMiIiIicnlcqZqIiMhK6lQCR3ILUXCzEqH+3ugbEwR3N24Ybg8YEBEREVlBWlYelmzPRl5xpeZYuMIbi8fHYkxcuA1rRgC7zIiIiFpcWlYenko5rhUMAUB+cSWeSjmOtKw8G9WM1BgQERERtaA6lcCS7dkQOs6pjy3Zno06la4SZC0MiIiIiFrQkdzCJpmhhgSAvOJKHMkttF6lqAkGRERERC2o4Kb+YMicctQyGBARERG1oFB/b4uWo5bBgIiIiKgF9Y0JQrjCG/om18tQP9usb0yQNatFjTAgIiIiakHubjIsHh8LAE2CIvXjxeNjuR6RjTEgIiIiamFj4sKx9qGeUCq0u8WUCm+sfagn1yGyA1yYkYiIyArGxIUjIVbJlartFAMiIiIiK3F3kyH+tmBbV4N0YJcZERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQujwERERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkcvzsHUFiIjIcupUAkdyC1FwsxKh/t7oGxMEdzeZratFZPcYEBEROYm0rDws2Z6NvOJKzbFwhTcWj4/FmLhwG9aMyP6xy4yIyAmkZeXhqZTjWsEQAOQXV+KplONIy8qzUc2IHAMDIiIiB1enEliyPRtCxzn1sSXbs1Gn0lWCiAAbB0TLly9Hnz594O/vj9DQUNx99904c+aMVplHHnkEMplM61///v21ylRVVWHOnDkICQmBn58fJkyYgEuXLmmVKSoqQlJSEhQKBRQKBZKSknDjxo2WbiIRUYs7klvYJDPUkACQV1yJI7mF1qsUkYOxaUC0d+9ezJo1C4cOHUJ6ejpqa2uRmJiIsrIyrXJjxoxBXl6e5l9qaqrW+Xnz5mHr1q3YvHkzDhw4gNLSUowbNw51dXWaMtOmTUNmZibS0tKQlpaGzMxMJCUlWaWdRM2lHigL1H/48Zs+NVRwU38wZE45Ildk00HVaWlpWo/Xr1+P0NBQHDt2DEOGDNEcl8vlUCqVOq9RXFyMDz/8EBs3bsSoUaMAACkpKYiMjMTu3bsxevRo5OTkIC0tDYcOHUK/fv0AAOvWrUN8fDzOnDmD22+/vYVaSNR86oGyhaUVWNEXeOyjowhq5cOBsqQR6u9t0XJErsiuZpkVFxcDAIKCgrSOf//99wgNDUXr1q0xdOhQLF26FKGhoQCAY8eOoaamBomJiZryERERiIuLw8GDBzF69GhkZGRAoVBogiEA6N+/PxQKBQ4ePKgzIKqqqkJVVZXmcUlJCQCgpqYGNTU1lmt0C1PX1ZHqbCpnbuPunCt49rNMCAByt/qskNxNoKi0AvM+PYZVU7pjVOcw21bSwpz599mQJdvZo60/ogLluFJSqXMckQxAWIA3erT1t/p9dYXfpyu0EXDcdkqtr0wIYRe5dyEEJk6ciKKiIuzfv19z/LPPPkOrVq0QFRWF3NxcLFq0CLW1tTh27Bjkcjk2bdqERx99VCt4AYDExETExMTg/fffx7Jly7Bhwwb88ssvWmU6duyIRx99FAsXLmxSn+TkZCxZsqTJ8U2bNsHX19dCrSYiIqKWVF5ejmnTpqG4uBgBAQF6y9lNhmj27Nk4efIkDhw4oHV8ypQpmv+Pi4tD7969ERUVha+//hqTJk3Sez0hBGSyvxYja/j/+so0tHDhQjz33HOaxyUlJYiMjERiYqLBG2pvampqkJ6ejoSEBHh6etq6Oi3CWdt4JLcQj310VPNY7ibwam8VFv3ohirVX3+3/5neB31jgnRdwiE56++zsZZo5+6cK3j9m5+RX/LXWCFlgDdeGtvJZplEV/h9ukIbAcdtp7qHxxi7CIjmzJmDbdu2Yd++fWjbtq3BsuHh4YiKisLZs2cBAEqlEtXV1SgqKkJgYKCmXEFBAQYMGKApc+XKlSbXunr1KsLCdL9JyOVyyOXyJsc9PT0d6g9BzVHrbQpna+O18lpU1TUN2KtUMq3j18prnardas72+9THku0c27UtEuPa2OVK1a7w+3SFNgKO106pdbXpLDMhBGbPno0tW7Zgz549iImJMfoz169fx8WLFxEeXj+YtFevXvD09ER6erqmTF5eHrKysjQBUXx8PIqLi3HkyBFNmcOHD6O4uFhThsjecKAsmcPdTYb424IxsXsbxN8WbBfBEJEjsGmGaNasWdi0aRO++uor+Pv7Iz8/HwCgUCjg4+OD0tJSJCcn495770V4eDjOnTuHv//97wgJCcE999yjKTtjxgzMnz8fwcHBCAoKwoIFC9ClSxfNrLPOnTtjzJgxePzxx/H+++8DAJ544gmMGzeOM8zIbvWNCUK4whv5xfoHyioV3k7VXUZEZCs2zRCtXbsWxcXFGDZsGMLDwzX/PvvsMwCAu7s7Tp06hYkTJ6Jjx46YPn06OnbsiIyMDPj7+2uus2rVKtx9992YPHkyBg4cCF9fX2zfvh3u7u6aMp988gm6dOmCxMREJCYmomvXrti4caPV20wklbubDIvHxwKoD34aUj9ePD6WGQAiIguwaYbI2AQ3Hx8f7Ny50+h1vL29sWbNGqxZs0ZvmaCgIKSkpJhcRyJbGhMXjrUP9dSsQ6Sm5IadREQWZReDqolIvzFx4UiIVeLQrwW4lnMI/5neB/3bhzIzRERkQdzclcgBuLvJNGOF7GXWEBGRM2FARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQujwERERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQujwERERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQujwERERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQujwERERERuTybBkTLly9Hnz594O/vj9DQUNx99904c+aMVhkhBJKTkxEREQEfHx8MGzYMp0+f1ipTVVWFOXPmICQkBH5+fpgwYQIuXbqkVaaoqAhJSUlQKBRQKBRISkrCjRs3WrqJRERE5ABsGhDt3bsXs2bNwqFDh5Ceno7a2lokJiairKxMU2bFihVYuXIl3nnnHRw9ehRKpRIJCQm4efOmpsy8efOwdetWbN68GQcOHEBpaSnGjRuHuro6TZlp06YhMzMTaWlpSEtLQ2ZmJpKSkqzaXiIiIrJPHrZ88rS0NK3H69evR2hoKI4dO4YhQ4ZACIHVq1fj5ZdfxqRJkwAAH330EcLCwrBp0ybMnDkTxcXF+PDDD7Fx40aMGjUKAJCSkoLIyEjs3r0bo0ePRk5ODtLS0nDo0CH069cPALBu3TrEx8fjzJkzuP32263bcCIiIrIrdjWGqLi4GAAQFBQEAMjNzUV+fj4SExM1ZeRyOYYOHYqDBw8CAI4dO4aamhqtMhEREYiLi9OUycjIgEKh0ARDANC/f38oFApNGSIiInJdNs0QNSSEwHPPPYdBgwYhLi4OAJCfnw8ACAsL0yobFhaG8+fPa8p4eXkhMDCwSRn1z+fn5yM0NLTJc4aGhmrKNFZVVYWqqirN45KSEgBATU0NampqzGmiTajr6kh1NpUrtBFgO50N2+k8XKGNgOO2U2p97SYgmj17Nk6ePIkDBw40OSeTybQeCyGaHGuscRld5Q1dZ/ny5ViyZEmT47t27YKvr6/B57ZH6enptq5Ci3OFNgJsp7NhO52HK7QRcLx2lpeXSypnFwHRnDlzsG3bNuzbtw9t27bVHFcqlQDqMzzh4eGa4wUFBZqskVKpRHV1NYqKirSyRAUFBRgwYICmzJUrV5o879WrV5tkn9QWLlyI5557TvO4pKQEkZGRSExMREBAQDNaa101NTVIT09HQkICPD09bV2dFuEKbQTYTmfDdjoPV2gj4LjtVPfwGGPTgEgIgTlz5mDr1q34/vvvERMTo3U+JiYGSqUS6enp6NGjBwCguroae/fuxRtvvAEA6NWrFzw9PZGeno7JkycDAPLy8pCVlYUVK1YAAOLj41FcXIwjR46gb9++AIDDhw+juLhYEzQ1JpfLIZfLmxz39PR0qD8ENUettylcoY0A2+ls2E7n4QptBByvnVLratOAaNasWdi0aRO++uor+Pv7a8bzKBQK+Pj4QCaTYd68eVi2bBk6dOiADh06YNmyZfD19cW0adM0ZWfMmIH58+cjODgYQUFBWLBgAbp06aKZdda5c2eMGTMGjz/+ON5//30AwBNPPIFx48ZxhhkRERHZNiBau3YtAGDYsGFax9evX49HHnkEAPDCCy+goqICTz/9NIqKitCvXz/s2rUL/v7+mvKrVq2Ch4cHJk+ejIqKCowcORIbNmyAu7u7pswnn3yCuXPnamajTZgwAe+8807LNpCIiIgcgs27zIyRyWRITk5GcnKy3jLe3t5Ys2YN1qxZo7dMUFAQUlJSzKkmEREROTm7WoeIiIiIyBYYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQujwERERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8jxsXQEicj51KoEjuYUouFmJUH9v9I0JgrubzNbVIiLSiwEREVlUWlYelmzPRl5xpeZYuMIbi8fHYkxcuA1rRkSkH7vMiMhi0rLy8FTKca1gCADyiyvxVMpxpGXl2ahmRESGmZ0h+uWXX/D999+joKAAKpVK69w///nPZleMiBxLnUpgyfZsCB3nBAAZgCXbs5EQq2T3GRHZHbMConXr1uGpp55CSEgIlEolZLK/3txkMhkDIiIXdCS3sElmqCEBIK+4EkdyCxF/W7D1KkZEJIFZAdFrr72GpUuX4sUXX7R0fYjIQRXc1B8MmVOOiMiazBpDVFRUhPvvv9/SdSEiBxbq723RckRE1mRWQHT//fdj165dlq4LETmwvjFBCFd4Q9/oIBnqZ5v1jQmyZrWIiCQxq8usffv2WLRoEQ4dOoQuXbrA09NT6/zcuXMtUjkichzubjIsHh+Lp1KOQwZoDa5WB0mLx8dyQDUR2SWzAqIPPvgArVq1wt69e7F3716tczKZjAERkYsaExeOtQ/1bLIOkZLrEBGRnTMrIMrNzbV0PYjISYyJC0dCrJIrVRORQ2n2StVC1CfGG069JyLX5u4m49R6InIoZq9U/fHHH6NLly7w8fGBj48Punbtio0bN1qybkRERERWYVaGaOXKlVi0aBFmz56NgQMHQgiBH374AU8++SSuXbuGZ5991tL1JCIiImoxZgVEa9aswdq1a/Hwww9rjk2cOBF33HEHkpOTGRARERGRQzGryywvLw8DBgxocnzAgAHIy+PmjURERORYzAqI2rdvj//+979Njn/22Wfo0KFDsytFREREZE1mdZktWbIEU6ZMwb59+zBw4EDIZDIcOHAA3377rc5AiYiIiMiemZUhuvfee3H48GGEhITgyy+/xJYtWxASEoIjR47gnnvusXQdiYiIiFqU2esQ9erVCykpKZasCxEREZFNSA6ISkpKEBAQoPl/Q9TliIiIiByB5IAoMDAQeXl5CA0NRevWrXWuTC2EgEwmQ11dnUUrSURERNSSJAdEe/bsQVBQEADgu+++a7EKEREREVmb5IBo6NChmv+PiYlBZGRkkyyREAIXL160XO2IiIiIrMCsWWYxMTG4evVqk+OFhYWIiYlpdqWIiIiIrMmsgEg9Vqix0tJSeHt7N7tSRERERNZk0rT75557DgAgk8mwaNEi+Pr6as7V1dXh8OHD6N69u0UrSERERNTSTAqITpw4AaA+Q3Tq1Cl4eXlpznl5eaFbt25YsGCBZWtIRERE1MJMCojUs8seffRRvP3221xviIiIiJyCWStVr1+/3tL1ICIiIrIZs7fuOHr0KD7//HNcuHAB1dXVWue2bNnS7IoRERERWYtZs8w2b96MgQMHIjs7G1u3bkVNTQ2ys7OxZ88eKBQKS9eRiMjh1akEMn67jq8y/0DGb9dRpxK2rhIRNWBWQLRs2TKsWrUKO3bsgJeXF95++23k5ORg8uTJaNeuneTr7Nu3D+PHj0dERARkMhm+/PJLrfOPPPIIZDKZ1r/+/ftrlamqqsKcOXMQEhICPz8/TJgwAZcuXdIqU1RUhKSkJCgUCigUCiQlJeHGjRvmNJ2IyGRpWXkY9MYeTF13CM9szsTUdYcwevU+W1eLiBowKyD67bffcNdddwEA5HI5ysrKIJPJ8Oyzz+KDDz6QfJ2ysjJ069YN77zzjt4yY8aMQV5enuZfamqq1vl58+Zh69at2Lx5Mw4cOIDS0lKMGzdOaz+1adOmITMzE2lpaUhLS0NmZiaSkpJMbDURkenSsvLwVMpx5BVXah2/UlL/eHfOFVtUi4gaMWsMUVBQEG7evAkAaNOmDbKystClSxfcuHED5eXlkq8zduxYjB071mAZuVwOpVKp81xxcTE+/PBDbNy4EaNGjQIApKSkIDIyErt378bo0aORk5ODtLQ0HDp0CP369QMArFu3DvHx8Thz5gxuv/12yfUlIjJFnUpgyfZs6OocUx97/ZufkRjXBu5uTRe7JSLrMSsgGjx4MNLT09GlSxdMnjwZzzzzDPbs2YP09HSMHDnSohX8/vvvERoaitatW2Po0KFYunQpQkNDAQDHjh1DTU0NEhMTNeUjIiIQFxeHgwcPYvTo0cjIyIBCodAEQwDQv39/KBQKHDx4UG9AVFVVhaqqKs3jkpISAEBNTQ1qamos2saWpK6rI9XZVK7QRoDtdERHcgtRWFoBuXvTc3K3+pCoqLQCh34tQN+YICvXzjqc6fepjyu0EXDcdkqtr1kB0TvvvIPKyvp078KFC+Hp6YkDBw5g0qRJWLRokTmX1Gns2LG4//77ERUVhdzcXCxatAgjRozAsWPHIJfLkZ+fDy8vLwQGBmr9XFhYGPLz8wEA+fn5mgCqodDQUE0ZXZYvX44lS5Y0Ob5r1y6tFbodRXp6uq2r0OJcoY0A2+loVvQ1fP7V3ipcyzmE1Bzr1MdWnOX3aYgrtBFwvHZK7bkyOSCqra3F9u3bMXr0aACAm5sbXnjhBbzwwgumXsqoKVOmaP4/Li4OvXv3RlRUFL7++mtMmjRJ78813mtN175r+vZjU1u4cKFmqxKgPkMUGRmJxMREh1qQsqamBunp6UhISICnp6etq9MiXKGNANvpiI7kFuKxj47qPCd3E3i1twqLfnTD2qS+Tp0hcpbfpz6u0EbAcdup7uExxuSAyMPDA0899RRycqz/dSY8PBxRUVE4e/YsAECpVKK6uhpFRUVaWaKCggIMGDBAU+bKlaaDFq9evYqwsDC9zyWXyyGXy5sc9/T0dKg/BDVHrbcpXKGNANvpSPq3D0VQKx/kF1fqHEcEAIGtfNC/fajTjyFyht+nMa7QRsDx2im1rmbNMuvXr59mXzNrun79Oi5evIjw8HAAQK9eveDp6amVvsvLy0NWVpYmIIqPj0dxcTGOHDmiKXP48GEUFxdryhARtQR3NxkWj48FADQOd9SPXxrbyemDISJHYNYYoqeffhrz58/HpUuX0KtXL/j5+Wmd79q1q6TrlJaW4tdff9U8zs3NRWZmJoKCghAUFITk5GTce++9CA8Px7lz5/D3v/8dISEhuOeeewAACoUCM2bMwPz58xEcHIygoCAsWLAAXbp00cw669y5M8aMGYPHH38c77//PgDgiSeewLhx4zjDjIha3Ji4cKx9qCeWbM/WmnofFuANoAyjOuvPVBOR9ZgVEKnH9sydO1dzTCaTacblNFwDyJAff/wRw4cP1zxWj9mZPn061q5di1OnTuHjjz/GjRs3EB4ejuHDh+Ozzz6Dv7+/5mdWrVoFDw8PTJ48GRUVFRg5ciQ2bNgAd/e/pnV88sknmDt3rmY22oQJEwyufUREZElj4sKREKvEkdxCFNysRKi/N3q09cfOtG9sXTUi+pNZAVFubq5FnnzYsGEQQv/y9Tt37jR6DW9vb6xZswZr1qzRWyYoKAgpKSlm1ZGIyBLc3WSIvy1Y89jRpi4TOTuzAqKoqChL14OIiIjIZswKiD7++GOD5x9++GGzKkNERERkC2YFRM8884zW45qaGpSXl8PLywu+vr4MiIiIiMihmDXtvqioSOtfaWkpzpw5g0GDBuHTTz+1dB2JiIiIWpRZAZEuHTp0wOuvv94ke0RERERk7ywWEAGAu7s7Ll++bMlLEhEREbU4s8YQbdu2TeuxEAJ5eXl45513MHDgQItUjIiIiMhazAqI7r77bq3HMpkMt9xyC0aMGIG33nrLEvUiIiIishqzAiKVSmXpehARERHZjEXHEBERERE5IskZIvU+Y1KsXLnSrMoQERER2YLkgOjEiRNaj48dO4a6ujrNjvG//PIL3N3d0atXL8vWkIiIiKiFSQ6IvvvuO83/r1y5Ev7+/vjoo48QGBgIoH6xxkcffRSDBw+2fC2JiIiIWpBZY4jeeustLF++XBMMAUBgYCBee+01zjIjIiIih2NWQFRSUoIrV640OV5QUICbN282u1JERERE1mRWQHTPPffg0Ucfxf/+9z9cunQJly5dwv/+9z/MmDEDkyZNsnQdiYiIiFqUWesQvffee1iwYAEeeugh1NTU1F/IwwMzZszAm2++adEKEhEREbU0swIiX19fvPvuu3jzzTfx22+/QQiB9u3bw8/PT6vcpUuXEBERATc3LndERERE9susgEjNz88PXbt21Xs+NjYWmZmZuPXWW5vzNEREREQtqkVTN0KIlrw8ERERkUU0K0NERETWU6cSOJJbiIKblQj190bfmCC4u8lsXS0ip8CAiIjIAaRl5WHJ9mzkFVdqjoUrvLF4fCzGxIXbsGZEzoGjnYmI7FxaVh6eSjmuFQwBQH5xJZ5KOY60rDwb1YzIebRoQCSTMZVLRNQcdSqBJduzoWtEpvrYku3ZqFNxzCZRc3BQNRGRHTuSW9gkM9SQAJBXXIkjuYXWqxSRE2r2GKKLFy9CJpOhbdu2Tc5lZ2cjIiKiuU9BROSyCm7qD4bMKUdEupmVIaqtrcWiRYugUCgQHR2NqKgoKBQK/OMf/9CsXA0AkZGRcHd3t1hliYhcTai/t0XLEZFuZmWIZs+eja1bt2LFihWIj48HAGRkZCA5ORnXrl3De++9Z9FKEhG5qr4xQQhXeCO/uFLnOCIZAKWifgo+EZnPrIDo008/xebNmzF27FjNsa5du6Jdu3Z44IEHGBAREVmIu5sMi8fH4qmU45ABWkGRetrK4vGxXI+IqJnM6jLz9vZGdHR0k+PR0dHw8vJqbp2IiKiBMXHhWPtQTygV2t1iSoU31j7Uk+sQEVmAWRmiWbNm4dVXX8X69eshl8sBAFVVVVi6dClmz55t0QoSEVF9UJQQq+RK1UQtxKyA6MSJE/j222/Rtm1bdOvWDQDw008/obq6GiNHjsSkSZM0Zbds2WKZmhIRuTh3Nxnibwu2dTWInJJZAVHr1q1x7733ah2LjIy0SIWIiIiIrM2sgGj9+vWWrgcRERGRzZg1qLqiogLl5eWax+fPn8fq1auxa9cui1WMiIiIyFrMCogmTpyIjz/+GABw48YN9O3bF2+99RYmTpyItWvXWrSCRERERC3NrIDo+PHjGDx4MADgf//7H5RKJc6fP4+PP/4Y//73vy1aQSIiIqKWZlZAVF5eDn9/fwDArl27MGnSJLi5uaF///44f/68RStIRERE1NLMCojat2+PL7/8EhcvXsTOnTuRmJgIACgoKEBAQIBFK0hEQJ1KaHYzP5JbiDqVrk0ciIjIXGYFRP/85z+xYMECREdHo2/fvpr9zHbt2oUePXpYtIJEri4tKw+D3tiDxz46CgB47KOjGPTGHqRl5dm4ZkREzsOsgOi+++7DhQsX8OOPP2Lnzp2a4yNHjsSqVassVjkiV5eWlYenUo4jr7hS63h+cSWeSjnOoIiIyELMCogAQKlUwt/fH+np6aioqAAA9OnTB506dbJY5YhcWZ1KYMn2bJ07nKuPLdmeze4zIiILMCsgun79OkaOHImOHTvizjvvRF5e/bfUv/3tb5g/f75FK0jkqo7kFjbJDDUkAOQVV2rGFhERkfnMCoieffZZeHp64sKFC/D19dUcnzJlCtLS0ixWOSJXVnBTfzBkTjkiItLPrK07du3ahZ07d6Jt27Zaxzt06MBp90QWEurvbdFyRESkn1kZorKyMq3MkNq1a9cgl8ubXSkiAvrGBCFc4Q2ZnvMyAOEKb/SNCbJmtYiInJJZAdGQIUM0W3cAgEwmg0qlwptvvonhw4dbrHJErszdTYbF42MBoElQpH68eHws3N30hUxERCSVWV1m//rXvzB06FD8+OOPqK6uxgsvvIDTp0+jsLAQP/zwg6XrSOSyxsSFY+1DPbFkezYKSys0x5UKbyweH4sxceE2rB0RkfMwOSCqqanB008/jW3btuGbb76Bu7s7ysrKMGnSJMyaNQvh4XyDJrKkMXHhSIhV4tCvBbiWcwj/md4H/duHMjNERGRBJneZeXp6IisrC8HBwViyZAl27NiB1NRUvPbaayYHQ/v27cP48eMREREBmUyGL7/8Uuu8EALJycmIiIiAj48Phg0bhtOnT2uVqaqqwpw5cxASEgI/Pz9MmDABly5d0ipTVFSEpKQkKBQKKBQKJCUl4caNG6Y2ncgsdSqBjN+u46vMP5Dx23Wz1g1yd5Npxgr1jQliMEREZGFmjSF6+OGH8eGHHzb7ycvKytCtWze88847Os+vWLECK1euxDvvvIOjR49CqVQiISEBN2/e1JSZN28etm7dis2bN+PAgQMoLS3FuHHjUFdXpykzbdo0ZGZmIi0tDWlpacjMzERSUlKz609kjHrbjanrDuGZzZmYuu4Qt90gIrJDZo0hqq6uxv/93/8hPT0dvXv3hp+fn9b5lStXSrrO2LFjMXbsWJ3nhBBYvXo1Xn75ZUyaNAkA8NFHHyEsLAybNm3CzJkzUVxcjA8//BAbN27EqFGjAAApKSmIjIzE7t27MXr0aOTk5CAtLQ2HDh1Cv379AADr1q1DfHw8zpw5g9tvv92cW0BklHrbjcb5IPW2G2sf6skxQEREdsKsgCgrKws9e/YEAPzyyy9a52Qyy6Tyc3NzkZ+fj8TERM0xuVyOoUOH4uDBg5g5cyaOHTuGmpoarTIRERGIi4vDwYMHMXr0aGRkZEChUGiCIQDo378/FAoFDh48qDcgqqqqQlVVleZxSUkJgPoxVDU1NRZpozWo6+pIdTaVPbaxTiWw/OvT8HLX3T0mA7D869MY1iFYcveXPbazJbCdzsUV2ukKbQQct51S62tWQPTdd9+Z82Mmyc/PBwCEhYVpHQ8LC9Ms/pifnw8vLy8EBgY2KaP++fz8fISGhja5fmhoqKaMLsuXL8eSJUuaHN+1a5fONZjsXXp6uq2r0OLsrY3PGd3Wrww7074x+br21s6WwnY6F1dopyu0EXC8dpaXl0sqZ1ZAZE2NM05CCKNZqMZldJU3dp2FCxfiueee0zwuKSlBZGQkEhMTERAQILX6NldTU4P09HQkJCTA09PT1tVpEfbYxtRTeXjhi5NGy624tyvu7CKt28we29kS2E7n4grtdIU2Ao7bTnUPjzF2GxAplUoA9RmehrPXCgoKNFkjpVKJ6upqFBUVaWWJCgoKMGDAAE2ZK1euNLn+1atXm2SfGpLL5TpX3fb09HSoPwQ1R623KeypjaEKP1TVGe8KC1X4mVxne2pnS2I7nYsrtNMV2gg4Xjul1tWsWWbWEBMTA6VSqZWaq66uxt69ezXBTq9eveDp6alVJi8vD1lZWZoy8fHxKC4uxpEjRzRlDh8+jOLiYk0ZIkvjthtERI7Fphmi0tJS/Prrr5rHubm5yMzMRFBQENq1a4d58+Zh2bJl6NChAzp06IBly5bB19cX06ZNAwAoFArMmDED8+fPR3BwMIKCgrBgwQJ06dJFM+usc+fOGDNmDB5//HG8//77AIAnnngC48aN4wwzajHqbTeeSjkOGaA104zbbhAR2R+bBkQ//vij1t5n6jE706dPx4YNG/DCCy+goqICTz/9NIqKitCvXz/s2rUL/v7+mp9ZtWoVPDw8MHnyZFRUVGDkyJHYsGED3N3dNWU++eQTzJ07VzMbbcKECXrXPiKylIbbbuQVV2qOc9sNIiL7Y9OAaNiwYRBC/6q9MpkMycnJSE5O1lvG29sba9aswZo1a/SWCQoKQkpKSnOqSmQW9bYbR3ILUXCzEqH+3lxpmojIDtntoGqi5qhTCbsJQtzdZIi/Ldgmz90S7OneOpLG961HW3/jP0REVsOAiJxOWlZek26qcHZTWQTvrXl03beoQLmEtaqIyFrsdpYZkTnU22U0/OAB/toug3uImY/31jz67tuVkvrHu3OaLgtCRNbHgIicRp1KYMn27CZ7hwF/zfJasj3bpN3mLbFTvTNoiXvrCqTct9e/+Zn3jcgOsMuMnMax80VNvoU3JADkFVfiSG6hpDE97B76y5HcQoveW1dh7L4BQH4J7xuRPWCGiJzGtdIq44UAFNw0/AEFsHuoMSn3zJRyroL3jchxMCAipxHSqulWK7qE+nsbPM/uoaaM3TNTy1mKvXdp2ut9I6Km2GVGTqNXVCDCFd7IL67UGczIUL8oorHtMtg91JR6K5Lm3ltLcoQuTWP3DQCUAdzChcgeMENETkO9XQaAJnuImbJdBrs5mrLUvbUUR+nSlHLfXhrbies4EdkBBkTkVNTbZSgV2l0QSoU31j7UU1LmgN0culni3lqCo3Vp6rtvYQH1j0d1DrNFtYioEXaZkdNp7nYZ9tg9ZC/sYSsSR+zS1HXferT1x860b2xdNSL6EwMickrN2S6DO9UbZuutSBy1S7PxfaupqbFhbYioMXaZEelgL91D1mbvs7YAdmkSUctghohID3voHrImR5i1BbBLk4haBjNERAaouzkmdm+D+NuCnToYcoRZW4D9zXgjIufAgIjIxTnarC3Adbs0iajlsMuMyMU54qwtQFqXZp1KuEyXJxE1DwMikowfLs7JUWdtAYZnvDnKmCgisg8MiEgSfrg4L2ectaUeE9W4k089JordakTUGMcQkVGONOCWTKeetaUv1ydDffDrKLO2HHFMFBHZHgMiMsgWHy6OsBaOM3G2WVumjIkiIlJjlxkZZO0Bt+ya0009fguo/530bx9q0QBFPWur8b1XOuC9d+QxUURkOwyIyCBrfrhw3Idu6iCxsLQCK/oCj310FEGtfCweqDjLQpTOOCaKiFoeu8wIgP5uKmt9uHDch27WHr/lDAtROtuYKCKyDmaIyGA3VUKs0irbJFi6a86elgiorlVhY8Y5nC8sR1SQL5Lio+HlYfy7iLEgUYb6IDEhVmnVtkm5t7a8/9ycl4jMwYDIxUnpprLGh4slu+bsaRzS8tRsrNufi4aJraWpOXh8cAwW3hlr8GftccHEtKw8JG/LRn5Jg3FGAd5InvDXvbWH++9MY6KIyDoYELkwqRmIAy+OaPEPF0t1zdnTOKTlqdl4f19uk+MqAc1xQ0GRvQ0OTsvKw5Mpx5sczy+pxJMpx/HeQz0BwG7uv7OMiSIi62BA5MJMyUC09IeLJXYwt6cupupaFdbtbxoMNbRufy7mJ3bS231mT4OD61QCL205ZbDMwi2nIPdws4v7r2ZoJWsiooY4qNqFmZqBaMkBt+pxH/qGTAsY75o7dr7Ibtaf2ZhxDsbGf6tEfTl97Glw8KHfr+NGeY3BMkXlNcgvqdJ7nuv/EJE9Y0DkwuwpA2EJ10r1fxg3ZI0upvOF5SaV0zXLz54WTMz47brFrsX1f4jIHrHLzIVZopvKUtTdXfpI6W4JaSWX9FzWCPCignwll6sfqHxaK7uiDJAjecIdWoODC0sr/jpv9cHBllvuwFECbCJyLcwQuTB7ykBYYruFXlGBJnUxteQWIUnx0TB229xkQJi/N55MOd6kqym/pApP/rnO0Ji4cBx4cQT+M70PAOA/0/vgwIsjrDpTKv7WEEnlAn097aKLj4jIVAyIXJw6A6FUaH9rVyq8rTojyBIzqkwJ8NKy8jDojT2Yuu4QntmcianrDmHQG3uaLHRobtDk5eGGxwfHGCwzY1AM/rEty2CZl7ac0nSfqQMJW8yU6n9bMFr7ehos09rXE0vv7gLA9gG2Kbh3HhEB7DIj2Mf0ZEuNZ5Ky/ozUqfnNXU9HPaW+8TpEbjLg8cExGNIh1OhMtBvlNTj023UM7CAtQ9NS3N1keH1SF53T7tVen9Sl/v67GV+iwV4WzrSHNZOIyD4wICIAtp+e3DcmCK19PQ3OZGrt6ympu8VQgCd1ar5KBcza1Pz1dBbeGYv5iZ10rlT9r50/G/15AMj4/ZrNAyKg/r6+91BPg+Od1OUMBdj2EoTY05pVRGR7DIjIYZiSP9AX4Ekdq/SPr7IkraejvqahTIeXhxtmDL5Vx9Wktsh+upikZhP13X8pQcjI21s++LOnNauIyD4wICK7cCS3UNI6N+ptKhp2uYT4Sv8zljpWqbCsWu85ddD0zp6z2Hz0otmZjvjbgvHOd79KKmdPzM0mSg1ChnUY3NwqGmWP26IQWZu9dF3bCwZEZFX6XoCmDKpu3OUidxdY0RfYnXMFY7u2NfjzlpzyvWr32SbHTOlu6X9rsNFuwkBfT/S/1Tk+kKUGIcfOF7V4XextWxQia7OXrmt7woCIrMbQC1BqoHLuWhlW7z6rM8vw7GeZkLm5G3wxSxmr5Cd3R1lVnaT6NGZKd4uUgcrLJ3Vxmm9sUoMLqQtsNoezLUpKZAqOn9ON0+7JKtQvwMYZAvULsKisStIaQp8euWBwicAl27ObPW3a000GZYD5H4SmbFGhHqjc+PnCFd54r8GbkjqzBtRnWux9ariuqexSgwupC2w2hz1ti0JkTca6rgHLvI86IgZE1OKkvABf/ToHi+4yvIbQA33aNXuvLCljlW5U1KJ3dKDBMlKY1t2ifXeE+Ouxes2kxz46CgB47KOjOtdMshf61niSGvT2imr+vTfGnhYlJbImSyyC66wYEFGLk/oCDPTzMrhIZHSItO0wDAUiUoOUA2evSSpniJSMiDpz1jjQu1JShadSjmN5arbBzJq9BUWGMoGzNp3AhG71GS97CELsZVFSImvi+Dn9OIaIWpwpL8CJ3dvondYtdYNRQ4GI1G6bGxWGs0iGSN0DTkrmbN3+XIeZGi5lFtm2n/Lw/6b1xKtf61+4sabG/HtvKntYlJTImjh+Tj8GRNTiTH0B6pvWLWUzWmPjPqRcQ+HjKTkgkkG7s8uUTIexzBkAGOrGt7ep4aZkAg+8OMJughBbL0pKZE32tKm3vWGXGbU4Sw1gVY/70BcjCBgPRKSMHXl0YLTBeqg9O6pDs7pbLJWStpfUtimZQHUQMrF7G8TfFsyMDJGVcPycfswQUYtTvwCfSjnerIyKpRjb72xox1Cdaww19sSQ2zB7RAezMx2WSknbS2rbUVPxXJyOXI2UPR9dEQMisgpLvADVY1T0MWVMjaGxIx/u/11SmzYdPo8Zg281u7ulV1Qg3GSGu8WMaZhZs/UHuyOm4rk4Hbkqjp9rigERWU1zX4CW3m5B39iR84XlkuojtZw+x84XNSsYAoAJ3cLh7iaziw92e8sEGsPF6cjVcfycNrsfQ5ScnAyZTKb1T6lUas4LIZCcnIyIiAj4+Phg2LBhOH36tNY1qqqqMGfOHISEhMDPzw8TJkzApUuXrN0UAiSNHdG1qB9gvemiUUHSpvdLLaePJcb+bPspD6knL9vN1HxHmcrOxenIVvS9v5HtOUSG6I477sDu3bs1j93d3TX/v2LFCqxcuRIbNmxAx44d8dprryEhIQFnzpyBv78/AGDevHnYvn07Nm/ejODgYMyfPx/jxo3DsWPHtK5FzWOJLhtDmQ6pKxg3d6XjpPhoLE3NMZi9cZPVl2sOS4ylySuuxD++yrKrqfmOkIrn5q7W0XiF9f7tQ+3q78Da7CGTS/o5REDk4eGhlRVSE0Jg9erVePnllzFp0iQAwEcffYSwsDBs2rQJM2fORHFxMT788ENs3LgRo0aNAgCkpKQgMjISu3fvxujRo63aFmcl9YVuKGgy1oUxd2QHaZURzQvOvDzc8PjgGLy/L1dvmccHx8DLww3VtSpszDiH84XliAryRVJ8NLw8pCVejY25kaqwTP8SAbb6YDeWirf1eCcuTtfy1O8JhaUVWNG3foX1oFY+Lvvhzy5a++cQAdHZs2cREREBuVyOfv36YdmyZbj11luRm5uL/Px8JCYmasrK5XIMHToUBw8exMyZM3Hs2DHU1NRolYmIiEBcXBwOHjzIgMgC9L3Q8xq90A0FTQmxSqOL+m04qD9AaWh3Tj4W/O+nZn0LW3hnLH6/Vob07IIm5xJiQ7HwzlgsT83Guv25Wpmkpak5eHxwDBbeGas5pu/DXz3mxtDmrpZiTx/s9vAt2VFnxDmKhu8J8gZJeFf98JeyaKk9LbLqquw+IOrXrx8+/vhjdOzYEVeuXMFrr72GAQMG4PTp08jPzwcAhIWFaf1MWFgYzp8/DwDIz8+Hl5cXAgMDm5RR/7wuVVVVqKr6azuFkpISAEBNTY1VV9JtLnVdW6rOdSqB5V+fhpe7/hzH8q9Po662FvM//6nJG2RRaQXmfXoMTw9rj8LSCq1zjVVW1+g8L3cTWv/ddPhc/WMdz7NqSneM6lz/91Jdq8JnRy/gQlEF2gX6YEqfdprszu6cK9h/5kqT55MB2H/mCp76+DD2nLkKTx3JoA0//A43UYfnEjthd84VLE/NwZWbf/0thfnLsfDOzhjVOQxCVQe5gXvXcHBy43YCkDxLLcTXw6p/t3UqgWPni3CttAohreToFRUIdzcZdudcwbOfZer9O1g1pTuGtq+fhdaS9e0a0Qo+HsJot2jXiFYtVo+Wfm3aSuP3hMZ/tzLUvycM6+A8608Z+10eyS00+v5WWFqBQ78W2NUszMYc9W9Wan1louEukg6grKwMt912G1544QX0798fAwcOxOXLlxEe/te3jccffxwXL15EWloaNm3ahEcffVQruAGAhIQE3HbbbXjvvfd0Pk9ycjKWLFnS5PimTZvg69u8wbRERERkHeXl5Zg2bRqKi4sREBCgt5zdZ4ga8/PzQ5cuXXD27FncfffdAOqzQA0DooKCAk3WSKlUorq6GkVFRVpZooKCAgwYMEDv8yxcuBDPPfec5nFJSQkiIyORmJho8Ibam5qaGqSnpyMhIQGenp4Wv/6Ony7jpa2nLH5dU8jdBF7trcKiH91QpTL+jXPsHWH45vQVs89L5e3hhspald7zfl7uKKuuk3w9fe18uF8UNh6uz4jqmureMCvW0hpmgBpqPA3fkP97qAcKf/mxxf5mASD1VB5e+OKk0XIr7u2KO7u0TNdOS782baXxvdX3d9uS99bajP0uj+QW4rGPjhq9zn+m97H7DJEj/s2qe3iMcbiAqKqqCjk5ORg8eDBiYmKgVCqRnp6OHj16AACqq6uxd+9evPHGGwCAXr16wdPTE+np6Zg8eTIAIC8vD1lZWVixYoXe55HL5ZDLm85W8vT0dKg/BLWWqndhRR2q6qyX9g709URRue70Z5VKJqkuX50sgNC7kYjx81JV1alHB+g5X6EyeF7vzzVq54g7ItDr1hCLjMtpzmDnOpXAK1+fQWUz/x4KK+qDxJZ8rYUq/CT9rYQq/CTVoTn3zVHfU/TRd28b/91KvbeORN/vsn/7UAS18jG6aKmjzMJztL9ZqXW1+4BowYIFGD9+PNq1a4eCggK89tprKCkpwfTp0yGTyTBv3jwsW7YMHTp0QIcOHbBs2TL4+vpi2rRpAACFQoEZM2Zg/vz5CA4ORlBQEBYsWIAuXbpoZp2R+YKaOcXdVN0jW+O7M1ebdQ1jmQpH6UNuuPKzu5tM0lR3Q7PimjvYWcpmtVKEtJLjWrOvYpglV9W2h0Hi9sQRVyxvaY62aKmrsvuA6NKlS5g6dSquXbuGW265Bf3798ehQ4cQFRUFAHjhhRdQUVGBp59+GkVFRejXrx927dqlWYMIAFatWgUPDw9MnjwZFRUVGDlyJDZs2MA1iCwg1MoB0Y/niwyed5MBQugOamQAfLzcUS6hm8pXYrnmaiV3R2mV/ucxlBEDtN9EjU11NzQrrke7wGZPCW7uTDb1B2WvqEDszGnWpYxq+AGlj5QPKE6lbqrxh39Drvzhz/3D7J/dB0SbN282eF4mkyE5ORnJycl6y3h7e2PNmjVYs2aNhWvnPMxO+Vv5Pe1mZa3B8+oPe33fwvpEB2LvL8bzD9HBvsjOu2lWHU0xrGModpzSv5L05N5tAQDr9msvOeAmq18LSeqb6PLUbJ3rKqkE8P6+XPh6XWj2lGBTpqjbw7fkMXHheGJITJMgUeq95VRq/Rp++BeWVmiOu/qHvyMsWurK7D4gopbXnJT/tdIqg+dt4bGB0fgmK1/nt7DyqjpJAdEfN5rf9WMsy9Tax8NoxuuzHy+huLymyYeuEMAH+3LRo12g0d9Rda2qSUDVmKF6Sl3cUWpXyaK7YvHq1/q/JVtrSm9aVh4+2Jdr9r3lateGqT/8D/1agGs5h/Cf6X0cZoxMS+L+YfaLAZGLa27K3x4XrkuIVeLlu2J1fgvL+O26pGsUVzT/Q3nmkNuwavcves8/OjAGq3afNXiNG3q6y0zJQGzMONfsTWQB411iUsdJjIkLx6jYMLNX+DaFvsynJbI7pq523bguPdr6G/lJx+fuJkPfmCCk5oCZELJ7DIhcmCU+FNRZAUPflMMV3hBC4EpJld7MQViAXO95U3WPbK33W1jfmCC09vXUG2gApk+H1yVc4Y3ZI9rjdmUrJG/LRn5J0+xblYEp+VJIzUCcLyxv1vOoSQl+pYyT0JWR/L8DuRbvSjGU+VT4eDU7u2PKate66hIVKMdznaS1hYhaHgMiF2aJlL+7mwwTuoUb3PdrQrdwzaBdfZmDqX2jDGZTTLHp8HnMGHyr2T8vkzX/W+yEbuFwd5NhTFw4RnTSnQ2Rmq0yxlimIiqoeQuJNp4VZGy8maFxElIykiNvD2lWfQHjmc9HB0ZLuo6heyv1y0BRWTVmbWpalyt/Bsm7c65gbNe2kupDRC2HAZELs8QGl3UqgW0/6R8UDADbfsrDC2M6G8wcVFhwRtfv18r0njuSW2gwOwQApVW1CPLzRFFZ07E7asa2zFC3OT07X282JCFWafQDVYoQIzP9kuKjsTQ1x2B9ZX/OzjM22FnqeDNdGTqpGclhHQYbbI8xUp7nq8zLkq5lKAsk5cvAuK5KvPq1/roAwOvf/IzEuDbsTiKyMct32pPDsMQGl1LWnlFnmcbEhWPv88Ox6K7OeDg+Covu6oy9zw/HmLhwXCutNqnuhhSUVKJOJZDx23V8lfkHMn67jro/owGpQeA93dsY7L4zNiYnr7gS7+w5i6dSjje5P+osRXp2PiZ0s0AXkZG6eHm44fHBMQbLPDE4Bu891BNKhfbvWqnw1tqc11B70rIMB8ZSM5LHjAw0N0bK81wvq0YrQxtLAWjt62lwrRwpXwa+OP6H0ddHfkn964OIbIsZIhcmNeVv6EPBlCyTobEjNyosFxBV1dRh0Bt7dGYxpAaBDTdjNdf6H84ZzYZYYivBa2XG67rwzlgA0DvFXH1eX1eXNQchN3fmotTnMXbrjeVrpHwZKCyTNji/uWs4EVHzMSByYVLH/1hi7Zlz18qxevcvesd0jImz3F5b+35tOjZH/Tz/b1oPo1PDwwLk+Pqk4W/+UtwwMFNNnQ2xBKm/g4V3xmJ+YieDs7v0DUa3xHgzqfU0ZaVqXeOZpD6PsYHzReU1BttjySDGHmdrErkaBkQuzJTxP8ZmmRkLMD49Ynjhv0O/t2yXgfp5Xv06B4vuisWsTfoHeA9sH4Ivjv/RrOczNpPNEszZAsHLw82sAeeWGG8mdZ0iqStV6xvPtOiuWKPPo/DxNBiwqhlqj9QgJsjPC0Vl1Xp7NpUBrrWNBZG94hgiF2bK+B991GvPAE27GP6aQdZOa9p5YwIwuD2FpaizGIF+XlhrYLzMzcrm12VQ++bPlGrIWlsg6Bt7ZYnxZlL+VqS2x9B4plmbjmvGZul7HqmzzAy1R72EgyGtfT3x2sQ4g3V5aWwnDqgmsgPMELkwQ0GKrnL6plsbW3umuevtWFrBzUpM7N5G73T4tKz8Zj/Hj+cKoQzwxpUSw9kQY+sz1a/s3Bmv7MhGUdlf9zYsQI7kCXdYbd0e9Yy45m7YKWWdImMrVUsZz7Ttpzz8v2k98OrXOTqfJyFWic1HL7b4BqQyAKPjlDrbHBbgDaAMozpbrrvYmsze7ofITjEgcmGFEgevFpZWGZ1ubY31diwlxE9ucID3vT3b4kuJ07L1yS+pwrOjOmL17l8MTmUHYHSDUe2fanwVy5CyPtDi8bF4Uk9dBaRnd5q7n5PU8UyBfnIceHGE3udp7u7jUpZwUI9D0tXmHm39sTPtG0lttjfN2e6HyF4xIHJhQX5ekspdLCrHa1/nGPywBIDFX53Wmp31wb7fsWTiHUiIVRodU+Pl4YZqCZkkuTtgYHN4SY6eK8Tb357V2541D3Rv3hP8KTrEV9Lu1oY2GAWgCVQazhLPL2m6tUp1rcqs7TCkziBbdFdnE++Afs3Zz8mU8UyGnqe5u4+bOq6qcV2stWebpTV3ux+ixuwl28iAyIUpFT6Sym37Kc/gh+VLW07pDHau3KzCkynH8e60HkafQ+qf/m2h/s3ehX7DQcPT4f+5/XSzrq8W0kqOge1DDGZDjG0wqvC9pHcwrsBfU91XpOU0CaqWpuZoTanXR2rG5R9fZektY82d3S0xnkmtOdkqS9bDUVhi+QWihuwp28iAyIVJWYcoyM8ThWX61wgS0L8Bqdpz//0JlUayP1LHGf16Vf8q1FIZmw4vde0Yo/781NCXpTD24QIYv7d5xZV4ZvMJ7NCxTIBKQLOkgqGgSGqmw9B9sebO7lJnq0kd/2NutsrS9XAEllh+gUjN3rKNnGXmBPTNDGroSG5hk/PqWT/6vsfJUL9ic3MZC4ZMIaVbzRBjs4IsyVigIWWWnxTG1kxatz/X4H0ztvWHKaQGV1L+ZvWx5Gw1oP5v6sP9v+OfX2Xhw/2/S/4bs3Q9HIElll8gAqR9IVyyPduk94bmYobIwRlLN+7OuQIAeOyjo6iqkzU5r28cRcNdwT/84ZxV2tJ4cGtLGNQ+RGc2pSWoM2v6+sct9aFh7J6pBLAx4xxmDL5VZ10sedOldA9ZIkXe3PE/astTs83uarRkPRyFK3YTUsuwx2wjAyIHZizd+MSQGHz0w+94o6/u8+p05Ji4cAztGIplqdk4d70c0cG++PudsfDxckedShjsFrAka3wPkDId3t1NhloLfCsJaqV7Npup24hYwvnCcr11GRunlHSN1j6eKK7QveGt1O4hS+5239zZastTs3Wu0i61q9FS9bBH+oJ4V+wmpJZhj9lGdpk5KGPpRoH6rhIp6cjlqdm4Y3EaNh66gP1nr2HjoQu4Y3EalqdmS+oWcCT5JVWY2rcdAP3tiQ33t8hzXbhebnAz1Os3q2Ctz8zyqlq9dfmPxAzgowPrZ72Z2z3UEily9fifid3bIP62YJO6ydbt179lDWC8q9ES9bBHaVl5GPTGHkxddwjPbM7E1HWHMOiNPUjLynPJbkJqGfaYbWRA5KCkjD8x9LmiTkc+s/kE3t+X26Ss+lvy8tRsTbeArpWd/z25u6T6hrYyPMU/yM96Y3uiQ3zxxJAYyBq9Z8tk9VPg547o2OznUBrZrkQAWLz9tMHfkSXtP3vN4MwgQ59fMtRnkmaPaG9whW9j3UMtsdu9uWORNmacM3rv1V2NrsTQCuBPpRxHWlaewfcDTrknqdTZRkNjWI1tLm5p7DJzUJZKIxobkPvB/lzMT+ykd+HFw79LW3Txgb7tsGbPr3rT7K9NjMPfv8wyOKsq0NcTkYE+OPlHiaTn1OfctXKdU91Vf051PxdbLvla+hb1m9q3HVbtPmvwZ68bmL0nlaebDDUSgoCG60M1JmB853f1t35DC3AaY+nd7pszFul8obTfsdRy5q4BZU9MmVLvjN2EZF3qbGNzFke1NAZEDirEzzIzg4x9lAoBfHTwHCKDfHSu7BwZKG0to4uF5XhiSEyTQESG+qzM6Lhw/P1L/evcAIBKpcKpy80LhtxkwKbD5w2u7bPnTIGka3UKa4Xiylqdg2kraqyzXYmUYEiqkZ1uwXdnrupcIFIdYBha4dtYEGLJ3e6bO103KshXUl2klGvuwGx7Yeog1+YsrkkE2N+kBAZEjsoCQbOnuww1dcY/ULef/AOnLpXo/PCROm3892ul2KpjOwyB+q45Xy8Po2vuFFc2c4lq1GeBDGVLAEi6JwAQGeSLr5N66/yW/OH+3yVdw9vTDZVWCp6M+fbnq02OqReI7NEuEAAkByG6BuVaard7SywOmBQfjaWpOQa7zdxk9eUMsdTAbEsyd9VfexzkSs7PnrKNDIgclNRuBUNUErMLP+fdNDgQVooz+YZXl35/n7QAwp70jdH/LTnAW9pLS6isEwwF/rl1ir5ARCbTPeZMHWAkbzsNQGZ0QHRCrBLp2fl6u7IskSK3xHRdLw83PD44Rmcwo/b44BiD3V5SB2bPT+xkte6z5nQj2uMgV3IN9pJtdKxObtKwxJuSxEQIqqUWNKCy1vA1yqubn/2xtof6R+ld1O/kH8WSrtHcfdmkuqdH/QKbumYGCRgfgJ9fUoX8EsOZgbziSryz56zBQbkAJA/I1Tdg2lKZjIV3xmLmkJgmA8rdZMDMIca7u0wdmN2cxSilkDIg2hB7HORKZE3MEDkoY90P9iQ6xBfnrkkfqOwonv88E6lZ+TrHjlhzdVUpEmKV6BsTpLOvfmycUvLUe2P+84P+feKA+izSgRdHSEqRj169D+eL/sqEmrp+k5RyC++MxfzETmYNiDZlYLauzE1UoBzPdZJ0CaMs0Y1oj4NciayJAZGDMvbmZU8fx3k3nHPMwY5T+U2OqceORAVJG2xuCT6ebgYHcQf6emoCDl2ByKHfrlssICo2sE8coN2VpS9Frl5dvT4j9deHrzrT8f+m9bTo4oBeHm6YMfhWSWUbkjowW70GVOO6Xvkz47Y75wrGdm1r8vM3ZKlVf+1tkCuRNTEgcmCG3rym9I7E6m8NT/u2FqkbtzqT84UVVnsu3SN7/tLwrM6+eit/4c+7of/e1KkEXv/mZ52ZE3Wm49Wvs7Hors6YtemERTIZ5g5Cljowe//ZqwazZq9/8zMS49o0K/NiyQHR9jTIlciaGBA5OH1vXjtONp3RRc6pvMZwQHSjvMZgZsASA/RNceJiESb10p0ROZJbaHCskjrTEegnt0gmozmDkKUMzL6zS7jRvfPyS5q/X5OlB0TbyyBXImtiQOQEdL15cSYINWQoM2DtvxVD4ZspmY6J3ds0K5PR3LWMgL+m1Ddeh0i9flNshELSZsLNncreNyYIrf+cSahP6z+7TolINwZETqpXVKDV9ski+2co6JGyPpC/twdKKmstUpeYYD+950zNdJibybDEIGQ1QwOzM36TtpK7NYJSvh0QGcZp907q2Pkiq+2TRbbjLvFTrldUoP5rSNiwMyZE2gBiY2QwvNhh35ggKAP0BweWmvptyiBkKdQDs1+ZGIcZg2/VzFIzNpUdAJQBlmmPsYVNi/7sOiUi3RgQ2Tkpa5foKsPVZF2D1CWiDhvJVBjbsDM6uJWk5zGWTfGVuxss4+4mw0tj60dUt+Ru6tZalVlKsPnS2E4O0x4iZ8YuMzsmZcCnvjIP9Gln9fqSNi93mcFFLY2dt6QvTlzC4NtvMVjG0Oyi89fL8dVPxgfqG1t/qayqzugA4lGdw5CaC4QFeGutQ2TJqd/WXJVZ32zQsABvAGUY1Tms2c/BVaaJmo8BkZ2SMuAT0L+31Ordv6C1rycqqvTvqO7jDlQ43gLRDiPA2wPXyvR3Y4S08sLlYuvM8JK6Eri+MTmhBrqxTCU1S7Fz3hCcuHSzRaZ+S91XzVKDkHUFmz3a+mNn2jcWub6120PkjBgQ2SGpAz6FEAbXN6kxsv5Pt3aBOJRb1LzKkl6GgiEAVguGAKC3gTFEUhga12Mqe5j6bYtVmRu3p6bG8N+HqdfmKtNEzcMxRDakb3yQ1AGf+SWGP1DLjGQFTlyUtt8WOb7O4QHN+vm+MUHw9XI3WMbX0w2tfT0Nlgm08tRvQ2PwjI2bcrRVmZ2tPUTWxgyRjRgaH2StlZ1dcQVpV1VYrr/rVIo6lUBFjeEAu6JGBU93w9+xrDnxUcoYPGdbldnZ2kNkTQyIbMDY+KB5ozrapF7kvJo7mHZjxjkII9GMAFBsZK0iY6tmW4opiy4626rMztYeImthl5mVGRsfBACbj16AwsdwrOpnpPuCXEeAt7vedW5MXbdHXxfTb9dKLVNZAPnFLbvPm5TX2JLt2UZnxBGRa2GGyMqkjg/ykxsOeGTMgDuFAG83lFQ2r+syMTYcXxy/1OzBtIa6mK4aGa9misKy5nXfGWOpnd+JyLUwQ2RlUqccl1UZHq9RauQ8OYayquaP4xrYPrjZg2nVXUyNAwl1F5Mlx5sFtZJb7Fq6cJFCIjIHM0RWxoXRqCFLrMuoVPgg/rZgswfTSlnmIfPijeZXVF1fC07h14WLFBKRORgQWZl6ATVDKf1gPy9cb+FuBWpZbgCsMYev4fggcwfTSuliKqmshUwGgwOr3WTALa28cOWm/r9dS+xDZoyUnd+tPf2fiOwfu8yszN1NhgndDHdhTOrZxuCGkPW7j3NQtT1TBrRstxBQ/3dgzX29RhjZ+uPxwTFYMjEOMujet8tS9bUEDqcmosYYEFlZnUpg2095BsvsOJmHRXd1BqB/Q8jld3eBHXyuuLR7e7ZpEvgoA+R476GeuKONwqLPE95ofFC4BRfbk9p19LfBt2HmkJgmf3duMmDmkBgsvDPWLhYHlLLz+w3u/E5EjbDLzMqMdU8A9TNgAv3kOjeEbLjB5anLxXh/X25LV5l0kMmA5ZO6wt1NpnPczqD2tyAueadFnmtQ+xCsuK8bDv1agGs5h/Cf6X3Qv32oTfb1ir8tGPMTO2FjxjmcLyxHVJAvkuKj4eXx13crWy8OyEHVRGQOBkRWZsqb9cTubQx+sCy8MxYAsG5/LhouqeImAzqFBSA7v8Ti9XcVjw6Mwvofzus9/8TgGE0QoGvcTitvD3RtG4CTl/T/Dm69xRe/Xy03WhelwgfubjL0jQlCag4sHlyYug+Wl4cbZgy+1eg1bTWlnYOqicgc7DKzMlPfrNUfLBO7t0H8bcFNPggX3hmL00vGIKl/OwzuEIKk/u1weskYfPH0AIvX3Vl0CPUzeD4hNhSLx8cZ7R4y5ulh7Q2eX5DQqUlXWGPWGIQMONc+WOqMl6UWqyQi1+BSGaJ3330Xb775JvLy8nDHHXdg9erVGDx4sFXrYEr3hBSNF9PbfxbYnVOAl8Z2slylnczTw9ojNSsP6dkFTc4lxIZi3cN9ANQHm8a6h/RRT2XXRwbg1a+zseiuzpi16YTevwVrDkK2dVeXpXDndyIyh8sERJ999hnmzZuHd999FwMHDsT777+PsWPHIjs7G+3atbNaPSz5Zm1ov6ZnNmdapsJ2JjbcH9l5N5t1DaXCB+se7oOK6josS83GuevliA72xd/vjIVPoy1RpHQP6SJ1tWR9Y8Uab0JqLc6yD5Y642VoDB4RUUMuExCtXLkSM2bMwN/+9jcAwOrVq7Fz506sXbsWy5cvl3yd8upaeFQ33cDSTSaDt6e7Vjl9ht0eqvPNOjRAjr/f2QlDOt6i+fnG162oroOAQJ1KYPG20wb3awLq142pqjO8fowjmTHoVvxypQQf7MvVtFPdxgf7RuLr01dxxcA2E2EBcsS1CdDc34V3doa3hzvc/gxAq2tVqFXpX0FIatmLRWWS2nOxqAzjukZg7/PDcex8EQpuViLIzwvdI1vD3U2m9XdUU1OLqjqgtk4FT88/j9WpUFOnv75e7m7w+HMH+to6FaoNlPV0d9PsVm9K2TqVQFWt/pXTPdzcNFk1KWXVXwVUKmHwddTwuiqVQGWj6w7peAt2PTsEP54rQmFZFSJa+6JvTBDcZIZfn+5uMsg96l9zQghU1Oivrymve11lq+rq/+spZEbLSr2u+j1CFxlkWkG/KWUra+qgMvBG4uvlobOs+u+2YTv1lTXlurr4eLpD9ue+RlW1dQb3qzOlrLHXfcM2+rt7SH4/kXu4a778mlLWlNe9Jd8j0KB+tnyPMPS611dWCpkQzvJRqV91dTV8fX3x+eef45577tEcf+aZZ5CZmYm9e/c2+ZmqqipUVf31wVpSUoLIyEhEzvsv3OS+TcoP7RiC/0vqqXnc9ZXdqKjR/cfSNzoQn8zogzqVwLHzRXjikxN6t+ro0iYAW57sr3k87K19+OOG7syDDAINExzVdYDQO5JCQO4OtGntjT9uVEoqa8p11WrqAJXesoDcXUgu6+UmsP6RPugbE4QF/zuFrwwsX+DlJjT7vdWoAJXQf93vnhuMtoE+AIDX087gQwODqVNnD0CHsFYAgH/v+RVrvvtdb1lPN6EZg1SrAuoM1CHlsd7o92c3acrhC1iy42e9Zdc+0AWj7qjPcHxx/A+8tPW03rL/ntIVY+OUAIBvsvIx97OTesu+fs8duLdnGwDAd2eu4omUE3rLLh7XCQ/1q8+sHs4txEP/+VFv2RdGd8Djg2IAACcvFePe9w/rLTtn+K14anAU0tPTEd1tACa+d0Rv2RkDo/DSmNsBAJeKKjB85X69ZR/sG4nk8fVLWVwvq0b/17/XW/aeHhFYMSkOQP0HXLdX9+gtO+aOMKx5oJvmcYdFu/SWNec9QvN4+Xco0rOUgCnvEe1v8cM3cwdqHo/99w/49aru4L1Na298P3+I5vGk9w7h1B+6JwkE+nriyMLhmscPfngUR84V6Szr4+mGk/8cpXn8t43HsfeXazrLAsDZVxM1/z9n809IO31Fb9mfFo3QBFAvbMnC1hOX9ZY99NIwBPt5AQCSt+fgkyMX9ZZtqfeIL2b2Q9e29Ut0rDuQixU7z+ota8p7xAcP9cDwP9cNs+R7xNIJndDqahYSEhJw4PcbNnuPmDuifnzm2SuluPOdg3rLqt8jSkpKEBISguLiYgQEBOgt7xIZomvXrqGurg5hYWFax8PCwpCfn6/zZ5YvX44lS5ZIfo6rBQVITU3VPK6rc0fTVYTqFRYWapWFgbI3bhRrla2o0F82zAdY2P2vwGp5pjvy9WwsHiQHFvesA1D/Zvivk+64qCep4ecBLOvz13XXnHbHr3omT3m5ASv6/lX2/Rw3ZN/QHwg0LLv+jBsyC/WXfa13Ha7lHEJqDpB32Q2G5gQs7lmHVn9mUT7/3Q0HrhgIiL77DsF/jiXOPWf4uvv278PZP+PhsxcNl51zRx2i6t8X8e0fMmy7oH8xzUOHDuN6Tn1weDpfBkB/2ROZmag+X/9GdLLAcNnjJ05AXKi/7onrhsuePHkSPvk/1dehyHDZ06dPI/V6FgDgbLHhsj/n/IzUkhwAwPlSwNDbztmzvyK98hcAQEbGQYNlc3/PRWrqbwCA65WGr3v+/HmkptYvUVFaY7jsH5cuITX1AoD6zKOhsvl5eUhN/aPBEf1lm/MeUV1tmfeI0tJSrbKlpfrLVlRUaJW9cUN/2erqaq2yhYX6y9bV1WmVvVpg+HXUsGx+nuGyO3fu0nwh++OS4bLf7t6teY84f95w2ZZ6j/jh4A+49Od7xM9/GH4dmfIe8eOPP6Lit/qylnyPOH36NPqFAunp6TZ9j0j98z0ir9xwWfV7RHm58dm8gItkiC5fvow2bdrg4MGDiI+P1xxfunQpNm7ciJ9/bhpp68sQXbicrzPCdJfJIG9G6lxqWXWK+8dzRXjqk+NNyssavAcJAcjdBBb1VOHV426oUmm/QY3sdAv+PbX+G+uNsmqs+vYXXCqqQNtAHzwzoiO8vepfyN+dKcCLX5zSum5DD/ePxMZDFzWJ94Z1gADeuK8LAODF/51qkpyXyerfNldN6Y6aOhWe//yk3gHGq6Z0Q0Js/TeZqloV6v5M39bU1GLPnj0YMWIEPD3rXxxe7m44fuEGrpVWQeHjia5tW8Ndz/tSS3SZAcCBs9cw//P6AKNhNl59e964rwuG3x4KQFo6XN3OMYkj4SOXGyyr5pBdZqIO6enpGDlqFOoMfJiYkjp3d3OD/M+yxrrBTCprwuu+cdnissomf7dqztZl1ridDctW1dShTuJ1jZXV7gb76z2iuWWldJmp2+jvI3fiLrM6fL/nWyQkJEDm5u4wXWbMEDUQEhICd3f3JtmggoKCJlkjNblcDrm86fYLCj8fBPj5GH1OhXqQhwSmlPX8s+ywzt4I9vcxOlutW4Qf5O5XUC1kqG4QECXEhmLtw3+l5G9p7Yll9/bQ+Zx394yCt5cXkrdlI79E98Df3reGGh0Y7O3lZbSMl6enpAHGDW9ZTU0N5O6Aws9bc38AYGBH3b9bQ0z4VRgte1f3SLh7eJg8YFrfddXt9JHLNe00tb7G/3LNKAvAW+JOJVLK1tTUdw3Jvby0fp/G6Hi56uXl1TJlTXrd+0Hn321zr2vKPbNGWX2vz5avg+SizS6rr43WrIOlyhp63atfm56envD09LTZe0RDUl73Uv9uXCIg8vLyQq9evZCenq41hig9PR0TJ060Yc3MJ3W22sjbQ5CamooH+kTi9+uVemdTGWNsSraUKduWKuNInK09RETOyiUCIgB47rnnkJSUhN69eyM+Ph4ffPABLly4gCeffNLWVTOblKnF6oj+H3fFmvTtShdjU7KlTNm2VBlH4mztISJyRi4TEE2ZMgXXr1/HK6+8gry8PMTFxSE1NRVRUVG2rlqzMANBRETUfC4TEAHA008/jaefftrW1bA4ZiCIiIiah3uZERERkctjQEREREQujwERERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLc6mVqptDiPrtU0tKSmxcE9PU1NSgvLwcJSUlzd7LzF65QhsBttPZsJ3OwxXaCDhuO9Wf2+rPcX0YEEl08+ZNAEBkZKSNa0JERESmunnzJhQKhd7zMmEsZCIAgEqlwuXLl+Hv7w+ZzHE2Ti0pKUFkZCQuXryIgIAAW1enRbhCGwG209mwnc7DFdoIOG47hRC4efMmIiIi4Oamf6QQM0QSubm5oW3btrauhtkCAgIc6g/YHK7QRoDtdDZsp/NwhTYCjtlOQ5khNQ6qJiIiIpfHgIiIiIhcHgMiJyeXy7F48WLI5XJbV6XFuEIbAbbT2bCdzsMV2gg4fzs5qJqIiIhcHjNERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkQOZvny5ejTpw/8/f0RGhqKu+++G2fOnNEqI4RAcnIyIiIi4OPjg2HDhuH06dNaZaqqqjBnzhyEhITAz88PEyZMwKVLl6zZFJMsX74cMpkM8+bN0xxzlnb+8ccfeOihhxAcHAxfX190794dx44d05x3hnbW1tbiH//4B2JiYuDj44Nbb70Vr7zyClQqlaaMI7Zz3759GD9+PCIiIiCTyfDll19qnbdUm4qKipCUlASFQgGFQoGkpCTcuHGjhVtXz1Aba2pq8OKLL6JLly7w8/NDREQEHn74YVy+fFnrGvbeRsD477KhmTNnQiaTYfXq1VrHnaWdOTk5mDBhAhQKBfz9/dG/f39cuHBBc94R2mkWQQ5l9OjRYv369SIrK0tkZmaKu+66S7Rr106UlpZqyrz++uvC399ffPHFF+LUqVNiypQpIjw8XJSUlGjKPPnkk6JNmzYiPT1dHD9+XAwfPlx069ZN1NbW2qJZBh05ckRER0eLrl27imeeeUZz3BnaWVhYKKKiosQjjzwiDh8+LHJzc8Xu3bvFr7/+qinjDO187bXXRHBwsNixY4fIzc0Vn3/+uWjVqpVYvXq1powjtjM1NVW8/PLL4osvvhAAxNatW7XOW6pNY8aMEXFxceLgwYPi4MGDIi4uTowbN87mbbxx44YYNWqU+Oyzz8TPP/8sMjIyRL9+/USvXr20rmHvbRTC+O9SbevWraJbt24iIiJCrFq1SuucM7Tz119/FUFBQeL5558Xx48fF7/99pvYsWOHuHLliqaMI7TTHAyIHFxBQYEAIPbu3SuEEEKlUgmlUilef/11TZnKykqhUCjEe++9J4SofxPz9PQUmzdv1pT5448/hJubm0hLS7NuA4y4efOm6NChg0hPTxdDhw7VBETO0s4XX3xRDBo0SO95Z2nnXXfdJR577DGtY5MmTRIPPfSQEMI52tn4w8VSbcrOzhYAxKFDhzRlMjIyBADx888/t3CrtBkKFNSOHDkiAIjz588LIRyvjULob+elS5dEmzZtRFZWloiKitIKiJylnVOmTNG8LnVxxHZKxS4zB1dcXAwACAoKAgDk5uYiPz8fiYmJmjJyuRxDhw7FwYMHAQDHjh1DTU2NVpmIiAjExcVpytiLWbNm4a677sKoUaO0jjtLO7dt24bevXvj/vvvR2hoKHr06IF169ZpzjtLOwcNGoRvv/0Wv/zyCwDgp59+woEDB3DnnXcCcJ52NmSpNmVkZEChUKBfv36aMv3794dCobDLdhcXF0Mmk6F169YAnKeNKpUKSUlJeP7553HHHXc0Oe8M7VSpVPj666/RsWNHjB49GqGhoejXr59Wt5oztFMfBkQOTAiB5557DoMGDUJcXBwAID8/HwAQFhamVTYsLExzLj8/H15eXggMDNRbxh5s3rwZx48fx/Lly5ucc5Z2/v7771i7di06dOiAnTt34sknn8TcuXPx8ccfA3Cedr744ouYOnUqOnXqBE9PT/To0QPz5s3D1KlTAThPOxuyVJvy8/MRGhra5PqhoaF21+7Kykq89NJLmDZtmmbzT2dp4xtvvAEPDw/MnTtX53lnaGdBQQFKS0vx+uuvY8yYMdi1axfuueceTJo0CXv37gXgHO3Uh7vdO7DZs2fj5MmTOHDgQJNzMplM67EQosmxxqSUsZaLFy/imWeewa5du+Dt7a23nKO3U6VSoXfv3li2bBkAoEePHjh9+jTWrl2Lhx9+WFPO0dv52WefISUlBZs2bcIdd9yBzMxMzJs3DxEREZg+fbqmnKO3UxdLtElXeXtrd01NDR544AGoVCq8++67Rss7UhuPHTuGt99+G8ePHze5Po7UTvUkh4kTJ+LZZ58FAHTv3h0HDx7Ee++9h6FDh+r9WUdqpz7MEDmoOXPmYNu2bfjuu+/Qtm1bzXGlUgkATaLwgoICzTdVpVKJ6upqFBUV6S1ja8eOHUNBQQF69eoFDw8PeHh4YO/evfj3v/8NDw8PTT0dvZ3h4eGIjY3VOta5c2fNjA5n+X0+//zzeOmll/DAAw+gS5cuSEpKwrPPPqvJ/jlLOxuyVJuUSiWuXLnS5PpXr161m3bX1NRg8uTJyM3NRXp6uiY7BDhHG/fv34+CggK0a9dO8350/vx5zJ8/H9HR0QCco50hISHw8PAw+p7k6O3UhwGRgxFCYPbs2diyZQv27NmDmJgYrfMxMTFQKpVIT0/XHKuursbevXsxYMAAAECvXr3g6empVSYvLw9ZWVmaMrY2cuRInDp1CpmZmZp/vXv3xoMPPojMzEzceuutTtHOgQMHNlk24ZdffkFUVBQA5/l9lpeXw81N++3G3d1d843UWdrZkKXaFB8fj+LiYhw5ckRT5vDhwyguLraLdquDobNnz2L37t0IDg7WOu8MbUxKSsLJkye13o8iIiLw/PPPY+fOnQCco51eXl7o06ePwfckZ2inXlYexE3N9NRTTwmFQiG+//57kZeXp/lXXl6uKfP6668LhUIhtmzZIk6dOiWmTp2qc6pv27Ztxe7du8Xx48fFiBEj7Gqati4NZ5kJ4RztPHLkiPDw8BBLly4VZ8+eFZ988onw9fUVKSkpmjLO0M7p06eLNm3aaKbdb9myRYSEhIgXXnhBU8YR23nz5k1x4sQJceLECQFArFy5Upw4cUIzw8pSbRozZozo2rWryMjIEBkZGaJLly5Wm8JsqI01NTViwoQJom3btiIzM1PrPamqqsph2misnbo0nmUmhHO0c8uWLcLT01N88MEH4uzZs2LNmjXC3d1d7N+/36HaaQ4GRA4GgM5/69ev15RRqVRi8eLFQqlUCrlcLoYMGSJOnTqldZ2Kigoxe/ZsERQUJHx8fMS4cePEhQsXrNwa0zQOiJylndu3bxdxcXFCLpeLTp06iQ8++EDrvDO0s6SkRDzzzDOiXbt2wtvbW9x6663i5Zdf1vrQdMR2fvfddzpfj9OnTxdCWK5N169fFw8++KDw9/cX/v7+4sEHHxRFRUU2b2Nubq7e96TvvvvOYdporJ266AqInKWdH374oWjfvr3w9vYW3bp1E19++aXWNRyhneaQCSFEy+agiIiIiOwbxxARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRE5DCGDRuGefPm2eS5v//+e8hkMty4ccMmz09ELYsBERFRI7oCrwEDBiAvLw8KhcI2lSKiFsWAiIhcRk1Njdk/6+XlBaVSCZlMZsEaEZG9YEBERHaprKwMDz/8MFq1aoXw8HC89dZbWudlMhm+/PJLrWOtW7fGhg0bAADnzp2DTCbDf//7XwwbNgze3t5ISUnB9evXMXXqVLRt2xa+vr7o0qULPv30U801HnnkEezduxdvv/02ZDIZZDIZzp07p7PL7IsvvsAdd9wBuVyO6OjoJnWMjo7GsmXL8Nhjj8Hf3x/t2rXDBx98YNH7RESWwYCIiOzS888/j++++w5bt27Frl278P333+PYsWMmX+fFF1/E3LlzkZOTg9GjR6OyshK9evXCjh07kJWVhSeeeAJJSUk4fPgwAODtt99GfHw8Hn/8ceTl5SEvLw+RkZFNrnvs2DFMnjwZDzzwAE6dOoXk5GQsWrRIE5CpvfXWW+jduzdOnDiBp59+Gk899RR+/vlns+4JEbUcD1tXgIiosdLSUnz44Yf4+OOPkZCQAAD46KOP0LZtW5OvNW/ePEyaNEnr2IIFCzT/P2fOHKSlpeHzzz9Hv379oFAo4OXlBV9fXyiVSr3XXblyJUaOHIlFixYBADp27Ijs7Gy8+eabeOSRRzTl7rzzTjz99NMA6oOzVatW4fvvv0enTp1MbgsRtRxmiIjI7vz222+orq5GfHy85lhQUBBuv/12k6/Vu3dvrcd1dXVYunQpunbtiuDgYLRq1Qq7du3ChQsXTLpuTk4OBg4cqHVs4MCBOHv2LOrq6jTHunbtqvl/mUwGpVKJgoICk9tBRC2LGSIisjtCCKNlZDJZk3K6Bk37+flpPX7rrbewatUqrF69Gl26dIGfnx/mzZuH6upqk+vYeIC1rnp7eno2qbdKpTLpuYio5TFDRER2p3379vD09MShQ4c0x4qKivDLL79oHt9yyy3Iy8vTPD579izKy8uNXnv//v2YOHEiHnroIXTr1g233norzp49q1XGy8tLK8ujS2xsLA4cOKB17ODBg+jYsSPc3d2N1oOI7AszRERkd1q1aoUZM2bg+eefR3BwMMLCwvDyyy/Dze2v73AjRozAO++8g/79+0OlUuHFF19sko3RpX379vjiiy9w8OBBBAYGYuXKlcjPz0fnzp01ZaKjo3H48GGcO3cOrVq1QlBQUJPrzJ8/H3369MGrr76KKVOmICMjA++88w7effddy9wEIrIqZoiIyC69+eabGDJkCCZMmIBRo0Zh0KBB6NWrl+b8W2+9hcjISAwZMgTTpk3DggUL4Ovra/S6ixYtQs+ePTF69GgMGzYMSqUSd999t1aZBQsWwN3dHbGxsbjlllt0ji/q2bMn/vvf/2Lz5s2Ii4vDP//5T7zyyitaA6qJyHHIhJTOeiIiIiInxgwRERERuTwGREREROTyGBARERGRy2NARERERC6PARERERG5PAZERERE5PIYEBEREZHLY0BERERELo8BEREREbk8BkRERETk8hgQERERkctjQEREREQu7/8Dn8Q23hADgoYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from plot import plotVariables\n", + "plotVariables(data_expanded[\"duration\"],data_expanded[\"resp_duration\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "584ab790-e5b7-4d52-af05-39f8d2f1692d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'role=\\'assistant\\' content=\\'{\"duration\":\"25\",\"ZusatzInfo\":\"Bitte geben Sie an, ob zusätzlich Fensterreinigung, Teppichreinigung, Bodenpflege, etc. erforderlich sind, sowie die genaue Aufteilung der 50\\\\u202fqm auf die einzelnen Räume.\",\"complete\":\"0\",\"confidence\":\"0.3\",\"missverständliche Aspekte\":\"Nicht spezifiziert, ob die 50\\\\u202fqm die gesamte Raumfläche oder die zu reinigende Bodenfläche umfasst; fehlende Angaben zu Fenstern, Bodenbelag, etc.\",\"Zu erbringende Leistungen:\":\"Reinigung aller Räume (Boden, Oberflächen), Grundreinigung.\",\"Rechenweg\":\"Annahme 5 Minuten pro 10\\\\u202fqm → 50\\\\u202fqm / 10 = 5 Einheiten × 5\\\\u202fMinuten = 25\\\\u202fMinuten.\",\"Kommentare\":\"Beschreibung unvollständig; weitere Angaben zu Fenstern, Bodenbelag und spezifischen Anforderungen nötig.\"}\\' thinking=\\'We need to respond only in JSON with specified fields: duration, ZusatzInfo, complete, confidence, missverständliche Aspekte, Zu erbringende Leistungen:, Rechenweg, Kommentare.\\\\n\\\\nThe user gave description: \"50qm Alle Räume bitte reinigen Küche und Wohnzimmer Abstellraum Schlafzimmer Badezimmer Wc Am 28.6.23\". It\\\\\\'s not specifying which specific tasks or details; only that total area is 50 qm and all rooms to be cleaned. We must interpret. But tasks are \"reinigungsaufträge zur Endreinigung\" for end cleaning after occupant moved out. The example durations given: windows, balcony, etc. But user didn\\\\\\'t mention windows, floor area? There\\\\\\'s mention of 50 qm total area. So we can assume floor cleaning area maybe 50 qm. But we don\\\\\\'t have tasks like windows, etc. So we need to interpret.\\\\n\\\\nWe must check if description is complete: It lists rooms but not details. We only have area 50qm, not each room area. So it\\\\\\'s incomplete. Should ask for more info. But per instruction: If no extra info needed, leave field empty. But we do need extra info: like details of windows, floor area, etc. So we should set ZusatzInfo empty? Wait \"Gibt es zusätzliche Informationen die du vom Kunden anfordern möchtest? Lass das feld leer, wenn nicht.\" So we can ask additional info. But the field \"ZusatzInfo\" is for extra info that we need? It says \"Gibt es zusätzliche Informationen die du vom Kunden anfordern möchtest? Lass das Feld leer, wenn nicht.\" So we should fill \"ZusatzInfo\" with the question we want to ask: like \"Bitte geben Sie an, ob zusätzliche Leistungen wie Fensterreinigung, Teppichreinigung etc. erforderlich sind.\" So we need to provide a question.\\\\n\\\\nWe must provide \"complete\" as 1 if description complete else 0. It\\\\\\'s incomplete, so 0.\\\\n\\\\nConfidence: how confident we are in interpretation? Maybe 0.3.\\\\n\\\\nMissverständliche Aspekte: likely lack of detail on area per room, whether windows included, floor area.\\\\n\\\\nZu erbringende Leistungen: we can list generic: Reinigung aller Räume (floor, surfaces), but we need to estimate duration based on area? They gave 50qm. Example durations: windows 20 min, balcony 20, altbau window 30, etc. For floor cleaning: Not specified. We might estimate 10 min per 10 sqm? Not given. But we can approximate? But no instructions for floor cleaning duration. The schema demands \"duration\": \"quoted integer\". So we must produce integer minutes. We could guess maybe 5 min per 10 sqm => 25 min. But uncertain. Since incomplete, we might leave duration as \"?\" But must provide integer. We can compute maybe 10 min per 10 sqm => 50sqm -> 50 min? Or 1 min per sqm? Not defined. Maybe safe: 5 min per 10sqm => 25 min. But mention uncertain. Provide explanation.\\\\n\\\\nRechenweg: explain calculation.\\\\n\\\\nKommentare: maybe note we need more info.\\\\n\\\\nSo produce JSON:\\\\n\\\\n{\\\\n \"duration\": \"25\",\\\\n \"ZusatzInfo\": \"Bitte geben Sie an, ob zusätzlich Fensterreinigung, Teppichreinigung, Bodenpflege, etc. erforderlich sind, sowie die genaue Aufteilung der 50 qm auf die einzelnen Räume.\",\\\\n \"complete\": \"0\",\\\\n \"confidence\": \"0.3\",\\\\n \"missverständliche Aspekte\": \"Nicht spezifiziert, ob die 50 qm die gesamte Raumfläche oder die zu reinigende Bodenfläche umfasst; fehlende Angaben zu Fenstern, Bodenbelag, etc.\",\\\\n \"Zu erbringende Leistungen:\": \"Reinigung aller Räume (Boden, Oberflächen), Grundreinigung.\",\\\\n \"Rechenweg\": \"Annahme 5 Minuten pro 10 qm → 50 qm / 10 = 5 Einheiten × 5 Minuten = 25 Minuten.\",\\\\n \"Kommentare\": \"Beschreibung unvollständig; weitere Angaben zu Fenstern, Bodenbelag und spezifischen Anforderungen nötig.\"\\\\n}\\\\n\\\\nMake sure JSON string quoting correct.\\' images=None tool_calls=None'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_expanded.loc[1,\"response\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a522e83-df13-4cc9-a566-4bc1131a6e6e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc17b8bd-c764-429b-b59c-c81e38bdc19e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8ba7982-709d-4f89-8bdf-b66d9e1f1610", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "58d01dcb-0ee5-428e-8d44-02db4c243389", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74a72a6a-daed-48bf-9da5-594567fc8087", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ea0f8f96-a3a5-4fcf-9567-28b9eb5ade74", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "921d4d2b-a01a-4f39-89f4-00ed5193df63", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c934a31d-c55f-406e-a381-fd6cf9778dca", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08eac323-951f-45f4-b2c7-925ea92c269e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/main.py b/main.py new file mode 100644 index 0000000..c9edaec --- /dev/null +++ b/main.py @@ -0,0 +1,145 @@ +import pandas as pd +from client import askGPT + +systempromptWindow = """Du bist ein Assistent zur Kostenschätzung von Reinigungsaufträgen. + Antworte nur im gewünschten JSON-Schema. + + Preisliste (EUR): + - normale_fenster: 15 + - balkon_terrassentuer: 15 + - altbau_doppelfenster: 25 (teurer, da üblicherweise unterteilt in 4 Scheiben) + - aussenjalousien: 15 + - schaufenster_pro_m2: 3.6 + + Aufgaben: + 1. Prüfe genau, ob die Beschreibung vollständig und klar ist: + - Sind alle Leistungen eindeutig und verständlich beschrieben? + - Sind Mengen klar spezifiziert? Falls nur Scheiben angegeben sind: Berechne daraus unbedingt, wie viele komplette Fenster gemeint sind. + - Kläre, ob Zahlen sich auf Scheiben, Fenster oder Quadratmeter beziehen. + + 2. Identifiziere explizit mögliche Missverständnisse in der Beschreibung und erläutere sie kurz. + + 3. Führe eine schrittweise Kalkulation durch: + - Wandle Scheibenanzahl ggf. zuerst in Fenster um. + - Fasse alle eindeutigen Leistungen zusammen (mit genauen Mengenangaben). + + 4. Kalkuliere den Gesamtpreis und erkläre den Rechenweg klar. + + 5. Gib den minimalen Gesamtpreis (nur vollständig angegebene Leistungen). + + 6. Gib den maximalen Gesamtpreis (unter Berücksichtigung angedeuteter/unvollständiger Angaben). + + 7. Schätze konservativ die Klarheit und Vollständigkeit der Beschreibung (zwischen 0 und 1). + + 8. Gibt es zuzätzliche Informationen die du vom Kunden anfordern möchtest? Lass das feld leer, wenn nicht. + + Response Schema: + {"totalPrice": "integer", "totalPriceLow": "integer", "totalPriceHigh": "integer","ZusatzInfo": "string", "complete": "boolean", "confidence": "float","missverständliche Aspekte": "string","Zu erbringende Leistungen:": "string", "Rechenweg": "string", "Kommentare": "string"} + + Berechne anhand der Auftragsbeschreibung, welche Leistungen wie oft vorhanden sind. Summiere diese zu einem Gesamtpreis! + """ + +systempromptUmzug = """Du bist ein Assistent zur Kostenschätzung von Reinigungsaufträgen zur Endreinigung nachdem der Bewohner ausgezogen ist. + Antworte nur im gewünschten JSON-Schema. + + Beispiele (Minuten): + - normale_fenster: 20 + - balkon_terrassentuer: 20 + - altbau_doppelfenster: 30 (aufwendiger, da üblicherweise unterteilt in 4 Scheiben) + - aussenjalousien: 20 + - schaufenster_pro_m2: 5 + + Aufgaben: + 1. Prüfe genau, ob die Beschreibung vollständig und klar ist: + - Sind alle Leistungen eindeutig und verständlich beschrieben? + - Sind Mengen klar spezifiziert? Falls nur Scheiben angegeben sind: Berechne daraus unbedingt, wie viele komplette Fenster gemeint sind. + - Kläre, ob Zahlen sich auf Scheiben, Fenster oder Quadratmeter Fensterfläche oder Quadratmeter Bodenfläche beziehen. + + 2. Identifiziere explizit mögliche Missverständnisse in der Beschreibung und erläutere sie kurz. + + 3. Führe eine schrittweise Kalkulation durch: + - Wandle Scheibenanzahl ggf. zuerst in Fenster um. + - Fasse alle eindeutigen Leistungen zusammen (mit genauen Mengenangaben). + + 4. Kalkuliere den Gesamtaufwand und erkläre den Rechenweg klar. + + + 5. Schätze konservativ die Klarheit und Vollständigkeit der Beschreibung (zwischen 0 und 1). + + 6. Gibt es zuzätzliche Informationen die du vom Kunden anfordern möchtest? Lass das feld leer, wenn nicht. + + Response Schema: + {"duration": "quoted integer","ZusatzInfo": "quoted string", "complete": "quoted number 1 or 0", "confidence": "quoted float between 0 and 1","missverständliche Aspekte": "quoted string","Zu erbringende Leistungen:": "quoted string", "Rechenweg": "quoted string", "Kommentare": "quoted string"} + + Berechne anhand der Auftragsbeschreibung, welche Leistungen wie oft vorhanden sind. Summiere diese zu einem Gesamtaufwand! + """ + +systempromptIntensiv = """Du bist ein Assistent zur Kostenschätzung von Reinigungsaufträgen zur besonders gründlichen Reinigung. + Antworte nur im gewünschten JSON-Schema. + + Beispiele (Minuten): + - normale_fenster: 30 + - balkon_terrassentuer: 30 + - altbau_doppelfenster: 45 (aufwendiger, da üblicherweise unterteilt in 4 Scheiben) + - aussenjalousien: 30 + - schaufenster_pro_m2: 7.5 + + Aufgaben: + 1. Prüfe genau, ob die Beschreibung vollständig und klar ist: + - Sind alle Leistungen eindeutig und verständlich beschrieben? + - Sind Mengen klar spezifiziert? Falls nur Scheiben angegeben sind: Berechne daraus unbedingt, wie viele komplette Fenster gemeint sind. + - Kläre, ob Zahlen sich auf Scheiben, Fenster oder Quadratmeter Fensterfläche oder Quadratmeter Bodenfläche beziehen. + + 2. Identifiziere explizit mögliche Missverständnisse in der Beschreibung und erläutere sie kurz. + + 3. Führe eine schrittweise Kalkulation durch: + - Wandle Scheibenanzahl ggf. zuerst in Fenster um. + - Fasse alle eindeutigen Leistungen zusammen (mit genauen Mengenangaben). + + 4. Kalkuliere den Gesamtaufwand und erkläre den Rechenweg klar. + + + 5. Schätze konservativ die Klarheit und Vollständigkeit der Beschreibung (zwischen 0 und 1). + + 6. Gibt es zuzätzliche Informationen die du vom Kunden anfordern möchtest? Lass das feld leer, wenn nicht. + + Response Schema: + {"duration": "quoted integer","ZusatzInfo": "quoted string", "complete": "quoted number 1 or 0", "confidence": "quoted float between 0 and 1","missverständliche Aspekte": "quoted string","Zu erbringende Leistungen:": "quoted string", "Rechenweg": "quoted string", "Kommentare": "quoted string"} + + Berechne anhand der Auftragsbeschreibung, welche Leistungen wie oft vorhanden sind. Summiere diese zu einem Gesamtaufwand! + """ + + + + +data = pd.read_csv("./intensivQuotationsSample.csv", on_bad_lines='skip',sep=";") +data["response"]="" +index = data.index +for i in index: + print(f"\n\n\n\n\n\niteration {i} in {index}\n") + quotation = data.iloc[i,] + print(quotation["requirements_textual"]) + response = askGPT(systempromptIntensiv,quotation["requirements_textual"]) + data.at[i,"response"] = response + print(quotation["duration"]) + + + data.to_csv("./intensivQuotationsSampleWithResponse.csv", index=False,sep=";") + + +data = pd.read_csv("./umzugQuotationsSample.csv", on_bad_lines='skip',sep=";") +data["response"]="" +index = data.index +for i in index: + print(f"\n\n\n\n\n\niteration {i} in {index}\n") + quotation = data.iloc[i,] + print(quotation["requirements_textual"]) + response = askGPT(systempromptUmzug,quotation["requirements_textual"]) + data.at[i,"response"] = response + print(quotation["duration"]) + + + data.to_csv("./umzugQuotationsSampleWithResponse.csv", index=False,sep=";") +#print(data) + +#print(systemprompt) diff --git a/plot.py b/plot.py new file mode 100644 index 0000000..bc8986b --- /dev/null +++ b/plot.py @@ -0,0 +1,97 @@ +import pandas as pd +import matplotlib.pyplot as plt +import numpy as np + + +def plotVariables(x,y): + + # scatter plot (matplotlib, single plot, no explicit colors) + #plt.ylim(0, 1) + plt.figure() + plt.scatter(x, y) + plt.axhline(0, linestyle="--") # reference line + plt.xlabel(x.name) + plt.ylabel(y.name) + plt.title("diff_price vs. confidence") + plt.grid(True) + plt.show() + +def plotPriceConfidence(condensed): + # pick the right confidence column + conf_col = "confidence" if "confidence" in condensed.columns else ( + "resp_confidence" if "resp_confidence" in condensed.columns else None + ) + if conf_col is None: + raise KeyError("No 'confidence' or 'resp_confidence' column found in condensed.") + + # keep only the needed columns and coerce to numeric + dfp = condensed[[conf_col, "diff_price"]].copy() + dfp[conf_col] = pd.to_numeric(dfp[conf_col], errors="coerce") + dfp["diff_price"] = pd.to_numeric(dfp["diff_price"], errors="coerce") + dfp = dfp.dropna(subset=[conf_col, "diff_price"]) + + # scatter plot (matplotlib, single plot, no explicit colors) + #plt.ylim(0, 1) + plt.figure() + plt.scatter(dfp[conf_col], dfp["diff_price"]) + plt.axhline(0, linestyle="--") # reference line + plt.xlabel(conf_col) + plt.ylabel("diff_price") + plt.title("diff_price vs. confidence") + plt.grid(True) + plt.show() + +def histPriceDiff(condensed): + conf_col = ( + "confidence" if "confidence" in condensed.columns + else "resp_confidence" if "resp_confidence" in condensed.columns + else None + ) + if conf_col is None: + raise KeyError("No 'confidence' or 'resp_confidence' column in condensed.") + + # --- prepare data --- + df = condensed[[conf_col, "diff_price"]].copy() + df[conf_col] = pd.to_numeric(df[conf_col], errors="coerce") + df["diff_price"] = pd.to_numeric(df["diff_price"], errors="coerce") + df = df.dropna(subset=[conf_col, "diff_price"]) + + # scale confidence to 0–100 if it looks like 0–1 + if df[conf_col].max() <= 1.01: + df[conf_col] = df[conf_col] * 100 + + # --- define bands --- + bands = [ + ("confidence == 100", df[ df[conf_col] == 100 ]), + ("100 > confidence ≥ 90", df[(df[conf_col] < 100) & (df[conf_col] >= 90)]), + ("90 > confidence ≥ 80", df[(df[conf_col] < 90) & (df[conf_col] >= 80)]), + ("80 > confidence ≥ 50", df[(df[conf_col] < 80) & (df[conf_col] >= 50)]), + ("50 > confidence", df[ df[conf_col] < 50 ]), + ] + + # --- common bins across all groups for fair comparison --- + all_vals = df["diff_price"].values + if all_vals.size == 0: + raise ValueError("No numeric diff_price values to plot.") + xmin, xmax = np.nanmin(all_vals), np.nanmax(all_vals) + if xmin == xmax: + # degenerate case: make a tiny range around the single value + xmin, xmax = xmin - 0.5, xmax + 0.5 + bins = np.linspace(xmin, xmax, 31) # 30 bins + + # --- plot each histogram in its own figure (no subplots, no explicit colors) --- + for title, d in bands: + if d.empty: + print(f"[skip] {title}: no rows") + continue + plt.figure() + plt.hist(d["diff_price"].values, bins=bins) + plt.title(f"diff_price for {title}") + plt.xlabel("diff_price") + plt.ylabel("count") + plt.grid(True) + plt.show() + + # (optional) quick counts per band + for title, d in bands: + print(f"{title}: {len(d)} rows") \ No newline at end of file