Random-Sampling/Z-Test-Self/Z-Test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fae3c63c-80bc-480e-b3c4-62c5e05899ff",
   "metadata": {},
   "source": [
    "## Basic Z-Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9806ac64-f784-4559-82d8-ddbf57169925",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dataset = [80, 85, 88, 92, 95, 78, 89, 91, 88, 82, 79, 94, 90, 87, 84]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0df6ea58-aca9-4d76-aea4-e5944f7b94f7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import hashlib\n",
    "\n",
    "def hash_function(value):\n",
    "    hash_object = hashlib.md5(str(value).encode())\n",
    "    return int(hash_object.hexdigest(), 16) % len(dataset)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fa504103-ad56-4156-bd9d-6efd5ecb06c1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Samples: [79, 85, 90]\n"
     ]
    }
   ],
   "source": [
    "samples = []\n",
    "for _ in range(3):\n",
    "    index = hash_function(_)\n",
    "    samples.append(dataset[index])\n",
    "\n",
    "print(\"Samples:\", samples)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "416e38ee-8775-4724-949b-974b43e27aae",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z Value: -0.3989107157369403\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "\n",
    "population_mean = statistics.mean(dataset)\n",
    "population_stddev = statistics.stdev(dataset)\n",
    "\n",
    "sample_mean = statistics.mean(samples)\n",
    "z_value = (sample_mean - population_mean) / population_stddev\n",
    "\n",
    "print(\"Z Value:\", z_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed522433-77c0-40ca-a188-50d0c582eee8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Sample: 79\n",
      "Z Value for Best Sample: -0.3989107157369403\n"
     ]
    }
   ],
   "source": [
    "best_sample_index = samples.index(max(samples, key=lambda x: abs(x - population_mean)))\n",
    "print(\"Best Sample:\", samples[best_sample_index])\n",
    "print(\"Z Value for Best Sample:\", z_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad96c7cb-43d1-479b-9193-3b683289d97a",
   "metadata": {},
   "source": [
    "## Z-Test (Sampling - College Students CGPA, SGPA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "adeaf0fd-6422-4716-844c-d7157d327e9e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import csv\n",
    "import random\n",
    "import statistics\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Read data from CSV file\n",
    "def read_data_from_csv(file_path):\n",
    "    data = []\n",
    "    with open(file_path, 'r') as csvfile:\n",
    "        reader = csv.reader(csvfile)\n",
    "        next(reader)  # Skip the header row\n",
    "        for row in reader:\n",
    "            # Assuming CGPA is in the first column and SGPA is in the second column\n",
    "            cgpa, sgpa = float(row[0]), float(row[1])\n",
    "            data.append((cgpa, sgpa))\n",
    "    return data\n",
    "\n",
    "# Write data to CSV file\n",
    "def write_data_to_csv(file_path, data):\n",
    "    with open(file_path, 'w', newline='') as csvfile:\n",
    "        writer = csv.writer(csvfile)\n",
    "        for row in data:\n",
    "            writer.writerow(row)\n",
    "\n",
    "# Read data from CSV file\n",
    "dataset = read_data_from_csv('students_data.csv')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "671edcb0-c4b1-4432-b262-ebb69d8a29ff",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def custom_hash(value):\n",
    "\n",
    "    # A simple hash function based on CGPA\n",
    "    return int(value[0] * 10) % 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "758ad4c1-1b30-4c0d-917f-b14098d9d8b3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Initializing empty sample lists\n",
    "sample1, sample2, sample3 = [], [], []\n",
    "\n",
    "# Performing custom sampling\n",
    "for data_point in dataset:\n",
    "    hash_value = custom_hash(data_point)\n",
    "    if hash_value == 0:\n",
    "        sample1.append(data_point)\n",
    "    elif hash_value == 1:\n",
    "        sample2.append(data_point)\n",
    "    else:\n",
    "        sample3.append(data_point)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fbb5ea27-8e63-4ba4-8b8c-42921238edde",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Calculating means and standard deviations for each sample\n",
    "mean1 = statistics.mean([x[1] for x in sample1])\n",
    "std_dev1 = statistics.stdev([x[1] for x in sample1])\n",
    "\n",
    "mean2 = statistics.mean([x[1] for x in sample2])\n",
    "std_dev2 = statistics.stdev([x[1] for x in sample2])\n",
    "\n",
    "mean3 = statistics.mean([x[1] for x in sample3])\n",
    "std_dev3 = statistics.stdev([x[1] for x in sample3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f38236b8-21fe-4d87-b93c-21d450564f57",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample 1 is the best sample.\n",
      "Best Sample: [(3.9, 4.0), (3.6, 3.8)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculating Z-values for each sample\n",
    "z_value1 = (mean1 - statistics.mean([x[1] for x in dataset])) / std_dev1\n",
    "z_value2 = (mean2 - statistics.mean([x[1] for x in dataset])) / std_dev2\n",
    "z_value3 = (mean3 - statistics.mean([x[1] for x in dataset])) / std_dev3\n",
    "\n",
    "# Comparing Z-values and concluding the best sample\n",
    "best_sample = None\n",
    "if z_value1 > z_value2 and z_value1 > z_value3:\n",
    "    best_sample = sample1\n",
    "    print(\"Sample 1 is the best sample.\")\n",
    "elif z_value2 > z_value1 and z_value2 > z_value3:\n",
    "    best_sample = sample2\n",
    "    print(\"Sample 2 is the best sample.\")\n",
    "else:\n",
    "    best_sample = sample3\n",
    "    print(\"Sample 3 is the best sample.\")\n",
    "\n",
    "# Printing the best sample\n",
    "print(\"Best Sample:\", best_sample)\n",
    "\n",
    "# Plotting the data points and best sample\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(*zip(*dataset), label='Original Data')\n",
    "plt.scatter(*zip(*best_sample), label='Best Sample', color='red', marker='x')\n",
    "plt.xlabel('CGPA')\n",
    "plt.ylabel('SGPA')\n",
    "plt.legend()\n",
    "plt.title('College Students CGPA vs SGPA')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8eab8c57-446b-4655-8643-554904bb3a8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Z-Test (Sampling - EB Bill)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d59d058c-2668-4d0c-b372-f8437b72295c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import csv\n",
    "import statistics\n",
    "\n",
    "# Read data from CSV file\n",
    "def read_data_from_csv(file_path):\n",
    "    data = []\n",
    "    with open(file_path, 'r') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        for row in reader:\n",
    "            units_consumed, amount = int(row['UnitsConsumed']), int(row['Amount'])\n",
    "            data.append((units_consumed, amount))\n",
    "    return data\n",
    "\n",
    "# Custom hash function for sampling\n",
    "def custom_hash(value):\n",
    "    # Hash function based on Units Consumed\n",
    "    return value[0] % 3\n",
    "\n",
    "# Read data from CSV file\n",
    "dataset = read_data_from_csv('eb_bill_data.csv')\n",
    "\n",
    "# Perform sampling using custom hash function\n",
    "sample1, sample2, sample3 = [], [], []\n",
    "for data_point in dataset:\n",
    "    hash_value = custom_hash(data_point)\n",
    "    if hash_value == 0:\n",
    "        sample1.append(data_point)\n",
    "    elif hash_value == 1:\n",
    "        sample2.append(data_point)\n",
    "    else:\n",
    "        sample3.append(data_point)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9501e71a-9eaa-42c4-9e3a-6ee4a7b29bdc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Calculate mean and standard deviation for each sample if they have at least two data points\n",
    "mean1, std_dev1 = statistics.mean([x[1] for x in sample1]), statistics.stdev([x[1] for x in sample1]) if len(sample1) >= 2 else (float('nan'), float('nan'))\n",
    "mean2, std_dev2 = statistics.mean([x[1] for x in sample2]), statistics.stdev([x[1] for x in sample2]) if len(sample2) >= 2 else (float('nan'), float('nan'))\n",
    "mean3, std_dev3 = statistics.mean([x[1] for x in sample3]), statistics.stdev([x[1] for x in sample3]) if len(sample3) >= 2 else (float('nan'), float('nan'))\n",
    "\n",
    "# Calculate Z-values for each sample\n",
    "z_value1 = (mean1 - statistics.mean([x[1] for x in dataset])) / std_dev1 if len(sample1) >= 2 else float('nan')\n",
    "z_value2 = (mean2 - statistics.mean([x[1] for x in dataset])) / std_dev2 if len(sample2) >= 2 else float('nan')\n",
    "z_value3 = (mean3 - statistics.mean([x[1] for x in dataset])) / std_dev3 if len(sample3) >= 2 else float('nan')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c27696e0-0666-4918-811b-c7a5891f6073",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Mean</th>\n",
       "      <th>Standard Deviation</th>\n",
       "      <th>Z-Value</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sample</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Sample 1</th>\n",
       "      <td>520.0</td>\n",
       "      <td>56.568542</td>\n",
       "      <td>0.864242</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sample 2</th>\n",
       "      <td>490.0</td>\n",
       "      <td>233.023604</td>\n",
       "      <td>0.081060</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sample 3</th>\n",
       "      <td>432.5</td>\n",
       "      <td>259.919859</td>\n",
       "      <td>-0.148550</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Mean  Standard Deviation   Z-Value\n",
       "Sample                                       \n",
       "Sample 1  520.0           56.568542  0.864242\n",
       "Sample 2  490.0          233.023604  0.081060\n",
       "Sample 3  432.5          259.919859 -0.148550"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create a DataFrame to display the calculations\n",
    "data = {\n",
    "    'Sample': ['Sample 1', 'Sample 2', 'Sample 3'],\n",
    "    'Mean': [mean1, mean2, mean3],\n",
    "    'Standard Deviation': [std_dev1, std_dev2, std_dev3],\n",
    "    'Z-Value': [z_value1, z_value2, z_value3]\n",
    "}\n",
    "\n",
    "result_df = pd.DataFrame(data)\n",
    "result_df.set_index('Sample', inplace=True)\n",
    "result_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5fc802e6-d738-464c-9c12-384642d7341b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample 1 is the best sample.\n",
      "Estimated Bill Amount for Total Units Consumed: 702000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Determine the best sample\n",
    "best_sample = None\n",
    "if z_value1 > z_value2 and z_value1 > z_value3:\n",
    "    best_sample = sample1\n",
    "    print(\"Sample 1 is the best sample.\")\n",
    "elif z_value2 > z_value1 and z_value2 > z_value3:\n",
    "    best_sample = sample2\n",
    "    print(\"Sample 2 is the best sample.\")\n",
    "else:\n",
    "    best_sample = sample3\n",
    "    print(\"Sample 3 is the best sample.\")\n",
    "\n",
    "# Calculate the estimated bill amount for the best sample\n",
    "total_units_consumed = sum([x[0] for x in best_sample])\n",
    "estimated_bill_amount = total_units_consumed * (mean1 if len(sample1) >= 2 else float('nan'))\n",
    "\n",
    "# Print the estimated bill amount\n",
    "print(\"Estimated Bill Amount for Total Units Consumed:\", estimated_bill_amount)\n",
    "\n",
    "# Plot the data points and best sample\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(*zip(*dataset), label='Original Data')\n",
    "plt.scatter(*zip(*best_sample), label='Best Sample', color='red', marker='x')\n",
    "plt.xlabel('Units Consumed')\n",
    "plt.ylabel('Amount')\n",
    "plt.legend()\n",
    "plt.title('Electricity Bill Data')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38722537-7c0d-4c07-80d7-903d1b794a2f",
   "metadata": {},
   "source": [
    "## Z-Test (Sampling - Salary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "23871346-3725-425f-89cd-8fad7e485705",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sample</th>\n",
       "      <th>Mean</th>\n",
       "      <th>Standard Deviation</th>\n",
       "      <th>Z-Value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sample 1</td>\n",
       "      <td>181800.0</td>\n",
       "      <td>89784.822134</td>\n",
       "      <td>-0.006493</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Sample 2</td>\n",
       "      <td>179562.5</td>\n",
       "      <td>94107.717537</td>\n",
       "      <td>-0.029971</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Sample 3</td>\n",
       "      <td>185750.0</td>\n",
       "      <td>95207.492702</td>\n",
       "      <td>0.035365</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Sample      Mean  Standard Deviation   Z-Value\n",
       "0  Sample 1  181800.0        89784.822134 -0.006493\n",
       "1  Sample 2  179562.5        94107.717537 -0.029971\n",
       "2  Sample 3  185750.0        95207.492702  0.035365"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtEAAAIjCAYAAADFk0cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACCr0lEQVR4nOzdd1gUVxsF8DNLWXoTaYqAgl3shRi7BiyJvcdeYo/GJEoSYzQaokaNGkuiX8QYjV1jrLFhRaModgUVBQugIk06e78/CBtXugKzwPk9zz66c+/Mnt0BfL3cuSMJIQSIiIiIiCjfFHIHICIiIiIqaVhEExEREREVEItoIiIiIqICYhFNRERERFRALKKJiIiIiAqIRTQRERERUQGxiCYiIiIiKiAW0UREREREBcQimoiIiIiogFhEExHlwc/PD5Ikwc/PT+4oWoefDRGVVSyiiUir+Pr6QpKkHB9nz56VO2KJlpKSgiVLlqB+/fowMzODhYUFatWqhdGjR+PWrVtyxysU33zzjcbXjJGRESpVqoT3338fa9euRXJy8hsfe9++ffjmm28KLywRlVi6cgcgIsrO7Nmz4eLikmW7q6urDGlKj549e2L//v3o378/Ro0ahdTUVNy6dQt79uzBO++8g+rVq8sdsdCsXLkSJiYmSE5OxqNHj3Dw4EEMHz4cP/74I/bs2QNHR8cCH3Pfvn1Yvnw5C2kiYhFNRNqpY8eOaNSokdwxSpXz589jz549mDt3Lr744guNtp9++gnR0dHyBHvFy5cvYWxsXCjH6tWrF6ytrdXPv/76a2zYsAGDBw9G7969+VsNInornM5BRCXS/fv3IUkSfvjhByxfvhyVK1eGkZER3nvvPYSFhUEIgW+//RYVK1aEoaEhunbtiqioKI1jODs7o0uXLvj7779Rr149GBgYoGbNmtixY0e+MmzduhUNGzaEoaEhrK2t8eGHH+LRo0fq9rVr10KSJFy6dCnLvt999x10dHQ0+p87dw5eXl4wNzeHkZERWrVqhdOnT2fZ99GjRxg+fDhsbW2hVCpRq1Yt/Prrr3nmvXv3LgCgefPmWdp0dHRQrlw59fMHDx5g3LhxqFatGgwNDVGuXDn07t0b9+/fz/N1Tp48id69e6NSpUpQKpVwdHTElClTkJiYqNFv6NChMDExwd27d9GpUyeYmppi4MCBmDlzJvT09PD06dMsxx49ejQsLCyQlJSUZ47sDBw4ECNHjsS5c+dw6NChAmUeOnQoli9fDgAa00Uy/fDDD3jnnXdQrlw5GBoaomHDhti2bdsb5SQi7ccimoi0UkxMDJ49e6bxeP78eZZ+GzZswIoVKzBx4kRMnToVx48fR58+ffDVV1/hwIEDmDZtGkaPHo2//voLn376aZb9g4OD0bdvX3Ts2BE+Pj7Q1dVF7969NQqs7Pj6+qJPnz7Q0dGBj48PRo0ahR07duDdd99Vj+j26tULhoaG2LBhQ7a5W7dujQoVKgAAjh49ipYtWyI2NhYzZ87Ed999h+joaLRt2xb//POPer+IiAg0a9YMhw8fxoQJE7BkyRK4urpixIgR+PHHH3PN7OTkpH7ttLS0XPueP38eZ86cQb9+/bB06VKMGTMGR44cQevWrZGQkJDrvlu3bkVCQgLGjh2LZcuWwdPTE8uWLcPgwYOz9E1LS4OnpydsbGzwww8/oGfPnhg0aBDS0tKwefNmjb4pKSnYtm0bevbsCQMDg1wz5GbQoEEAgL///rtAmT/66CN06NABALB+/Xr1I1PmXPPZs2fju+++U38t7d27942zEpEWE0REWmTt2rUCQLYPpVKp7hcSEiIAiPLly4vo6Gj1dm9vbwFA1K1bV6Smpqq39+/fX+jr64ukpCT1NicnJwFAbN++Xb0tJiZG2Nvbi/r166u3HTt2TAAQx44dE0IIkZKSImxsbETt2rVFYmKiut+ePXsEAPH1119rvK6Dg4NIT09Xb7t48aIAINauXSuEEEKlUgk3Nzfh6ekpVCqVul9CQoJwcXERHTp0UG8bMWKEsLe3F8+ePdP43Pr16yfMzc1FQkJCjp+tSqUSrVq1EgCEra2t6N+/v1i+fLl48OBBlr7ZHcff318AEL/99luOn01O+/r4+AhJkjRea8iQIQKAmD59epb+Hh4eomnTphrbduzYkeW1sjNz5kwBQDx9+jTb9hcvXggAonv37gXOPH78eJHTP52vHyMlJUXUrl1btG3bNte8RFQycSSaiLTS8uXLcejQIY3H/v37s/Tr3bs3zM3N1c+bNm0KAPjwww+hq6ursT0lJUVj+gQAODg4oHv37urnZmZmGDx4MC5duoTw8PBss124cAGRkZEYN26cxoho586dUb16dY2Rx8GDB+Px48c4duyYetuGDRtgaGiInj17AgACAwMRHByMAQMG4Pnz5+qR95cvX6Jdu3Y4ceIEVCoVhBDYvn073n//fQghNEbpPT09ERMTg4sXL+b4mUqShIMHD2LOnDmwtLTEH3/8gfHjx8PJyQl9+/bVmBNtaGio/ntqaiqeP38OV1dXWFhY5Poar+/78uVLPHv2DO+88w6EENlObRk7dmyWbYMHD8a5c+fUU1AyPzdHR0e0atUq19fPi4mJCQAgLi7ujTNn59VjvHjxAjExMWjRokWenxcRlUy8sJCItFKTJk3ydWFhpUqVNJ5nFtSvr7yQuf3Fixca211dXTXmtQJA1apVAWTMu7azs8vymg8ePAAAVKtWLUtb9erVcerUKfXzDh06wN7eHhs2bEC7du2gUqnwxx9/oGvXrjA1NQWQMaUEAIYMGZLj+4yJiUFqaiqio6Pxyy+/4Jdffsm2X2RkZI7HAAClUokvv/wSX375JZ48eYLjx49jyZIl2LJlC/T09PD7778DABITE+Hj44O1a9fi0aNHEEJoZMlNaGgovv76a+zevTvL5/36vrq6uqhYsWKWY/Tt2xeTJ0/Ghg0b8PXXXyMmJgZ79uzBlClTspyvgoqPjwcA9edf0Mw52bNnD+bMmYPAwECNZfTeNi8RaScW0URUouno6BRo+6vFYHHQ0dHBgAEDsHr1aqxYsQKnT5/G48eP8eGHH6r7qFQqAMCCBQtQr169bI9jYmKinhP+4Ycf5lhwu7u75zubvb09+vXrh549e6JWrVrYsmULfH19oauri4kTJ2Lt2rWYPHkyPDw8YG5uDkmS0K9fP3Xe7KSnp6NDhw6IiorCtGnTUL16dRgbG+PRo0cYOnRoln2VSiUUiqy/FLW0tESXLl3URfS2bduQnJys8bm9qWvXrgH4b7nEgmbOzsmTJ/HBBx+gZcuWWLFiBezt7aGnp4e1a9di48aNb52ZiLQPi2giKtPu3LkDIYTGaGFQUBCAjNU7spN5gd7t27fRtm1bjbbbt2+r2zMNHjwYCxcuxF9//YX9+/ejfPny8PT0VLdXqVIFQMZUkvbt2+eYtXz58jA1NUV6enqu/QpKT08P7u7uCA4OxrNnz2BnZ4dt27ZhyJAhWLhwobpfUlJSnsvgXb16FUFBQVi3bp3GRXl5XaiZncGDB6Nr1644f/48NmzYgPr166NWrVoFPs7rMi8GzDwHBcmc06jy9u3bYWBggIMHD0KpVKq3r1279q3zEpF24pxoIirTHj9+jJ07d6qfx8bG4rfffkO9evWyncoBAI0aNYKNjQ1WrVql8Wv7/fv34+bNm+jcubNGf3d3d7i7u2PNmjXYvn07+vXrpzFfu2HDhqhSpQp++OEH9VSDV2Uu9aajo4OePXti+/bt6tHU7PrlJDg4GKGhoVm2R0dHw9/fH5aWlihfvrz6tV4ftV+2bBnS09NzfY3M3wC8uq8QAkuWLMl1v+x07NgR1tbWmDdvHo4fP14oo9AbN27EmjVr4OHhgXbt2hU4c+Ya1q//Z0JHRweSJGl8Pvfv38euXbveOjMRaSeORBORVtq/f3+2t6F+5513ULly5UJ7napVq2LEiBE4f/48bG1t8euvvyIiIiLXEUQ9PT3MmzcPw4YNQ6tWrdC/f39ERERgyZIlcHZ2xpQpU7LsM3jwYPUSe68XgwqFAmvWrEHHjh1Rq1YtDBs2DBUqVMCjR49w7NgxmJmZ4a+//gIAfP/99zh27BiaNm2KUaNGoWbNmoiKisLFixdx+PDhLGthv+ry5csYMGAAOnbsiBYtWsDKygqPHj3CunXr8PjxY/z444/qgrJLly5Yv349zM3NUbNmTfj7++Pw4cMaa0lnp3r16qhSpQo+/fRTPHr0CGZmZti+fXuWecb5oaenh379+uGnn36Cjo4O+vfvX6D9t23bBhMTE/UFpQcPHsTp06dRt25dbN269Y0yN2zYEAAwadIkeHp6QkdHB/369UPnzp2xaNEieHl5YcCAAYiMjMTy5cvh6uqKK1euFPi9E1EJIM+iIERE2cttiTu8sixc5hJ3CxYs0Ng/c8m1rVu3Znvc8+fPq7c5OTmJzp07i4MHDwp3d3ehVCpF9erVs+yb3TJuQgixefNmUb9+faFUKoWVlZUYOHCgePjwYbbv68mTJ0JHR0dUrVo1x/d+6dIl0aNHD1GuXDmhVCqFk5OT6NOnjzhy5IhGv4iICDF+/Hjh6Ogo9PT0hJ2dnWjXrp345Zdfcjx25n7ff/+9aNWqlbC3txe6urrC0tJStG3bVmzbtk2j74sXL8SwYcOEtbW1MDExEZ6enuLWrVvCyclJDBkyJNfP5saNG6J9+/bCxMREWFtbi1GjRonLly9rnD8hMpa4MzY2zjXzP//8IwCI9957L9d+r8pc4i7zYWBgICpWrCi6dOkifv31V41lDguaOS0tTUycOFGUL19eSJKksdzd//73P+Hm5qb+Olq7dq06CxGVPpIQxXyVDRGRlnB2dkbt2rWxZ8+eIn+tZ8+ewd7eHl9//TVmzJhR5K9XWly+fBn16tXDb7/9pr5JChGRNuCcaCKiYuDr64v09HQWggW0evVqmJiYoEePHnJHISLSwDnRRERF6OjRo7hx4wbmzp2Lbt265bjiB2n666+/cOPGDfzyyy+YMGGC+oI+IiJtwSKaiKgIzZ49G2fOnEHz5s2xbNkyueOUGBMnTkRERAQ6deqEWbNmyR2HiCgLzokmIiIiIiogzokmIiIiIiogFtFERERERAXEOdH5oFKp8PjxY5iamuZ4y1ciIiIiko8QAnFxcXBwcIBCUfTjxCyi8+Hx48dwdHSUOwYRERER5SEsLAwVK1Ys8tdhEZ0PpqamADJOipmZmcxpiIiIiOh1sbGxcHR0VNdtRY1FdD5kTuEwMzNjEU1ERESkxYpr6i0vLCQiIiIiKiAW0UREREREBcQimoiIiIiogDgnupAIIZCWlob09HS5o1AJoKOjA11dXS6ZSEREVEKxiC4EKSkpePLkCRISEuSOQiWIkZER7O3toa+vL3cUIiIiKiAW0W9JpVIhJCQEOjo6cHBwgL6+PkcXKVdCCKSkpODp06cICQmBm5tbsSwKT0RERIWHRfRbSklJgUqlgqOjI4yMjOSOQyWEoaEh9PT08ODBA6SkpMDAwEDuSERERFQAHP4qJBxJpILi1wwREVHJxX/FiYiIiIgKiEU0EREREVEBsYimN3b//n1IkoTAwMB87+Pr6wsLCwvZcxARERG9DRbRZVxYWBiGDx+uXlnEyckJH3/8MZ4/f57nvo6Ojnjy5Alq166d79fr27cvgoKC3ibyG2ndujUkSYIkSVAqlahQoQLef/997Nixo8DH+uabb1CvXr3CD0lEREQlBlfnKMPu3bsHDw8PVK1aFX/88QdcXFxw/fp1fPbZZ9i/fz/Onj0LKyurbPdNSUmBvr4+7OzsCvSahoaGMDQ0LIz4BTZq1CjMnj0baWlpePjwIXbu3Il+/fph6NCh+OWXX2TJREREVFoEBwNxcUBCShr8bj/FxQcvkJyWjoqWRnivli1crE0AAKamgJubzGELg6A8xcTECAAiJiYmS1tiYqK4ceOGSExMfOvXiYxNEqv87oivdl4Vq/zuiMjYpLc+Zm68vLxExYoVRUJCgsb2J0+eCCMjIzFmzBj1NicnJzF79mwxaNAgYWpqKoYMGSJCQkIEAHHp0iV1vz///FO4uroKpVIpWrduLXx9fQUA8eLFCyGEEGvXrhXm5ubq/jNnzhR169YVv/32m3BychJmZmaib9++IjY2Vt1n//79onnz5sLc3FxYWVmJzp07izt37qjbs8vxulatWomPP/44y/Zff/1VABCHDh1Sb/v888+Fm5ubMDQ0FC4uLuKrr74SKSkp6vwANB5r164VQgixcOFCUbt2bWFkZCQqVqwoxo4dK+Li4nLMVJhfO0RERHIKChICyP8jKKjwM+RWrxUFTufQEodvRKD5vKOYd+AW/vgnFPMO3ELzeUdx5GZEkbxeVFQUDh48iHHjxmUZGbazs8PAgQOxefNmCCHU23/44QfUrVsXly5dwowZM7IcMyQkBL169UK3bt1w+fJlfPTRR/jyyy/zzHL37l3s2rULe/bswZ49e3D8+HF8//336vaXL1/ik08+wYULF3DkyBEoFAp0794dKpXqLT6BDEOGDIGlpaXGtA5TU1P4+vrixo0bWLJkCVavXo3FixcDyJiOMnXqVNSqVQtPnjzBkydP0LdvXwAZS9YtXboU169fx7p163D06FF8/vnnb52RiIhI28XFFW1/bcTpHFrgaVwyxm28iNQ0FQQA1b+Fa2qaCmM3XMTpaW1R3lRZqK8ZHBwMIQRq1KiRbXuNGjXw4sULPH36FDY2NgCAtm3bYurUqeo+9+/f19jn559/RrVq1bBgwQIAQLVq1XDt2jXMnTs31ywqlQq+vr4wNTUFAAwaNAhHjhxR79ezZ0+N/r/++ivKly+PGzduFGg+dnYUCgWqVq2q8V6++uor9d+dnZ3x6aefYtOmTfj8889haGgIExMT6OrqZpnKMnnyZI395syZgzFjxmDFihVvlZGIiIi0D0eitcCOiw+Rlp5RQL9KAEhLV2HnpYdF9tqvjjTnpVGjRrm23759G40bN9bY1qRJkzyP6+zsrC6gAcDe3h6RkZHq58HBwejfvz8qV64MMzMzODs7AwBCQ0PznT03QgiNW7Vv3rwZzZs3h52dHUxMTPDVV1/l67UOHz6Mdu3aoUKFCjA1NcWgQYPw/PlzJCQkFEpOIiIibRUVnyx3hGLHIloLPHyRCMUrRdyrFJKEsKjEQn9NV1dXSJKEmzdvZtt+8+ZNWFpaonz58uptxsbGhZ4DAPT09DSeS5KkMVXj/fffR1RUFFavXo1z587h3LlzADIubnxb6enpCA4OhouLCwDA398fAwcORKdOnbBnzx5cunQJX375ZZ6vdf/+fXTp0gXu7u7Yvn07AgICsHz58kLLSUREpM0i4speEc3pHFqgoqWhegrH61RCwNGq8FezKFeuHDp06IAVK1ZgypQpGvOiw8PDsWHDBgwePFhjhDYv1apVw759+zS2nT9//q1yPn/+HLdv38bq1avRokULAMCpU6fe6pivWrduHV68eKGeMnLmzBk4OTlpzOV+8OCBxj76+vpIT0/X2BYQEACVSoWFCxeqb+e9ZcuWQstJRESkzQx0y964bNl7x1qoR4OK0NVR4PVyVQKgq6NAjwYVi+R1f/rpJyQnJ8PT0xMnTpxAWFgYDhw4gA4dOqBChQp5zmV+3UcffYRbt25h2rRpCAoKwpYtW+Dr6wsABSrGX2VpaYly5crhl19+wZ07d3D06FF88sknb3SshIQEhIeH4+HDhzh79iymTZuGMWPGYOzYsWjTpg0AwM3NDaGhodi0aRPu3r2LpUuXYufOnRrHcXZ2RkhICAIDA/Hs2TMkJyfD1dUVqampWLZsGe7du4f169dj1apVb5STiIiopKlUrmh+W63NWERrgfKmSqwc2AB6ugooJEBXIUEhAXq6Cqwc2ADWJoV7UWEmNzc3XLhwAZUrV0afPn1QpUoVjB49Gm3atIG/v3+Oa0TnxMXFBdu2bcOOHTvg7u6OlStXqkd0lco3ew8KhQKbNm1CQEAAateujSlTpqgvXCyo1atXw97eHlWqVEGPHj1w48YNbN68WePCvw8++ABTpkzBhAkTUK9ePZw5cybLSiQ9e/aEl5cX2rRpg/Lly+OPP/5A3bp1sWjRIsybNw+1a9fGhg0b4OPj80Y5iYiIShodxZsNlpVkkijIlWVlVGxsLMzNzRETEwMzMzONtqSkJISEhMDFxQUGBgZv9TpP45Kx89JDhEUlwtHKED0aVCyyArq4zJ07F6tWrUJYWJjcUbROYX7tEBERFYWbkWGYfXg1HsU9grnSHOM9BsCrWtaFBi5eBBo2zP9xAwKABg0KMShyr9eKAudEa5HypkqMbllF7hhvZcWKFWjcuDHKlSuH06dPY8GCBZgwYYLcsYiIiKgAklJT0Hb1SPhHbkDGemEKAAJ7HiyGg9IDJ0ZuRxVre3X/VxbZypeC9tdGLKKpUAUHB2POnDmIiopCpUqVMHXqVHh7e8sdi4iIiAqg8fI+uBb9J/67YOu/C+ofJ51DvZXv4t6UiyhvYg4g4zbeQUH/3URFCIGI2CSkpguUM9GHkf5/JWdpue03i2gqVIsXL1bf3Y+IiIhKns2Bx3Et5tUC+jWSCvHpIZjy12L83v8b9WbNwlgCUPiri2kTXlhIRERERGo+J5YBQifPfjuC/1cMabQXi2giIiIiUnsQewOQ0nPvJAkkqh4iLT2PfqUYi2giIiIiUtNV6GdcS5gnnRzvuFwWsIgmIiIiIrUm9q2RZ4koFLA1qK++S29ZVHbfORERERFl8b3nxwCk3EejJRXGN5pUXJG0EotoIiIiotIqNhYIDQUAhEUl4K/Lj/HX5ccIfZ6Q0f7wIRAdrbFLHQcXfNxgUcYT8Vqp+G9h3bBcP3zZdmARBtd+XOKOtJYkSdi5cye6desmdxQiIqKSJzYW6NgRaWEPMW3CEuyI0tMYXO5mlYYFK6dAz6Y8cPAgYGGhbvvxg0moZGGPuSdnIyrtmnq7UmGH/jUm4H89vcv0VA6AI9Fl2tOnTzF27FhUqlQJSqUSdnZ28PT0xOnTp+WOVmgmTZqEhg0bQqlUol69enLHISIiKj4vXyI14il0w0Ix5buPUCEmQt3kEBuJKT5joHc/BKmRz4D4+Cy7f9KyN55/eRXHB13Byvd2Y3uPU4j/8iHW9v6yzBfQAIvoMq1nz564dOkS1q1bh6CgIOzevRutW7fG8+fP5Y5WqIYPH46+ffvKHYOIiKh42dtj+vgfcc+qAirGRGLTRm9UjImAQ2wk/vjjCzhFh+OBhT0+G7cYqFgxx8O0rFwHYzzeR486zaGrk/f60WUFi2htsWcPEBamuS0sLGN7EYiOjsbJkycxb948tGnTBk5OTmjSpAm8vb3xwQcfqPstWrQIderUgbGxMRwdHTFu3DjEv/K/VV9fX1hYWGDPnj2oVq0ajIyM0KtXLyQkJGDdunVwdnaGpaUlJk2ahPRX1pJ0dnbGt99+i/79+8PY2BgVKlTA8uXLc80cFhaGPn36wMLCAlZWVujatSvu37+f6z5Lly7F+PHjUbly5Tf7oIiIiEqoR9GJ2BEp0K/fd7hrVQEVYyNxYtVInFw1Ek7R4bhvYY9+/b/Dn891/psjTfnGIlob7NkDdO8OtG79XyEdFpbxvHv3IimkTUxMYGJigl27diE5OTnHfgqFAkuXLsX169exbt06HD16FJ9//rlGn4SEBCxduhSbNm3CgQMH4Ofnh+7du2Pfvn3Yt28f1q9fj59//hnbtm3T2G/BggWoW7cuLl26hOnTp+Pjjz/GoUOHss2RmpoKT09PmJqa4uTJkzh9+jRMTEzg5eWFlJSUt/9AiIiISplrj2IgBBBpWg79+32HRF0lFBDQESqkSQr07/8dnpiVhwBw5VG03HFLHF5YqA3q1gUqVQLu3csonNevBwYNynheuXJGeyHT1dWFr68vRo0ahVWrVqFBgwZo1aoV+vXrB3d3d3W/yZMnq//u7OyMOXPmYMyYMVixYoV6e2pqKlauXIkqVaoAAHr16oX169cjIiICJiYmqFmzJtq0aYNjx45pTKto3rw5pk+fDgCoWrUqTp8+jcWLF6NDhw5Z8m7evBkqlQpr1qyB9O/C7mvXroWFhQX8/Pzw3nvvFernQ0REVNK9ehsUXZEO6ZXLCiUAOkL1yvOye9OUN8WRaG3g6Aj4+WUUzPfuAc2b/1dA+/lltBeBnj174vHjx9i9eze8vLzg5+eHBg0awNfXV93n8OHDaNeuHSpUqABTU1MMGjQIz58/R0LCf7/2MTIyUhfQAGBrawtnZ2eYmJhobIuMjNR4fQ8PjyzPb968mW3Wy5cv486dOzA1NVWPoltZWSEpKQl37959m4+BiIioVHKvaAGFBPUcaIO0FCTqKpGgp4SOUKnnSEsA6jqayx23xGERrS0cHTNGoF+1fn2RFdCZDAwM0KFDB8yYMQNnzpzB0KFDMXPmTADA/fv30aVLF7i7u2P79u0ICAhQz1t+dQqFnp6exjElScp2m0qlwpuKj49Hw4YNERgYqPEICgrCgAED3vi4REREpZWduQH62Aj1RYT3LezRdtQqtB71i3qO9KY/vNHTOhUVLY3kjlvisIjWFmFhGVM4XjVoUNaLDYtYzZo18fLlSwBAQEAAVCoVFi5ciGbNmqFq1ap4/Phxob3W2bNnszyvUaNGtn0bNGiA4OBg2NjYwNXVVeNhbs7/PRMRUdnyJCYRt8Jj8Tw+5+ua8OgR5iydpF6FI3MOdOYc6cxVO75f+rH6hiyUf5wTrQ0yLyLMnMLx6pzo1q2LZErH8+fP0bt3bwwfPhzu7u4wNTXFhQsXMH/+fHTt2hUA4OrqitTUVCxbtgzvv/8+Tp8+jVWrVhVahtOnT2P+/Pno1q0bDh06hK1bt2Lv3r3Z9h04cCAWLFiArl27Yvbs2ahYsSIePHiAHTt24PPPP0fFHJbmuXPnDuLj4xEeHo7ExEQEBgYCyPjPgr6+fqG9FyIioqIWHAz8HfgMWy6EISgiY6UsSQIaOVmifxMnVLMzhakp4Ob27w4WFtB1qoQ0ScLKSUsQEfHfrbyfmpXDiq9Xw2fZx9CzswEsLeV5UyUYi2htcPlyxv8AX50D7eeXUUCHhma0F3IRbWJigqZNm2Lx4sW4e/cuUlNT4ejoiFGjRuGLL74AANStWxeLFi3CvHnz4O3tjZYtW8LHxweDBw8ulAxTp07FhQsXMGvWLJiZmWHRokXw9PTMtq+RkRFOnDiBadOmoUePHoiLi0OFChXQrl07mJmZ5fgaI0eOxPHjx9XP69evDwAICQmBs7NzobwPIiKiohYcDFStCgDW/z7+89e/j0xBQf8W0sbGwN690I2OxvcVKmByTBKuPoqBEAJ1KprD3twQ6FMPMDEBTE2L662UGpIQQuTdrWyLjY2Fubk5YmJishRsSUlJCAkJgYuLCwwMDN78RfbsyViF49ViOSwso4Du0uXNj6ulnJ2dMXnyZI3VP8qaQvvaISKiUm/bwXj09jLJuyOAgACgQYMiDqSFcqvXigJHorVFdoWyo2ORX1hIRERE2m/PlScA3PLsR8WHFxYSERERablLoS/kjkCv4Ug0ySKv23UTERHRf9JVnH2rbTgSTURERKTlqtjkbz40FR8W0URERERarnMde7kj0GtYRBMRERHJKD939G3oxHWctQ2LaCIiIqJi9vxlHAZtmgXj2U7Qma0LxTf6cFnQFqv8/8q2vyRJxRuQ8sQLC4mIiIiK0YMXT+G+/F3EpgVnbJAEBFJx/+UJjP37GA7fnY5tH/po7FOQe6HwvinFg0U0ERERUTFq9+sAxKbdAaTXVtyQ0gEA2+9+jyWnGuPjd3uom9zcMu5EGBeX+7E1bvtNRYpFNGktSZKwc+dOdOvWTe4oREREheJ8WDDuxh3JWkC/Sijww5lFGkU0wOJY23BOdBn29OlTjB07FpUqVYJSqYSdnR08PT1x+vRpuaMVisuXL6N///5wdHSEoaEhatSogSVLlsgdi4iIyrBf/tkBII81nyUVHiacQUpaWrFkojfDkWgt8iLxBTZe3YiQ6BC4WLhgQJ0BsDQsuqtxe/bsiZSUFKxbtw6VK1dGREQEjhw5gufPnxfZaxangIAA2NjY4Pfff4ejoyPOnDmD0aNHQ0dHBxMmTJA7HhERlUEvUxIASMi7kBZISE2Gvi5LNW3FkWgtceTeETgudsTE/ROx9NxSTNw/EY6LHXHk3pEieb3o6GicPHkS8+bNQ5s2beDk5IQmTZrA29sbH3zwgbrfokWLUKdOHRgbG8PR0RHjxo1DfHy8ut3X1xcWFhbYs2cPqlWrBiMjI/Tq1QsJCQlYt24dnJ2dYWlpiUmTJiE9PV29n7OzM7799lv0798fxsbGqFChApYvX55r5rCwMPTp0wcWFhawsrJC165dc73z4fDhw7FkyRK0atUKlStXxocffohhw4Zhx44db/7BERERvQV3u+q5T+UAAAHowQoWhsbFE4reCItoLfAi8QW6buqKhNQECAikqlIhIJCYloium7oiOim60F/TxMQEJiYm2LVrF5KTk3Psp1AosHTpUly/fh3r1q3D0aNH8fnnn2v0SUhIwNKlS7Fp0yYcOHAAfn5+6N69O/bt24d9+/Zh/fr1+Pnnn7Ft2zaN/RYsWIC6devi0qVLmD59Oj7++GMcOnQo2xypqanw9PSEqakpTp48idOnT8PExAReXl5ISUnJ9/uOiYmBlZVVvvsTEREVpk9a9IYeyuUxEC3hvUqDiysSvSEW0Vpg49WN6gL6VSqhQkJqAjZc2VDor6mrqwtfX1+sW7cOFhYWaN68Ob744gtcuXJFo9/kyZPRpk0bODs7o23btpgzZw62bNmi0Sc1NRUrV65E/fr10bJlS/Tq1QunTp3C//73P9SsWRNdunRBmzZtcOzYMY39mjdvjunTp6Nq1aqYOHEievXqhcWLF2ebd/PmzVCpVFizZg3q1KmDGjVqYO3atQgNDYWfn1++3vOZM2ewefNmjB49Ov8fFBERUSHS19WFt8eCjCfZFdJCAQOFPZZ3+6JYc1HBsYjWAiHRIdBVZD/nSVehi5DokCJ53Z49e+Lx48fYvXs3vLy84OfnhwYNGsDX11fd5/Dhw2jXrh0qVKgAU1NTDBo0CM+fP0dCQoK6j5GREapUqaJ+bmtrC2dnZ5iYmGhsi4yM1Hh9Dw+PLM9v3ryZbdbLly/jzp07MDU1VY+iW1lZISkpCXfv3s3zvV67dg1du3bFzJkz8d577+XZn4iIKE9PngAjRuDpk2dYdiQYXX86Bc8fT2Dypks4fz8KYsUKYPPmLLvNem8Yvmi2GrqSRcYGoQOIjJup2Crr4/zo03CyLF+Mb4TeBGerawEXCxekqbK/AjdNlQYXC5cie20DAwN06NABHTp0wIwZMzBy5EjMnDkTQ4cOxf3799GlSxeMHTsWc+fOhZWVFU6dOoURI0YgJSUFRkZGAAA9PT2NY0qSlO22/NzWNCfx8fFo2LAhNmzIOipfvnzuP2hu3LiBdu3aYfTo0fjqq6/eOAMREZGaEED37sC5cwg5/A9+7jUT8XqGAIA7kfEw+XU1Gh9aCaFQQKpWDahXT2P3uV4j8WXbQZh//A9cfHwNhroGGNaoG7yqNZLhzdCbYBGtBQbUGYBph6chMS0RKvFfoamQFDDUNcRA94HFlqVmzZrYtWsXgIzVLVQqFRYuXAiFIuOXFq9P5XgbZ8+ezfK8Ro0a2fZt0KABNm/eDBsbG5iZmeX7Na5fv462bdtiyJAhmDt37lvlJSIiUpMkhM30gUX3LmgSeg3/2zoLw3rNRIK+Ifpf2IM5h1YCAAJ6DEWjunWzPYSRvhLfdBhajKGpMHE6hxawNLTEn/3+hKGuISRI0FPoQYIEQ11D/NnvT1gYWBT6az5//hxt27bF77//jitXriAkJARbt27F/Pnz0bVrVwCAq6srUlNTsWzZMty7dw/r16/HqlWrCi3D6dOnMX/+fAQFBWH58uXYunUrPv7442z7Dhw4ENbW1ujatStOnjyJkJAQ+Pn5YdKkSXj48GG2+1y7dg1t2rTBe++9h08++QTh4eEIDw/H06dPC+09EBFR2bUqyRpD+n6LWH0jNA27hrXbZmH0ue3qAvrnJj0wuHovJKSm53EkKok4Eq0l2lVuh4efPMSGKxvU60QPdB9YJAU0kLE6R9OmTbF48WLcvXsXqampcHR0xKhRo/DFFxkXM9StWxeLFi3CvHnz4O3tjZYtW8LHxweDBxfOFcNTp07FhQsXMGvWLJiZmWHRokXw9PTMtq+RkRFOnDiBadOmoUePHoiLi0OFChXQrl27HEemt23bhqdPn+L333/H77//rt7u5OSU69J4RERE+bE78DHi7KthcN9v8dvmGWgadg1Nw64ByCigfVoPA1JVOBn8DJ617GROS4VNEkLksVghxcbGwtzcHDExMVkKtqSkJISEhMDFxQUGBgYyJSx5nJ2dMXnyZEyePFnuKLLh1w4RUclW2XsvVP9WUT/sXYxe1/67t0PNKVuRoJ8xR3pBL3f0buQoR8QyJbd6rShwOgcRERHRG7A1yxgA+fDiXo0CGgDWbpsFo5REAEAFC8Niz0ZFj0U0ERER0Rvo36QSBl/aqzEHutughRpzpCsbCDSrXE7mpFQUOCeaZME5yUREVNKNvLIfRn//V0D7tB4GSJLGHOmte+ZC8Wlr4JV7J1DpwCKaiIiIyrzgYCAuDnj8IhFHbkXgWXwKTJW6aFm1PKramQIATE0BN7d/dxACRmdPAwC2tekHn8YDoaujgCQBgQ7VMPrDuVi/+WuUC7uXcVMW9Y5UWrCIJiIiojItOBioWjXzmSEAZ3Xbytf6BgX9Ww9LEvD778D776PngAFwDo3GsduRSElTwc3GFF3qekJvtMdrlTeVJrLOif7mm28gSZLGo3r16ur2pKQkjB8/HuXKlYOJiQl69uyJiIgIjWOEhoaic+fOMDIygo2NDT777DOkpWne/S/zdtZKpRKurq4at7UmIiKisi0u7g376ukBH34ISaFAI2crfOZZHV92rok+jR1hpK8LNG0K1KxZ6HlJO8h+YWGtWrXw5MkT9ePUqVPqtilTpuCvv/7C1q1bcfz4cTx+/Bg9evRQt6enp6Nz585ISUnBmTNnsG7dOvj6+uLrr79W9wkJCUHnzp3Rpk0bBAYGYvLkyRg5ciQOHjxYrO+TiIiItNPz+GS5I1AJJPt0Dl1dXdjZZV2APCYmBv/73/+wceNGtG3bFgCwdu1a1KhRA2fPnkWzZs3w999/48aNGzh8+DBsbW1Rr149fPvtt5g2bRq++eYb6OvrY9WqVXBxccHChQsBADVq1MCpU6ewePHiHG/sQURERGXHiaCnACrKHYNKGNlHooODg+Hg4IDKlStj4MCBCA0NBQAEBAQgNTUV7du3V/etXr06KlWqBH9/fwCAv78/6tSpA1tbW3UfT09PxMbG4vr16+o+rx4js0/mMbKTnJyM2NhYjQcRERGVTi8SU+WOQCWQrEV006ZN4evriwMHDmDlypUICQlBixYtEBcXh/DwcOjr68PCwkJjH1tbW4SHhwMAwsPDNQrozPbMttz6xMbGIjExMdtcPj4+MDc3Vz8cHXmXITlIkoRdu3bJHYOIiEo5C0M9uSNQCSRrEd2xY0f07t0b7u7u8PT0xL59+xAdHY0tW7bIGQve3t6IiYlRP8LCwmTNU1SePn2KsWPHolKlSlAqlbCzs4OnpydOnz4td7RC8fz5c3h5ecHBwQFKpRKOjo6YMGECf7NAREQaWrqVlzsClUCyz4l+lYWFBapWrYo7d+6gQ4cOSElJQXR0tMZodEREhHoOtZ2dHf755x+NY2Su3vFqn9dX9IiIiICZmRkMDbO/DadSqYRSqSyst5UvmetTvq4oV8bp2bMnUlJSsG7dOlSuXBkRERE4cuQInj9/XjQvWMwUCgW6du2KOXPmoHz58rhz5w7Gjx+PqKgobNy4Ue54RESkJaxNi/fffCodZJ8T/ar4+HjcvXsX9vb2aNiwIfT09HDkyH/3or99+zZCQ0Ph4eEBAPDw8MDVq1cRGRmp7nPo0CGYmZmh5r9Lynh4eGgcI7NP5jG0Qeb6lA0bZn1UrZrRXtiio6Nx8uRJzJs3D23atIGTkxOaNGkCb29vfPDBB+p+ixYtQp06dWBsbAxHR0eMGzcO8fHx6nZfX19YWFhgz549qFatGoyMjNCrVy8kJCRg3bp1cHZ2hqWlJSZNmoT09HT1fs7Ozvj222/Rv39/GBsbo0KFCli+fHmumcPCwtCnTx9YWFjAysoKXbt2zfXOh5aWlhg7diwaNWoEJycntGvXDuPGjcPJkyff/IMjIqISY8vl4xi0aRYGb56NHVdLx29ZSXvIWkR/+umnOH78OO7fv48zZ86ge/fu0NHRQf/+/WFubo4RI0bgk08+wbFjxxAQEIBhw4bBw8MDzZo1AwC89957qFmzJgYNGoTLly/j4MGD+OqrrzB+/Hj1SPKYMWNw7949fP7557h16xZWrFiBLVu2YMqUKXK+dQ15rU9ZkPUr88vExAQmJibYtWsXkpNzXtpHoVBg6dKluH79OtatW4ejR4/i888/1+iTkJCApUuXYtOmTThw4AD8/PzQvXt37Nu3D/v27cP69evx888/Y9u2bRr7LViwAHXr1sWlS5cwffp0fPzxxzh06FC2OVJTU+Hp6QlTU1OcPHkSp0+fhomJCby8vJCSkpKv9/z48WPs2LEDrVq1yld/IiIqmY7euQzLOTXRd1dr/H5rFtbf/AY9d7wLq7m1cTrkRpb+pqb5P3ZB+lIpJ2TUt29fYW9vL/T19UWFChVE3759xZ07d9TtiYmJYty4ccLS0lIYGRmJ7t27iydPnmgc4/79+6Jjx47C0NBQWFtbi6lTp4rU1FSNPseOHRP16tUT+vr6onLlymLt2rUFyhkTEyMAiJiYmCxtiYmJ4saNGyIxMbFAx3xVQIAQQM6PgIA3PnSutm3bJiwtLYWBgYF45513hLe3t7h8+XKu+2zdulWUK1dO/Xzt2rUCgMZ5++ijj4SRkZGIi4tTb/P09BQfffSR+rmTk5Pw8vLSOHbfvn1Fx44d1c8BiJ07dwohhFi/fr2oVq2aUKlU6vbk5GRhaGgoDh48mGvmfv36CUNDQwFAvP/++291rgpTYXztEBGRpgthQUL3G3OBmQqBb6D5mKkQut9YiatPQrLsFxSU8e9tbo+goOJ/P5R/udVrRUHWOdGbNm3Ktd3AwADLly/P9df8Tk5O2LdvX67Had26NS5duvRGGUuznj17onPnzjh58iTOnj2L/fv3Y/78+VizZg2GDh0KADh8+DB8fHxw69YtxMbGIi0tDUlJSUhISICRkREAwMjICFWqVFEf19bWFs7OzjAxMdHY9uq0GwBZptR4eHjgxx9/zDbr5cuXcefOHZi+NgSQlJSEu3fv5vo+Fy9ejJkzZyIoKAje3t745JNPsGLFilz3ISKikmnMn18jTcQBkipro6RCmojG2D9n4+RHv2o08c7cVFBaNSeaip+BgQE6dOiAGTNm4MyZMxg6dChmzpwJALh//z66dOkCd3d3bN++HQEBAer/0Lw6hUJPT3NpIEmSst2mUmXzAy2f4uPj0bBhQwQGBmo8goKCMGDAgFz3tbOzQ/Xq1fHBBx/g559/xsqVK/HkyZM3zkJERNopISUZAU93Zl9AZ5JUOPNkM9JeuU6H6E1o1eocJL+aNWuq12YOCAiASqXCwoULoVBk/H+rMJcfPHv2bJbnNWrUyLZvgwYNsHnzZtjY2MDMzOyNXzOzkM9tHjgREZVMD6IjIaS8f76rpARExEejgnm5YkhFpRVHorVAXhcpFMVFDM+fP0fbtm3x+++/48qVKwgJCcHWrVsxf/58dO3aFQDg6uqK1NRULFu2DPfu3cP69euxatWqQstw+vRpzJ8/H0FBQVi+fDm2bt2Kjz/+ONu+AwcOhLW1Nbp27YqTJ08iJCQEfn5+mDRpEh4+fJjtPvv27cPatWtx7do13L9/H3v37sWYMWPQvHlzODs7F9r7ICIi7WBjbAEIKe+OQgeWhiZ59yPKBUeitYCbGxAUVLzrRJuYmKBp06ZYvHgx7t69i9TUVDg6OmLUqFH44osvAAB169bFokWLMG/ePHh7e6Nly5bw8fHB4MGDCyXD1KlTceHCBcyaNQtmZmZYtGgRPD09s+1rZGSEEydOYNq0aejRowfi4uJQoUIFtGvXLseRaUNDQ6xevRpTpkxBcnIyHB0d0aNHD0yfPr1Q8hMRkXYpZ2wKR6PmCEs4k/OUDqFAFdO2MNLn2tD0diQhhJA7hLaLjY2Fubk5YmJishRsSUlJCAkJgYuLCwwMDGRKWPI4Oztj8uTJmDx5stxRZMOvHSKiwvfr+QMYsbcTAAG8PigtAECBjV0Po3/9NsUfjopUbvVaUeB0DiIiItJO4eGAEBBC4PrjGJy5+wyhzxMy2mJjgZcvs+wyvLEXpjddBUA3Y2qHwL8PCRL0MLP5/1hAU6HgdA4iIiLSPnfuAK1bI+SddhjacAgevEhUN7W01cfK37+EsakRsHcvYGyssatPx9EY2rATph9YiovhGRexN3Zojnlek1DF2r5Y3waVXiyiSRa53a6biIgIAQEQjx/DZetvGHnnGWZ0GAtIEkySEzD5h6kwfnwbaeYW0H3wAKhZM8vu1WwqYufg+TIEp7KC0zmIiIhI60R26orPO02GChIGXdqHbw+thGnyS/y2ZQYaPL6NaAMTjBs+HyKHpVGJihpHogsJr8+kguLXDBFRzrYFPMT2Ou2gEsCCfT9i0KV9GHQp4w7F0QYmGNhvLq7rOyDgwQs0craSOS2VRRyJfkuZd+ZLSEiQOQmVNJlfM6/f3ZGIiIA7EfGQAGyv0w6z2o/WaBvYdw6u21bJ6BcZL0M6Io5EvzUdHR1YWFggMjISQMZ6xpKUj4XeqcwSQiAhIQGRkZGwsLCAjo6O3JGIiLSOgb4OJEmCSdJLdL3hp9HW78rfmGFbBZAkGOjxZyjJg0V0IbCzswMAdSFNlB8WFhbqrx0iItLUoYYtdp+4pTEHeketthga8Jd6Wscsz3FoWbW8zEmprGIRXQgkSYK9vT1sbGyQmpoqdxwqAfT09DgCTUSUi5Z2SmzZ+Q1q/ltAD+w3F9dtq+C6bRX1HGk3GxNYGXWSOyqVUSyiC5GOjg4LIyIiolwIIRCblAalriLXqRg6639DzQc3EGtoioF95+CmXRVAALvqtgcALNj/I5oe3g4EBACNGhVXfCI1FtFERERUpIKDgcioNOy69Bh7rzzBi4QUSADqOVqgV6OKqOdoCVNTwM3tlZ0mTAAiI6F8vyuG6djhz8BHeJGQgkpWxug61Bvo5Q7JyJAFNMlGElxnK0/FfS92IiKi0iI4GKhaNX99g4JeK6SJCqC46zUucUdERERFJi6uaPoSyY1FNBERERWZ5LR0uSMQFQkW0URERFRkHkcnyh2BqEiwiCYiIqIio6vgDciodGIRTUREREXGwcJI7ghERYJFNBERERUZHY5EUynFIpqIiIiIqIBYRBMREVGBnLp3Hc1XDoXhbAfoz7KG0/xWWHh8C1QqVZa+pqb5P25B+hLJjTdbyQfebIWIiCjDwuNb8NmxDyGQDkj/Fs1CAUgqNLEeCP+xv0Gh0ByjCw7Oew3oLHcsJCqg4q7XeNtvIiIiypfbkQ/x2bHBEEgDpFfG4P4tpv95tgGTdjfET92maOzH4phKI07nICIionyZfmApBFI0C+hXCQnrrv5UvKGIZMIimoiIiPLl3OMTAHKZBSoJxKvu4VHM82LLRCQXFtFERESUT/m7jEqVz35EJRmLaCIiIsqXBrbvINfSQUgwkiqhgqlVsWUikguLaCIiIsqX7zt+DECRy4C0QP+aY7OszkFUGvGrnIiIiPKltp0zvn7nFwA6gND5r0FklBO1LD7Aqu6fyROOqJhxiTsiIqKyKDAQuHwZ19p3w5YLYXgcnYRyxvroVr8CmgX9A0mhADw9s+w2671haOJYC18dXoBrUYegEmkop6yGUfXH4tv3hnMUmsoM3mwlH3izFSIiKlXCwiDq1YMUFYVpXhOxrb4X0lUCOgoJ7965gNU750JPR4J06hTQqJHcaYnypbjrNf53kYiIqKypWBGBrd8HAMw7sAy9Lh0AALx75wJ+2TEH+mkpuOreHKhbV86URFqN0zmIiIjKmKQ0FQbX6ocpD15geMBuzDuwDK3uBaDd3fNQpqfiQFUPTGo9CScT02Grpyd3XCKtxJFoIiKiMuZSaDTiUtIxu90o/NrwAwBAp6Az6gJ6wgfTkKLQxfGgpzInJdJeLKKJiIjKmNR0VcZfJAknXBpotJ1yro80nYxfVKekqYo7GlGJwSKaiIiojKluZwqFBLS6F4Cfd87VaJvz9wr0vXwQAFC7grkc8YhKBBbRREREZYyNmQGmpN/DLzvmqKdwuH26Uz21Y96BZZhy/wTqVmQRTZQTLnGXD1zijoiISpWwMAg3N0jJyThY1QPjP5iWMYVDCMw8ugbDLvyZ0c/fH2jWTN6sRPlU3PUaV+cgIiIq4YKDgdhYgasPY3D9SSwUANwdLVDdzhSSJMHUFHBze2UHR0dICxYg5chR3PxoDiwDnuBpfDLMDPUQNmMu4vdXhImhPtC0qVxviUjrcSQ6HzgSTURE2io4GKhaNe9+QUGvFdIAIAQgSQAAlUpAoZD+2w6o24hKAt5shYiIiPLt8dPUfPWLi8tm4ytFsrqAztzOApooVyyiiYiISrDDNyLkjkBUJrGIJiIiKsFOBPOGKERyYBFNRERUgiUkp8sdgahMYhFNRERUglWyNpI7AlGZxCKaiIioBOtU217uCERlEotoIiKiEqyeo4XcEYjKJN5shYiISMskpabA98JBPIl7hiaOtdC5RpMc+5qZ5W8pOlPTwkpHRACLaCIiIq0yefdSrLg0C6mIytjgD1jo1MDabmvQrfY7Wfq7uWXcSCUuDhBCID45DQoJMFbqqftkuWMhEb01FtFERERaYvzORVhxZSogALwywByddhs9t7XHAf1T6FC1QZb9/iuQJQB6WdqJqPBxTjQREZEWiE9Ows9XvslSQAMAJBVUSMbEPV8VfzAiyhaLaCIiIi2w9PQ2pCMuawGdSVLhduzfiE58Way5iCh7LKKJiIi0wKOYyLw7Sel4EhdV9GGIKE8soomIiLRATZsqefaRhAGcLGyKIQ0R5YVFNBERkRb4qFkXKCVbQOQwn0Mo0Kh8dxjpK4s3GBFli0U0ERGRFtDV0cG8tisAKADx2j/PQgGlVB7res+TJRsRZcUimoiIqCgkJQEAUtJUeBSdiBcvUzK2p6UBqanZ7vLxuz3wa+e9sFX+t4ydJPTgbtkVAR/9gxo2jkUem4jyRxJCCLlDaLvY2FiYm5sjJiYGZmZmcschIiJtd+oURJ8++H3qQiyIs0JsUhoAoKmjKVbsW4RyxvrAhg2AXs5rOt+OfIhHsc9Ry9YJtqYWxRScqOQq7nqNI9FERESFLH3+AkhPnqD7FyPgeucqAEBHlY7BP32Jcvv+hGrnLuDSpVyPUc2mItq61mUBTaSlWEQTEREVsk1TvsdpJ3eYpCTit61fo0nYNSzZvQCdb51CikIXn/SdgdSGjeSOSURvgUU0ERFRIVt/+SlG9vxaXUhv2TgdXW5nFNBjun+BXRUb4Pjtp3LHJKK3wCKaiIiokD2OTkSingE+6q55m+7VTbrjqGsTSAAeRSfKE46ICgWLaCIiokJmbaKEjiod3+9fqrF9yMU9aPDwJgQAG1Ou90xUkrGIJiIiKmT96ttj6V8L1FM4xn8wTWOO9LtPg9CmOu88SFSSsYgmIiIqZMP+N1t9EeGY7l9gb40WGPHKHOm1m2bA4NoVuWMS0VtgEU1ERFTI9Pr1hTAxwW+fLsSJqk0BAEl6Bpg96ns8a/Iu9Jo2AapVkzklEb0N3mwlH3izFSKisis4GLgZmoBdlx7B/+5zpKpUqGZriq71KqCRsxVMTQE3t2x2fPYMsLZGdEIKQp69hLFSF242JpAS/72g0MioWN8HUWlX3PUai+h8YBFNRFQ2BQcDVavm3S8oKIdCmoiKDe9YSEREpCVeRKvy1S8uroiDEJHWYRFNRESUgwsPXsgdgYi0FItoIiKiHDx8kSB3BCLSUiyiiYiIcmCsryt3BCLSUiyiiYiIcuBRpZzcEYhIS7GIJiIiyoGFkb7cEYhIS7GIJiIiIiIqIE72IiKiMuV//+zHj/4/IyIhFFZKO4xpPAKTmneHQpF1XMnUNH/HzG8/Iio9tGYk+vvvv4ckSZg8ebJ6W1JSEsaPH49y5crBxMQEPXv2REREhMZ+oaGh6Ny5M4yMjGBjY4PPPvsMaWlpGn38/PzQoEEDKJVKuLq6wtfXtxjeERERaROVSoUmywdi5P5OuPZiD56mXMLt2IOYcrQXavzYGSmv/dsBZNxAJSgICAjI+cEbrRCVTVoxEn3+/Hn8/PPPcHd319g+ZcoU7N27F1u3boW5uTkmTJiAHj164PTp0wCA9PR0dO7cGXZ2djhz5gyePHmCwYMHQ09PD9999x0AICQkBJ07d8aYMWOwYcMGHDlyBCNHjoS9vT08PT2L/b0SEZE8Ju1egvPPNmY8kdL//TPjZipBsQcwcNPX2Prhd1n2Y4FMRNmR/bbf8fHxaNCgAVasWIE5c+agXr16+PHHHxETE4Py5ctj48aN6NWrFwDg1q1bqFGjBvz9/dGsWTPs378fXbp0wePHj2FrawsAWLVqFaZNm4anT59CX18f06ZNw969e3Ht2jX1a/br1w/R0dE4cOBAvjLytt9ERCWf6beuiE+/B0jZ/LMnAH3JGi+/Coeujk7xhyOit1bmbvs9fvx4dO7cGe3bt9fYHhAQgNTUVI3t1atXR6VKleDv7w8A8Pf3R506ddQFNAB4enoiNjYW169fV/d5/dienp7qY2QnOTkZsbGxGg8iIiq50tLTEa+6m30BDQASkIJnuPv8SfEGI6ISS9bpHJs2bcLFixdx/vz5LG3h4eHQ19eHhYWFxnZbW1uEh4er+7xaQGe2Z7bl1ic2NhaJiYkwNDTM8to+Pj6YNWvWG78vIiLSLgpJAoQuIGWd9/wqMwPjYkpERCWdbCPRYWFh+Pjjj7FhwwYYGBjIFSNb3t7eiImJUT/CwsLkjkRERG9BoVDAzbQtIHL4Z08oYKtsBHszy+INRkQllmxFdEBAACIjI9GgQQPo6upCV1cXx48fx9KlS6GrqwtbW1ukpKQgOjpaY7+IiAjY2dkBAOzs7LKs1pH5PK8+ZmZm2Y5CA4BSqYSZmZnGg4iISraFHWdDgk7WQlpIAIC5bWfLkIqISirZiuh27drh6tWrCAwMVD8aNWqEgQMHqv+up6eHI0eOqPe5ffs2QkND4eHhAQDw8PDA1atXERkZqe5z6NAhmJmZoWbNmuo+rx4js0/mMYiIqGx4v2ZTrO70JwwUdhrb9aVy8Gn1O0Y06ShTMiIqiWRfneNVrVu3Vq/OAQBjx47Fvn374OvrCzMzM0ycOBEAcObMGQAZS9zVq1cPDg4OmD9/PsLDwzFo0CCMHDlSY4m72rVrY/z48Rg+fDiOHj2KSZMmYe/evfle4o6rcxARaZljx6CqXAXHkwxw7l4UdBRA62o2aBQTBgkA6tbNcVeVSoX/nT+AG5F3UdnKER817QJ9Xa1Y8ZWI3kJx12ta/VNj8eLFUCgU6NmzJ5KTk+Hp6YkVK1ao23V0dLBnzx6MHTsWHh4eMDY2xpAhQzB79n+/knNxccHevXsxZcoULFmyBBUrVsSaNWu4RjQRUUl17BhEp054YmyFL/rMxVMLGwDAkc2HsWXLVzBR6kBx4gRQq1a2uysUCoxq2qk4ExNRKaRVI9HaiiPRRETaQ3X/AcIbvQOH549x38Ie/ft/B/OkeGzc9CWsEmNxz6UmKl88Dby2uhMRlW5lbp1oIiKigjieZIhefebggYUdnKOfwH/lMBxYOxFWibEItHdDtw++xp0U3jCFiIoWi2giIipRzoY8R6SFLfr317xFd4SJFQb3+RZxBiY4ey9KpnREVFawiCYiohJFR8pYks4s6aXGdr30NBinJEIA0FFIMiQjorKERTQREZUoravZwDX8HjZu+hIAEGlsiRcGprBKjMUff3wBh7inaFm1vMwpiai0YxFNREQlSuPYMGzZ8pV6DnT7kSvRedgS9Rzp3du/RoW4Z3LHJKJSjkU0ERGVKJJKBROlDu651FTPgX5sZoMB/b/DM9uKKGekC6hUcsckolKOS9zlA5e4IyIqOsHBQNQLFa48ikFcUioqWRmhcnkTAICpKeDmls1O164BFSsiOFkHZ0OioCNJaFnVGhXjngFCAE5OxfsmiEh2vNkKERGVGcHBQNWqQMYvRi2z7RMUlE0hXbs2AMANgJut6X/bLSsVQUoioqw4nYOIiGTjd+1Fnn3i4oohCBFRAbGIJiIi2Ww890DuCEREb4RFNBERySImMRW3wjnMTEQlE4toIiKShUrF69qJqORiEU1ERLKwMNKDo6Wh3DGIiN4Ii2giIpKFJEno09hR7hhERG+ERTQREcmmbXVbuSMQEb0RFtFERFSoohNf4lDQRVwLv59nX1PTPLvkqw8RUXHjzVaIiKhQxCYl4P3fJuHU441QSYkAAGu9uljacTH612+T7T5ubhk3U8lpLegc71hIRCQzFtFERPTWVCoVai31xMOE04D036obz1KuYuCfntBVHEbvui2z3ZdFMhGVRJzOQUREb22l/194mHhKo4AGAEgqCKRjygFveYIRERURFtFERPTW1l76AxA62TdKKjxKPIOn8THFG4qIqAixiCYioreWmJYAIJebp0gZc6aJiEoLFtFERPTWGtk3BqDKvlEAStjCxYrL2RFR6cEimoiI3tp3XuOgI5kCIpt/ViSgT/VxUCj4Tw4RlR78iUZERG+tgnk5rP/gz4xCGsiYH/1vQd3MZhB8e38lYzoiosLHJe6IiCgrIQBJyroNyLr9X/3rt4FXtYf4+tAaXHwcCDOlOT5tMRTt3OoXcVgiouLHIpqIiDTt2YOEpcsxZ8g3+Cs4GmnpAk2cLfFdwCZUKG8GfPNNjoW0pZEJlnWdXKxxiYjkwCKaiIj+ExeH9MGDYfTiBToFh2N7jxlI1tVH0/8tRAX/rRl9OnYEmjWTNycRkcw4J5qIiP5jaopvR/rgpZ4B3r0fiDXbv8WMo2sw7t8C+jvPMUhs0FjmkERE8mMRTUREapGxSfBVVMSQPrPwUs8ALR4EYsSFPwEA37QbjV/qdcHRW5EypyQikh+LaCIiUotOTAUAXKhQE9dsq2i0/VHXEwDwIiGl2HMREWkbFtFERKRWwcIQSh0Jn534DU0fXtdoW7P9WyhTk1HV1lSmdERE2oNFNBERqRnr62BN0E6MP5sxB/qbdqPRa+A89dSOP/Z8h8a2BjKnJCKSH4toIiL6T3w8ml87DSCjgP69SVdcqlQbQ/rMQoK+Aeo9DoIUHCxzSCIi+XGJOyIi+o+pKRTHjkJ14CDaNe+E9OsRSElToUlPd+iMbAqFvh5Qt67cKYmIZCcJkXkLKspJbGwszM3NERMTAzMzM7njEBHlW3AwcPZ2DA5cC8fj6ETYmhnAq5Yd3B0tYGoKuLnJnZCIqHAUd73GkWgiolIqOBioWhUAzP99ZNj8Sp+gIBbSRERvgnOiiYhKqYDguDz7xOXdhYiIsvFGRfSxY8cKOwcRERWyv2+Eyx2BiKjUeqMi2svLC1WqVMGcOXMQFhZW2JmIiKgQPI1PljsCEVGp9UZF9KNHjzBhwgRs27YNlStXhqenJ7Zs2YKUFN7FiohIW9ibcT1nIqKi8kZFtLW1NaZMmYLAwECcO3cOVatWxbhx4+Dg4IBJkybh8uXLhZ2TiIgKyLO2ndwRiIhKrbe+sLBBgwbw9vbGhAkTEB8fj19//RUNGzZEixYtcP369bwPQERERcLF2kTuCEREpdYbF9GpqanYtm0bOnXqBCcnJxw8eBA//fQTIiIicOfOHTg5OaF3796FmZWIiArA1LRw+hARUVZvdLOViRMn4o8//oAQAoMGDcLIkSNRu3ZtjT7h4eFwcHCASqUqtLBy4c1WiEgbpKSlYeGJLdgbdAh6Cj0Ma9gbH9ZvB4Ui5/GQ4OCcl7HjzVaIqDQpETdbuXHjBpYtW4YePXpAqVRm28fa2ppL4RERFZKQ5+Gov7I1YtJvA0IHAOD3ZDVm+7XHlYl7YKSf/c9iFslEREWjwNM5UlNT4eTkhGbNmuVYQAOArq4uWrVq9VbhiIgoQ7tfByAmLTjjiZSe8QBwN+4Iem+YJmMyIqKyqcBFtJ6eHrZv314UWYiIKBuXH99DyEs/QMpmepwkcDB0LdLS04s9FxFRWfZGFxZ269YNu3btKuQoRESUHf8H1wEp58tX0hGLR7FRxZiIiIjeaE60m5sbZs+ejdOnT6Nhw4YwNjbWaJ80aVKhhCMiIqB6eadc2yWhhK2JeTGlISIi4A1X53Bxccn5gJKEe/fuvVUobcPVOYhIbuXm1kZU6s2sUzqEAg2te+PChE3yBCMi0hIlYnWOkJCQws5BRES52NJnPbw2tkGaiAUgAEgABEx1XLB94DKZ0xERlT1vfcdCIiIqeu3c6uPGuBt43+UT2CobwsGwKUbW+R4PpgbCybK83PGIiMqcN5rOAQAPHz7E7t27ERoaipSUFI22RYsWFUo4bcHpHERUqK5eRUr1mjh97zmiE1JQy8EcVdPjAH19wNpa7nRERCVSiZjOceTIEXzwwQeoXLkybt26hdq1a+P+/fsQQqBBgwaFnZGIqPTYvRuqXr2wtVEXfNliOCBJsIl7jj+3z4CNjQV0jh5hIU1EVAK80XQOb29vfPrpp7h69SoMDAywfft2hIWFoVWrVujdu3dhZyQiKjWe3nkARWoqBvrvxIyja2AT9xx/bPoC9hGhiHocCcTHyx2RiIjy4Y2K6Js3b2Lw4MEAMu5MmJiYCBMTE8yePRvz5s0r1IBERKXJcte2+NJrAgBgxIU/8c+KIagS9QgPzWzQvfdc3NC3kjkhERHlxxsV0cbGxup50Pb29rh796667dmzZ4WTjIioFLoY+gIb6nphcfMBGtv79f8OD81tcfVRtDzBiIioQN6oiG7WrBlOnToFAOjUqROmTp2KuXPnYvjw4WjWrFmhBiQiKk0sjfRhF/8cH9w8rrF9WMBfgBAwN9SXKRkRERXEG11YuGjRIsT/O29v1qxZiI+Px+bNm+Hm5lbqVuYgIipMAxx14frZF+opHH/WbIXxZ7dixIU/oa+jQOtvveSOSERE+fDGS9yVJVzijogKi2riRCh++gkPzWzQf4APwsxtMfDyAcw98BOEQgHpn3+Ahg3ljklEVOKUiCXuiIjozSh++AGq1FRc6zIEjk8kGL1MQWqjkXjc1g0OFcuzgCYiKiHyPRJtaWkJSZLyddCoqKi3CqVtOBJNRLlJSk3HwxeJsDDSg7WJUu44RERlktaORP/4449FGIOIqOS5dVtg9dFQ7Lr0CAkp6ZAA1K9kgfFtXOFW0RBubnInJCKiosI50fnAkWgiel1wMFC1au59goLAQpqIqJho7Uh0TpKSktRrRmdioUlEpV1YRAqA3Jeji4srnixERFT83mid6JcvX2LChAmwsbGBsbExLC0tNR5ERKXd7XBWyEREZdkbFdGff/45jh49ipUrV0KpVGLNmjWYNWsWHBwc8NtvvxV2RiIiraOv+0Y/PomIqJR4o+kcf/31F3777Te0bt0aw4YNQ4sWLeDq6gonJyds2LABAwcOLOycRERapbaDudwRiIhIRm80lBIVFYXKlSsDyJj/nLmk3bvvvosTJ04UXjoiIi2lx5FoIqIy7Y3+FahcuTJCQkIAANWrV8eWLVsAZIxQW1hYFFo4IiJtZWpaOH2IiKhkeqPpHMOGDcPly5fRqlUrTJ8+He+//z5++uknpKamYtGiRYWdkYhI67i5ZSxhl9MKHKamXN6OiKg0K5R1oh88eICAgAC4urrC3d29MHJpFa4TTVT6XX58D8O2T8fl5/shkAZnk3ewyOtbdKv9jtzRiIgoH4q7XivQdA5/f3/s2bNHY1vmBYZjxozBTz/9hOTk5EINSERU1G5GhqHx6qa49Hw7VFI8hJSEkHg/9NjWBpsDj8sdj4iItFCBiujZs2fj+vXr6udXr17FiBEj0L59e3h7e+Ovv/6Cj49PoYckIipK43Z9i1QRBUiq/zZKKgikYcqBz+ULRkREWqtARXRgYCDatWunfr5p0yY0bdoUq1evxpQpU7B06VL1RYZERCXFP+EHNQvoTJIKT5L+QUIKf8NGRESaClREv3jxAra2turnx48fR8eOHdXPGzdujLCwsMJLR0RUHCQpt8Zii0FERCVHgYpoW1tb9dJ2KSkpuHjxIpo1a6Zuj4uLg56eXuEmJCIqYu/YdwJENj8OhQIVDD1gpK8s/lBERKTVClREd+rUCdOnT8fJkyfh7e0NIyMjtGjRQt1+5coVVKlSpdBDEhEVpVXdZkCpsNEspIUCEvTxU+cF8gUjIiKtVaAi+ttvv4Wuri5atWqF1atXY/Xq1dDX11e3//rrr3jvvfcKPSQRUVGqYm2PS2P+gYfth9CDFXRgimpmntjX/ySXuCMiomy90TrRMTExMDExgY6Ojsb2qKgomJiYaBTWpQHXiSYiIiLSblq9TnQmc3PzLAU0AFhZWRWogF65ciXc3d1hZmYGMzMzeHh4YP/+/er2pKQkjB8/HuXKlYOJiQl69uyJiIgIjWOEhoaic+fOMDIygo2NDT777DOkpaVp9PHz80ODBg2gVCrh6uoKX1/fgr1hIio59u5F2NJf8Pm2y+i18gymbb+Ch4tXAAcPyp2MiIhKkTcqogtLxYoV8f333yMgIAAXLlxA27Zt0bVrV/Va1FOmTMFff/2FrVu34vjx43j8+DF69Oih3j89PR2dO3dGSkoKzpw5g3Xr1sHX1xdff/21uk9ISAg6d+6MNm3aIDAwEJMnT8bIkSNxkP+gEpU+ly8jvXsPVPh4DNJ+W48LD14Av/4Kh08mIP2DrsAr69wTERG9jUK57XdhsrKywoIFC9CrVy+UL18eGzduRK9evQAAt27dQo0aNeDv749mzZph//796NKlCx4/fqxeem/VqlWYNm0anj59Cn19fUybNg179+7FtWvX1K/Rr18/REdH48CBA/nKxOkcRCVDfGIK9rzbDf0u7ocKEs5WqoNmoVehgMCGxu+j+8ntMFJyBSEiotKoREznKArp6enYtGkTXr58CQ8PDwQEBCA1NRXt27dX96levToqVaoEf39/ABm3Ia9Tp47G2tWenp6IjY1Vj2b7+/trHCOzT+YxspOcnIzY2FiNBxFpvxN3nsO7/VhsqOcFBQTeCb0CBQR8G3TBl21G49Sd53JHJCKiUkL2Ivrq1aswMTGBUqnEmDFjsHPnTtSsWRPh4eHQ19eHhYWFRn9bW1uEh4cDAMLDwzUK6Mz2zLbc+sTGxiIxMTHbTD4+PjA3N1c/HB0dC+OtElERS05Lh5AUuGxXVWP7ZfuqgCQhOS2buxISERG9AV25A1SrVg2BgYGIiYnBtm3bMGTIEBw/flzWTN7e3vjkk0/Uz2NjY1lIE5UAzSqXQ98rf8PnwDKN7Qv3LoakkNC0cjuZkhERUWkj+0i0vr4+XF1d0bBhQ/j4+KBu3bpYsmQJ7OzskJKSgujoaI3+ERERsLOzAwDY2dllWa0j83lefczMzGBoaJhtJqVSqV4xJPNBRNrPPuQ2vj+wDAoIrGvQBS6f71ZP7fhh72LYPLgjd0QiIiolZC+iX6dSqZCcnIyGDRtCT08PR44cUbfdvn0boaGh8PDwAAB4eHjg6tWriIyMVPc5dOgQzMzMULNmTXWfV4+R2SfzGERUitSrB8yciVu9BuPXvlOg0NHB//p/huDuAyB9+y1Qu7bcCYmIqJSQdXUOb29vdOzYEZUqVUJcXBw2btyIefPm4eDBg+jQoQPGjh2Lffv2wdfXF2ZmZpg4cSIA4MyZMwAyLkasV68eHBwcMH/+fISHh2PQoEEYOXIkvvvuOwAZS9zVrl0b48ePx/Dhw3H06FFMmjQJe/fuhaenZ75ycnUOohJGCECScn5ORESlTnHXa7LOiY6MjMTgwYPx5MkTmJubw93dXV1AA8DixYuhUCjQs2dPJCcnw9PTEytWrFDvr6Ojgz179mDs2LHw8PCAsbExhgwZgtmzZ6v7uLi4YO/evZgyZQqWLFmCihUrYs2aNfkuoIlIPkFBAqdvRuNSWDT0dBRo4WqNSuWMYWoKuLnlsuPrBTMLaCIiKmRat060NuJINFHxu35Thdo1c55xFhSURyFNRERlSpldJ5qI6FUbTz3KtT0urpiCEBERZYNFNBFppb+vR+TdiYiISCYsoolIK8Ulp8kdgYiIKEcsoolIK9WuwOsPiIhIe7GIJiKt1Lcx7xJKRETai0U0EWmlepVNc203zb2ZiIioSMm6TjQRUU7c3DKWsYuLA1LTVFAoJOgoMtZ7znOdaCIioiLGIpqIikVKWhpWn9uLR3GR6FazFZpUqprnPv8VyvylGRERaRcW0URU5HZf90ef7T2QLMIBAD5nJdQv1wtnx26Evi5/DBERUcnD4R0iKlLxyUnoua0LklWR/22UBC4934Y+G73lC0ZERPQWWEQTUZGa57cRaYgCJJVmgySwL2StPKGIiIjeEotoIipSIVGhgJCybUsVUcWchoiIqHCwiCaiItWqchNAElkbhARTncrFH4iIiKgQsIgmoiI1orEXyum5A+KVHzcCgCTwcZMvZMtFRET0NlhEE1GRUigUuDT+CGpbvg+IjJU4lAo7TG20At96Dpc5HRER0Zvh2lJEVOQcza1x9eNdiE58iafxMahSzg4KBf8PT0REJReLaCIqmMREpOkrER6bBAsjfZiINECpBKTsLx58lYWhMSwMjYshJBERUdHiUBAR5d/Ro0io5Izh45bj3XnH4PHlbtxt8C5SJn0MiGwuHiQiIiqlWEQTUf4IgcgZ38LoWSR+WucNjwdXsGbLTFS5GYC0//0K3L8vd0IiIqJiwyKaiPJHkjD6g2k4X7EmzJJf4o9NX6Bp2DXE6hthQK/ZuGtSXu6ERERExYZFNBHl2804gbHdNG/V/UPLQQh0qIZ7T1/KlIqIiKj4sYgmonyrZqrA8j/naWz79OTvqPv4NiqX5wWDRERUdrCIJqL8EQKrd3//3xSOvnPwT+bUjm0zUSX+qdwJiYiIig2XuCOi/JEk2M7+Col9r2NCj69wxqoKrlasjj/3zkXFNh6As7PcCYmIiIqNJATXpcpLbGwszM3NERMTAzMzM7njEMkrMRGp+kqExyTB3EgPZiINMDDI1zrRRERERaW46zWORBNRwRgaQg+Ao5XRvxv05ExDREQkCxbRRGXUletp+N+xMBy79RRpKhU8qpTDgCZOqGSnDzc3udMRERFpNxbRRGXQ7dsCdWvrAnD59wHcBPDrv+1BQWAhTURElAuuzkFUBp28GZ1re1xc8eQgIiIqqVhEE5VBdyLi5Y5ARERUorGIJiqDrE305Y5ARERUorGIJiqD3nG1ljsCERFRicYimqgMKm+lk2u7qWkxBSEiIiqhuDoHURnk5paxAkdcHPAkOhFpKoEKFoZQKCSYmnJlDiIiorywiCYqo/4rlA3ljEFERFQicToHUSlwOuQG3l01DE7zW6Hd6jG49Oiu3JGIiIhKNY5EE5VwWy4fR7+dnhBIBaBCaMIpNFq9AQcGHEeHqg3kjkdERFQqcSSaqISbsO+TjAJaUgESAEkFFRIwZvfnckcjIiIqtVhEE5VgKpUKT5MDMwroV0kq3I8/K0smIiKisoBFNFEJplAooCMZZW0QgL7CvPgDERERlREsoolKuNYVPgSElGX7B1WGyZCGiIiobGARTVTC7Rq0GHUsu/1XSAsdeNgMwoZ+s2TNRUREVJpxdQ6iEs5EaYArH+/AtfD7+CfsFlo4u8OtvIPcsYiIiEo1FtFEpURtO2fUtnOWOwYREVGZwCKaSJsEBuKOZIzD0QoYK3XxQXwIzBvVAyws5E5GREREr+CcaCJtcfEiklq2htS2LdZuO4MDP/4O/Y5eiGvVDoiJkTsdERERvYIj0URa4naSDkygjypRD3Hup8Hq7SeT9NBMTx96MmYjIiIiTRyJJtISBxKMMHCgj8a2K3auGPH+dFx/nixTKiIiIsoOi2giLWGgp0DF6HCNbZaJcTBPioOBHr9ViYiItAn/ZSbSEj1ehmD1tm8BAEHlKuGpkQUcYyKwY+uXqKabInM6IiIiehXnRBNpifIN6yDOyQnHFRYY9YE3bOOfY9vmL2DZpiUkS0u54xEREdErJCGEkDuEtouNjYW5uTliYmJgZmYmdxwqzZ4+RZKhMS5FJMJYqYM6igRItraAjo7cyYiIiLRacddrHIkm0ibly8MAgIeJ0b8bLGQMQ0RERDlhEU1URIKDgRsPXiI6IRWuNiYw1NeFqSng5iZ3MiIiInpbLKKJisDFK6loWFcPgHGWtqAgFtJEREQlHVfnICoCC/fdy7EtLq4YgxAREVGRYBFNVMjSVQIngp7KHYOIiIiKEItooiLANW+IiIhKNxbRRIVMRyHhnSrl5I5BRERERYhFNFER+Kh1FbkjEBERURFiEU1UBCrZ6ufYZmpajEGIiIioSHCJO6Ii4OaWsZTd6ytxcJ1oIiKi0oFFNFE+xSYlwETfAApF/n6Bw2KZiIio9OJ0DqI8/O+f/TD71g3m84yh/60VPvzjG6hUKrljERERkYxYRBPlIuBhMEbt64a49LsAgHTEYEPQLEzdu1zmZERERCQnFtFEuZh7bA0E0gDplYWfhYR1V36WLxQRERHJjkU0US5ikmIASJobJYHkdN67m4iIqCxjEU2Uiw/rdQekdM2NQoFm9h3lCURERERagUU0US6GNfaEp+NEQPw3Gl1evy429vtexlREREQkNy5xR5SHA8OX4uyDcdhx7Rhq27niw/rt8r3MHREREZVOLKKJ8qGZU3U0c6oudwwiIiLSEhxOIyIiIiIqIBbRVOaIoCDc7DUEfX46gX4/HcftnoMg7t6VOxYRERGVIJzOQWVLSgpiWrVDjfCHGHElCAqhQrU7/+DFuVOwDAkC9PTkTkhEREQlAEeiqUxJVujgs+bDAQCewWfR4c4/SJMUmNp8GNJ1+H9KIiIiyh8W0VSmvExOh59LfaQqdNTbEvWUOO5UDwkpaTImIyIiopKERTSVKZZ6wOp9C6Gn+u8GKqYpiVh9YBFMdaVc9iQiIiL6D4toKlMkXV3Uca+MZB09DOk9CyN6zkCqji7q1ncFdHTyPgARERERAEkIIeQOoe1iY2Nhbm6OmJgYmJmZyR2H3pZKheh/LuKMcQVIAN55+QjmTRsCEkeiiYiISqrirtd4JRWVPQoFLJo1Qif1BnsZwxAREVFJxOkcREREREQFJGsR7ePjg8aNG8PU1BQ2Njbo1q0bbt++rdEnKSkJ48ePR7ly5WBiYoKePXsiIiJCo09oaCg6d+4MIyMj2NjY4LPPPkNamuZKC35+fmjQoAGUSiVcXV3h6+tb1G+PitHFK6n4YnUYxv14D4v+iERAgEBwsNypiIiIqLSSdTrH8ePHMX78eDRu3BhpaWn44osv8N577+HGjRswNjYGAEyZMgV79+7F1q1bYW5ujgkTJqBHjx44ffo0ACA9PR2dO3eGnZ0dzpw5gydPnmDw4MHQ09PDd999BwAICQlB586dMWbMGGzYsAFHjhzByJEjYW9vD09PT9nePxWOC5dT0LiePgDHLG1BQYCbW/FnIiIiotJNqy4sfPr0KWxsbHD8+HG0bNkSMTExKF++PDZu3IhevXoBAG7duoUaNWrA398fzZo1w/79+9GlSxc8fvwYtra2AIBVq1Zh2rRpePr0KfT19TFt2jTs3bsX165dU79Wv379EB0djQMHDmTJkZycjOTkZPXz2NhYODo68sJCLTXppxAsm+iSbVtAANCgQTEHIiIiomJX3BcWatWc6JiYGACAlZUVACAgIACpqalo3769uk/16tVRqVIl+Pv7AwD8/f1Rp04ddQENAJ6enoiNjcX169fVfV49RmafzGO8zsfHB+bm5uqHo2PWEU7SHk/jkvPuRERERFSItKaIVqlUmDx5Mpo3b47atWsDAMLDw6Gvrw8LCwuNvra2tggPD1f3ebWAzmzPbMutT2xsLBITE7Nk8fb2RkxMjPoRFhZWKO+RioaTlbHcEYiIiKiM0Zol7saPH49r167h1KlTckeBUqmEUqmUOwblU9f6DpgndwgiIiIqU7RiJHrChAnYs2cPjh07hooVK6q329nZISUlBdHR0Rr9IyIiYGdnp+7z+modmc/z6mNmZgZDQ8PCfjtUzKwtc77ToKlpMQYhIiKiMkPWIloIgQkTJmDnzp04evQoXFw0Lw5r2LAh9PT0cOTIEfW227dvIzQ0FB4eHgAADw8PXL16FZGRkeo+hw4dgpmZGWrWrKnu8+oxMvtkHoNKNje3jFU4AgI0H1yZg4iIiIqKrKtzjBs3Dhs3bsSff/6JatWqqbebm5urR4jHjh2Lffv2wdfXF2ZmZpg4cSIA4MyZMwAylrirV68eHBwcMH/+fISHh2PQoEEYOXKkxhJ3tWvXxvjx4zF8+HAcPXoUkyZNwt69e/O1xB1v+01ERESk3Yq7XpO1iJYkKdvta9euxdChQwFk3Gxl6tSp+OOPP5CcnAxPT0+sWLFCPVUDAB48eICxY8fCz88PxsbGGDJkCL7//nvo6v435dvPzw9TpkzBjRs3ULFiRcyYMUP9GnlhES0vvztXcOxeAKqXd0bfuq2gUGjFLCQiIiLSImWqiC4pWETLZ/T2eVh91RuQMr5M61v1xoXxm1hIExERkYYyvU400asCHgZj9dUv1AU0AFyK2oo5R3+XMRURERERi2jSYmceXAckleZGocCFR1fkCURERET0LxbRpLUaOFTNulFSobp1leIPQ0RERPQKFtGktZq71MT7zlMznvw7o6OSUUvM8RwlXygiIiIiaNEdC4mys3vID1h7vgOOh5yHWzknTGs9ALo6Od9chYiIiKg4cHWOfODqHERERETajatzEBERERFpOU7nIPmkpCBOJUFPRwEDkQ7o68udiIiIiChfOBJNsog/H4CnFZwxbORizOkyCU9q1IPq6TO5YxERERHlC0eiSRbBk79E/WdPsG3DNPW2Cz7L0GjRLBlTEREREeUPR6JJFp94fazx/KJDNWxo0k2eMEREREQFxCKaZNHv+hGN59WePkD9sOsypSEiIiIqGBbRJIv3K5sCAH5r0BknnepBV6Sja1ULeUMRERER5RPnRJMsHL6bichmTaEoXx2R6alIS4+Aeat35Y5FRERElC8sokk2Nh944UP1MzcZkxAREREVDKdzEBEREREVEItoIiIiIqIC4nQOKnRbjrzAqsOhSEhJQyu38hjexhHVqklyxyIiIiIqNCyiqVAdPhuPvu0tAVgCAM4BmA8gKAhw47RnIiIiKiU4nYMK1fFr0dluj4sr3hxERERERYlFNBUqY6WO3BGIiIiIihyLaCpULavayB2BiIiIqMixiKZCVd4q+5FoU9NiDkJERERUhHhhIRUqN7eMiwhfnQNtasqLComIiKh0YRFNhY4FMxEREZV2nM5BRERERFRAHImmfEtJS8O4XT/gauQ1vOPYFAs7j4dCwf+HERERUdnDIpryrcmKfrgctR2ADv55ugHXIm7i0MgVcsciIiIiKnYcRqR8iU58mVFASwCkdADA0Ye+smYiIiIikguLaMoXXYUOXv9ykSTeWIWIiIjKJhbRlC8mSgN4Vhqf8URIAICB1T+XMRERERGRfDgnmvLtwPClWHj8XZx7eBntqryDj5p1ljsSERERkSxYRFOBTG3VB0AfuWMQERERyYrTOYiIiIiICohFNBERERFRAXE6BwEAYm8G44LKGBVinqKahzsgSXJHIiIiItJaHIkmhJ88h/RGjeHcojEcWzfFpe5DACHkjkVERESktVhEE47tOwvLhBhUfvEYRqnJSLl4CTHR8XLHIiIiItJaLKIJ0WZWGs+fG5ohTcEbqRARERHlhEU0wcvZFEm6+urnlcz0UM6Q0+WJiIiIcsJKieDSvxseWx7AYR0buD4KRrN+HQF9/bx3JCIiIiqjWEQTAMDBqw0GAwBqyZyEiIiISPtxOgcRERERUQGxiCYiIiIiKiAW0WVIukpApeL6z0RERERvi3Oiy4jZG0Kx+mgoFJAwumVl9HnHHm5ucqciIiIiKpkkIXhrurzExsbC3NwcMTExMDMzkztOgR0+G48OHiZZtgcFgYU0ERERlQrFXa9xOkcZ8CgyLdvtcXHFHISIiIiolGARXQZUszOVOwIRERFRqcIiugwoZ5n9LbxNWVsTERERvRFeWFgGuLllzH9+dfqGqSnnQxMRERG9KRbRZQQLZiIiIqLCw+kcREREREQFxCKaiIiIiKiAWESXMpce3UX1RZ3hOO9d/Hx2r9xxiIiIiEolzokuZdr7dkNU6g0AAmMP9MB7bg/gUs5O7lhEREREpQpHokuZ6NQQQFIBkoCQUnDxcbDckYiIiIhKHRbRpUxTmx7qv5soqqBjtSYypiEiIiIqnTido5Q5NcYXPsc6ICI+Ct5tBsNIXyl3JCIiIqJSh0V0KaNQKPBlu0FyxyAiIiIq1Tidg4iIiIiogFhEExEREREVEItoIiIiIqICYhFdgl3bfxKHVmzC06cxckchIiIiKlN4YWEJdW7zATTt1xG1AVyeXwumV8/BwNRY7lhEREREZQJHokuo6INH1H+v++A6wsKeypiGiIiIqGxhEV1CWffupv77qdrvwqmyg3xhiIiIiMoYTucooRp2bI6Qs4F4+PA56nl6QN9AX+5IRERERGUGi+gSzKVpXbg0lTsFERERUdnD6RxERERERAXEIpqIiIiIqIBYRBMRERERFRCL6BJACIHYpFQIIeSOQkRERERgEa310tJV+GDuZVQbcxZ9F1xjIU1ERESkBbg6h5Y7fC4Be2bUAwBsBTCxXRJaNDSQNRMRERFRWceRaC1npmOo8Vyp4nrQRERERHJjEa3lylvpaDy3tOApIyIiIpIbp3NoOTc3ICgIiIsDTE0znhMRERGRvFhElwAsnImIiIi0C+cGEBEREREVkKxF9IkTJ/D+++/DwcEBkiRh165dGu1CCHz99dewt7eHoaEh2rdvj+DgYI0+UVFRGDhwIMzMzGBhYYERI0YgPj5eo8+VK1fQokULGBgYwNHREfPnzy/qt0ZEREREpZisRfTLly9Rt25dLF++PNv2+fPnY+nSpVi1ahXOnTsHY2NjeHp6IikpSd1n4MCBuH79Og4dOoQ9e/bgxIkTGD16tLo9NjYW7733HpycnBAQEIAFCxbgm2++wS+//FLk74+IiIiISidJaMndOyRJws6dO9GtWzcAGaPQDg4OmDp1Kj799FMAQExMDGxtbeHr64t+/frh5s2bqFmzJs6fP49GjRoBAA4cOIBOnTrh4cOHcHBwwMqVK/Hll18iPDwc+voZy8NNnz4du3btwq1bt/KVLTY2Fubm5oiJiYGZmVnhv/nXbLl8HN8cXYBBdQfAu+2AIn89IiIiopKuuOs1rZ0THRISgvDwcLRv3169zdzcHE2bNoW/vz8AwN/fHxYWFuoCGgDat28PhUKBc+fOqfu0bNlSXUADgKenJ27fvo0XL15k+9rJycmIjY3VeBSncXsm4mbsXnx1YnTenYmIiIio2GltER0eHg4AsLW11dhua2urbgsPD4eNjY1Gu66uLqysrDT6ZHeMV1/jdT4+PjA3N1c/HB0d3/4NFUADu5YAAEfjRnn0JCIiIiI5aG0RLSdvb2/ExMSoH2FhYcX6+n+P+AlB4x7h3tSjxfq6RERERJQ/WrtOtJ2dHQAgIiIC9vb26u0RERGoV6+euk9kZKTGfmlpaYiKilLvb2dnh4iICI0+mc8z+7xOqVRCqVQWyvt4U27lHWR9fSIiIiLKmdaORLu4uMDOzg5HjhxRb4uNjcW5c+fg4eEBAPDw8EB0dDQCAgLUfY4ePQqVSoWmTZuq+5w4cQKpqanqPocOHUK1atVgaWlZTO+GiIiIiEoTWYvo+Ph4BAYGIjAwEEDGxYSBgYEIDQ2FJEmYPHky5syZg927d+Pq1asYPHgwHBwc1Ct41KhRA15eXhg1ahT++ecfnD59GhMmTEC/fv3g4JAxkjtgwADo6+tjxIgRuH79OjZv3owlS5bgk08+keldExEREVFJJ+sSd35+fmjTpk2W7UOGDIGvry+EEJg5cyZ++eUXREdH491338WKFStQtWpVdd+oqChMmDABf/31FxQKBXr27ImlS5fCxMRE3efKlSsYP348zp8/D2tra0ycOBHTpk3Ld87iXjKFiIiIiAqmuOs1rVknWpuxiCYiIiLSblwnmoiIiIhIy7GIJiIiIiIqIBbRREREREQFxCKaiIiIiKiAWEQTERERERUQi2giIiIiogJiEU1EREREVEAsoomIiIiICohFNBERERFRAbGIJiIiIiIqIBbRREREREQFxCKaiIiIiKiAWEQTERERERWQrtwBSgIhBAAgNjZW5iRERERElJ3MOi2zbitqLKLzIS4uDgDg6OgocxIiIiIiyk1cXBzMzc2L/HUkUVzlegmmUqnw+PFjmJqaQpKkYnnN2NhYODo6IiwsDGZmZsXymqSJ50B+PAfy4zmQH8+B/HgOtENe50EIgbi4ODg4OEChKPoZyxyJzgeFQoGKFSvK8tpmZmb8hpUZz4H8eA7kx3MgP54D+fEcaIfczkNxjEBn4oWFREREREQFxCKaiIiIiKiAWERrKaVSiZkzZ0KpVModpcziOZAfz4H8eA7kx3MgP54D7aBt54EXFhIRERERFRBHoomIiIiICohFNBERERFRAbGIJiIiIiIqIBbRREREREQFxCK6kHzzzTeQJEnjUb16dXV7UlISxo8fj3LlysHExAQ9e/ZERESExjFCQ0PRuXNnGBkZwcbGBp999hnS0tI0+vj5+aFBgwZQKpVwdXWFr69vlizLly+Hs7MzDAwM0LRpU/zzzz9F8p7lduLECbz//vtwcHCAJEnYtWuXRrsQAl9//TXs7e1haGiI9u3bIzg4WKNPVFQUBg4cCDMzM1hYWGDEiBGIj4/X6HPlyhW0aNECBgYGcHR0xPz587Nk2bp1K6pXrw4DAwPUqVMH+/btK3CWkiivczB06NAs3xdeXl4afXgO3o6Pjw8aN24MU1NT2NjYoFu3brh9+7ZGH236+ZOfLCVNfs5B69ats3wvjBkzRqMPz8GbW7lyJdzd3dU34fDw8MD+/fvV7fweKHp5nYNS+T0gqFDMnDlT1KpVSzx58kT9ePr0qbp9zJgxwtHRURw5ckRcuHBBNGvWTLzzzjvq9rS0NFG7dm3Rvn17cenSJbFv3z5hbW0tvL291X3u3bsnjIyMxCeffCJu3Lghli1bJnR0dMSBAwfUfTZt2iT09fXFr7/+Kq5fvy5GjRolLCwsRERERPF8EMVo37594ssvvxQ7duwQAMTOnTs12r///nthbm4udu3aJS5fviw++OAD4eLiIhITE9V9vLy8RN26dcXZs2fFyZMnhaurq+jfv7+6PSYmRtja2oqBAweKa9euiT/++EMYGhqKn3/+Wd3n9OnTQkdHR8yfP1/cuHFDfPXVV0JPT09cvXq1QFlKorzOwZAhQ4SXl5fG90VUVJRGH56Dt+Pp6SnWrl0rrl27JgIDA0WnTp1EpUqVRHx8vLqPNv38yStLSZSfc9CqVSsxatQoje+FmJgYdTvPwdvZvXu32Lt3rwgKChK3b98WX3zxhdDT0xPXrl0TQvB7oDjkdQ5K4/cAi+hCMnPmTFG3bt1s26Kjo4Wenp7YunWretvNmzcFAOHv7y+EyChGFAqFCA8PV/dZuXKlMDMzE8nJyUIIIT7//HNRq1YtjWP37dtXeHp6qp83adJEjB8/Xv08PT1dODg4CB8fn7d+j9rs9QJOpVIJOzs7sWDBAvW26OhooVQqxR9//CGEEOLGjRsCgDh//ry6z/79+4UkSeLRo0dCCCFWrFghLC0t1edACCGmTZsmqlWrpn7ep08f0blzZ408TZs2FR999FG+s5QGORXRXbt2zXEfnoPCFxkZKQCI48ePCyG06+dPfrKUBq+fAyEyCoiPP/44x314DgqfpaWlWLNmDb8HZJR5DoQond8DnM5RiIKDg+Hg4IDKlStj4MCBCA0NBQAEBAQgNTUV7du3V/etXr06KlWqBH9/fwCAv78/6tSpA1tbW3UfT09PxMbG4vr16+o+rx4js0/mMVJSUhAQEKDRR6FQoH379uo+ZUVISAjCw8M1Pgtzc3M0bdpU4zO3sLBAo0aN1H3at28PhUKBc+fOqfu0bNkS+vr66j6enp64ffs2Xrx4oe6T23nJT5bSzM/PDzY2NqhWrRrGjh2L58+fq9t4DgpfTEwMAMDKygqAdv38yU+W0uD1c5Bpw4YNsLa2Ru3ateHt7Y2EhAR1G89B4UlPT8emTZvw8uVLeHh48HtABq+fg0yl7XtAt0C9KUdNmzaFr68vqlWrhidPnmDWrFlo0aIFrl27hvDwcOjr68PCwkJjH1tbW4SHhwMAwsPDNb5wMtsz23LrExsbi8TERLx48QLp6enZ9rl161Zhvl2tl/mZZfdZvPp52tjYaLTr6urCyspKo4+Li0uWY2S2WVpa5nheXj1GXllKKy8vL/To0QMuLi64e/cuvvjiC3Ts2BH+/v7Q0dHhOShkKpUKkydPRvPmzVG7dm0A0KqfP/nJUtJldw4AYMCAAXBycoKDgwOuXLmCadOm4fbt29ixYwcAnoPCcPXqVXh4eCApKQkmJibYuXMnatasicDAQH4PFJOczgFQOr8HWEQXko4dO6r/7u7ujqZNm8LJyQlbtmyBoaGhjMmI5NOvXz/13+vUqQN3d3dUqVIFfn5+aNeunYzJSqfx48fj2rVrOHXqlNxRyqyczsHo0aPVf69Tpw7s7e3Rrl073L17F1WqVCnumKVStWrVEBgYiJiYGGzbtg1DhgzB8ePH5Y5VpuR0DmrWrFkqvwc4naOIWFhYoGrVqrhz5w7s7OyQkpKC6OhojT4RERGws7MDANjZ2WW5MjTzeV59zMzMYGhoCGtra+jo6GTbJ/MYZUXm+83ts7Czs0NkZKRGe1paGqKiogrlvLzanleWsqJy5cqwtrbGnTt3APAcFKYJEyZgz549OHbsGCpWrKjerk0/f/KTpSTL6Rxkp2nTpgCg8b3Ac/B29PX14erqioYNG8LHxwd169bFkiVL+D1QjHI6B9kpDd8DLKKLSHx8PO7evQt7e3s0bNgQenp6OHLkiLr99u3bCA0NVc8V8vDwwNWrVzUKikOHDsHMzEz9qxAPDw+NY2T2yTyGvr4+GjZsqNFHpVLhyJEjGnOSygIXFxfY2dlpfBaxsbE4d+6cxmceHR2NgIAAdZ+jR49CpVKpv7k9PDxw4sQJpKamqvscOnQI1apVg6WlpbpPbuclP1nKiocPH+L58+ewt7cHwHNQGIQQmDBhAnbu3ImjR49mmfqiTT9/8pOlJMrrHGQnMDAQADS+F3gOCpdKpUJycjK/B2SUeQ6yUyq+Bwp0GSLlaOrUqcLPz0+EhISI06dPi/bt2wtra2sRGRkphMhYTqVSpUri6NGj4sKFC8LDw0N4eHio989c2uW9994TgYGB4sCBA6J8+fLZLu3y2WefiZs3b4rly5dnu7SLUqkUvr6+4saNG2L06NHCwsJC42rX0iIuLk5cunRJXLp0SQAQixYtEpcuXRIPHjwQQmQsaWZhYSH+/PNPceXKFdG1a9dsl7irX7++OHfunDh16pRwc3PTWF4tOjpa2NraikGDBolr166JTZs2CSMjoyzLq+nq6ooffvhB3Lx5U8ycOTPb5dXyylIS5XYO4uLixKeffir8/f1FSEiIOHz4sGjQoIFwc3MTSUlJ6mPwHLydsWPHCnNzc+Hn56exdFRCQoK6jzb9/MkrS0mU1zm4c+eOmD17trhw4YIICQkRf/75p6hcubJo2bKl+hg8B29n+vTp4vjx4yIkJERcuXJFTJ8+XUiSJP7++28hBL8HikNu56C0fg+wiC4kffv2Ffb29kJfX19UqFBB9O3bV9y5c0fdnpiYKMaNGycsLS2FkZGR6N69u3jy5InGMe7fvy86duwoDA0NhbW1tZg6dapITU3V6HPs2DFRr149oa+vLypXrizWrl2bJcuyZctEpUqVhL6+vmjSpIk4e/ZskbxnuR07dkwAyPIYMmSIECJjWbMZM2YIW1tboVQqRbt27cTt27c1jvH8+XPRv39/YWJiIszMzMSwYcNEXFycRp/Lly+Ld999VyiVSlGhQgXx/fffZ8myZcsWUbVqVaGvry9q1aol9u7dq9GenywlUW7nICEhQbz33nuifPnyQk9PTzg5OYlRo0Zl+Q8dz8Hbye7zB6Dxs0Gbfv7kJ0tJk9c5CA0NFS1bthRWVlZCqVQKV1dX8dlnn2mskSsEz8HbGD58uHBychL6+vqifPnyol27duoCWgh+DxSH3M5Baf0ekIQQomBj10REREREZRvnRBMRERERFRCLaCIiIiKiAmIRTURERERUQCyiiYiIiIgKiEU0EREREVEBsYgmIiIiIiogFtFERERERAXEIpqIiIiIqIBYRBMRlXFDhw5Ft27d5I5BRFSi8I6FRETFYOjQoVi3bl2W7Z6enjhw4IAMif4TExMDIQQsLCxkzUFEVJLoyh2AiKis8PLywtq1azW2KZVKmdIA6enpkCQJ5ubmsmUgIiqpOJ2DiKiYKJVK2NnZaTwsLS3h5+cHfX19nDx5Ut13/vz5sLGxQUREBACgdevWmDBhAiZMmABzc3NYW1tjxowZePWXicnJyfj0009RoUIFGBsbo2nTpvDz81O3+/r6wsLCArt370bNmjWhVCoRGhqaZTqHSqWCj48PXFxcYGhoiLp162Lbtm3qdj8/P0iShCNHjqBRo0YwMjLCO++8g9u3b2u837/++guNGzeGgYEBrK2t0b1793xnJSLSdiyiiYhk1rp1a0yePBmDBg1CTEwMLl26hBkzZmDNmjWwtbVV91u3bh10dXXxzz//YMmSJVi0aBHWrFmjbp8wYQL8/f2xadMmXLlyBb1794aXlxeCg4PVfRISEjBv3jysWbMG169fh42NTZY8Pj4++O2337Bq1Spcv34dU6ZMwYcffojjx49r9Pvyyy+xcOFCXLhwAbq6uhg+fLi6be/evejevTs6deqES5cu4ciRI2jSpEmBshIRaTVBRERFbsiQIUJHR0cYGxtrPObOnSuEECI5OVnUq1dP9OnTR9SsWVOMGjVKY/9WrVqJGjVqCJVKpd42bdo0UaNGDSGEEA8ePBA6Ojri0aNHGvu1a9dOeHt7CyGEWLt2rQAgAgMDs2Tr2rWrEEKIpKQkYWRkJM6cOaPRZ8SIEaJ///5CCCGOHTsmAIjDhw+r2/fu3SsAiMTERCGEEB4eHmLgwIHZfhb5yUpEpO04J5qIqJi0adMGK1eu1NhmZWUFANDX18eGDRvg7u4OJycnLF68OMv+zZo1gyRJ6uceHh5YuHAh0tPTcfXqVaSnp6Nq1aoa+yQnJ6NcuXLq5/r6+nB3d88x4507d5CQkIAOHTpobE9JSUH9+vU1tr16HHt7ewBAZGQkKlWqhMDAQIwaNSrb18hvViIibcYimoiomBgbG8PV1TXH9jNnzgAAoqKiEBUVBWNj43wfOz4+Hjo6OggICICOjo5Gm4mJifrvhoaGGoV4dscBMqZjVKhQQaPt9Ysg9fT01H/PPKZKpVK/zttmJSLSZiyiiYi0wN27dzFlyhSsXr0amzdvxpAhQ3D48GEoFP9dunLu3DmNfc6ePQs3Nzfo6Oigfv36SE9PR2RkJFq0aPHGOV694LBVq1ZvfBx3d3ccOXIEw4YNy9JWWFmJiOTEIpqIqJgkJycjPDxcY5uuri4sLS3x4YcfwtPTE8OGDYOXlxfq1KmDhQsX4rPPPlP3DQ0NxSeffIKPPvoIFy9exLJly7Bw4UIAQNWqVTFw4EAMHjwYCxcuRP36/2/vDlUVBsM4jP/B7FjQKzDY3I5BDEMGgmVegBq0WUUmCBbDBjOaLV6AVYbF6G0IhiWTySJywuGY/UDOOPD8LuDljQ/jZd+XrterjsejarWagiB4a8disajZbKbpdKrn8ynP83S73XQ6nWRZlkaj0Vtzlsul2u22KpWKer2eHo+H0jTVfD7/2K4AkCciGgD+yOFweN0O/6pWqxoMBrpcLtrv95J+7os3m436/b46nY4cx5EkDYdD3e93NRoNFQoFTSYTjcfj16ztdqs4jhWGobIsU6lUUrPZVLfbNdoziiKVy2UlSaLz+SzbtlWv17VYLN6e4fu+drudoijSarWSZVlqtVof3xUA8sKLhQDwD/i+L9d1tV6v814FACD+Ew0AAAAYI6IBAAAAQ5xzAAAAAIb4Eg0AAAAYIqIBAAAAQ0Q0AAAAYIiIBgAAAAwR0QAAAIAhIhoAAAAwREQDAAAAhohoAAAAwNA3hiNdhNTbAVAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import csv\n",
    "import statistics\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Read data from CSV file\n",
    "def read_data_from_csv(file_path):\n",
    "    data = []\n",
    "    with open(file_path, 'r') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        for row in reader:\n",
    "            salary, daa, experience = int(row['Salary']), int(row['DAA']), int(row['Experience'])\n",
    "            data.append((salary, daa, experience))\n",
    "    return data\n",
    "\n",
    "# Custom hash function for sampling\n",
    "def custom_hash(value):\n",
    "    return value[2] % 3  # Hash based on Experience\n",
    "\n",
    "# Read data from CSV file\n",
    "dataset = read_data_from_csv('employee_data.csv')\n",
    "\n",
    "# Perform sampling using custom hash function\n",
    "sample1, sample2, sample3 = [], [], []\n",
    "for data_point in dataset:\n",
    "    hash_value = custom_hash(data_point)\n",
    "    if hash_value == 0:\n",
    "        sample1.append(data_point)\n",
    "    elif hash_value == 1:\n",
    "        sample2.append(data_point)\n",
    "    else:\n",
    "        sample3.append(data_point)\n",
    "\n",
    "# Calculate mean and standard deviation for each sample\n",
    "mean1, std_dev1 = statistics.mean([x[0] for x in sample1]), statistics.stdev([x[0] for x in sample1]) if len(sample1) >= 2 else (float('nan'), float('nan'))\n",
    "mean2, std_dev2 = statistics.mean([x[0] for x in sample2]), statistics.stdev([x[0] for x in sample2]) if len(sample2) >= 2 else (float('nan'), float('nan'))\n",
    "mean3, std_dev3 = statistics.mean([x[0] for x in sample3]), statistics.stdev([x[0] for x in sample3]) if len(sample3) >= 2 else (float('nan'), float('nan'))\n",
    "\n",
    "# Calculate Z-values for each sample\n",
    "z_value1 = (mean1 - statistics.mean([x[0] for x in dataset])) / std_dev1 if len(sample1) >= 2 else float('nan')\n",
    "z_value2 = (mean2 - statistics.mean([x[0] for x in dataset])) / std_dev2 if len(sample2) >= 2 else float('nan')\n",
    "z_value3 = (mean3 - statistics.mean([x[0] for x in dataset])) / std_dev3 if len(sample3) >= 2 else float('nan')\n",
    "\n",
    "# Create a DataFrame to display mean, standard deviation, and z-values in a table\n",
    "data = {\n",
    "    'Sample': ['Sample 1', 'Sample 2', 'Sample 3'],\n",
    "    'Mean': [mean1, mean2, mean3],\n",
    "    'Standard Deviation': [std_dev1, std_dev2, std_dev3],\n",
    "    'Z-Value': [z_value1, z_value2, z_value3]\n",
    "}\n",
    "\n",
    "result_df = pd.DataFrame(data)\n",
    "display(result_df)\n",
    "\n",
    "# Plot the data points and samples\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(*zip(*dataset), label='Original Data')\n",
    "plt.scatter(*zip(*sample1), label='Sample 1', color='red', marker='x')\n",
    "plt.scatter(*zip(*sample2), label='Sample 2', color='green', marker='o')\n",
    "plt.scatter(*zip(*sample3), label='Sample 3', color='blue', marker='s')\n",
    "plt.xlabel('Experience')\n",
    "plt.ylabel('Salary')\n",
    "plt.legend()\n",
    "plt.title('Employee Salary Data')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a4d3a8df-23af-4db7-b62e-1d30fd39a18c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sample</th>\n",
       "      <th>Mean Salary</th>\n",
       "      <th>Standard Deviation Salary</th>\n",
       "      <th>Z-Value Salary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sample 1</td>\n",
       "      <td>181800.0</td>\n",
       "      <td>89784.822134</td>\n",
       "      <td>-0.006493</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Sample 2</td>\n",
       "      <td>179562.5</td>\n",
       "      <td>94107.717537</td>\n",
       "      <td>-0.029971</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Sample 3</td>\n",
       "      <td>185750.0</td>\n",
       "      <td>95207.492702</td>\n",
       "      <td>0.035365</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Sample  Mean Salary  Standard Deviation Salary  Z-Value Salary\n",
       "0  Sample 1     181800.0               89784.822134       -0.006493\n",
       "1  Sample 2     179562.5               94107.717537       -0.029971\n",
       "2  Sample 3     185750.0               95207.492702        0.035365"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import csv\n",
    "import statistics\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Read data from CSV file\n",
    "def read_data_from_csv(file_path):\n",
    "    data = []\n",
    "    with open(file_path, 'r') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        for row in reader:\n",
    "            salary, daa, experience, hra, pf = int(row['Salary']), int(row['DAA']), int(row['Experience']), int(row['HRA']), int(row['PF'])\n",
    "            data.append((salary, daa, experience, hra, pf))\n",
    "    return data\n",
    "\n",
    "# Custom hash function for sampling\n",
    "def custom_hash(value):\n",
    "    return value[2] % 3  # Hash based on Experience\n",
    "\n",
    "# Read data from CSV file\n",
    "dataset = read_data_from_csv('employee_data.csv')\n",
    "\n",
    "# Perform sampling using custom hash function\n",
    "sample1, sample2, sample3 = [], [], []\n",
    "for data_point in dataset:\n",
    "    hash_value = custom_hash(data_point)\n",
    "    if hash_value == 0:\n",
    "        sample1.append(data_point)\n",
    "    elif hash_value == 1:\n",
    "        sample2.append(data_point)\n",
    "    else:\n",
    "        sample3.append(data_point)\n",
    "\n",
    "# Calculate mean and standard deviation for each sample (including HRA and PF)\n",
    "mean_hra1, std_dev_hra1 = statistics.mean([x[3] for x in sample1]), statistics.stdev([x[3] for x in sample1]) if len(sample1) >= 2 else (float('nan'), float('nan'))\n",
    "mean_hra2, std_dev_hra2 = statistics.mean([x[3] for x in sample2]), statistics.stdev([x[3] for x in sample2]) if len(sample2) >= 2 else (float('nan'), float('nan'))\n",
    "mean_hra3, std_dev_hra3 = statistics.mean([x[3] for x in sample3]), statistics.stdev([x[3] for x in sample3]) if len(sample3) >= 2 else (float('nan'), float('nan'))\n",
    "\n",
    "mean_pf1, std_dev_pf1 = statistics.mean([x[4] for x in sample1]), statistics.stdev([x[4] for x in sample1]) if len(sample1) >= 2 else (float('nan'), float('nan'))\n",
    "mean_pf2, std_dev_pf2 = statistics.mean([x[4] for x in sample2]), statistics.stdev([x[4] for x in sample2]) if len(sample2) >= 2 else (float('nan'), float('nan'))\n",
    "mean_pf3, std_dev_pf3 = statistics.mean([x[4] for x in sample3]), statistics.stdev([x[4] for x in sample3]) if len(sample3) >= 2 else (float('nan'), float('nan'))\n",
    "\n",
    "# Create a DataFrame to display mean, standard deviation, and z-values in a table\n",
    "data = {\n",
    "    'Sample': ['Sample 1', 'Sample 2', 'Sample 3'],\n",
    "    'Mean Salary': [mean1, mean2, mean3],\n",
    "    'Mean HRA': [mean_hra1, mean_hra2, mean_hra3],\n",
    "    'Mean PF': [mean_pf1, mean_pf2, mean_pf3],\n",
    "    'Standard Deviation Salary': [std_dev1, std_dev2, std_dev3],\n",
    "    'Standard Deviation HRA': [std_dev_hra1, std_dev_hra2, std_dev_hra3],\n",
    "    'Standard Deviation PF': [std_dev_pf1, std_dev_pf2, std_dev_pf3],\n",
    "    'Z-Value Salary': [z_value1, z_value2, z_value3]\n",
    "}\n",
    "\n",
    "# Unzip the dataset for scatter plotting\n",
    "experience, salary, daa, hra, pf = zip(*dataset)\n",
    "sample1_experience, sample1_salary, sample1_daa, sample1_hra, sample1_pf = zip(*sample1)\n",
    "sample2_experience, sample2_salary, sample2_daa, sample2_hra, sample2_pf = zip(*sample2)\n",
    "sample3_experience, sample3_salary, sample3_daa, sample3_hra, sample3_pf = zip(*sample3)\n",
    "\n",
    "# Plot the data points and samples with distinct markers for each sample\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(experience, salary, label='Original Data', marker='o', s=50)\n",
    "plt.scatter(sample1_experience, sample1_salary, color='red', label='Sample 1', marker='x', s=100)\n",
    "plt.scatter(sample2_experience, sample2_salary, color='green', label='Sample 2', marker='o', s=100)\n",
    "plt.scatter(sample3_experience, sample3_salary, color='blue', label='Sample 3', marker='s', s=100)\n",
    "plt.xlabel('Experience')\n",
    "plt.ylabel('Salary')\n",
    "plt.legend()\n",
    "plt.title('Employee Data')\n",
    "plt.show()\n",
    "\n",
    "# Display the mean, standard deviation, and z-values in a table\n",
    "result_df = pd.DataFrame({\n",
    "    'Sample': ['Sample 1', 'Sample 2', 'Sample 3'],\n",
    "    'Mean Salary': [mean1, mean2, mean3],\n",
    "    'Standard Deviation Salary': [std_dev1, std_dev2, std_dev3],\n",
    "    'Z-Value Salary': [z_value1, z_value2, z_value3]\n",
    "})\n",
    "\n",
    "display(result_df)\n"
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}