{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "861a772d-2016-48c2-98ac-6090e6aea2f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "50268a22373a43c6a9f77b11bfffacab",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=1.0, description='参数：', max=10.0), Output()), _dom_classes=('widget-in…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function update_parameter at 0x00000283DB1CF880>\n"
     ]
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "def update_parameter(parameter_value):\n",
    "    # 在这里执行代码，并使用 parameter_value 作为参数值\n",
    "    # 例如，你可以将 parameter_value 用于某个函数或条件\n",
    "    print(\"参数值已更新为:\", parameter_value)\n",
    "\n",
    "# 创建一个滑动条控件\n",
    "parameter_slider = widgets.FloatSlider(\n",
    "    value=1.0,  # 初始值\n",
    "    min=0.0,    # 最小值\n",
    "    max=10.0,   # 最大值\n",
    "    step=0.1,   # 步进值\n",
    "    description='参数：'\n",
    ")\n",
    "\n",
    "# 使用 interactive 函数将滑动条控件与函数关联起来\n",
    "interactive_plot = widgets.interactive(update_parameter, parameter_value=parameter_slider)\n",
    "\n",
    "# 显示滑动条\n",
    "display(interactive_plot)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cb54e39e-0113-4acb-9eba-23fdfa22178e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "630d6888ed9b4999900fcd95722a3652",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=0.0, description='参数paramter1：')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f173ad0d928c4f788e8cbafd02644a02",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=0.0, description='参数paramter2：')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "# 定义paramter1和paramter2的初始值\n",
    "initial_paramter1_value = 0.0\n",
    "initial_paramter2_value = 0.0\n",
    "\n",
    "# 创建滑动条控件用于paramter1\n",
    "paramter1_slider = widgets.FloatSlider(\n",
    "    value=initial_paramter1_value,\n",
    "    min=0.0,\n",
    "    max=100.0,\n",
    "    step=0.1,\n",
    "    description='参数paramter1：'\n",
    ")\n",
    "\n",
    "# 创建滑动条控件用于paramter2\n",
    "paramter2_slider = widgets.FloatSlider(\n",
    "    value=initial_paramter2_value,\n",
    "    min=0.0,\n",
    "    max=100.0,\n",
    "    step=0.1,\n",
    "    description='参数paramter2：'\n",
    ")\n",
    "def update_paramters(change):\n",
    "    paramter1_value = paramter1_slider.value\n",
    "    paramter2_value = paramter2_slider.value\n",
    "    sum_paramters = paramter1_value + paramter2_value\n",
    "    # 输出paramter1和paramter2的和\n",
    "    print(f\"参数paramter1的值：{paramter1_value}\")\n",
    "    print(f\"参数paramter2的值：{paramter2_value}\")\n",
    "    print(f\"paramter1 + paramter2 = {sum_paramters}\")\n",
    "\n",
    "# 将滑动条控件的值与函数绑定\n",
    "paramter1_slider.observe(update_paramters, names='value')\n",
    "paramter2_slider.observe(update_paramters, names='value')\n",
    "display(paramter1_slider)\n",
    "display(paramter2_slider)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d3d88790-abe2-4c4c-a3f6-fdb1acd83c47",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'paramter1_value' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[5], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mparamter1_value\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'paramter1_value' is not defined"
     ]
    }
   ],
   "source": [
    "paramter1_value\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f7281bdb-b7b6-4be1-9ef7-6e5553f340ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "948a80daf63e4c809b3e5d02030d2cd6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=5.0, description='paramter1', max=10.0), FloatSlider(value=5.0, descri…"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import ipywidgets as widgets\n",
    "\n",
    "def f(paramter1, paramter2):\n",
    "    print(f'paramter1: {paramter1}, paramter2: {paramter2}, sum: {paramter1 + paramter2}')\n",
    "    return paramter1, paramter2\n",
    "\n",
    "interactive_plot = interactive(f, paramter1=(0.0,10.0), paramter2=(0.0,10.0))\n",
    "interactive_plot\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "98697097-952d-4a2d-873a-dfbb9f2b5f83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paramter1: 6.6, paramter2: 5.9\n"
     ]
    }
   ],
   "source": [
    "paramter1, paramter2 = interactive_plot.result\n",
    "print(f'paramter1: {paramter1}, paramter2: {paramter2}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "407a07f0-af7f-49ce-9518-42dc455d466b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "两个圆相交\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def calculate_distance(p1, p2):\n",
    "    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)\n",
    "\n",
    "def check_circles(line1, line2):\n",
    "    # 计算线段的中点作为圆心\n",
    "    c1 = [(line1[0][0]+line1[1][0])/2, (line1[0][1]+line1[1][1])/2]\n",
    "    c2 = [(line2[0][0]+line2[1][0])/2, (line2[0][1]+line2[1][1])/2]\n",
    "\n",
    "    # 计算线段的长度作为圆的直径，因此半径是长度的一半\n",
    "    r1 = calculate_distance(line1[0], line1[1]) / 2\n",
    "    r2 = calculate_distance(line2[0], line2[1]) / 2\n",
    "\n",
    "    # 计算两个圆心之间的距离\n",
    "    d = calculate_distance(c1, c2)\n",
    "\n",
    "    # 判断两个圆的关系\n",
    "    if d > r1 + r2:\n",
    "        return \"两个圆没有交点\"\n",
    "    elif d == r1 + r2:\n",
    "        return \"两个圆相切\"\n",
    "    elif d < r1 + r2:\n",
    "        if d > abs(r1 - r2):\n",
    "            return \"两个圆相交\"\n",
    "        elif d == abs(r1 - r2):\n",
    "            return \"一个圆在另一个圆内相切\"\n",
    "        else:\n",
    "            return \"一个圆在另一个圆内且不相交\"\n",
    "    else:\n",
    "        return \"未知情况\"\n",
    "\n",
    "# 测试\n",
    "line1 = [(0, 0), (2, 0)]\n",
    "line2 = [(1, 0), (3, 0)]\n",
    "print(check_circles(line1, line2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6064e6a6-e673-49f1-84eb-2c09d36333b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "\n",
    "# 计算两点之间的距离\n",
    "def calculate_distance(p1, p2):\n",
    "    return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)\n",
    "\n",
    "# 计算两线段的角度\n",
    "def calculate_angle(p1, p2):\n",
    "    return math.degrees(math.atan2(p2[1] - p1[1], p2[0] - p1[0]))\n",
    "\n",
    "# 计算点到线段的最短距离\n",
    "def point_to_line_distance(point, line):\n",
    "    p1, p2 = line\n",
    "    line_vector = np.array(p2) - np.array(p1)\n",
    "    point_vector = np.array(point) - np.array(p1)\n",
    "    line_length = np.linalg.norm(line_vector)\n",
    "    unit_line_vector = line_vector / line_length\n",
    "    projected_point_length = np.dot(point_vector, unit_line_vector)\n",
    "    if projected_point_length < 0:\n",
    "        return calculate_distance(point, p1)\n",
    "    elif projected_point_length > line_length:\n",
    "        return calculate_distance(point, p2)\n",
    "    else:\n",
    "        projected_point = p1 + projected_point_length * unit_line_vector\n",
    "        return calculate_distance(point, projected_point)\n",
    "\n",
    "# 判断两线段的一致性\n",
    "def check_consistency(line1, line2):\n",
    "    # 判断角度差\n",
    "    angle1 = calculate_angle(*line1)\n",
    "    angle2 = calculate_angle(*line2)\n",
    "    if abs(angle1 - angle2) > 2:\n",
    "        return False\n",
    "\n",
    "    # 判断线段1上所有点到线段2的垂直距离\n",
    "    for point in line1:\n",
    "        if point_to_line_distance(point, line2) > 5:\n",
    "            return False\n",
    "\n",
    "    # 判断以线段为直径的圆的关系\n",
    "    c1 = [(line1[0][0]+line1[1][0])/2, (line1[0][1]+line1[1][1])/2]\n",
    "    c2 = [(line2[0][0]+line2[1][0])/2, (line2[0][1]+line2[1][1])/2]\n",
    "    r1 = calculate_distance(line1[0], line1[1]) / 2\n",
    "    r2 = calculate_distance(line2[0], line2[1]) / 2\n",
    "    d = calculate_distance(c1, c2)\n",
    "    if d > r1 + r2:\n",
    "        return False\n",
    "\n",
    "    return True\n",
    "\n",
    "# 测试\n",
    "line1 = [(0, 0), (2, 0)]\n",
    "line2 = [(1, 0), (3, 0)]\n",
    "print(check_consistency(line1, line2)) # 输出：True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cb6fd875-453c-4085-a800-e791de9c0330",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[(0, 0), (2, 0)], [(0, 0), (0, 2)]]\n"
     ]
    }
   ],
   "source": [
    "def find_matching_lines(lines1, lines2):\n",
    "    lines3 = []\n",
    "    for line1 in lines1:\n",
    "        for line2 in lines2:\n",
    "            if check_consistency(line1, line2):\n",
    "                lines3.append(line1)\n",
    "                break\n",
    "    return lines3\n",
    "\n",
    "# 测试\n",
    "lines1 = [[(0, 0), (2, 0)], [(0, 0), (0, 2)], [(0, 0), (-2, 0)]]\n",
    "lines2 = [[(1, 0), (3, 0)], [(1, 1), (3, 1)], [(0, 0), (0, 2)]]\n",
    "lines3 = find_matching_lines(lines1, lines2)\n",
    "print(lines3)  # 输出：[[(0, 0), (2, 0)], [(0, 0), (0, 2)]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7cdccf36-10c7-4b2a-8830-9c7ab3840ec5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABK0UlEQVR4nO3de3hU5bk3/u/MJDMJECIYSQLEInjgJAfBxHCohwY51GjfvfuWrRaQVt1F6OU2e+8KVaHUVsRayvVTKr9Sqd3bWqzdirXEUAimCkZSwWyhERAIkkImENAk5pyZ9f4xWcNMMpPMmlmHZ631/VxXLsJkTWZlDmvd67nv534ckiRJICIiIjKI0+gdICIiIntjMEJERESGYjBCREREhmIwQkRERIZiMEJERESGYjBCREREhmIwQkRERIZiMEJERESGSjJ6B2Lh9/tx9uxZpKWlweFwGL07REREFANJktDU1IThw4fD6Yw+/mGKYOTs2bPIyckxejeIiIgoDjU1NRg5cmTUn5siGElLSwMQ+GMGDx5s8N4QERFRLBobG5GTkxM8j0djimBETs0MHjyYwQgREZHJ9FdiwQJWIiIiMpTiYOTdd99FYWEhhg8fDofDge3bt/d7n7KyMtxwww3weDy4+uqr8dJLL8Wxq0RERGRFioOR5uZmTJ48GZs2bYpp++rqanz961/HrbfeisrKSvzbv/0b7r//fuzcuVPxzhIREZH1KK4ZmT9/PubPnx/z9ps3b8ZVV12Fn//85wCAcePGYe/evfjFL36BuXPnKn14IiIishjNa0bKy8tRUFAQdtvcuXNRXl4e9T7t7e1obGwM+yIiIiJr0jwY8Xq9yMzMDLstMzMTjY2NaG1tjXifdevWIT09PfjFHiNERETWJeRsmlWrVqGhoSH4VVNTY/QuERERkUY07zOSlZWFurq6sNvq6uowePBgpKamRryPx+OBx+PReteIiIhIAJoHI/n5+SguLg67bdeuXcjPz9f6oYmIyEJ8fgkV1RdxrqkNw9JSkHvVULicXK/MChQHI19++SWOHz8e/H91dTUqKysxdOhQXHnllVi1ahXOnDmD//qv/wIAfO9738Pzzz+PH/zgB/jOd76DPXv24A9/+AN27Nih3l9BRESWVnK4FmvfqkJtQ1vwtuz0FKwpHI95E7MN3DNSg+KakQ8//BBTp07F1KlTAQBFRUWYOnUqVq9eDQCora3F6dOng9tfddVV2LFjB3bt2oXJkyfj5z//OX79619zWi8REcWk5HAtlr18MCwQAQBvQxuWvXwQJYdrDdozUotDkiTJ6J3oT2NjI9LT09HQ0MC1aYiIbMTnlzBr/Z5egYjMASArPQV7H72NKRsBxXr+NsVCeUREZD6SJKGzsxPt7e1ob29HR0dH2L+xfH/0zEUc2XcCkq8Tkq8THd4T8DVfROo1N2HQxK8hKT0TtQ1tqKi+iPwxlxv9J1OcGIwQEZmcz+dTdIKP5Xu1fodWOs9Vo3Hf7+EckA5P9rV4rvFmNH1jDnJzc3HZZZdp9rikDaZpiIhiEHqVr8eJXMnj+Hw+o5+emLhcLng8Hrjd7mALh/6+b+oE9p1sgCMpCQ5XMroaz8PXdAFSZxs6P68F/F29Hue6665DXl5e8GvSpElITk424C+mWM/fDEaISCh+v1/XE7mS781Cyck+9Pt47xfr73a5XIr/FrlmxNvQhp4nK6mrE53nTsL9+UnMSPscFRX7ceLEiV6/IyUlBVOnTg0LUEaNGgWHgzUmWmMwQkRRyVf5Rg7hR/veClf5Wp/U+/p5cnKy5U6y8mwaAGEBifxXvvDtG4LTe+vr61FRUYH9+/dj//79qKiowOeff97rdw4bNgy5ubnB4OTGG29kekcDDEaIBBDpKl+Uq32zUPMEr2ZgEM9VvtXo2YQs3j4jkiTh008/DQtQKisr0dnZ2WvbsWPHho2eXH/99UzvJIjBiIrY9U9skiShq6tLiIK9nt+b6SrfyCH8aI9jxat8qzCiCZlax+K2tjZUVlYGg5P9+/fj5MmTvbZLSUnBtGnTwgKUK6+8ku9JBRiMqIRd/y6Rr/KNHMKPdpsJ3sYAAlf5Rg7hR/ueV/mkhJw26fmpi5Q2MYvz58/3Su988cUXvbbLzMzsld5JT0/Xf4dNgsGICoz4wIVe5YtQsBf6fVdX76p1ETmdTlVP5EnJyaj70oc2yYmhgwZg7IihSE1NUfy73W43r6jI9OzShMzv9+PTTz8NGz353//9317HQYfDETG9k5TEzhkAg5GE9fzAff7e7yB1tCBpSDYcziTA14lBycCDs65Ep8rz8k3wkgAIv8o3Ygg/2vdqXuVzZIwoXPmJC7h7ywf9bvf7B26yXBOy1tbWXumd6urqXtulpqb2Su/k5OTY8mKEHVgTVFF9MewE1Fj+KiD5w7a5CODxt7XdD/kqP9qJt8XnwNnGLnTCBYcrMA8/NcWDqaOuwOisyzTL+dvhKj/ayJi8HoYZh6KJEnWuKfKISLzbmUlqairy8/PDVp0/d+5cr/ROQ0MD9u7di7179wa3y8rKCgtOpk+fzgkZIRiMRNHrg+R0AT4/PCPGw5maBocrGY6kZNx09TBcO3yoZlf7fQ31ySfLoT1udwA4DuDfebKMm88vYe1bVb0CESAwtdABYO1bVZgzPsvUQ9FESg1LS1F1O7MbNmwY7rjjDtxxxx0AAumdY8eOhY2efPzxx/B6vXjzzTfx5ptvAgikd8aNGxcWoEycONG26R17/tUx6PlBcjickABkFP47ktIzg7c/adBQJE+W2uo5MtaTBHA9DLKl3KuGIjs9JWITMuBSzUjuVT0vk+zB6XRi7NixGDt2LJYsWQIgkN45ePBgWIDy2WefoaqqClVVVfjNb34DABgwYECv9M7IkSMtPwoNMBiJKvQD5/f7IHUF+jI4kgNBitEfOJ4stWXnoWiivricDqwpHI9lLx+EA5GbkK0pHM+LoBCpqamYOXMmZs6cGbytrq6uV3qnsbER7733Ht57773gdtnZ2b3SO2lpaUb8GZpiMBJF6AcOnZdOOE53qhAfOJ4stcWhaKLo5k3MxgvfvqFXcXcWi7tjlpmZicLCQhQWFgIIpHeOHj3aK71TW1uL7du3Y/v27QAC6Z0JEyYEg5Pc3FxMmDBBcXpHtP5ZDEb6IH/gHnv5XZwGAnUjrmQhPnA8WWqLQ9FEfZs3MRtzxmcJdULTktYnb6fTiXHjxmHcuHG47777AAAtLS290junT5/G4cOHcfjwYbz44osAgIEDB0ZM70Qj4ixBTu2NQdUnRzBh/DgMTEvHro9OCPGB62vxKEC/uf6iRddqUrIeBhFZl0gnb6/XGxac/O1vf0NTU1Ov7YYPH94rvTNo0CDd+2exz4iKPvzwQ9x4440YOXIkampqdH/8aIw+WYr0AdWKHf5GIopO9G6zPp+vV3rn0KFDvZaicDqdmDBhAuo8I9GVcTU8w69D8uU5cDgv9WXS4iKWwYiKysrKcOutt2LcuHGoqqrS/fH7YtTJUvQPqJqsPPpDRNHF2m322W9ORn1zuzDHh+bm5l7pnYgX0q4kOJI8GDj+Zlx++0PBm9VsWMemZyr68ssvAQCDBg0yeE96MyJva7dpxS6ngzOSiGwo1lmL9764P3ibCCOnAwcOxOzZszF79uzgbbW1tfj/thXjl38oQfvZY+jwfgqpoxWSrwtdn3vD7m/ExAcGIzGQ83EiBiOA/idLTismIjuI56Qsaofm7Oxs3HnnN/D7uiwAgOT34fyfnkHr0X1IGjo8bFsjJj44dX9EExJ5ZMQInFZMRHYQz0lZHjFe+1YVfH6xqiDkWYIOAA6nC64BgdWGXamB9IkDgZEdI2YJMhiJgRyMWLHRTDw4rZiI7CD05K1E6OiwSOT+WUAg8Ah2dpX8hvfPYjASA9HTNHrr7wNqZHRNRKSWnidvpUQcHZb7Z2WlpwCOQAggSRKy0lMMTS0xGIkB0zTh+vqAGh1dE5G9+fwSyk9cwJuVZ1B+4kLCqZKwk7dCoo4Oz5uYjb2P3oYF1wdqRe6alIW9j95maI0LC1hjwDRNb2wHTUSi0arVQc9ZixmDPPj3P1SirrHdtB2aXU4HRl4euMDOTvcYfvHIYCQGTNNEZrd20EQkrmi9j9Sa3dJz1uKP7pxg+sUCnc5AcsTv9xu8J0zTxIRpmujkD+hdU0Ygf8zlwn/4iMhafH4J+47XY+X/HIra+whQf3ZLtPSN0bUXSsjBSM9urUbgyEgMmKYho7ELLFFvkdIykWjV+8jso8MuV6AVvAgjIwxGYsA0DRmJ6+MQ9RYtLdMXLWa3mLlDs0gjI0zTxIBpGjKKfMDteeUn58FLDtcatGdExulrSYq+iDq7xSgijYwwGIkB0zRkhP7WAALE7PJIpLX+lqToib2PImMBq8kwTUNGULIGEJGdKEm3mGl2SyLi6a8iUpqGNSMxYJqGjMA1gIgiU5JusUPvo3jrykRK0zAY6UdHRwc6OjoAME1D+uIaQESRyUtSeBvaotaNXDYgGZvuvgE3WbzlQCL9VUQaGWGaph/yqAgADBw40MA9IbvhGkBEkfW3JIUDwNP/dD1mXpNh6UAk0boykUZGGIz0Qw5G3G433G63wXtDRlF7vYtYcA0gouis0HQsUYnWlYlUwMo0TT84k4aM7PPBNYCIojN707FEJVpXJlKahsFIPziTxt60Xu8iFnY/4BL1xcxNxxKVaF2ZSGkaBiP94Ewa++ovH+tAIB87Z3yW5oGBnQ+4RBRZf4W8/a0eLNLICGtG+sE0jX2xzwcRiSzRujKRRkYYjPSDIyP2xT4fRGIxopBcdIkU8rKA1URYM2Jf7PNBJA4uGBldvHVlIqVpGIz0g2ka+0o0H0tE6hChkFx08dSVMU1jIkzT2Bf7fBAZjwtGakekkREGI/1gmsbe2FiJyFgsJNeOSCMjTNP0g2kaYp8PEoHPL9nyPchCcu2wgNVEmKYhgH0+yFh2Lt5kIbl2mKYxEaZpiMhIcvFmz1SFXLxZcrjWoD3TBxeM1I5IaRoGI/3gyAgRGYXFmywk1xJHRkyENSNE1BctG3GxeDOAheTaEGlkhDUj/WCahvRm10JFM9K6loPFm5ewkFx9LGA1EaZpSE+RTm6XpSZj6cxRWHHbNTzwCkSPRlws3gzHQnJ1MU1jIkzTkF6iFSp+0dqJX+z+FNN+ssvyxYpmoVctB4s3SUsipWkYjPRBkiSmaUgXfZ3cZF+0dNpi9oQZ6FXLweJN0hJHRkyivb09+CIxGCEt9Xdyk0mw/uwJM9CzloPFm6QVkUZGWDPSBzlFAzAYIW0pOWnJV9zMnRtH71oOFm+SFljAahJyiiY1NTUYQRJpQelJyw6zJ0RmxIrOLN4ktTFNYxKcSUN6kU9usbLL7AlRsZaDrECkNE1cwcimTZswatQopKSkIC8vDxUVFX1uv3HjRlx33XVITU1FTk4OHnnkEbS1iX9lx5k0pJfQk1tfOHtCHKzlILMTaWREcZrm1VdfRVFRETZv3oy8vDxs3LgRc+fOxdGjRzFs2LBe27/yyitYuXIltm7dihkzZuDYsWO477774HA4sGHDBlX+CK1wJg3pad7EbGz+9g1Y+fohfNHS2evnZrnilpu2eRtacbG5A0MHeZA12Jo1DqzlIDMTaWREcTCyYcMGPPDAA1i6dCkAYPPmzdixYwe2bt2KlStX9tr+/fffx8yZM3HPPfcAAEaNGoW7774b+/fvT3DXtcc0DelNPrk9v+c4frOvGl+0XgpKskywSmukpm0yq64ya1QtBzv1UqJMW8Da0dGBAwcOYNWqVcHbnE4nCgoKUF5eHvE+M2bMwMsvv4yKigrk5ubi5MmTKC4uxqJFi6I+Tnt7O9rb24P/b2xsVLKbqmGahozgcjrwcME1WHHb1aY62UTrSCqrVbEzqd1p3Yae7MG0aZr6+nr4fD5kZmaG3Z6ZmYkjR45EvM8999yD+vp6zJo1C5IkoaurC9/73vfwwx/+MOrjrFu3DmvXrlWya5pgmoaMZKbZE7E0bZOtfasKc8ZnCR1YiUyPNvRkDyKlaTSfTVNWVoannnoKv/zlL3Hw4EG8/vrr2LFjB5588smo91m1ahUaGhqCXzU1NVrvZkRM0xDFRknTNjusMqsVvdrQkz2YdmQkIyMDLpcLdXV1YbfX1dUhKysr4n2eeOIJLFq0CPfffz8A4Prrr0dzczMefPBBPPbYY8EnI5TH44HH41Gya5pgmoYoNkr7nrBPSnyUtKE3y6gaGce0IyNutxvTpk1DaWlp8Da/34/S0lLk5+dHvE9LS0uvgEN+AiRJ7OidIyNEsVHa94R9UuKjZxt6sj7TFrACQFFREZYsWYLp06cjNzcXGzduRHNzc3B2zeLFizFixAisW7cOAFBYWIgNGzZg6tSpyMvLw/Hjx/HEE0+gsLBQ+K6mrBkhio3ctK2/VI0WnUntRO829GRtpk3TAMDChQtx/vx5rF69Gl6vF1OmTEFJSUmwqPX06dNhIyGPP/44HA4HHn/8cZw5cwZXXHEFCgsL8dOf/lS9v0IjTNMQxUZu2tbXbBqZ6H1SRGZEG3qyLpHSNA5J9FwJAlN709PT0dDQgMGDB+v2uHfccQd27NiBF198Ed/5znd0e1wis7JjnxG9ybNpAIQFJHJ4x9k0FKsTJ07g6quvxqBBg4KZALXFev7mQnl9YJqGSJnQjqR26MBqBLkNfc+gzwxN8UgsIo2MMBjpA9M0RMqZqT+KWbENPanB1AWsdsLZNEQkKgZ9lCiRClg1b3pmZkzTEBGRVTFNYxIcGbmEi3IREVmLSCMjDEaikCSJNSPdzLwoF4MoIqLIQnt9SZIEh8O4YyODkShaWlqCHWLtPDJi5kW5zBxEEZEYrHxBE9oTzO/3G9qIlMFIFPKoCAAMGDDAwD0xTn+Lcjkg7gqsZg6iiMzKaiduq1/QhAYjPp+PwYiIQutFIi3mZwdmXZTLzEEUkVlZ7cRthwua0ODD6CJWe55lY8CZNOZdlEtJEEVEiZNP3D0/d/KJu+RwrUF7Fp/+LmiAwAWNzy98A/M+9RwZMRKDkSg4k8a8i3KZNYgiMiMrnrjtckHTs2bESAxGouBMmkuLckVLZDgQGIYVbVEuswZRRGZkxRO3XS5omKYxAaZpLq3ECqBXQCL/X8QVWJUEUT6/hPITF/Bm5RmUn7hgqqs3IhFY8cRtlwsakdI0LGCNgmmaADMuyhW6nL0DkVc2XVM4HruqvJYquCMyghVP3PIFjbehLWL6yYHAMVC0UWGlRBoZYTASBdM0l5hxUa7+gigAlq+UJ9KDFU/csV7QiHwMjEVokzOOjAiKaZpwZlyUK1oQBQCz1u/h1N9+WK1nBGnDqiduM44Kx8PpdMLv93NkRFRM01hDpCCq/MQFU/ZP0ZPVekaQtqx64jbjqLBSLpeLwYjImKaxLisW3KnJDs2eSH1WPXGbcVRYCVEWy2MwEgXTNNZlxYI7tbB7LSXC6ifuvpg1rSkXsXJkRFBM01iXFQvueor3wGjWJQCIjGTmtCZHRgTHNI11WbXgTpbIgZEpLCJlzJ7WlIMRo0dG2PQsCo6MWJtccJeVHp6KyUpPEf7g0ZdE1whhCks7bLBnPVZohc80jeBEqxkxaz5SZFYruFOj3sMOKSwjmHkYn6KzQlqTaRrBiZSm4YFMO1YquFPjwGj1FJYRzD6MT9FZIa0pysgI0zRRiJKmsdrS3KQdtQ6MVk1hGcEKw/gUnRXSmhwZEZwIaRpOsyQl1DwwWi2FZRQrDONTdFZIa7KAVWA+nw8tLS0AjE3TWHFpbtKOktWKYyGnsO6aMgL5Yy5nIBIHKwzjU3RmXdk8FNM0ApMDEcDYkREeyEgJKxwYrcYKw/gUnc8vIT3VjaUzR2HIQHfYz8yS1mSaRmByisbpdCIlxbiDBA9kpJRV1wgxKysM41NkkSYWDB2YjP8zZQQKxmeZJq0pysgIg5EIQmfShC6xrDceyCgerPcQB2cnWVO0GVKfN3di675TuNFEnzfWjAhMlJk0HHaneLHeQxycnWQtVpshxTSNwESYSSPTYtidDdSI9MXRKuuw2gwppmkEJsrIiEzNA1nxx2fx+JuHcbG5M3gbG6gRJSaWAN9KDfasrL/X0moTCzgyIjA9uq8qHZ1Q40C2rrgK//+71b1ur2UnSKK4sUOydcTyWlptYgFHRgSmdZrGiINX8ce1EQMRmQQ2UCNSSu9W70yxaifW19JqEwtYwCowLdM0RrR39/klPP7m4X63YwM1otjpXchYcrgWs9bvwd1bPsDD2ypx95YPMGv9Hi4JoQIlr6XVJhaIkqZhMBKBVmkao6qwK6ov4mJzR0zbmiXPSWQ0PTskc40qbSl9La00Q4ppGoFplaYxqgpbSYBhljwnkdH0KmTkGlXai+e1tMoMKVFGRhiMRKBVmsaoKuxYA4yhA5NNk+ckMppehYxWm0oqonhfSyvMkBJlZIRpmgi0StMYVYUtF1z15yd3TTRdVE9kFLUXJoxGjYsYn19C+YkLeLPyDMpPXDBNQy696PVaiogFrALTKk1j1BteLrjqK8z4169ehQWThqv6uKQMTxjmolchY6IXMSx87Z/VilKVECVNw2AkAq3SNEa+4eWCq54jJJcPdOOX99yAVQvGq/6YFDueMMxJj0LGRC5iWPgaOysVpSohSpqGNSMRaNn0zMhVVa1ScGU1eveqIHVp/bmKd7E9Fr4qZ8djpCgjIwxGItC66ZmRb3grFFxZCU8Y1qD15yqeixgWvsbHbsdIjowITI+1aez2hqfIeMKgWCm9iLHaGiqkDVEKWBmMRKDH2jREAE8YpIySixirraFC2mCaRmBap2mIZDxh6MtOa7tYbQ0V0gbTNILq7OxEe3s7AAYjpD2eMPRjt9V14y18JXsRZWSEU3t7aG5uDn7PNA1pzc79DfRk1ymudp2uSrHjyIig5HqR5ORkuN1ug/eG7MDI6d52YPcZS3acrkqxYwGroFgvQkbgCUM7nLHE2XsUnShpGgYjPXAmDRmFJwxtcMYSUXRM0whKjx4jRKQfM89YstPsHzIGR0YExTQNkbWYdcaS3Wb/kDFEGRnhbJoemKYhshYzzliy6+wf0p8oBawMRnpgmobIesw0xbW/2T9AYPaPzx9pCyJlmKYRFNM0RNZklhlLnP1DehIlTcNgpAeOjBBZlxlmLHH2D+lJlJERpml6YM0IERnJzLN/yHxEGRmJKxjZtGkTRo0ahZSUFOTl5aGioqLP7b/44gssX74c2dnZ8Hg8uPbaa1FcXBzXDmuNaRoiMpI8+yda8siBwKwa0Wb/kDmZtoD11VdfRVFREdasWYODBw9i8uTJmDt3Ls6dOxdx+46ODsyZMwenTp3CH//4Rxw9ehRbtmzBiBEjEt55LTBNQ0RGMuPsHzIv06ZpNmzYgAceeABLly7F+PHjsXnzZgwYMABbt26NuP3WrVtx8eJFbN++HTNnzsSoUaNw8803Y/LkyQnvvBaYpiEio5lp9g+ZmyhpGkUFrB0dHThw4ABWrVoVvM3pdKKgoADl5eUR7/OnP/0J+fn5WL58Od58801cccUVuOeee/Doo48Gn4Se2tvb0d7eHvx/Y2Ojkt1MCNM0RCQCs8z+IXMTZWREUTBSX18Pn8+HzMzMsNszMzNx5MiRiPc5efIk9uzZg3vvvRfFxcU4fvw4HnroIXR2dmLNmjUR77Nu3TqsXbtWya6phmkaIhKFGWb/kLmJMjKi+Wwav9+PYcOG4Ve/+hWmTZuGhQsX4rHHHsPmzZuj3mfVqlVoaGgIftXU1Gi9m0FM0xARkV2IUsCqaGQkIyMDLpcLdXV1YbfX1dUhKysr4n2ys7ORnJwclpIZN24cvF4vOjo64Ha7e93H4/HA4/Eo2TXVME1DRER2IUqaRtHIiNvtxrRp01BaWhq8ze/3o7S0FPn5+RHvM3PmTBw/fjws6jp27Biys7MjBiJGY5qGiIjswrRpmqKiImzZsgW//e1v8cknn2DZsmVobm7G0qVLAQCLFy8OK3BdtmwZLl68iIcffhjHjh3Djh078NRTT2H58uXq/RUqYpqGiEgcPr+E8hMX8GblGZSfuMA1eVQmysiI4nbwCxcuxPnz57F69Wp4vV5MmTIFJSUlwaLW06dPB/84AMjJycHOnTvxyCOPYNKkSRgxYgQefvhhPProo+r9FSppb29HZ2cnAI6MEBEZreRwLda+VRW2Vk92egrWFI7n9GaViDIyEtfaNCtWrMCKFSsi/qysrKzXbfn5+fjggw/ieShdyaMiAIMRIiIjlRyuxbKXD/Zavdjb0IZlLx9kvxWViFLAyrVpQsjBSEpKCpKSuIYgEZERfH4Ja9+q6hWIAAjetvatKqZsVCBKmobBSAjOpCEiMl5F9cWw1ExPEoDahjZUVF/Ub6csSpQ0DYOREJxJQ0RkvHNN0QOReLaj6DgyIiDOpCEiMt6wtJT+N1KwHUXHkREBcWSEiMh4uVcNRXZ6Sq9Vi2UOBGbV5F41VM/dsiQWsAqINSPGYj8BIgICa/KsKRwPAL0CEvn/awrHc9FAFYiSpuGUkRBM0xiH/QSIKNS8idl44ds39DouZPG4oCpR0jQMRkIwTWMM9hMgokjmTczGnPFZqKi+iHNNbRiWFkjNcEREPRwZERDTNPrrr5+AA4F+AnPGZ/EARGRDLqcD+WMuN3o3LEuUkRHWjIRgmkZ/7CdARGQcFrAKiGka/bGfABGRcURJ0zAYCcE0jf7YT4CIyDiipGlYMxKCIyP6k/sJeBvaItaNOBConmc/AfX4/BILAokIgDgjIwxGQrBmRH9yP4FlLx+EAwgLSNhPQH2cQk1EoUQZGWGaJgTTNMaQ+wlkpYenYrLSUzitV0XyFOqeBcPyFOqSw7UG7RmJiE0I7UGUAlaOjIRgmsY47CegLU6hJiU4gmYfoqRpODISgmkaY8n9BO6aMgL5Yy7nSVFFnEJNseIImr0wTSMgpmnIqjiFmmLR3wgaEBhBY8rGOjgyIhhJkpimIcviFGqKBUfQ7IcjI4Jpa2sLvhhM05DVcEl2igVH0OxHlAJWBiPd5BQNAAwYMMDAPSFSH5dkp1hwBM1+mKYRjJyiGTBgQHDYishKOIWa+sMRNPsRJU3Dqb3dOJOG7IBTqKkvbEJoP6KMjDAY6caZNGQXXJLd/LRs6S+PoPXsM5LFPiOWxJERwXAmDRGZgR4NyTiCZh+iFLAyGOnGNA2RfZll8UC5IVnPLh9yQzI1a3+0HEEzy/NtB0zTCMbOaRoeGMjOzNL63Cot/c3yfNsF0zSCsWuahgcGsjM9RxoSpaQhmag1QWo837x4UhdHRgRjxzSNmQ7ERGoz20iD2RuSqfF88+JJfaLUjLDPSDe7jYxwDQqyO7O1Pjd7Q7JEn28u4KcNUdI0DEa62a1mxGwHYiK1mW2kwewNyRJ5vnnxpB1R0jQMRrrZLU1jtgMxkdrMNtJg9pb+iTzfvHjSDkdGBGO3NI3ZDsREajPjSIOZW/on8nzz4kk7ooyMsIC1m93SNPKBwdvQFnHo04HAAU6kAzGRmsza+tysDckSeb558aQdFrAKxm5pGrMP+RKpwawjDXJDsrumjED+mMtN8zmN9/k24yiWWYiSpuHISDe7pWkArkFBBJh3pMGs4nm+zTqKZQZM0wjGbmkaGQ/ERFw8UG/xPN+8eNIGR0YEY7c0TSgeiInIDHjxpD6OjAjGjmkaIiKz4cWTuljAKhC/389ghIiIbEeUNA2DEQAtLS3B7xmMEBGRXYiSpmEwgkspGofDgQEDBhi8N0RERPrgyIhAQmfSOBwshCIiInuQR0YAYwMSFrCCxatERFrz+SXOghFQz2Ak9P96YjACe0/rJSLSWsnh2l79QbLZH0QIcpoGMHZkhGka2LfhGRGR1koO12LZywd7rbrrbWjDspcPouRwrUF7RkD4yIiRRawMRsA0DRGRFnx+CWvfqoq4GKd829q3quDzR9qC9MCREYEwTUNEpL6K6ou9RkRCSQBqG9pQUX1Rv52iMCxgFQjTNCwuEwVfB7KSc03RA5F4tiP1iZKmYTACpmlYXCYGvg5kNcPSUlTdjtTHNI1A7JymYXGZGPg6kBXlXjUU2ekpiDa250Ag4M69aqieu0UhRBkZYTAC+6ZpWFwmBr4OZFUupwNrCscDQK+ARP7/msLxTEUayOFwBJt9cmTEYHZN07C4TAx8HcjK5k3MxgvfvgFZ6eGpmKz0FLzw7RuYghSACCv3smYE9k3TsLhMDHwdyOrmTczGnPFZLM4WlNPphM/nYwGr0ew6MsLiMjHwdSA7cDkdyB9zudG7QRG4XC50dnYyTWM0u9aMmKW4zOeXUH7iAt6sPIPyExcsVzthlteBiKxJTtNwZMRgdk3TyMVly14+CAcQVkApSnGZHaa7muF1ICLrkqf3cmTEYHqlaUS8whe5uMxO0137eh023XMD0lPdQr1viMg6WMAqCD3SNCJf4YtYXNbfdFcHAtNd54zPssyIQaTX4fPmdjy5I/b3TbwdXNn5lci+TJum2bRpE372s5/B6/Vi8uTJeO6555Cbm9vv/bZt24a7774bd911F7Zv3x7PQ2tC6zSNfIXf88QqX+EbPQIBiFdcpmS6q0j7najQ16HkcC2Wv/JRzO+beANekQNlrTEIIzJpmubVV19FUVER1qxZg4MHD2Ly5MmYO3cuzp071+f9Tp06hf/4j//A7Nmz495ZLfh8PrS2tgLQZmSEDa3iY/fprkrfN/GmtOyUCuup5HAtZq3fg7u3fICHt1Xi7i0fYNb6PZb+m4l68vkl+KRAAH7wlHFpYMXByIYNG/DAAw9g6dKlGD9+PDZv3owBAwZg69atUe/j8/lw7733Yu3atRg9enRCO6w2eVQE0CYYYUOr+Nh9uquS9028Aa+dA2U7B2FEMjkgb2wPpGd+8MdKwwJyRcFIR0cHDhw4gIKCgku/wOlEQUEBysvLo97vxz/+MYYNG4bvfve7MT1Oe3s7Ghsbw760IgcjSUlJ8Hg8qv9+u1/hx8vu012VvG/iDXj1CJRFLNq2cxBGJAsPyLuPtJJkWECuqGakvr4ePp8PmZmZYbdnZmbiyJEjEe+zd+9evPjii6isrIz5cdatW4e1a9cq2bW4hc6kkfvzq8nuV/jxsvt0VyXvm3gDXq0DZVFrUexaj0Qk6xmQS1LgO39nh2ETBDSd2tvU1IRFixZhy5YtyMjIiPl+q1atQkNDQ/CrpqZG030EtJtJY/cr/ESIPO1Ya0reN/EGvFoGyiKnQThaSXbXMyD3tzYAADrrPwNgTPmAopGRjIwMuFwu1NXVhd1eV1eHrKysXtufOHECp06dQmFhYfA2uVo3KSkJR48exZgxY3rdz+PxaJIyiUTrHiN2v8JPlIjTjvWg5H0jBy7ehraIqQcHAgFcz4A33vv1R/Rp2RytJLuLFmg7ktwxbacFRSMjbrcb06ZNQ2lpafA2v9+P0tJS5Ofn99p+7NixOHToECorK4Nfd955J2699VZUVlYiJycn8b8gQXp0X7XzFb4a5Omud00Zgfwxl1s+EJHF+r6Jd5l2rZZ3F71om6OVZHc9A22nZyAAwJ11dZ/baUlxn5GioiIsWbIE06dPR25uLjZu3Ijm5mYsXboUALB48WKMGDEC69atQ0pKCiZOnBh2/8suuwwAet1uFL3WpbHrFT4lJtb3jRy49KzRyOqnRiPe+/VF9DQIRyvJ7nqOikpdHQAujYzEOyqaCMXByMKFC3H+/HmsXr0aXq8XU6ZMQUlJSbCo9fTp08Fubmag54q9ojUWI3OI9X0Tb8CrdqBshjSIFkEYkVmEBuSQpLBgxKiAPK4OrCtWrMCKFSsi/qysrKzP+7700kvxPKRm7LpIHqlPhG6e8Qa8agbKWtWiqI2jlWRnckC+ZvvH+EwK1HI6ktyGBeS2X5tGrzQNWZuo01iNYKY0CEcryc7mTczGTTkDMeSJwP//+8FZmD12uCGfTfPkUzSiZ5qGrEnkaaxGYdE2kTl0tF86bt08zphABODICNM0lBDRp7EaiWkQIvG1tQWCEY/Ho0njz1jZPhhhmoYSwW6efWMahEhs8kKxqamphu6H7YMRpmkokcJT0aexEhH1RR4ZSUkxtskfgxGmaWwt0cJTM0xjJSKKRpRgxPYFrEzT2Jcahafs5kkkJhFXjBYR0zSCYJrGntQqPDXTNFYiu+BU+9hxZEQQTNPYk5rrp3AaK5E4ONVeGVGCEduPjDBNY09qF55yGiuR8TjVXjmmaQTBNI09aVF4ymmsRMbiVHvlRBkZsXWapqOjAx0dgQWCmKaxFxaeElkPp9orx2BEAM3NzcHvBw4caOCekN7kwlMAvQISFp4SmROn2isnSprG1sGIXC/idrvhdrsN3hvSGwtPiayFI57KiTIyYuuaEc6kIRaeElkHp9orJwcjRo+MMBgBi1eNkkgbdjWx8JTIOuQRz559RrLYZyQiOU3DkREDcVqvcdiUiIi0whHP2DFNIwCmaYwhNyXq2QtAbkrEeg0iShRHPGPDAlYBME2jv/6aEgGBpkRcR4LIHLgGjLlxZEQATNPoj02JiKyD6VbzEyUY4cgImKYB9Lu6YVMiImvgGjDWIEqaxtYjI0zTBOh5dcOmRETmxzVg4iPKDMJQooyM2DYY8fklHK05BwBo7HLB55cMf1MYQe9iUrkpkbehLeKBzIHAFDw2JSISF9Otyoma0hIlGLFlmqbkcC1mrd+DPx+oBgD8+ZPPMWv9HtsNKxpRTMo27ETmx3SrMiKntERJ09guGAl9U/g7Ay+C050qxJtCb0qubtTENuxE5sZ0a+xEn0EoysiIrdI0Pd8UUkcgGHEkp9gyz2nk1Q2bEhGZF9OtsRM9pSVKO3hbjYz0fFO0e48DAHxfBq78tRoJEJXRVzdyU6K7poxA/pjLGYgQmQTTrbETPaUlSjt4WwUjPV9sqb0l8K+vs8/trIorXBJRvERKt4rceM3oi77+ME1jgJ4vdnLGleioPQbXwKF9bmdVXOGSiBIhQrpV1FkqMtFTWixgNUDPkYCktAwAgMPlCvwLdUYCRI7SexLp6oaIzMfIdKvIs1RkIqe0JElCe3s7AI6M6KrnSIDDHXjy/R2tqr0pRI/SIxHh6oaISAkzNV6TL/p6nhuyDD43yIEIwGBEd6FvivrkwJMvdbSp8qYw82q0XOGSiMxE9FkqPYl40SenaADj0zS2C0aAS2+KJdXb8buPgAXjhuC/H70toTeFmaJ0IiKzE32WSiSiXfTJxatOpxNJScaGA7aqGQnlcjpw7cgrAACDk3wJBwhGNRAjIrIj0WepmEHoTBqHw9iLZNsGIwAwcOBAAJcWzEuEGaN0IiKzYmuCxIkykwaweTAir9bb3Nyc8O9ilE5EpB+RZ6mYhSg9RgAGIwDUGRlhlE5EpC+2JgiIt52ESMGILQtYZWqmadhAjIhIfyLOUtFTIu0kmKYRhJppGoBROhGREey6zlWiTd84MiIINdM0MrtH6UREpD012kmIsmIvYPNgRM00TSjR5pITEZG1qNH0TZQVewGmaQCol6YhIiLSgxrtJJimEYQcjLS0tMDn88HVvWAekch8folpQCKbU6OdhEgFrLYORuQ0DRAISNLS0gzcG6L+mXEhRiJSn9xOwtvQFrFuxIHA5Im+2kmINDJi6zRNampqsAUuUzUkOjMsl05E+lCj6RuDEUE4HA5NZtQQqa2/ynkgUDkfa7MjIjK/RNtJME0jkIEDB6KpqYnBCAnNbMulE5E+EmknIdLIiO2DEc6oITPgQoxEFE287SRECkZsnaYBtGl8RqQ2LsRIRGoTKU1j+2BEq8ZnRGriQoxEpDaOjAiEaRoyAy6XTvGKd0VXMo5erxnbwQuEaRpSi9bNyOTK+Z59RrLYZ4SiYF8a89HzNROpHbztgxGmaUgNeh1AuBAjxUruS9PzmlruS8OVxMWj92vGNI1AmKahROndjMyuy6VT7NiXxnyMeM1YwCoQjoxQInjQJxEp6UtDYjDiNePIiEBYM0KJ4EGfRMS+NOZjxGvGYEQgTNNQInjQJxGxL435GPGaMU0jEKZpKBE86JOI2JfGfIx4zTgyIhCmaSgRPOiTiNiXxnyMeM1MH4xs2rQJo0aNQkpKCvLy8lBRURF12y1btmD27NkYMmQIhgwZgoKCgj631xvTNJQIHvRJVImu6Er60/s1EylNo7jPyKuvvoqioiJs3rwZeXl52LhxI+bOnYujR49i2LBhvbYvKyvD3XffjRkzZiAlJQXr16/H7bffjr///e8YMWKEKn9EIpimoUSxGRmJin1pzEev16yrqwtdXV0AxBgZcUiSpGjOYV5eHm688UY8//zzAAC/34+cnBx8//vfx8qVK/u9v8/nw5AhQ/D8889j8eLFMT1mY2Mj0tPT0dDQgMGDByvZ3X598MEHyM/Px6hRo1BdXa3q7yZ70boDKxGRWpqbm8PKFOQLc7XFev5WNDLS0dGBAwcOYNWqVcHbnE4nCgoKUF5eHtPvaGlpQWdnJ4YOjZ5Db29vR3t7e/D/jY2NSnZTEaZpSC3xLuNNRKQ3OUUDiDEyoqhmpL6+Hj6fD5mZmWG3Z2Zmwuv1xvQ7Hn30UQwfPhwFBQVRt1m3bh3S09ODXzk5OUp2UxGmaYiIyG7k4tXk5GS4XC6D90bn2TRPP/00tm3bhjfeeKPPSGzVqlVoaGgIftXU1Gi2T/LISGtrK3w+n2aPQ0TWwxVxyaxEWrEXUJimycjIgMvlQl1dXdjtdXV1yMrK6vO+zz77LJ5++mns3r0bkyZN6nNbj8cDj8ejZNfiJgcjQCCFlJaWpsvjEpG5cUVcMjORVuwFFI6MuN1uTJs2DaWlpcHb/H4/SktLkZ+fH/V+zzzzDJ588kmUlJRg+vTp8e+tBlJSUuBwBIoMmaoholjovTgikdpE6jECxJGmKSoqwpYtW/Db3/4Wn3zyCZYtW4bm5mYsXboUALB48eKwAtf169fjiSeewNatWzFq1Ch4vV54vV5hTvwOh4ONz4goZlwckaxApB4jQBx9RhYuXIjz589j9erV8Hq9mDJlCkpKSoJFradPn4bTeSnGeeGFF9DR0YFvfvObYb9nzZo1+NGPfpTY3qtk0KBBaGpq4owaIkGJNG1ayeKInF1FohJtZERxMAIAK1aswIoVKyL+rKysLOz/p06diuchdMUZNeIR6eRDxhKtNoOLI5IVWCIYsRqmacQi2smHjCPXZvRMeMi1GUa0NefiiGQFoqVpbL9QHsDGZyJhYSDJRK3N4OKIZAWijYwwGAHTNKLw+SX86E9/F+7kQ8ZQUpuhJy6OSFbAYERATNOI4fk9x+FtbI/6c6NOPmQMkWszuCKuNg3f2EROP6KlaVgzAqZpRFByuBa/2H0spm1ZGGgPotdm2G1F3NCi8lP1Lfh9xWl4G9Wr62KtmL5EGxlhMAKmaYwm1wbEioWB9iDXZngb2iKm7hwIjEQYWZthl8URIwUKPSVSVCxiobLVidYOnmkaME1jtP5qA0KxMNA+WJshhmhF5T3FW9claqGy1Zm6HbxVMU1jLCVpF5587IW1GcbqK1CIJJ66LlELla2OaRoBMU1jrFjTLo8UXMOTjw3ZrTZDJEpGLUMpucAQuVBZNGo2g2QBq4A4MmKs/moDgEB6ZsVt1+i6XyQOu9RmiCbeAEBJXZfohcqiULvAV7SREaZpwJoRo/VXG+AA0zNERlAaAMTT8I1N5PqndjNIn1/CmfpGAEBtk0+IehwGI2CaRgSsDSAST3+BQqh4i4pZqNw3tQt8Sw7XYtb6PSg/dhYA8FLFWcxav8fw7tZM04BpGlGwNoBILHKgsOzlg3AAfRayZiWQMpAvRnqmIRL5nVah5irRoVOopa5OAIAjKVmIKdQMRsA0jUhYG0AklqiBwmAP7s69EqMyBqpy4cCLkcjUKvANHWGRJAm+1kCaBg4nJARGoda+VYU547MMec4ZjIBpGiKivugVKPBipDe1Cnz3fHwKx/fvRuvJA2irPgDfl4Gp0l2fB9IzSkZYtMBgBEzTEBH1h4GCMeLtRCxJEg4dOoTi4mK8/fbb2LtvH/w+36UNnC44PQPhSgu/n1FTqBmM4FIw0traCp/PB5fLZfAexU7NeedEFBk/Z2SUvup2ehb4NjY2Yvfu3Xj77bfx9ttv48yZM2G/K2noSKSOnobU0dORkjMBjiR3r8czago1gxFcStMAgdGRwYMHG7g3sePCUkTa4+eMjBatbidzsAf3jXPh4+L/xvrvv429e/eiq6sr+PPU1FTcdtttmD9/Pm6fOw+LXzsl7FpPDkmSjJ9g3I/Gxkakp6ejoaFBk0BBkiQkJSXB7/fj7NmzyM4W/wATbWEpOVLmdFiixPFzRiLx+SW8c+gzlO4pRdX+v+Lgvnfwj3/8I2yba665BgsWLMD8+fNx8803hzU1k9/PQOQRFi3ez7GevzkyAsDhcGDQoEFobGw0RRFrf/POja6KJrICfs5IBJIkoaqqKph6ee+999DZ2Rn8eUpKCm699dZgADJmzJiov0vkKdQMRroNHDjQNMGImvPOiSgyfs7IKF9++SX27NkTLD49ffp02M/HjBkTDD5uueUWRevLiDqFmsFINzPNqOHCUkTa4+eM9CJJEo4cOYK3334bxcXFeO+999DR0RH8ucfjwS233BIMQK65JrF1ukScGcVgpJuZGp9xYSki7fFzRlpqbm7Gnj17ggHIZ599Fvbz0aNHY/78+ViwYAFuueUWDBgwwKA91QeDkW5manwW77xzIoodP2ekJkmScOzYsWDq5a9//WvY6Ifb7cYtt9yC+fPnY/78+bj22mvhcNinFonBSDczpWmUzDsnovjwc0aJamlpwTvvvBMc/aiurg77+ahRo4Kpl1tvvTWszYTdMBjpZqY0DSB2VTSRVfBzRkp9+umnwdGPsrIytLe3B3/mdrvx1a9+NZh+ue6662w1+tEXBiPdzJSmkYlaFU1kJfycUV9aW1tRVlYWDEBOnDgR9vMrr7wyOPpx2223BS98KRyDkW5mStOEErEqmshq+DmjUMePHw+mXsrKytDWdmnULDk5GbNnzw4GIOPGjePoRwwYjHQzW5qGYsd1RYgoEa2trfjrX/8abDz26aefhv08JycnWHj6ta99DWlpaQbtqXkxGOlmxjQN9Y/rihBRPE6ePBkc/XjnnXfQ2toa/FlSUhJmz54dDEAmTJjA0Y8EMRjpZtY0DUUXbV0Rb0Mblr18kOuKEFFQW1sb3n333eDox9GjR8N+PmLEiGDh6de+9jXTLKhqFgxGujFNYy1cV4SI+nPq1Kng6MeePXvQ0tIS/JnL5cKsWbOCAcjEiRM5+qEhBiPdmKaxFq4rQkQ9tbe347333gsGIEeOHAn7eXZ2drDwtKCgAOnp6Qbtqf0wGOnGNI21cF0RIgKAzz77LJh6KS0tDTvGu1wuzJgxIxiATJo0iaMfBmEw0o1pGmvhuiJE9tTR0YG9e/cG+35UVVWF/TwrKytYeDpnzhxcdtllxuwohWEw0o1pGmvhuiJE9lFTUxMc/di9e3fYcdzpdCI/Pz84+jF58mQ4nU4D95YiYTDSjWkaa+G6IkTW1dnZiX379gVHPw4fPhz288zMTMybNw8LFizAnDlzMGTIEIP2lGLFYKQb0zTWw3VFiMSltBnhmTNngoWnu3fvRlNTU/BnTqcTN910UzD9MnXqVI5+mAyDkW5ymqatrQ0+nw8ul8vgPTIfETudcl0RIvHE0oyws7MT77//fjAAOXToUNjvuOKKK4LBx+23346hQ5lyNTOHJEmRUupCaWxsRHp6OhoaGjRrNNPW1obU1FQA0PRxrIqdTokoFtGaEToAdDVdwDczz6Pm43Ls2rULjY2Nl37ucCAvLy9Y+3HDDTdw9MMEYj1/c2Skm8fjgcvlgs/nw5dffslgRAF2OiWiWPRsRij5fWg/8wlaTx5A68kP0XmuGhtDts/IyMC8efOCox8ZGRkG7DXpgcFIN4fDgYEDB6KxsZF1Iwqw0ykRxaqi+iJqzpxF28kDgQDk1EeQ2kMnDTjgzr4Wi/7vXXjw3n/G9OnTOfphEwxGQgwaNAiNjY22nlGjtO4j1k6nH5y8gJlX86qGyG66urqwf/9+FBcXY9vrf8KZI+EzX5ypg5Fy1VSkjp6O1KtugGtAOgr/ZQpyp4wwaI/JCAxGQth9Rk08dR+xdjBd/ruDePqfr2e6hsgG6urqUFJSgrfffhs7d+7EF198EfZzd/Y1SL1qOlLHTIc762o4nOETBtiM0H4YjISwc+OzeOs+Yj1ofNHayfoRIovy+XyoqKgI9v04cOBA2M+HDh2KuXPnYu7ceXju2ABc8KWyGSGFYTASwq6NzxKp++iv02lPrB8hsoZz585h586dKC4uxl/+8hdcvHgx7OfTpk0Lrnibm5sbbJeQ2X3hw2aEFIrBSAi7pmkSWeE2tNNpf7hSbnxE7N9C9uPz+fC3v/0t2Hb9ww8/RGhniCFDhuD222/H/PnzMW/ePGRmZkb8PWxGSJEwGAlh1zRNoivcygeXlf9zCF+0dqr2eMT+LWSs+vr64OjHzp07ceHChbCfT506Ndj3Iy8vD0lJsZ1S2IyQemIwEsKuaRo1VridNzEbaZ5k3PviftUez+7Yv4X05vf78eGHHwa7nv7tb38LG/1IT0/H7bffjgULFmDu3LnIzo7//edyOjhCSkEMRkLYNU2j1gq3N425nCvlqoT9WyheStN6Fy5cwM6dO4MzX86fPx/28ylTpgTbrufn58c8+kGkBN9VIeyaplFrhVuulKueROp4qDe71N3Ektbz+/04ePBgcOZLRUUF/H5/cPvBgwdjzpw5WLBgAebNm4fhw4fr/neQ/TAYCWHXNA2gXlEZi9PUoaSOxy4n2njZpe6mr7Teg1v+intGfo7awx+gpKQE586dC9tm0qRJwZkv+fn5SE5O1m/HicBgJMyA7pGRIzXnUH7igu0O6moVlbE4LXGn6lti3m7W+j2WP9HGyy51N73WfJH86Kg7idaTH6Lt5AG0nz2K9dKl0Y+0tDTMmTMnOPNl5MiRxuw4UTeu2tut5HAtHlr9M1S/8QukXp2LYf+8mgd1MkS0E2goB4D0AcloaOmMuPopAMucaOPl80u9ArVQcg3T3kdvizlQ9vv96OjoQGdnZ8R/+/qZ2v+Gft/Q3Iaa+kZIfh/8bV9Cam8BerwzkjO+gm/90524/+5/wowZM+B2uxN8hon6x1V7FZAP/l92BZ4OqTNw8LLa1ROJr6/C1VB+SYLk98Pv9wF+PyTJD0gSIPkBSIAk4fFt5Zi8YiYckOD3+4NfPp8v7P9q367HY8Ryu7ehFYeO1AGSPzhSIHW0ImlINpxJHki+LtT6uzDltVSkuKSYAoDQ2grhOZxIvTo3sObL6GlIGnwF/u+/TMEtXPOFBGT7YCT04O9wB6ac+jsCwYgVZi1IkpTwAV6Uk4vIt6v1u9o7fWhsae8+gUoIBBaBQEPy+4PfAxJO9/Pa1wAY/lPt32Nm42uqD/v/4Zr4f5fD4YDb7UZycrKif9W+z7HzLfhpyadwOJMg+X3ovPAPpFx5PZKHhF9EcVo9icr2wUjorAV/RysAoOvzs7i464Xug7+EesmPbxz8DTIGJQt5IuzrdiKHwwGn0xn8crlcYf+P93Y1f5cWj1HzeRu2fVgDwAmHw4GOc9Xwd7bDnTUaSQOHAK5kOJwu/Pu8Cbj+ysvjCg7kFudGK/BLeKVmT3BafcrI8WE/57R6Ep3tg5HQWQtSV6B7qL/tSzQd3BG23Z8/1nW3DGGFE5AZHruvnx0604Qf/M8hwOHo/nICDgccTieA7u8dThTdfi027D4OOF1wOBwAQrbt/hdOJ37/QD5mXJ1h9FvLED6/hMr1e/rte/Of/xp7zYioOK2ezM72wUjosKX7ilFwD78OzuQUeEaMDx7QHQ4n/iX3K7jqikFCnMy0eOzACY2MNmGihOcr2/o9gS5fMB1/+HtTv9vljbZvDxK7naA5rZ7MLK7ZNJs2bcLPfvYzeL1eTJ48Gc899xxyc3Ojbv/aa6/hiSeewKlTp3DNNddg/fr1WLBgQcyPp+VsGrnivr+DupKKe6JEyAXVQOQTqFxQHet2dmeXPiMy9p0hkcR6/lYcjLz66qtYvHgxNm/ejLy8PGzcuBGvvfYajh49imHDhvXa/v3338dXv/pVrFu3DnfccQdeeeUVrF+/HgcPHsTEiRNV/WPixYM6iSbWE6jdTrTx4gmayBiaBSN5eXm48cYb8fzzzwMIzLvPycnB97//faxcubLX9gsXLkRzczP+/Oc/B2+76aabMGXKFGzevFnVPyYRPKiTaGI9gfJES0Si0qTPSEdHBw4cOIBVq1YFb3M6nSgoKEB5eXnE+5SXl6OoqCjstrlz52L79u1RH6e9vR3t7e3B/zc2NirZzbiwayiJJtZVTbn6KRGZnaJgpL6+Hj6fD5mZmWG3Z2Zm4siRIxHv4/V6I27v9XqjPs66deuwdu1aJbumCh7UiYiI9Oc0egciWbVqFRoaGoJfNTUJdCUiIiIioSkaGcnIyIDL5UJdXV3Y7XV1dcjKyop4n6ysLEXbA4DH44HH41Gya0RERGRSikZG3G43pk2bhtLS0uBtfr8fpaWlyM/Pj3if/Pz8sO0BYNeuXVG3JyIiIntR3PSsqKgIS5YswfTp05Gbm4uNGzeiubkZS5cuBQAsXrwYI0aMwLp16wAADz/8MG6++Wb8/Oc/x9e//nVs27YNH374IX71q1+p+5cQERGRKSkORhYuXIjz589j9erV8Hq9mDJlCkpKSoJFqqdPn4bTeWnAZcaMGXjllVfw+OOP44c//CGuueYabN++PeYeI0RERGRtcXVg1ZsefUaIiIhIXbGev4WcTUNERET2wWCEiIiIDMVghIiIiAyluIDVCHJZix5t4YmIiEgd8nm7v/JUUwQjTU1NAICcnByD94SIiIiUampqQnp6etSfm2I2jd/vx9mzZ5GWlgaHQ9nCdY2NjcjJyUFNTQ1n4uiAz7f++Jzri8+3/vic60vN51uSJDQ1NWH48OFhbT96MsXIiNPpxMiRIxP6HYMHD+abWEd8vvXH51xffL71x+dcX2o9332NiMhYwEpERESGYjBCREREhrJ8MOLxeLBmzRquAqwTPt/643OuLz7f+uNzri8jnm9TFLASERGRdVl+ZISIiIjExmCEiIiIDMVghIiIiAzFYISIiIgMZYlgZNOmTRg1ahRSUlKQl5eHioqKPrd/7bXXMHbsWKSkpOD6669HcXGxTntqDUqe7y1btmD27NkYMmQIhgwZgoKCgn5fH+pN6Xtctm3bNjgcDnzjG9/QdgctRunz/cUXX2D58uXIzs6Gx+PBtddey+OKQkqf840bN+K6665DamoqcnJy8Mgjj6CtrU2nvTW3d999F4WFhRg+fDgcDge2b9/e733Kyspwww03wOPx4Oqrr8ZLL72k7k5JJrdt2zbJ7XZLW7dulf7+979LDzzwgHTZZZdJdXV1Ebfft2+f5HK5pGeeeUaqqqqSHn/8cSk5OVk6dOiQzntuTkqf73vuuUfatGmT9NFHH0mffPKJdN9990np6enSP/7xD5333LyUPuey6upqacSIEdLs2bOlu+66S5+dtQClz3d7e7s0ffp0acGCBdLevXul6upqqaysTKqsrNR5z81L6XP+u9/9TvJ4PNLvfvc7qbq6Wtq5c6eUnZ0tPfLIIzrvuTkVFxdLjz32mPT6669LAKQ33nijz+1PnjwpDRgwQCoqKpKqqqqk5557TnK5XFJJSYlq+2T6YCQ3N1davnx58P8+n08aPny4tG7duojbf+tb35K+/vWvh92Wl5cn/eu//qum+2kVSp/vnrq6uqS0tDTpt7/9rVa7aDnxPOddXV3SjBkzpF//+tfSkiVLGIwooPT5fuGFF6TRo0dLHR0deu2i5Sh9zpcvXy7ddtttYbcVFRVJM2fO1HQ/rSiWYOQHP/iBNGHChLDbFi5cKM2dO1e1/TB1mqajowMHDhxAQUFB8Dan04mCggKUl5dHvE95eXnY9gAwd+7cqNvTJfE83z21tLSgs7MTQ4cO1Wo3LSXe5/zHP/4xhg0bhu9+97t67KZlxPN8/+lPf0J+fj6WL1+OzMxMTJw4EU899RR8Pp9eu21q8TznM2bMwIEDB4KpnJMnT6K4uBgLFizQZZ/tRo/zpikWyoumvr4ePp8PmZmZYbdnZmbiyJEjEe/j9Xojbu/1ejXbT6uI5/nu6dFHH8Xw4cN7vbEpsnie87179+LFF19EZWWlDntoLfE83ydPnsSePXtw7733ori4GMePH8dDDz2Ezs5OrFmzRo/dNrV4nvN77rkH9fX1mDVrFiRJQldXF773ve/hhz/8oR67bDvRzpuNjY1obW1Fampqwo9h6pERMpenn34a27ZtwxtvvIGUlBSjd8eSmpqasGjRImzZsgUZGRlG744t+P1+DBs2DL/61a8wbdo0LFy4EI899hg2b95s9K5ZVllZGZ566in88pe/xMGDB/H6669jx44dePLJJ43eNYqTqUdGMjIy4HK5UFdXF3Z7XV0dsrKyIt4nKytL0fZ0STzPt+zZZ5/F008/jd27d2PSpEla7qalKH3OT5w4gVOnTqGwsDB4m9/vBwAkJSXh6NGjGDNmjLY7bWLxvMezs7ORnJwMl8sVvG3cuHHwer3o6OiA2+3WdJ/NLp7n/IknnsCiRYtw//33AwCuv/56NDc348EHH8Rjjz0Gp5PX2WqKdt4cPHiwKqMigMlHRtxuN6ZNm4bS0tLgbX6/H6WlpcjPz494n/z8/LDtAWDXrl1Rt6dL4nm+AeCZZ57Bk08+iZKSEkyfPl2PXbUMpc/52LFjcejQIVRWVga/7rzzTtx6662orKxETk6OnrtvOvG8x2fOnInjx48Hgz4AOHbsGLKzsxmIxCCe57ylpaVXwCEHgxKXW1OdLudN1UphDbJt2zbJ4/FIL730klRVVSU9+OCD0mWXXSZ5vV5JkiRp0aJF0sqVK4Pb79u3T0pKSpKeffZZ6ZNPPpHWrFnDqb0KKH2+n376acntdkt//OMfpdra2uBXU1OTUX+C6Sh9znvibBpllD7fp0+fltLS0qQVK1ZIR48elf785z9Lw4YNk37yk58Y9SeYjtLnfM2aNVJaWpr0+9//Xjp58qT0l7/8RRozZoz0rW99y6g/wVSampqkjz76SProo48kANKGDRukjz76SPrss88kSZKklStXSosWLQpuL0/t/c///E/pk08+kTZt2sSpvZE899xz0pVXXim53W4pNzdX+uCDD4I/u/nmm6UlS5aEbf+HP/xBuvbaayW32y1NmDBB2rFjh857bG5Knu+vfOUrEoBeX2vWrNF/x01M6Xs8FIMR5ZQ+3++//76Ul5cneTweafTo0dJPf/pTqaurS+e9Njclz3lnZ6f0ox/9SBozZoyUkpIi5eTkSA899JD0+eef67/jJvTOO+9EPC7Lz/GSJUukm2++udd9pkyZIrndbmn06NHSb37zG1X3ySFJHNMiIiIi45i6ZoSIiIjMj8EIERERGYrBCBERERmKwQgREREZisEIERERGYrBCBERERmKwQgREREZisEIERERGYrBCBERERmKwQgREREZisEIERERGYrBCBERERnq/wHC3DiqqQvjGgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.spatial import ConvexHull\n",
    "\n",
    "# 生成100个随机点\n",
    "points = np.random.rand(100, 2)\n",
    "\n",
    "# 计算凸包\n",
    "hull = ConvexHull(points)\n",
    "\n",
    "# 绘制所有点\n",
    "plt.scatter(points[:,0], points[:,1])\n",
    "\n",
    "# 绘制凸包的边\n",
    "for simplex in hull.simplices:\n",
    "    plt.plot(points[simplex, 0], points[simplex, 1], 'k-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8732912-7fc5-44fc-b89a-d1d24f8337dc",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}