From a78c566a5ddf32708015373a2bf77b86c5304e86 Mon Sep 17 00:00:00 2001 From: XRubberDuck Date: Tue, 31 Oct 2023 20:56:40 +0800 Subject: [PATCH] add matplotlib --- ch-visualization/matplotlib.ipynb | 758 ++++++++++++++++++++++++++++++ 1 file changed, 758 insertions(+) create mode 100644 ch-visualization/matplotlib.ipynb diff --git a/ch-visualization/matplotlib.ipynb b/ch-visualization/matplotlib.ipynb new file mode 100644 index 0000000..9a4099e --- /dev/null +++ b/ch-visualization/matplotlib.ipynb @@ -0,0 +1,758 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# matplotlib库" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Matplotlib 是一个用于绘制二维图形的 Python 库，它是一个非常流行的数据可视化工具，特别适用于绘制各种类型的图表、图形和图像。通常和pandas库与NumPy库一起使用。\n", + "\n", + "基本上有两种使用 Matplotlib 的方法：\n", + "1. 依靠 pyplot 自动创建和管理图形和轴，并使用 pyplot 函数进行绘图。\n", + "2. 显式创建图形和轴，再调用方法。\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## 安装包\n", + "#!pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple\n", + "## 导入库\n", + "import matplotlib.pyplot as plt\n", + "## 设置字体为宋体【有一些默认配置不能正常显示中文，则添加以下两行代码】\n", + "plt.rcParams['font.family'] = ['serif'] # 设置字体为有衬线字体（宋体是有衬线字体之一）\n", + "plt.rcParams['font.serif'] = ['SimSun'] # 设置有衬线字体为宋体\n", + "## 下面的是设置字体为黑体\n", + "# plt.rcParams['font.family'] = ['sans-serif'] # 设置字体为无衬线字体（黑体是无衬线字体之一）\n", + "# plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置无衬线字体为黑体\n", + "\n", + "# 设置公式格式\n", + "plt.rcParams['mathtext.fontset'] = 'stix'\n", + "\n", + "# 正常显示负号\n", + "plt.rcParams['axes.unicode_minus'] = False\n", + "plt.rcParams['font.size']=18 #设置字体字号\n", + "plt.rcParams['xtick.labelsize']=16 # 设置横坐标轴字体字号\n", + "plt.rcParams['ytick.labelsize']=16 # 设置纵坐标轴字体字号\n", + "\n", + "# 设置刻度朝里\n", + "plt.tick_params(which=\"major\",direction='in',length=5,bottom=True,left=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## plt模块画图\n", + "### 基本图形\n", + "\n", + "Matplotlib 中的 pyplot(plt) 模块提供了各种函数，用于绘制不同类型的图表进行可视化。以下是一些常见的 plt 绘图类型：\n", + "\n", + "- 折线图 `plt.plt()` 用于绘制一系列点，通常用于显示数据的趋势。\n", + "- 散点图 `plt.scatter()` 用于绘制单个点或一组点，用于观察数据的分布和关系。\n", + "- 柱状图 `plt.bar()` 用于绘制垂直柱状图;`plt.barh()` 用于绘制水平柱状图。\n", + "- 直方图 `plt.hist()` 用于显示数据分布的频率。\n", + "- 饼图 `plt.pie()`用于表示数据的占比。\n", + "- 箱线图 `plt.boxplot()` 用于可视化数据的分布、中位数、四分位数等统计信息。\n", + "\n", + "通常，饼图、柱状图用来描述分类数据，其他用于连续变量，散点图可以描述多个变量的关系。\n", + "\n", + "### 其他操作\n", + "\n", + "- 添加信息\n", + "\n", + " `plt.xlabel()` # 设置 x 轴标签\n", + "\n", + " `plt.ylabel()` # 设置 y 轴标签\n", + "\n", + " `plt.title()` # 设置标题\n", + "\n", + "- 显示刻度 \n", + "\n", + " `plt.xticks()`\n", + "\n", + "- 显示图例\n", + "\n", + " `plt.legend()`\n", + "\n", + "- 显示图像\n", + "\n", + " `plt.show()`\n", + "\n", + "- 样式设计\n", + "\n", + " 1. 设置线条宽度\n", + "\n", + " plt.rcParams['lines.linewidth']=1\n", + "\n", + " 2. 设置线条颜色\n", + "\n", + " plt.rcParams['lines.color']='green'\n", + "\n", + " 3. 设置线条样式\n", + "\n", + " plt.rcParams['lines.linestytle']='-'\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例： 作出函数图像$$f(x)=xsin\\frac{1}{x}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAHCCAYAAAANVtgqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACIb0lEQVR4nO3dd3xb1fk/8M/V9N4jy7GdHUII2YEkEEjKCBQolLRNW3ahUKBl9FtGBy2U8KOFAoWyCg0dUEYILYUCJQRICNkhJBAy7cRxhrclL837+0M6V7It2RpXuhqf9+vlF0G+vjqyZN1Hz3nOcyRZlmUQERERpRid1gMgIiIiigUGOURERJSSGOQQERFRSmKQQ0RERCmJQQ4RERGlJAY5RERElJIY5BAREVFKYpBDREREKYlBDhEREaUkBjlEfbhcLjz55JM47bTTUFxcDL1eD0mSIEkSPvvss4A/c9FFF0GSJHz961+P2bjWrl0LSZJgNBrxxRdfxOx+0p14rhcsWBD3+47H60gLFosFRUVFkCQJTz/9tNbDoTTCIIfIj9vtxoUXXogbbrgBa9asQUtLC9xu94A/8+677+Jf//oXAOCee+6J2djmzZuHM888E06nEzfffHPM7oe0Eerr6OjRo3jzzTdxzz334Pzzz8fQoUOVwKyqqiri+7darTCbzZAkCb///e8jPk8geXl5uOWWWwAAd999N1pbW1U9P1FQMhEpVqxYIQOQAciVlZXy7373O/mVV16RV65cKa9cuVJua2vrdbzb7ZanTJkiA5AvuOCCmI/v448/Vsb3zjvvxPz+0pH4/Z5++ulxu89QX0f//ve/lfEF+qqsrIx4DC+//LJynt27d0d8nmDa29vlwsJCGYB8xx13qH5+okAY5BD5ufrqq5U3+k8//XTQ41999VXl+PXr18dhhLI8b948GYA8e/bsuNwfxV6or6OVK1f2CmqMRqM8depUVYKc7373uzIAefz48RGfYzA///nPZQBydna23NTUFLP7IRI4XUXkp66uTvn31KlTBz3+oYceAgCMHz8es2fPjtm4/F122WUAgA0bNmDdunVxuU+KrVBfR2VlZfjBD36Ap556Cps2bUJHRwe2bt0a9f07nU7897//BQBccMEFUZ8vGPHa7ezsZG0OxQWDHCI/NptN+bfZbB7w2M8++wzr168HAHz3u9+N6bj8ffOb31TG9qc//Slu90uxEc7r6NRTT8UzzzyD6667DjNmzIDJZFJlDGvXrkVLSwuA2AY5Y8eOxcyZMwEATz31FGRZjtl9EQEMcojw4YcfKoWbH330kXK7uE189S0G/dvf/qb8O9jFqaenByeeeKJyjhUrVgw4lq9//evKsffdd1/AYwoLC3HuuecCAFauXImOjo5QHmZCu++++5THPdhFdsWKFcqxkydPRk9PT79j9u7di9tuuw3Tp09HQUEBjEYjiouLMX78eJx55pm46667gq6UG2x11RVXXKEcU1tbC8BTNHzRRRdhxIgRMJvNGDZsGC699FJs2LBh0Mceyuso1v79738DAEpKSnDqqacqt19zzTXKY73pppsGPMfvf/975dizzjoraAAjHmNdXR0+/PBDdR4AUTBaz5cRaW316tUDFnOKr1/96le9fm706NEyAHnkyJEDnv/zzz+XMzIyZAByUVGRXFdXF/C4xx9/XLmv0047TXa5XEHP+eijjyrHrly5MtyHnHBcLpc8f/585TE98cQTAY+rq6tTilczMjLkHTt29Dvm2WeflU0m06DP55QpUwLeh/h+sMLjyy+/XDlm//798vXXXx/0PnQ6nfznP/95wMce6utoIOL+Iq3JGTNmjAxAvvzyy3vd3tHRIY8bN045/3/+85+AP79161bld15SUiIfOXIk6H1t375dOd+Pf/zjiMZLFCoGOZT2GhsbldVTkyZN6hU8+H/t2rVL+Zn9+/crx33zm98c9D4ee+wx5fgFCxb0C2B27typBEKFhYXyoUOHBjzfhg0blPP98Ic/jOyBJ5iDBw/KBQUFMgA5MzNT3rlzZ6/vu1wu+fTTT1ce9x//+Md+59iyZYus0+lkALLBYJC/9a1vyU888YT86quvyi+++KL80EMPyd/73vfksrIyVYKc73znOzIAedy4cfJ9990n//Of/5SfffZZ+dxzz1WOMZlMvV47/sJ9HQUTTZDzxRdfKD+/YsWKft/fvHmzbDQaZQByWVmZfOzYsV7f7+zslMePH6+c48033xzw/lwul5yTkyMDkCdMmBD2eInCYYgwAUSUMkpKSnDRRRcBAB555BHldnFbIP7TEKEUHN90001499138dZbb+HDDz/E//t//w933nknAE8d0He+8x1l2uWZZ55BRUXFgOc7+eSTYTabYbPZQpoSGcjWrVtx6NChqM4hnHXWWcjKyoroZ0eOHIlnnnkGS5YsQXd3N5YuXYqNGzcq9UcPPPCAMp14/vnn48Ybb+x3jueff17pa/SPf/wDS5YsCXhfLpcr6t8bALz00ku47LLL8Nxzz8Fg8L2dXnPNNfjxj3+Mxx57DHa7HY899ljA+qlwX0exIKaqzGYzzj777H7fnz59On7729/i//7v/9DQ0IDLL78c//3vfyFJEgDgJz/5CXbv3g0A+NGPfoTzzz9/wPvT6XSYMWMGPvzwQ+zevRvt7e3Iz89X+VEReWkdZRElEv9MwUDuuusu5bh///vfIZ27oaFBHjJkiLL0d+PGjbIsy/JNN92knOvqq68OeawTJ05UMgUDTW0Nxj8zEe1XTU1NxOMQrrrqKuV8N998syzLnsyVwWCQAchDhgyRGxoaAv7s2WefLQOQ8/PzZbfbHdH9i/sOJZMzYcIE2WazBTzOYrHImZmZMgB51KhRAY+J5HU00JgjyeSccsopMgD53HPPDXqM2+2WFy1apNzPww8/LMty775SJ554otzd3R3SffpP8a1ZsybsMROFioXHRBE4ePCg8u+ioqKQfqa0tBQvvPACJEmCw+HA0qVL8corr+CPf/wjAGDcuHF49NFHQx5DYWEhAMBut+Po0aNhjD6xPfbYYxg3bhwA4I9//CNeeeUVLF26FE6nE5Ik4a9//StKS0sD/qzIIlmt1l7tAGLl+uuvD7rCKTc3FzNmzAAA1NTUBCyQjuR1pKaGhgYlmzRQwbf4vZeUlAAA7rzzTrz11lv4wQ9+AADIyMjASy+9hIyMjJDuV7x2gd6/AyK1McghioBYbguEd3E666yzlPb2+/btw7e+9S0AgMlkwksvvYTs7OyQz1VcXKz8O5o2+cuXL4fsqc+L+iuabQWE7OxsvPjiizAajZBlGd/61rewf/9+AMCtt96Kr33ta0F/VnzP7XZjwYIF+POf/4ympqaoxxTMnDlzBvz+8OHDAQCyLKOtra3f9yN9HanlP//5D9xud0j7ZQ0dOhTPP/88AM8U6/nnn6+M/3e/+x1OPPHEkO9Xrdcu0WAY5BBFwL+fTm5ublg/u2zZsn6NBn/7299i2rRpYZ0nLy9P+Xd3d3dYP5voRB2Iv2nTpuH+++8f8OeuvvpqZel3TU0NfvCDH6CsrAyTJ0/Gddddh5deegnt7e2qjVNkNoLx77UUKJMTzetIDaIeZ/r06UpANpCvf/3ruOGGG3rdFqw+aiCp/NqlxMIghygC/hcvi8US1s+aTCZUV1cr/6/X63HxxReHPQb/i3VmZmbYP5/oxo8f3+v/L7jggkGb35lMJrz77rv43e9+p2SVZFnGzp078cwzz2Dp0qUoLy/HjTfeGPbzFohOF91baDSvo2h1d3fjf//7H4DwGgD2fV6++c1vhn3fqf7apcTB1VVEEfCfWvCfcgjFn//8Z7z++uvK/7tcLnz/+9/Hxx9/DL1eH/J51JrqSJTVVf6OHTuGa665ptdt999/Py688EKcfPLJA/6syWTC7bffjttvvx1ffvklPvnkE3zyySdYtWoVDh8+DJvNhieeeAJr167Fp59+qulFNprXUbTef/99dHV1AQg9yNm5cyd+9rOf9brt1ltvxaJFi0LKBAlaT9NR+mCQQxQB/9qTcC5Oe/bswU9+8hMAQH5+PmbMmIFVq1Zh3bp1uPfee/t1VR6IuF+TyYShQ4eG/HN9PfbYY3jhhRci/nl/NTU1UdflyLKMyy67DI2NjQCAiy++GK+//jrsdjuWLl2KLVu2hByYnHDCCTjhhBOUAtnVq1fjqquuQm1tLbZv347nnnsu7KkWNUX6OlKDmKqqrKzElClTBj2+p6enV6sD8by0tLTg+9//Pt5///2QM1v+j7WysjKC0ROFhtNVRBHwL7IUPUIGI1ZUdXZ2AgCefPJJvPzyyxg2bBgAz9YGn3zySUjnstlsOHDggDIW0bMkFTz88MPKNMrZZ5+N1157Dddeey0AYNeuXUrhdiTOOOMMPP7448r/r127NrrBRimS15EaZFnGf/7zHwAYtOBY+OlPf4qdO3cCAK699lq89tprSl+d1atX48EHHwz5/nft2gUAytYcRDETx+XqRAkv1D45Bw4cUI675JJLQjr3T3/6U+Vnvv/97yu3v//++7IkSTIAuaqqSm5raxv0XOvXr1fOdf3114d0/8lg27ZtyvYApaWl8tGjR2VZ9nTVnTBhgvKY33jjjYjvY+fOnQM+d+J7ofTJGawv0GDHRvI6CkScI9Q+Of6vn/fee2/Q4//zn/8ox48fP17u7OyUZVmWjx49KpeWliq9nzZt2jTouZxOp5ydnS0DkCdOnBjSeIkixUwOUQSqq6sxevRoAMDGjRsHPX7VqlX4/e9/DwAYNWoUnnjiCeV7CxcuxO233w4AqK2txfXXXz/o+fw75QbqUpuMurq68J3vfAd2ux2Ap3vxkCFDAHj637z44otK4fHVV1+NI0eO9DvHbbfdpuzoHcyTTz6p/DuUaZpYCvd1pBYxVZWXlxd0I1Lh+PHjuOqqqwD4Wh2IuqshQ4bgL3/5C4D+mcpgvvjiC+WYVHntUuJiTQ5RhC666CI89NBDqKurw4EDBzBq1KiAxzU3N+Oyyy6DLMswGAz4xz/+0W+58H333YdVq1Zh69ateOmll3Duuefi+9//ftD7Xr16NQBPT5lFixap96A0dMstt+Crr74CEHh7gKlTp+L+++/H7bffjubmZlx++eV47733ek3VrVixAg8//DCqq6uxaNEinHTSSSgrK4PNZkNdXR1effVVZffx4uJiZRpMS6G+joSHHnooaG+ZtrY2/PznP+91W3V1Na6++upet4kg55xzzoHRaAx6X7Is4/LLL0dDQwMAT6uDvu0PzjvvPNx44414/PHHsXfvXtx888147rnngp5TvHaBgbdOIVKF1qkkokQS6nSVLMvyZ599phz7m9/8JuhxF154YUjH7d69W0nj5+bmyvv37w94XGtrq2w2m2UA8ve+973BH1QSeP3115Xf0aRJk4JuD+B2u+Wvfe1ryrG/+93ven2/qqoqpO0nKisr5a1btwa8D3FMPKarZDn015FQWVkZ1lYbfR+H/xTZ3//+9wHv6+GHH1aOXbRoUdCtMrq7u+UTTzxROfbVV18Nes5Zs2bJgGfX9Ui33iAKFYMcIj/hBDmyLMunnnqqDHh2oQ7kySefVM43b9482el0Dni+Z599Vjl+zpw5ssPh6HfMM888oxzzySefhDTORHb48GG5qKhIBiCbzWZ5+/btAx5/5MgRuaSkRAY8+3Zt2bJF+V5TU5P8j3/8Q/7hD38oz5o1Sy4pKZGNRqNsNpvlESNGyIsXL5afeuopuaurK+j54x3kyPLgryN/0QY5jzzyiAx4dmlvaWkJej+fffaZEkwXFxfL9fX1A45rx44dckZGhgxALiwslA8dOtTvmD179ijj+u1vfzvoYyWKliTLshx2+oeIAAArV65UGvmtW7cOp5xySszv87TTTsOaNWswe/bsQetPKDnE83W0cOFCfPDBB1iwYEGvqaN4+OUvf4l7770X2dnZOHjwYK/tHYhigYXHRFG46KKLlOZ0y5Yti/n9rV27FmvWrAEA/PrXv475/VF8xOt11NbWprx+wulyrAaLxaIU3N90000McCguGOQQRUGSJDzwwAMAgDfffBNbtmyJ6f2JZoFnnnkmV6akkHi9jv773//C4XAAiH+Q89hjj6GlpQXFxcX4v//7v7jeN6UvTlcRqeCiiy7Cv/71L5x//vl48803Y3Ifa9euxfz582EwGPDZZ59h0qRJMbkf0k48XkdasFgsqK6uRktLC5566ilcd911Wg+J0gSDHCIiIkpJnK4iIiKilMQgh4iIiFJS2nY8drvdOHLkCHJzc1Nqc0MiIqJUJssyrFYrhg0bNujO92kb5Bw5cgQVFRVaD4OIiIgiUFdXhxEjRgx4TNoGOWLvoLq6OuTl5Wk8GiIiIgqFxWJBRUVFvz0AA0nbIEdMUeXl5THIISIiSjKhlJqw8JiIiIhSEoMcIiIiSkkMcoiIiCglMcghIiKilMQgh4iIiFISgxwiIiJKSQxyiIiIKCUxyCEiIqKUxCCHiIiIUhKDHCIiIkpJDHKIiIgoJTHIISIiopTEIEdl+xo68MB/v8IzH+/XeihERESaaOqw4eH3dmPboVZNx8EgR2X7Gzvw1Ef78ff1hyDLstbDISIiirsPdzfisQ/24Rf/2qnpOBjkqGzumBIY9RIOtXShpqlT6+EQERHF3erdDQCAM8eXaToOBjkqyzEbMKu6CACwenejxqMhIiKKL4fLjY/3eK5/CyYwyEk5Z3gj1w+9kSwREVG62HqwFdYeJ4qyTZgyokDTsTDIiYEF3iBnw4EWdNmdGo+GiIgofsQsxunjSqHXSZqOhUFODIwuzUZFUSbsLjfW7WvWejhERERxs/orzyzGgvGlGo+EQU5MSJKkTFmt5pQVERGlifq2buw+boVO8mRytMYgJ0Z8dTmNXEpORERpQWRxpo0sREGWSePRMMiJmTmjimE26FDf1o29DR1aD4eIiCjmxIKbMzReVSUwyImRTJMep4wuBuCLbImIiFJVj8OFT7x1qGdo3B9HYJATQ6zLISKidLGhpgXdDheG5GVg4tBcrYcDgEFOTIkgZ3NtKyw9Do1HQ0REFDti1uKMCaWQJG2XjgsMcmJoZHEWRpVmw+mW8cneJq2HQ0REFDOiHmdBgkxVAQxyYo5TVkRElOoONHagtrkLRr2EeWNKtB6OgkFOjPmCHC4lJyKi1CS6HM+uLka22aDxaHwY5MTYzOpCZJn0aLTa8MURi9bDISIiUp1vqkr7BoD+GOTEmNmgx1xv6o4bdhIRUarptruwoaYFQGLV4wAMcuLCf8qKiIgolayvaYbd6cbwgkyMLs3Weji9MMiJA5G+23aoFa2ddo1HQ0REpJ6PxK7j4xNn6bjAICcOhhVkYsKQXLhl4OO9zOYQEVHq+HiPN8hJgA05+2KQEycL/DbsJCIiSgWHmrtwoKkTBp2EU71bGSUSBjlxIqasPtrTCLebS8mJiCj5feSdnZheWYjcDKPGo+kvpkHOq6++igULFqCwsBDZ2dmYMmUKHnzwQTgc4W1xsG3bNixbtgwLFy5EeXk5jEYjCgsLMX/+fDzxxBNhn08L0ysLkWM2oKXTzqXkRESUEvzrcRJRzDr2/OQnP8Gjjz4Kg8GAM888Ezk5Ofjggw/ws5/9DG+++Sbee+89ZGZmDnoep9OJadOmAQBycnIwc+ZMlJeX4/Dhw/j000+xdu1a/PWvf8W7776LgoKCWD2cqBn1Opwyuhj/+/I4PtrTgMkj8rUeEhERUcTsTjfW7fdsWZSI9ThAjDI5b7zxBh599FHk5ORgw4YNePfdd7FixQrs3bsXkydPxtq1a/GLX/wi5PNNnz4dr7zyCpqamvDBBx/gpZdewpo1a7Bt2zYMHToUGzduxK233hqLh6Kq07wvgo/3cB8rIiJKbpsPtqDL7kJprhknDM3TejgBxSTIuf/++wEAd9xxh5KFAYCSkhL86U9/AgA8/vjjaG9vH/RcBoMBmzdvxqWXXgqz2dzre5MnT8aDDz4IAPjnP/+Z8NNWp4/1BDlbD7XCyl3JiYgoiX3kXVV12tjEWzouqB7k1NfXY9OmTQCApUuX9vv+vHnzUFFRAZvNhrfffjvq+5s6dSoAoLu7G01NiZ0hGVmcheoSz67k6/Y3az0cIiKiiCV6PQ4QgyBn27ZtAICioiJUV1cHPGbGjBm9jo3G3r17AQAmkwlFRUVRny/WThvr2eJBRMBERETJ5rilB18ds0KSgPkJtOt4X6oHOTU1NQCAkSNHBj2moqKi17GRkmVZma46//zz+01n+bPZbLBYLL2+tOCry+Gu5ERElJzEB/UpIwpQmG3SeDTBqR7kWK1WAEB2dvD9K3JycgAg6kDj17/+NT799FPk5OTggQceGPDYZcuWIT8/X/kSgVa8zRlVDJNeh8Ot3ahp6tRkDERERNH4KIG7HPtL2maAf/3rX/Gb3/wGOp0Ozz//PMaOHTvg8XfeeSfa29uVr7q6ujiNtLdsswEzqgoBcMqKiIiSj9Plxtq93qXjCVyPA8QgyMnNzQUAdHYGz1J0dHQAAPLyIlty9uqrr+Kqq64CADz77LO49NJLB/0Zs9mMvLy8Xl9a8Z+yIiIiSibbD7ejvduB/Ewjpowo0Ho4A1I9yKmqqgKAATMl4nvi2HC8/vrrWLp0KdxuN55++mkl2Ekmp3mXkq8/0AKb06XxaIiIiEInZiHmjS2BXpeYS8cF1YMcsaS7ubk5aGHx5s2bAaBXD51QvPHGG/j2t78Nl8uFJ598Ej/4wQ+iG6xGJg7NRWmuGd0OFzbXtmo9HCIiopAlSz0OEIMgZ8SIEZg5cyYA4MUXX+z3/bVr16Kurg5msxmLFy8O+bxvvvkmlixZAqfTiSeffBLXXXedamOON0mSlGwO63KIiChZtHTa8fnhNgBpGuQAwF133QUAeOCBB7B161bl9ubmZtxwww0AgBtvvBH5+b79m1auXIkJEyZg4cKF/c739ttv45vf/CacTieeeuqppA5whNPGefoKsC6HiIiSxZq9jZBlYMKQXJTnZWg9nEHFZIPOiy66CDfffDMee+wxzJkzBwsXLkR2djZWrVqFtrY2zJ07F/fee2+vn2lvb8fu3bvR09PT6/aGhgZcfPHFsNvtGDFiBNatW4d169YFvN/f//73KClJ3KZE/uaPLYUkAV8ds+K4pScpXixERJTelKmqBF9VJcRsF/JHH30Uc+fOxRNPPIF169bB4XBg9OjRuOOOO3DLLbfAZAqteVBXVxdsNhsA4PDhw3jhhReCHnvPPfckTZBTlG3CScPzsf1wOz7a04glM7Tp20NERBQKt1tWNpgWezEmOklO07a7FosF+fn5aG9v12w5+UPv7cYfP9iH808aiseXhleETUREFE9fHrFg8WNrkGXSY9svvwazQa/JOMK5fidtM8BUIPrlrN3XBJc7LWNNIiJKEmv3eaaqZlcXaRbghItBjoamVhQgN8OAti4HdtS3az0cIiKioNZ4uxzPT5KpKoBBjqYMeh3mjvbuSr6bq6yIiCgx9Thc2FjTAgCYPzY5al8BBjmaU7Z42Msgh4iIEtPm2lbYnG6U55kxpixH6+GEjEGOxkS/nG2HWtHe7dB4NERERP2t8X4Q97Q/SeytHPwxyNHYiMIsjCrJhlsGPt3frPVwiIiI+vHV4yTPVBXAICchzPO+aETlOhERUaJotNrw5VELAGDuGAY5FKZ53hfNWm+kTERElCjW7fdcm04YmoeSHLPGowkPg5wEMGd0MfQ6CbXNXahr6dJ6OERERIpknaoCGOQkhLwMI06uKAAAfLKP2RwiIkoMsiz3KjpONgxyEoSYslrDIIeIiBLEvoYOHLfYYDboMKOqUOvhhI1BToIQxcfr9jXBzS0eiIgoAXzsnaqaVV2EDGNybOXgj0FOgji5ogA5ZgNauxz44ohF6+EQERFhrTJVlXz1OACDnIRh1OswZ1QRAGANl5ITEZHGbE4X1h8QWzkkXz0OwCAnoYi6HBYfExGR1rYebEO3w4WSHDMmDMnVejgRYZCTQOZ5I+VNta3ocbg0Hg0REaUz0aB23pjipNrKwR+DnAQyujQbQ/IyYHe6ld1eiYiItODrj5OcU1UAg5yEIkmS3xYPnLIiIiJttHbasaO+HYBv9W8yYpCTYEQF+xpu8UBERBpZt78ZsgyML89FeV6G1sOJGIOcBCM2P9t11IKmDpvGoyEionQkuhwncxYHYJCTcEpyzJg4NA8AV1kREVH8ebZy8Fx/GOSQ6sSUFXclJyKieKtp6kR9WzdMeh1mVxdpPZyoMMhJQGLKau2+Jsgyt3ggIqL4EQtfplcWIstk0Hg00WGQk4BmVRXBpNfhaHsP9jd2aj0cIiJKI2tTZKoKYJCTkDJNemW3V7FvCBERUay53DLWH2gG4JtVSGYMchKUr19Os8YjISKidLGzvh2WHidyMwyYPDxf6+FEjUFOgpo/xtNhcv2BZjhcbo1HQ0RE6eCT/Z6pqjmjiqHXJedWDv4Y5CSoScPyUJBlRIfNie11bVoPh4iI0sA67+zB3NHFGo9EHQxyEpROJ2HuaHY/JiKi+OhxuLCp1rNvYirU4wAMchKaqMtZt59BDhERxdbWQ62wOd0oyzVjTFmO1sNRBYOcBHaqN1247VAbuuxOjUdDRESpTExVnTq6GJKU/PU4AIOchDayKAvDCzLhdMvYWNOi9XCIiCiFiaLjU1NkqgpgkJPQJElSsjmf7udSciIiig1rjwOfH24HkDr1OACDnIQnXmyfsC6HiIhiZMOBFrjcMqqKPTMIqYJBToI7xZvJ+eKIBW1ddo1HQ0REqSgVp6oABjkJrzwvA2PKciDLUFptExERqcnXH4dBDsWZqMtZx7ocIiJSWaPVht3HrQB8swepgkFOEjjVG1l/so91OUREpC7Ri+2EoXkoyjZpPBp1MchJAqeMKoYkAfsbO3GsvUfr4RARUQpRpqrGpFYWB2CQkxTys4w4cZhnN9hPDzCbQ0RE6pBlGWv3pWbRMcAgJ2mc6o2wP9nHuhwiIlLHoZYu1Ld1w6CTMKuqSOvhqI5BTpIQdTmf7m+GLMsaj4aIiFKB+OA8dWQBss0GjUejPgY5SWJmVSGMegn1bd042Nyl9XBII0fbu3H937fgnEc+xl8+qWHASxE52NyJq5dvwrmPrsE/Nx7SejikIaU/TootHRdSL2xLUVkmA6ZWFGJjbQvW7W9GVUm21kOiOOuyO/G9P2/A/sZOAMCv3/wSBr0O359TqfHIKJlYehy47PmNyoelO17fAZ1OwpIZFRqPjOLN7ZaVLYNSaSsHf8zkJBGlLodbPKSlJz/cj/2NnSjPMyuBzYPvfAVLj0PjkVEy+fOaGhxs7sLwgkx8Z9ZIAMC9//kS7d18HaWbr45Z0dJpR6ZRj5MrCrQeTkwwyEkiIp24fn8z3G5OU6QTa48Dy9fVAgB+9fVJ+PUFkzC2LAfWHide2sDpBgpNj8OF5Z/UAADuWjwR9110IsaVe15HL3hfX5Q+RH+cWdVFMBlSMxxIzUeVok6uKECmUY/mTrvSnZLSw5vbj8La48To0mycM2kIdDoJV86tBgCs3Fav8egoWaz+qgGWHieGF2Ti3BOHQK+TcP2C0QCAlzfV8cNTmhENZlOxP47AICeJmAw6zKr2LPFj9+P08ub2IwCAS2dUQKeTAACLJw+BUS/hq2NW7Gtg0EuD+8/nRwEA5580VHkdnXviUOSaDahv68b6GraoSBcOlxsba1oApG7RMcAgJ+mIfaw+5T5WaaPB0qNcfM4/aahye0GWCXNGeV4PH+9h0EsDc7rc+HhPIwDg3Mm+11GGUY9zJw8BALz3xXFNxkbxt72uDZ12FwqzjDhhaJ7Ww4kZBjlJRlTAb6hpgdPl1ng0FA8f7m6ELANTKgowojCr1/fmjeG+ZhSaL49aYLU5kZthwOTh+b2+t3BiOQDgg68a2JYgTYj+OKeMLlayeqmIQU6SmTg0D/mZRnTYnPi8vl3r4VAciJbrp43tn1IWQe/6A80MemlA6w94Lmqzq4ug73NRmzemBCa9DodaupQWBZTaxBZBp6TwVBXAICfp6HUSTvFOUazjp/eU53bLSpZmXoA+FicMzUOu2YBOuwt7GzriPTxKIusPeOovxBSnv2yzQan3W7u3Ma7jovjrcbiw9VAbACjXk1TFICcJiX4561iXk/J2HbOgudOOLJMeU0cW9vu+Tidh8gjP1MP2urY4j46ShSzL+Mz7+pgRZH+i2d4gZ1Nta7yGRRrZeqgVdqcbpblmjC5N7cayDHKSkKiE33ywFT0Ol8ajoVgSqx9mVgXvY3HSiAIAwPbDbXEaFSWbY5YetHTaoddJmDAkN+AxIpOzsbaFdTkpbr33A/Ipo4ohSalbjwMwyElKo0uzUZZrht3pxpaD/NSVyrZ5U8rTK/tncYSTKzyZnM/qWKNFge2stwAAxpblIMOoD3jMlIoCmPQ6NFpt3B8vxX16wFd0nOoY5CQhSZKUgtN13OIhpYkphoFarp/oXSmzr8EKB4uPKYAvjngC4BOGBV8qnGHU4yTv1OfG2pa4jIvir9vuUt5XUr0eB2CQk7TEi1MUE1Lqae6w4VCL5xP1lAGCnOEFmcgxG+Bwyaht4soY6k9kciYNyx/wuGnejOHnnPpMWVsOtsLhkjE0PwOVxVmD/0CSi2mQ8+qrr2LBggUoLCxEdnY2pkyZggcffBAOR3gbwTU3N2P58uW46aabcOqppyIrKwuSJGHRokUxGnniE2nG7XVt6LQ5NR4NxYL4tDW6NBv5mcagx0mShLHlOQDA7T4ooK+OeYKcwZq+iazgDm9QRKlHWTqeBvU4AGCI1Yl/8pOf4NFHH4XBYMCZZ56JnJwcfPDBB/jZz36GN998E++99x4yMzNDOteaNWtw5ZVXxmqoSWlEYSaGF2Sivq0bWw624rRxpVoPiVQmgpxAq6r6GleWi22H2rDnOJeRU289Dhfq27oBQAmGgxFNAncdtcDhcsOoZ7I/1Yhu+XPSoB4HiFEm54033sCjjz6KnJwcbNiwAe+++y5WrFiBvXv3YvLkyVi7di1+8YtfhHy+8vJyXHfddXj66aexadMmPPXUU7EYdlKRJEnpdyGKyCi1fH7YU0cx0FSVIC5ee44xk0O91TR1QpaBvAwDirNNAx5bWZSFXLMBdqcbexkwp5xOm1N5X0mHehwgRkHO/fffDwC44447MG3aNOX2kpIS/OlPfwIAPP7442hvD201yCmnnIKnnnoK1157LWbMmAGz2az+oJPQnFGeJZ/rGeSkpFCnGABgvHdZ8B5u1El9HPB2MB5dljPo9IROJ2HScM/rbSc7qqecTbUtcLplDC/IREVR6tfjADEIcurr67Fp0yYAwNKlS/t9f968eaioqIDNZsPbb7+t9t2nFZHJ+fxwOzpYl5NSWjrtOG6xAfAFMAMZU+bJ5Bxq7uL2DtTL/kZPRmZUycBTVYKYsvq8vi1WQyKNpNPScUH1IGfbtm0AgKKiIlRXVwc8ZsaMGb2OpchUFGVhRGEmXG4Zm7nkM6V8ddSTxakszkKOefDSufLcDJgMOjjdMo609cR6eJREDniDnNFloXW2PVGpy2FWMNX4NwFMF6oHOTU1NQCAkSNHBj2moqKi17HxYLPZYLFYen2lglNYl5OSdnlra4J1p+1Lp5NQ6U0/1zZzGTn5HPC2FQg1k6NMfR6zsvNxCrH0OLDDOwXJTE4UrFbPm3N2dvBPDTk5nj+2eAYay5YtQ35+vvIlAq1kJ16s7JeTWkQmZ8KQwetxhMpiz9/cwRZ2qyUPWZaVmpwxIWZyRpXkwKCTYLU5cbSdWcFUsammBW7Zkx0eVhDayuZUkDbrA++88060t7crX3V1dVoPSRWiLmdnfTusPeH1H6LEtctbdDxxaGiZHABKY6+DbAhIXi2ddnTYnJAkhFxoajLoUF3iCYj2sO9SyhALVNJpqgqIQZCTm+t5U+7sDP5G29HhmSPOywv9U2q0zGYz8vLyen2lgmEFmagszoLLLWMT63JSgtPlVvrdTAxhZZVQVSymq5jJIY+6Vk9/nPLcDJgNgfesCmScmLJikJMy0rHoGIhBkFNVVQUAA2ZKxPfEsRSdOdWcskoltc2dsDvdyDLpUVEY+jJPZbqKNTnkdbjVE/COKAxvemJ8uSfI2X2MvXJSQXuXA18c8WSH5zCTE52pU6cC8GzFEKywePPmzQDQq4cORU5E5qKTJSW3fQ2eC8uYshzodKG3Xa/yBjmHWrrgdrNglIDD3kxOuD1RxpUzk5NKNtQ0Q5aBUSXZKM/L0Ho4caV6kDNixAjMnDkTAPDiiy/2+/7atWtRV1cHs9mMxYsXq333aUlE5l8caUd7N+tykt1+UShaGtpqGGFYQQZ0EmBzutHUYYvF0CjJ1LVEmMnxTlftbbDCxYA56YmpqnTZysFfTAqP77rrLgDAAw88gK1btyq3Nzc344YbbgAA3HjjjcjP9+2Iu3LlSkyYMAELFy6MxZBS2pD8DFSXZMMteyroKbntbxB9TcILcgx6HYZ4P6WJvYoovYlMTrhBzsiiLJgNOvQ43EqgRMnr0zTsjyPEZIPOiy66CDfffDMee+wxzJkzBwsXLkR2djZWrVqFtrY2zJ07F/fee2+vn2lvb8fu3bvR0xN4yeKcOXOUfzc2NgIANm3a1Ov2X/ziFzjvvPNi8IgS35xRxahp6sT6A81YdEK51sOhKIgOtaNLQ1vy629YQSaOtPfgSFsPpgZvVUVpwleTE950lV4nYVRpDnYdtWB/YweqSsJ/LVJiaOm04ytv3610q8cBYrgL+aOPPoq5c+fiiSeewLp16+BwODB69GjccccduOWWW2AyDbxRXF8bNmzod5vFYul1uwh+0tGcUUV4aeMhNgVMcrIsK9NVo8OcrgI8QQ4OtuIIMzlpT5ZlX01OmEEO4Knf2HXUggONnVg4Ue3RUbxs8F4TxpbloDQ3/fZ9jFmQAwBLlizBkiVLQjr2iiuuwBVXXBH0++y8OTCRhvzyqAXtXQ7kZxk1HhFFotFqQ4fNCb1Owsji8C9MoskXp6uoscMGm9MNneSZ0g7XKG8m8QD7LiW1dF06LqRNM8BUV5aXgdGl2ZBlTyU9Jad93qkqT01E6H1NhOEFnosZMzkksjhD8jz7moVLCXIauYw8maVzPQ7AICelzOE+VknPN1UVWQ3E8EJmcsij3hvkDA+z6Fio9u51xUxO8mrqsGGvdyHDbAY5lOy4j1XyU1ZWRVCPA/imq5jJoWPefaeG5EcW5IhMTqPVxi1jkpTYymHCkFwUZYdXB5sqGOSkkNnezse7jlrQ2mnXeDQUCd/KquiCnNYuB7rsTtXGRcnnmMUT5AyNoB4HAPIyjCjJ8RSq1jCbk5TEVFU6rqoSGOSkkNJcM8Z6e6tsYL+cpCR2jB4d4o7RfeVlGJFr9qwnONLGHaTTmQhyoulw66vLYZCTjNK96BhgkJNyRMS+nnU5Safb7lJqaUaVRJbJAbjCijyOi+mqaIKcEhYfJ6vjlh4caOyEJPn2N0xHDHJSjK8uh0FOsjnY4vm0nJ9pRGEU8+diufBxCzM56UxkcobkR94bhcvIk5e4BpwwNC+tW4owyEkxs6uLAABfHbOimfsXJZWDzZ7utFUR9MfxV57nuag1MMhJW263jAaL5+8/qukqscKK01VJRwQ56bp0XGCQk2KKc8wY791BeCPrcpLKIW+QM7I4uhb64qJ23MIgN121dNlhd7kBAGW5kQc51d5MTk1TJxuyJpkN3lW26bp0XGCQk4LElBX75SSX2mbPp+XKougyOWV5nK5Kd2L5eEmOKaJGgEJFYRZ0EtDtcKGRmeGk0WDpwYEmTz3OrKoirYejKQY5KWjOKM+LWiwfpORwqEVkcqKcrvLuT3PcGruL0ntfHMMTq/fB7nTH7D5S2ZaDrXj4vd1o745N/5njKqysAgCTQYeh3j47ItNIiU+srp0wJL3rcYAY711F2phdXQxJAvY2dKDRakvLTdmSka8mJ7rpKpHJaYxRJudQcxd++PctcHtnL350xpiY3E+q6ra7cMVfNsLa48Thtm48vORk1e8j2h45/kYWZaG+rRsHm7swI82zAslCbO0jajTTGTM5Kagw28S6nCTjcLmVJd+VahUeW21wu9Wvo/jPjiNKgPPOzmOqnz/VfbKvCdYeT6PG9744DodL/WyYWD4ebSYH8L0eRaaREp+oxxFZ/XTGICdFiX453KwzOdS3dsPllpFh1KEsysxbSY4ZkgQ43TJautTvfL2zvl35966jFk5ZhWn74Tbl3x02Z0xWLinLx1UIckYyyEkqzX77Vc1K4/44AoOcFCXSlBu4j1VSOOi9gFQWZUOSpKjOZdTrUJztrcuJwZTVrqNW5d9Ot6wUTFNo9vdprLfrqEX1+zgmlo+rMF1VWeSZPj3I5zkpbKr1vOePK89J2/2q/DHISVGzvEHO7uNWtHAfq4QnLiDRFh0Lvl456hYf9zhcSlBTUeQpSN3XwG644RC/r+HeztSx6CasRrdjgdNVyUVs0DyL9TgAGOSkrOIc3z5WrMtJfKLoONrl40J5jJaR17d1Q5aBXLMBJ40oAMAdz8Mhy7ISLMwfWwIAqGtV//fX5F3uXZYX/aKDCu9rsqnDjg4bN31NdGJl1WxOVQFgkJPSZnuLzliXk/hEJqeyJLqVVYLI5KjdEFAENEMLMjDMOxUierLQ4Cw9TvQ4PDVM0ysLAQCHW9XNkLj8arHUmK7IzzSiwLsMmcvIE1t7lwNfHfNMf85m0TEABjkpTUTyrMtJfGpnckSX2+NWdQOQo21iaXImhnj7pxxlkBOyRu/zkZdhwFjvCsjDKmdyWrvsEM2Ji7LUqckQr0tOWSW2jbUtkGXPxqrRdLpOJQxyUpiI5Hcds6C9KzZNxyh6brdvCiPa5eOCMl2lcgAilrkPK8hUMjlH2jldFSqRWSvLy1Bqco5ZelRdRt7c4cniFGYZYdCr8xYvtho51MLi40S2wdvlnlkcHwY5KawsNwOjSrIhy76Ke0o8x609sDndMOgk5cIXLdEAsknlVvxHvQHNsPwMpd5DXFRpcA1W0b/GjKJsE/Q6CbIMVRcHNHd6nvPiHPWagIpMzkFOVyU01uP0xyAnxbEuJ/GJC8fwwkzVPnmX5HimKZpUDkDE1NTQgkwUeqdCuHovdCKTU56bAb1OQrG3ZqZRxS04RNBZrOLyYfbKSXyWHge+OOLpYcVMjg+DnBSn1OVwhVXCUnYfV6keB/A0BASAxg6bqrtHi4txSY5J6cXTYXPC5nSpdh+pTPz+RKbN/3lSS3OHeI7Uy+SMZCYn4W2pbYVb9jxXYr8xYpCT8kREv7O+HdYe1uUkIrG6pkLFIEdcRO1ON6wqLvsVWZuSHDNyMwzQ6zyNC1s7+doKRat31VOhN8sinidVMzne56g4R71MjqgVq2/rjsk2FBQ931QVszj+GOSkuKH5mRhZlAW3DGw+2Kr1cCgAsbpmRKF6n74yjHrkmD377zapdAGVZVm5SBdlm6DTSZyyCpNYAFCQ6VmSHYsgR0xRqtnttjw3A2aDDi63zL5ICUrZlHMU63H8MchJA9ziIbH5ghz1MjmA75O8WnU5lh4nHC7P1Je4gBZley7WDHJC097tDXKyYhfkiOkqNQuPdTpJCcLVXvJO0euyO7HjsLceh5mcXhjkpIHZ3KwzoYnpKjUzOYCvJkOtFVYikMk26ZFh1APwBTuDbQTabXfhxQ2HlNVFqWbVruMhrWBs8wY5+Zme31ssanKUKUWV9y0SQbjazQspelsOtsLpljG8IFPVae9UwCAnDYjIfsfhdnTZ2ZY9kThcbmXHaPWDHM9FrlmlC2igDIES5AxyH4+s2oO7Vu7AnSt2qDKWRLLjcDuufmEzvvvshkH7UbV19c7kqP0cAf41OeplcgAwk5PANnC/qqAY5KSBiqIsDC/IhNMtYwvrchLKsfYeuGXAbNChVOWLki9LoM5Ukrh4+td6iIyEpWfg4Pnvnx4EAKz6qkHV1V6J4LM6z9+U3eXG9sNtQY+TZRnt3Z7fYb63JkfUNLWp2KyzSQlGY5XJYZCTaJR6HAY5/TDISROsy0lMda2+HjmSJKl67lhNV/n3X8nL8BQ3W7oHvkg73b7AptOeWsvN9zf6ugAPFAB02V1KTZPI5Ij/qhXk2JwuWL0BZ0l2rDI5nK5KJD0OF7bXif44LDrui0FOmmBTwMQUq6JjACgRXY9VKmptCZDJyfNmJCwDtCdwuNywOX3LjtUaT6Lwr6cZaNd3UY9j0uuQ6a1pEpmc1kFqmkIlniODTkJepkGVcwqi1qOuhZmcRLL1UCvsLjfKcs2oUmlbmFTCICdNiKaA2+va0eNIrU/SyUwEOWpt5+CvVFldpVZNjjfI8ZsGyfVmcqwDTFf1zVKoWWSbCPzrcAYMcryBTH6WUcnaiUyOzelGtwoZrma/5eNqZwZFJsezDQnfQxKFyM7PHlWs+nOeChjkpInK4iyU55lhd7mx9RDrchJFrFZWAb7CU7WWkIs9kfynQfIyBs/k9M1SpFomx//xDbSUvm+PHADIMRtg8DZUbOuO/nmKVdEx4JmmzDDqIMu+3ehJe6zHGRiDnDQhSZJviwfW5SSMWDQCFERNjlord/quDAKgTIkMlMnpe+FXswNzIvDPVLUPUJvU1t3/9ydJkvL/anSN9m3poG7RMeAZK4uPE4vN6cK2Q20AgDncryogBjlphHU5iac+ljU53gtdp92lylRIu9LjxXeRzhWZnAEu7q19g5xBVmIlmza/TM5Aq8zE70hkv4QCZYWVCpmcGGzO6a+CxccJ5fPD7bA53SjJMWF0aY7Ww0lIDHLSiMjkbDvUxjn1BOBwuXG03RPkVMQgk5NjNsBs8PyJq1GXI6ak8vyCHN901QCZnK6+QU7vgOjml7bhG3/6JOF7OL2yuQ6nLFuFz+ralNvsTnev1WIDBXsd3gxWTkbvguBCscJqkBVqoWjqVL/bsT8RjNcxyEkIGw54PrDOqi5iPU4QDHLSyOjSbJTkmGFzupUlh6Qd0SPHZNCpumO0IEmSqh11LQEzOWK6yhG0/03fzE2H3/+3dzvw7+1HsO1QGz7dn9gZxv977XMcbe/BQ+/tVm7r6DP1FkqQk23uHeSIXkNqrLBqjsG+Vf7YEDCx+Dbl5NLxYBjkpBFPXY7ol5PYF5R0oNTjFGRCp4vNpzC1lpHLsgxLt+ci3SuT4/23wyWjxxF4d+quPoGAf9Djv2dTs0oF0rG2r6FD+Xd3n5WKVpsTLnfgYE8EdznmIJkcFXrlxLImB2BDwETicLmV5q6zWY8TFIOcNOOry2HxsdYO+zUCjJVSlTbp7HG4YXd5ghj/TE62SQ8RnwVbYdXlnc7JMnl6w1htvuN6BTkJvMmnf5ZK7xeQdvd5bED/6Tih0x4kyMlWsSZHadgYq+kq1uQkih317eiyu1CQZcS4slyth5OwGOSkGZHW3HKwFQ5X4E/eFB+xXFkliItdtDU5IoDR6yRk+13QJUlSio+DX9w9gUCZN6vkn8nxH5caF/lY8a+7Mep9b5ui51Ruhq/+KVhhtbi973SVsrpKlUyOWEIeo8Jjb0PA4xYb6/o0puxXVVUUs0xwKmCQk2bGluWgMMuIbocLnx9mXY6WYtntWBAXu4H6t4SiXVkZZOhX4Cjqctq7A1/cu70ZDFEf5N+M0r/YWGQ6Xt96GPf8+4ug0z7xsm5fE259+TO0dtp7jdnu171ZTFdlGvVK8NIVZCVbp3faLrdvkJOpzv5Vsiz7ehnFqPC4MMuoZK3qOWWlKbFKlptyDoxBTprR6STlj4JLybUVy0aAgihAjXYqSFn+nGns973BMjnioi/G4h8E+NfxiNtvfWU7lq+rxbtfHItqzNG6/7+78Pq2ejz10f5e21L4P04xXZVh1CsX/2CrxDptnmP7ZnJ8vYaiC3K67C7l9xmrTI6nVw6Lj7XmdLmxudZTjzOH+1UNiEFOGmJTwMQQl+kqJZMT3XRVoB45Qo7Zc3EXF/G+RPAiljX7F+v6Z0i67S4l2wEMvulnrO2stwAA3vniWK9xdticSo2Okskx6ZFtGjiTYw2yhDyUZfihEFNVmUY9skzq7lvlj8XH2vvyqAUdNidyMwyYODRP6+EkNAY5aUgUH2+ubYGTdTmacLrcOObd5yiW01VF2aLrcZSZnJ7AjewAX2aiM0gGo0uZrvIEXD0DZHL8p9VkeDq6xvs12jcT43TJsPmN0y1D2U28x2+6KksJ9oJlckThsb7X7comp1EGdaJHTqyWjwtsCKg98QF1ZlVRr0J46o9BThqaMCQPeRkGdNpd+OKIRevhpKVjlh643DJMeh1KY1Q/Afg630Zdk9Mlpqv6ZwiUICfIxb3fdJV/JsfZO5PjPy1U19KFOfevwtJnN0Q19nBsrGnB5Hvew+Mf7FVuc7rd/Ypsxbj9g5zBMjlKM0Bz70Axz5vZGWj/r1CIQDZWy8cFZnK0x/2qQscgJw3pWZejOWX38cLY9cgBehceB2vWFwoxlRJwusoUWpCjTFf5BQH+GZIuh7NXMLF6dyNauxzYWNsSt5WAP39jB1xuGb9/b49ym8st9wq+AF82SqnJMflqcoJltHzNAANncjpsTrijKLZuiXG3Y0FMr7LrsTbcbhkba3w7j9PAGOSkKdblaEsJcgpiV48D+LInTrevmV8k2oPsuwT4MjkdQWtyvNNV3rHYnG7lYu6fyemyuXqtXLL7fe/1rYeVN/ZYsDldWP5JDfYc7+j3PWegIMcbnHV7/5vpX3gc4Pdgd7qVx9a3T45YnSbL0e3r1RTjfasEZnK09dUxKyw9TmSb9DhxGOtxBsMgJ02JupyNtS2aL9VNR/FYWQUAZoNeuag2R1F8PNDqqpxBalH6ZnIAX8Guf0GvzenuFUz4//tnK3ZgydOfRjr8QT383h7c8+aXAb/ncsmw9elsLMbf3asmJ3htkv/vpu/qKrNBjwyj5604mikrX4+c+GRyGq22Xs8fxYfIvk+vKoJBz0v4YPgbSlMnDM1DjtkAa48Tu46yLife4rGySihSoS6nfYAgZ6CaHLdbVgKBwmzfz4rb/KerbH7ZDqD/vlAA8Mj7ewLeHo3Vuxvw9McHgh8gIUAmp09NjkmvNEkMVJMjxmw26Ho1ExREhqw9iuJjX4+c2GZyCrKMSuBc38ZsTryJ7DvrcULDICdNGfQ6zKgqBMAtHrTgy+TEbmWVoEavHJFhCFST45uu6h989DhdEKVAOWaDkrEQtSy9Mzm9p6s6AkzdPPL+XvzyXzsjfBT9udwyrvzLpgGPkdA/yFEyOb365IjC4/7jFr+b3IzAS7uVFVYqZHJivbrKv1dOXQvrcuJJlmVsrPW8X8/hflUhYZCTxnx1OSw+jjfxCTgemRw1VliJbsZ5AS7SOQNM0/hnNTIMvkBAma7yq7ux95mucgaZRn19az1e33o43IfQj8Plxll/+CikY/tOy/QEmK4SBcWBanI6g+xALuQry8ijqcmJT+Ex4HvdMpMTX3sbOtDSaUeGUYfJwwu0Hk5SYJCTxvzrcqJZ1UHhcbrcONoW+x45ghrTVZYBmgGKgttAhcfigp9p1EOnk5Bp9Bzry+T4FRq7+i/VDubWV7ZjZ31025J8988bsL+xc9DjJEkKOl3lC3J0SgAXKNhTGgEGCXLUWEbe0hmfwmOAxcdaER9Ip1cWwmTg5TsU/C2lscnD85Fl0qOty4E9DVath5M2jlttcLplGPWSsmllLBV5azSiaQg4cOFx8JqcLkfvZdPKdFWAwmNZ7r0R5mDO/+PaiLdCWP5JTVirtfr1yfEGZ2IpeabJL5MT4DEMlsmJtiGg2y0rQU6s9q3yx60dtLG+RmzKyaXjoWKQk8aMeh2mV3rrcriUPG4Oe+sYhhfEtkeO4Juuimx1lcstK5mIgWpyAgU5YquHTG+2R5muClCTA4S/f9Pke94Lu//PjsPtQVdSBeJwuXsVSAP9V1f51+QEqk0S9UV9N+cUot3awdLjUKb3Yl2TA/gHOazJiRdZln1Fx6zHCRmDnDQ3m00B486/EWA8KFs7RDhd5R94DNwnp/8FWgQzohuwMl3l6D9d5bmv8C/yP33t85CP7ba78PXH14Z1/r61QkDgmhwxbdc9wOqq4Jkc73RVhJkc0SMnL8MQl2kMTlfF34GmTjR12GAy6HByRYHWw0kaDHLS3Cxv8fHGmpaoOuJS6JTl4wWxr8cBfF2PI52uEsWwmUZ9wAuo/3RV39eQWGkkMjkZfZZZ950GimT66bUth9HWFdpjm3rve2Gf3+mWAxQee5sB+k1XZYWwhDxokJMR3eqq5jgWHQO+JpbslRM/IotzckUBMoz6QY4mIaZBzquvvooFCxagsLAQ2dnZmDJlCh588EE4HJH9IW/ZsgWXXnopysvLkZGRgerqatx0001oaGhQeeTpY0pFPswGHZo67Njf2L/bK6kvXo0AhWhXV/l65AS+QItaFLfcf6m1uOCLACDTW5PTo2ImBwBO/s3/0GDtGfCYs/7wUb/7C1Xf4KNfn5xBlpB3hrqEPMLVVc1xLDoGPL1yRF8grrCKj43ebPsc9scJS8yCnJ/85CdYsmQJPvnkE8yaNQvnnHMODh06hJ/97Gc488wz0d0d3h/Ga6+9hjlz5uC1115DZWUlLrzwQuh0Ojz++OM46aSTsG/fvhg9ktRmNugxdWQBAGA963LiQlk+XhSv6aro9q8aqEcO4JuKAvpPWfmCnN7TVX2DBOXno9jWYNZvVwV9fNsOtQbcsiFUfYMvsfS9d03OQJmc3tN2fUWdyRFBTowbAQqeXjmcsooXWZaVfmbcryo8MQly3njjDTz66KPIycnBhg0b8O6772LFihXYu3cvJk+ejLVr1+IXv/hFyOc7cuQILr/8cjidTjz99NPYuHEjXn75ZezZswff+973cPz4cSxdupTTLRFS+uWwKWBc+Lodx2m6yluTY3e5I+oWPNC+VQCg00m+zSn7BTme/1cyOX51K06XWymWFauuotm7CQCq73y7320f7WnEN/60LqrziloZMTVnCzhd5esB1Lclg7IDedBMTnQ1OfGergJYfBxPdS3dONreA6NewrSRhVoPJ6nEJMi5//77AQB33HEHpk2bptxeUlKCP/3pTwCAxx9/HO3tofW5eOSRR9DV1YVFixbh2muvVW7X6/V48sknkZ+fj02bNuG998Kfbydfpf6GA80MFGPM5ZZxJI6NAAHPBVhkUCKZshqoR44QrPi4byYnw6/w2H9qK9pMhr8bX9yq/Lvb7sLlz2+M+pzWPruw951u8y88luXeTQ4BX/CXYw5cSyEef6RBnqi3KonTdBXg1xCQmZyYW++dqjppRIHyQYFCo3qQU19fj02bPG3Sly5d2u/78+bNQ0VFBWw2G95+u/+nrkBWrlwZ9Hw5OTm44IILAACvv/56pMNOa9NGFsKk16HBakNtMz+VxdJxS49fj5yMuN1vNFs7DLRvleArPu59ce9fk+MLcvynqkStSrSZHAD4z+dH8d8dRwEAE3/5TtTnAwCrrXeg1+PwZKLsLl+Qk+lXDNp3ykpMw+WYA/8Oo+2TI/atim8mh9NV8cL9qiKnepCzbds2AEBRURGqq6sDHjNjxoxexw7EarUq9Tbi56I5H/WXYdRjSkU+AF9xG8WGuCAMK8iEPg49cgRRq9ESwQorkV0JtKWDkB1kJ/J+01V+NTk93kyOSa9TMjyRNvfr6/p/bMXNL6n3ftA/k+NWxg94smX+HZ37bu3gW10VLJPjDfJsTrgi6D7eFKd9q/xxuip+RIsP1uOET/Ugp6amBgAwcuTIoMdUVFT0OnYgtbW1yr+DnTOc81Fgvn2sWJcTS+KCIJbgxks0Wzu0hzJdFaQRXr/CY7+aHJHJMRt1MHuXpqu5w/i/tx9R7Vz9ghynq1c/HDF+pfjY0ftxdAyyrUOuX71TJIGeryYnnkEOMznxUN/WjcOt3dDrJKV5K4VO9SDHavVsD5CdnR30mJycHACAxWIJ+XwDnTOU89lsNlgsll5f5KPU5bD4OKZ8RcfaBDlNEXQ9FsuaQ5uuGjiTkxFguirDr/9Oom6hJrIr/tNV/svHJcmTlctSMlqBa3KC9ckxGXRKFiiSZeTx3NJBEK/hBvbKiSmxX9WJw/ODBskUXNo0A1y2bBny8/OVL5H9IY/plYUw6CTUt3WjroXp51jx9ciJz8oqQemVE9V0VfAgJ2vQwuO+NTlupWg3w6iD2ZAcxZT5WX7TVQ7fyiohy9h72wphsEwO4LfCKsxMjtPlRmuX52fi1ScH6N0r5wh75cQM63Gio3qQk5ubCwDo7Ay+u29Hh6dfRV5eXsjnG+icoZzvzjvvRHt7u/JVV1c36H2nkyyTAZNHeOpymM2Jnfo4r6wSREFqNNNVA2dyAmcwRG1K3+mqHrsLNpHJMQTupJyI/DM5So8cv7FnKZt0+oI9p8u3LUSwTA7gCyLbwyw+bvF2e9ZJQEFW/IIc9sqJD6Ueh0FORFR/Z6mqqgKAAYMI8T1x7EAqKyuVfx86dCji85nNZuTl5fX6ot58dTksPo6VePfIEaJZXWUZpOMx4KvJ6ezT7VfUpgRcXeXsP12llkunj0DNssWqnhPwBXo2p1vJ1mT4Z3ICNAT0D/yCFR4DvgAq3JqcZr+i43gWswO+/dcY5MTGcUsPapu7IEnAjCoGOZFQPciZOnUqAKC5uTloIfDmzZsBoFcPnWDy8vIwZsyYXj8XzfkoONblxJYWPXKEaLZ2sPQpug1ENLkbbLrK7LetQ+/pKnXfin536RRIkoR1d5yp6nkDZXL8l477tnbwBTYd3sDPqJcGnJYTAVS4mRwR5Iimj/HEFVaxJd6LTxiaN+DfHwWnepAzYsQIzJw5EwDw4osv9vv+2rVrUVdXB7PZjMWLQ/uk9Y1vfCPo+To6OvDmm28CAC6++OJIh00AZlQWQicBh1q6cLSdn8zU1mDtgcMlw6CTUJ4Xvx45QHSrqyyDdDwGBig87jtdFaTwWK0NByuKMlH7wHnK/w8ryFQ10Cnwy+T0BAxy+k9XDVZ0LIhl5OEWHoseOfFcPi6MYCYnpkRWXWTZKXwxmQi/6667AAAPPPAAtm71dR9tbm7GDTfcAAC48cYbkZ+fr3xv5cqVmDBhAhYuXNjvfD/5yU+QlZWF999/H88++6xyu8vlwg033IC2tjbMnDkTZ511ViweTtrIzTDixOHeuhwuJVeduBAMLciI+7SC+JTfHObqqh6/zsShrK7qu/eUsrrK3HtbB/9MjtmgVy2Ts+b/+gc0wwoycdYJ5aqcP2AmZ5DpKqVHTpB9q/qeO+JMThyXjwu+mhxmcmLBt18Vp6oiFZMg56KLLsLNN9+Mjo4OzJkzB+eeey6++c1vYsyYMdixYwfmzp2Le++9t9fPtLe3Y/fu3di/f3+/8w0bNgzLly+HXq/Htddeizlz5uDb3/42xo0bh7/97W8oLy/Hiy++qCzjpMiJ4rYNbAqoOmVlVUF863EAoMh7AexxuAPukh2M6A8jSUDuAJmIUKerlEyO3T+To1Mlk/PL808I+r2nvz896vMDvYMc8dgyAkxXdQbI5Ay2/FfpehxuTY43cI3n8nFB2dqBq6tU19Rhw74Gz6KaWazHiVjMljQ8+uijePnll3HKKadg3bp1ePvttzFixAg88MAD+OCDD5CZGV5NwqWXXooNGzbg4osvxoEDB7By5Uq4XC786Ec/wvbt25W6HYoOmwLGzuEWz4VgeJzrcQAg2+Qr7m0OYxm5uODmmA3QDZB9CrR3ld3p24Az4HSVX+FxtJmcyuIsXDUvcId1wLMSaPsvo8/0ikDELfsCwEDTVd29Co8H7nYsRJ3J0WS6yhOwH7fYYOuzXxdFZ6M3izNhSC4KNXhuU0VMOwstWbIES5YsCenYK664AldcccWAx0yfPh0rVqxQYWQUzMyqIkgScKCpEw2WHpTFuXYklYlPuxVxXlkFeC7yxdkmHG3vQXOnHRVFoY0hlG7HgC/L4x/k+GeMlGaA3v/6BwmBMjk5ZkNY3Y8/vH3BoMfkZxnx4g9mY+mzG0I+rz+D327rANDqXbodqPDYf0VVh/ffg9fkRLZ/VZMyXRX/TE5hlhFZJj267C4caetBdUnwJrAUHl89DrM40UiO5hQUN/lZRkwY4llez1VW6tKq27HgKz4OvS4nlKJjwDdd1dkryPFc3I16CUa9563GPyBo8wYJGQFqcnIH2Cerr12/OSfkqepTR5fg2tNGhXzubL+gxmzwrAITd9XW6fndBKrJ6XZEPl0VdianM/5bOgieXjlcYRULvnocFh1Hg0EO9cO6nNjwdTvWNsgJb7pKbOkw8AVaFNX67yLu29LB97NGvQ4G77SXWOmVaeq/umqwrIfwyR1n9goyQnHX4onIMIb21ue/p1SGd/sGEZCJJnwhFx4PGuSIjsdhrq7ScLoK4B5WsdDWZcdXxzxbGs1kPU5UGORQP3NEvxzW5ajG7ZZ93Y5DnCpSW0kEXY9DzeSIzIvN6YbD5Vk1JS702X2CEJHNEVsRBKrJCSUIefCSkyLe6HTj3YtCOs4/uBOBmPhv2wDTVf67kIeayYm0Jkc8n1pMVwHslRMLoh5ndGk2SnO1eV5TBYMc6meWt/h4b0OHsrsxRafBavP1yNHoTSuSXjnKvlWD1OT4ZynERV3UpWT1ubiLupxW7zj69smRJCjTW8FcPa8aS2ZGvv9cXoYR79962qDH+WdyRCPDDG9DP/F7zAqUyQkwXTVY4XEkNTk9DpeSKdJiugpgr5xY4FSVehjkUD9F2SaMK/fs7L6pltkcNYhPuUPyM2AY5AIeK5Fs7SAa0w1WeGzU+7oWiykrMV01eCand8djs0GHgSpsTh9Xip+fNzHkxxDMmLJc/OXKmQMek+dXGySCG5FlavPLRAlKkBNB4bHY/NO/0eBgxHNp0usGXOIfS8MLOF2lNu5XpR4GORSQWEq+nlNWqtC66BiIbGuH9hCnqwDflJXoEdNp798sD/APcnzTPf6BgtmgH7CQ+IWrZqnWE+uM8WV4eMmUoN/3D+5EcCPGKmpyemdy+m/rEOp0VY7JoBQ1h9orR2Rai3NMmvUJ43SVuiw9Dnx5xAIAmMNMTtQY5FBA3MdKXb6iY23qcYAIMzk9g2/OKWT36XrcFaTTr5iucnl76PStyTEFyeRMryzEC1fNCnnsoTr/pGG4ZNqIgN/zD3LEvlNmb5Aje4bfuyZH7Mbu3wzQHvj30JdOJ4U9ZaVlt2NBBDnslaOOzbUtcMtAVXFW3Ld/SUUMciigWd406VfHLGjvCq8Qkvqr12hjTn/iQhhOnVWohceA39YONjFdFbgmJ7NPUXH/TI5OaSLo74WrZuH0caUhjz1UJoMODy2ZErCIOWAmp0+RdMAl5HYXZG8UFOrqKsAXTLaHuH9VU4fYt0q74tSibJMS6B1p69FsHKlCLPjgflXqYJBDAZXlZmBUaTZkGdjIupyo+aartMzkRLC6SllCHkmQM3BNjmAOUJMjVmgBwMSheZg/tqTfedT2u0tPQlG2CWdOKFNuy8vsvYTc/79CoNVVTrcMu/cxhDpdBfiCqlAzOeK5LNGwIy575aiL+1Wpi0EOBeXb4oH9cqKVCDU5Yrqqy2/fqMFYlUzO4Bfovpt0dir7VvXJ5AQIesRUEACYDHo4Xb5Mzts3z8Pfrp4d85qTU0eXYOsvvobzJg9VbivI8gUPviCn99um/+Pzr88RWzt0KoXHgwdpynRViDU5TR3aNQL0p+xhxeLjqHTanNhR3w7Al02n6DDIoaDmsC5HFW63rLz5axnk5GUYYNR7AoVQ63LExVas/BlI3006RU1OVp+gpm8mxLOE3PdWlGXS9+p4HO+CWv8gzD946Ft47DveN3ajXgeTd/WcmK7riCCTE2qvHFGTo8XmnP7YEFAdWw62wuWWMbwgU9OsbyphkENBiUzOF0faw94ZmXwaO2ywu9zQ6yQM0bCQUJIkv67Hg9flyLIc1uqqvpt0Kpkc88DTVX0zOWaDDr/6+iTkZhhUWSoervljS1BRlIkLpgzrFZiIf2cY+gY5gTNVXXYnZFn265MTQk1OmIXHjUomR+sgh9NValCWjnOqSjXaNFagpDAkPwOVxVk42NyFLbWtOMOvVoFCp/TIydOuR45QkmPGcYtNmeYYSI/DDYd32iiUmhzRp0Vc1LuVjsd9VlcFyOTk+GVunG4Zk0fkY/svzxpw5/NYyc0w4uOfngEA2NfQodwuAhBzgMJpf1kmPdq7Heiyu2Dz24k9lCBHZMzCz+RoPV3FTI4aRNHxHBYdq4aZHBqQaEa1nvtYRSwR6nEEMa3RZB18ukpk73RS/+LhQPoWHnfaA09X9Q0KMow66P2CGVF0rEWAI0iSBEmSeq2uEoFY3yCt7+MT/99pcymNESUJITXrE7VPljBXV2k/XcWux9Hqtruw/XAbAGZy1MQghwbkKz5mXU6kEmFllSAuho0hZHKU5eOZxpDqYkSmQul4bAut8LhvhqNvEKQl/wyWCMT8l5Cb9LoAQY/n8XQ7nEqgmGM2hBS0hVOT43bLvtVVCRLkHLf2sFdOhLYdaoXDJWNIXgZGarS/XSpikEMDEp8odtS3K9MQFJ6EyuTkeqY1QpmuUoqOQ5iqAnyZjs6+mRxz8MLjTKNe2afq/JM8q5q+M2tkSPcXDxlGPcaV58ColzB/rKdHj9lv/IGaJPpnckSgGOrvUARVodTAtXc7lKmwIg2XkIv7zzDqIMvAUfbKiYj/0nGtulenItbk0IBGFGZheEEm6tu6seVgK06LQTO2VOfrdqx9kFMqpqs6Qpiu8k6ZhFJ0DPimY/o2A+xbk+O/HN1/FdX/u+QkXHFqFaZXFoZ0f/Hy92tmo73LgeqSbAC9p+4C/W78GwIqfYZC/B3mhZHJae70BKr5mUaYDNp+XvX0ysnCvoYOHG7tRpX3d0Wh8+1XxXocNTGTQ4PybfHAupxI1CfgdFWTdfBMTlu3JxAKZUsHwH91lSe4EdNWffvD+Gcd/IOcbLMBM6oS71NsWW4GxpbnKv9fGGT8gujw3GV3+lanhfg7DKdPTqM1MYqOBa6wipzN6cK2Q20A2B9HbQxyaFCi+Jh1OeFzu2UcToAtHQQlyAlhukrssu3fEG8gYrrK6r1AW4NMd/UOckLLcCSSQr/fR6BVZ1lGsX+VK6xtMQC/mpwQtlIRmRytl48LLD6O3Pa6dticbpTkmDG6lFkwNXG6igYl0qfbD7eh2+7qVzhKwTV12GB3uqGTPEvytRZOTU6r90JbGEIjQKD3BbrH4Vk+DfQPZPyDnIIQz51I/McfqNbGf7pKJKVCWYLvOc4bKNqccLvlAYuVRTauNGGCHLGMnJmccImu8rOrEy+TmeyYyaFBVRZnoTzPDIdLxra6Vq2Hk1TqvJ9qh+ZnKgW2WhKZnNYuR6/9oQJp6/JMhxRkhpbJERkOq82JVu/PBlo6XThIkJDo/McfaJdoMV3VaXeGXdckjpNlz+9xIKJrtdZbOgjM5ESO+1XFjvbvupTwJEniUvIIiU+1wxNgqgrwBCIiOTDYRp2tynRV6Jkc8SH0ULPncQdaOu0f9ASqaUl0Zbm+zEmgIE30C7J0+5aQh1qTk2HUK5uVDtb1OFF65Agik1PfxiAnHA6XG1sOej48suhYfQxyKCQsPo5MIi0fBzy9XsRu5I2DFB+LTE5hiDU5ep2ved6hFk+QEyiDIUkS7jx3AiYMycX1C8aEPPZEYdTrcNOZYzB5eD6Wzu6/3F38vtq67GHX5ACh98oRK+QSLZNzzNIDu3PgLCH57KhvR7fDhcIsI8aW5Wg9nJTDIIdCIj5hbDvUxmZfYahvS5yVVYJYjTNYXU5bmJkcwHeBV4KcINNR150+Gu/85DQML0iM4C9ct501Hm/eNC9gFkXUMLV1O5RAJZxpOfH7bhuk+DjRMjnF/r1y2pnNCZXIjs+qLtK0y3eqYpBDIRldmo2SHDNsTje217VrPZykkWiZHAAozQ2tV46oqwl1dZXnWM8F+qB3uioZp6OiJX5frV12ZW+pcLIthX4/P5BE2bdKEL1yANblhIP9cWKLQQ6FxFOXI5aSc8oqVInUCFAIdRl5W5irqzzHei64B5s7AYQ3TZMqCrN9mRixzDucbItYvTVYzVSiZXIA9soJl9PlxuZaTz0O++PEBoMcCpmvLofFx6GQZVlpBFiRiNNVA9TkOFxupXNxqDU5gC+TI3bvLtZ4uwEt+GdiIqmbKQwhyOmyO5WO0onSJweAMv3ITE5ovjxqQYfNidwMAyYOzdN6OCmJQQ6FTKRTtxxsHXT5MXk2wbQlUI8cIZRMjsjiSFLoPV4A3wW+03sBFn150okI9GQZcEWwt5QIDAearhK7yGcYdSHtEB8vnK4Kj1KPU1WkbABL6mKQQyEbW5aDwiwjuh0ufH6YdTmDEW/0Q/IyEqJHjlASwv5VYmVVXoYxrDffIX36xiTSVEq8mA16pSEg4KlLMhtCD0REoDhQJqfB6tkEszwvI6Gax3G6KjxKPQ7748RM4rzzUsLT6SRl3phLyQd3OIH2rPJXkjt4JifcbsdC335ApbnpF+QAvZsEBmoYOJBQanKOWzzPXXlu4mQIATYEDIfbLWOjaALIouOYYZBDYWFTwNDVeZdRVxQlWJATwhLytghWVgHotyQ83At8qvB/zkeG+fyHUpNz3OLJ5JTlJVYQKQJ69soZ3FfHrLD0OJFjNmDSMNbjxAqDHAqLSKturm2Bk3U5AxJdf8O9yMVamffTf3OnPWhtVSQ9coD+q8iqS9Jzs8GRRb7fQ0WYK+tCqck57jddlUhKckwwG9grJxQiGz69shCGBJrOTjX8zVJYJgzJQ16GAZ12F744YtF6OAlNNMQbWZw4y8cBz0XUqJcgy0BDkBVWYl+kojAzOX0LbNNxdRUAjCrxda6dEOaqGf9MjizLAY9pENNVCZbJ8fTK4ZRVKEQ2nPU4scUgh8KiZ11OyJQgJ8EyOTqdpGRzjrX3BDxG6cESZk2NJEm4cm4VAODbMysSqig2nr52QjmyTHpkGvU4fVxpWD8rAkuHS1aW8fclpqsSLZMD+O1hxSAnKLdbZhPAOEm/dqQUtdnVxXh/VwM2HGjBtaeN1no4CcnudCvp+kSryQGAofkZqG/rHjzIiaCb7t2LJ+KCKcMweXh+VGNMZhVFWXjnx6cBAIaFuXVFpkmPDKMOPQ43WjsdyA3QUFGpyUmwwmOAK6xCsfu4Fa1dDmSZ9DhpRPr+ncQDMzkUNpFe3VjbovQBod6OtHXDLXv6mJQm4DLqcm/fnmB1E9F00zXodZg6knUGI4uzMLI4sgC32LuJquiY3FeiTlcB7JUTik/3e7I4M6qKEqq9RCrib5fCdsLQPOSYDbD2OPHVMdblBFLX6puqSsQpm6HeaQ6REehLNJtLxz43iUBsDRGo+LjT5oTVO41VlpDTVazJGcx679Y4p4ziVFWsMcihsBn0OkyvLATApeTBiHqcRNrOwd8QJZMz2HQVgxwtFGUHb9goisWzTXrkmBOv4mA4p6sG5KnH8bxvnjKaQU6sMcihiPj2sWLxcSCHErRHjiCCnEA1OS63jBZvBiEdt2VIBOXegu/GAKvfErnoGPBlctgrJ7Avj1rQ3u1AjtmAE9kfJ+YY5FBExIqAjTUtcLMup5+6BF1ZJQwVQU6A6SrP0mXPvlXhLiEndZQPMJ14pM27XUgC7YfmrzTHDLNBBzd75QQkpqpmVrFuLR74G6aInDQiH5lGPVq7HNjr3XGafBJ1+bgwJN/zafu4padfkCqmqoqyTHwT1ogoKA4U5Pi2C0ms/kuCJElKBlP8HZCPCHLmsB4nLvgORhEx+tflcMqqH6XbcYSra2KtLNcMSfL0Ymnus30A63G0V6ZkcvpPV4n+M8MLEvO1BQCV3iDnYDODHH8u1uPEHYMciths0RSQxce9tHc5YOnxrH5J1MJjo16nBDF963LEhTXR9kVKJ2K6qiFAJqfeO13VdzPURCKCe2ZyevvyiAXWHidyzQZMGsb+OPHAIIciNtubbt1Q0xy0/Xw6Em/spblmZJr0Go8mODHdUddnFcxR70V0aILWfKQDMV3VYLX1m04Uq5b6boaaSHyZnE6NR5JYPj3QBACYVV0EvS7xWkukIgY5FLEpFfnIMOrQ1GFnXY6fRK/HEYJNKRzxFouG26mX1FOa45lOdPqtdAM8y4+PtHmyO4lakwMAlcWejVk5XdXb+gOcqoo3BjkUMbNBj5lVnimrdfuaNB5N4kiWIGek90J0qKX3p21xER2Wn7gX0VRn8JtO9C8+buqwwe5yQycl7uoqoPd0FbO8Hk6XGxu99TgsOo4fBjkUFfGJZN1+Fh8LYvonUXvkCEEzOWK6qiBxL6LpQExZ+ddMidfWkLyMhN4OYERhJnQS0GV3obEj8NYU6WbnEQs6bE7kZRgwMcyd6SlyiftXQknh1NElAIANNdzHSkj0HjlCVUngIEd0QR7KTI6mRNG6f/HugUZP1q2qJFuTMYXKbNArr59DnLIC4Fs6PntUMetx4ohBDkXlxGF5yDUb0N7twK6j3McK8N/SIbGDhJFFngvlkfZu2JwuAEB7twMd3n2RhjGToykx5eMfhB5o8gQ5o0oTO8gBgMoA409nYlNOTlXFF4MciopBr8Ms71LydftZl+N0uZU+JonaI0coyTEhy6SHLPsazNV6L6IlOWZkmRJvX6R0UqUU7/pqpg40egr8R5fmaDKmcChBDpeRw+FyY1Ott+iYQU5cMcihqIm6nE9Zl4Oj7T1wumWY9DqU5yZ2JkSSJCUjsPe45+J5oElcRBM/U5DqAtVM7W8UmZzED3JEppDLyIEd9e3osrtQkGXEhCG5Wg8nrTDIoaiJupyNNS1wuNJ7Qz5xQRpRlAldEsy7n+AtgPzSO9V4IIkuoqmu0lt3U9faBZdbht3pVgKGUQlekwNwusqf+AA4u7ooKd4XUgmDHIrahCG5KMwyotPuwueH27UejqZqvReh6uLEvwgBUFZ5fHmkd5DDTI72huZlINOoh8Mlo6apA3uOW+FwycjPNCZ0jxyhkl2PFaLomFNV8ccgh6Km00lKMd2naV6XI2paEn31iyAyOaJofOcRT5A6rpwpda3pdBJOGOZ5fnbUt2P74TYAns1xJSnxswGiIWBLpx3WHofGo9GO3enG5tpWAMAcNgGMOwY5pIpTRV3OgfSuyxGZnKQJcoblQa+TUN/WjZ317crUwpSKAm0HRgCAycM9+xvtOGzBZ4faet2W6HLMBhRnmwCk95TV54fb0O1woSjbhHFl/PAQbwxySBWneOtyNte2osfh0ng02qkRmZwEX1kl5GYYcbI3oPn9e7sBeJYn52caNRwVCeK5Wbe/CR/vbQSQXEuQuVEn63G0xiCHVDG6NBtluWbYnG5s837iTDcut4y6Fs9S7KokqckBgNPHlQIAPtztuYieOb5My+GQn9PHlUKvk/DVMSuOW2zIMumVlg3JIFhX7XQistvcr0obMQly3n//fSxevBglJSXIzMzEhAkTcPfdd6OjI/xNHDs7O/Hiiy/itttuw4IFC5CXlwdJkjBmzJgYjJwiJUmS31Ly9KzLOdLWDbvLDZNel1SbWy6ZUQGj3vcJ8xvThms4GvJXmG3CmRN8Qecl00Ygw5i4O9v3NTJAr5900uNwYfNBTz3OqQxyNKF6t68//OEPuPXWWyFJEubPn4/y8nKsWbMG999/P1asWIG1a9eipKQk5PPt3bsX3/3ud9UeJsXAqaOL8a/PjqRtXY6ox6koykyqtu1D8jPw+0un4Lm1Nbh46nBMGpYcNR/p4jcXToLD5YbZoMPtZ43XejhhqUrzZeRbDrbC7nSjLNecFA0cU5GqQc62bdtw2223Qa/X480338S5554LAOjq6sIFF1yAVatW4Yc//CFee+21kM+Zm5uLK6+8EtOmTcPUqVPR1taG888/X81hk0pEv5xth9rQZXemXcdcsbKqOkmKjv1dePJwXHgyMziJaGh+JpZfOUvrYUQk3ZeRf7LPk9WeN6YkKVbEpSJVp6uWLVsGWZZx5ZVXKgEOAGRlZeG5556DTqfDihUr8NVXX4V8ztGjR+P555/HjTfeiLlz5yI7O/kuIOmioigLIwoz4XTL2ORdMplOar2fVpOpHocolgLtj5ZORJBz6pjQZy9IXaoFOXa7HW+99RYAYOnSpf2+X1lZiblz5wIAVq5cqdbdUoIR887puI+VyORUJmEmhygWSnJMyDEbIMvptxt5e7cDO+o9fafmjmE9jlZUC3L27NmDri7Pi3jGjBkBjxG3b9u2Ta27pQQjio/Xp+E+VjVJ1u2YKNb890cTO6ini/UHmuGWPVtwDM1PnoUIqUa1IKempgYAUFBQgNzcwA2PKioqeh0bTzabDRaLpdcXqe+UUZ607I76drR3p0+XU8/yce90VUly9MghigdRoya2DEkX67xTVXM5VaUp1YIcq9UKAAPWzOTkeKrLtQgwli1bhvz8fOVLBFykriH5GRhVmg237NmwM10caeuGw+XZfZyf2oh8RpV43vdrmsJvIZLM1ipBDqeqtJQ2zQDvvPNOtLe3K191dXVaDyllpWNdjuh0PLI4K6mWjxPFWnVp+mVyjrX3YH9jJyQpuTpUp6Kw1vjefvvtaGrqf+Favny5MkXV2Rn8hSyaAebl5YVzt6owm80wm81xv990dOroEvx9/SGs25c+dTnKnlWsxyHqZZR3uqomjWpyxAe8ycPzUZBl0ng06S2sIOe1117DwYMH+92+fPlyVFVVAQDa2tpgtVoD1uWI7Ik4llLTKaOKIUnA7uNWNFh6UJaXofWQYq62SSwfZz0OkT9Rk9PcaUd7lwP5Wam/L9on3g94oncYaSes6ara2lrIstzvCwDGjx+PrCzPG/zmzZsD/ry4fdq0adGMmRJcYbZJ2SlZzEunumTbfZwoXrLNBpTnebLoB9KgLkeWZaU/DutxtKdaTY7JZMJ5550HAHjxxRf7ff/gwYNYt24dAOAb3/iGWndLCWqed0XB2r3pEeQcaPS8eYvlskTkI4qP06Eu50BTJ45ZemDS6zCjMnk2U01VqhYe33HHHZAkCX/5y1/wzjvvKLd3dXXh6quvhsvlwiWXXIIJEyb0+rmNGzdiwoQJ/W6n5DVvrCfIWbOvScn2paoeh0tpWz+G+9MQ9SOKj9OhLkcsHZ9eWYhMU/JsppqqVN1caNq0aXjooYdw6623YvHixTj99NNRVlaGNWvW4OjRoxg/fjyeeuqpfj/X1dWF3bt3Bz3vN77xDRw9ehSAb/n54cOHMWfOHOWYa665Btdcc42aD4eiML2yEJlGPRqtNuw+bsWEIfEvNo+Xg81dcMtArtmA0lwWtxP1JYqP02G6StTjcKoqMai+g+Itt9yCyZMn46GHHsLGjRvR2dmJkSNH4s4778Sdd94ZtFHgQLZt29av4Nlms2HDhg3K/59zzjlRj53UYzboMau6CB/tacTavU0pHeTsF1NVZTnchI8ogFFpsozc5ZaVlVXcryoxxGSb6EWLFmHRokUhH79gwYIBpzRqa2tVGBXF2/yxJfhoTyPW7G3CNfNHaT2cmNnf4AlyRrMehyggUZNT29wJt1uGLkV7SX1xpB2WHidyzQac5F18QdpKm2aAFH+iLmdDTXNK70AsMjmjWY9DFNCIwkwY9RJ6HG4ctfRoPZyYEVNVs0cVwaDn5TUR8FmgmBlfnovSXDN6HG5sOdiq9XBiZr83BT+mjEEOUSAGvQ4jizwtRsRKxFT08Z5GAMD8saUaj4QEBjkUM5IkpfxSclmWmckhCkG1sodVatbldNqc2HzQs1/faeMY5CQKBjkUU0qQk6JNAY9ZetBld8Ggk1DJbsdEQYmaNVHDlmrWH2iGwyVjRGEmO58nEAY5FFOiLmdHfTtaO+0aj0Z9+xt8G3MaOQdPFNRo73Tu3hQNctZ4s9WnjSvlKssEwndliqnyvAyMK8+BLAPr9qfehp2cqiIKzbhyT/uQVA1yRD3OaazHSSgMcijm5o3x/NGv3deo8UjUt6+BQQ5RKERhfqPVhrau1Mrq1rV04UBTJ/Q6CaeyCWBCYZBDMTffO2X18Z7U2+LBl8lhjxyigeSYDRhekAkg9bI5YqpqakUB8jJSf5f1ZMIgh2Ju9qgiGPUS6tu6UdvcpfVwVKUEOVw+TjQokc3Zc9yq8UjUpUxVcVVVwmGQQzGXZTJg2shCAMCavakzZWXpceC4xQYAGF3CIIdoMOPKvcXHx1Mnk+N0ufHJfl/RMSUWBjkUF6eP9/zxf7g7dYKcvd5Po0PyMpCfxRQ10WDGKsXHqZPJ+ayuDdYeJwqyjJjMrRwSDoMciosF48oAAOv2N6HHkRpbPOw+5vk0Om5I+JvOEqWjsWWpl8n52FuPM3dMCfQpuidXMmOQQ3ExcWguyvM8WzxsrGnRejiqEHUF48s5VUUUCpHJabDa0N7l0Hg06hD1OKdz6XhCYpBDcSFJkpLNSZUpq93HvEHOkDyNR0KUHHLMBgzLzwCQGlNWbV12fH64DQAwf1yJtoOhgBjkUNwsUOpyGjQeSfRkWcZuJZPD6SqiUIlszp4UmLL6ZF8z3LJnGm5ofqbWw6EAGORQ3MwdWwKDTsKBpk4cSvKl5E0ddrR02iFJ3H2cKBxKXU4KZHJWez+wcVVV4mKQQ3GTl2HEtErPUvIP9yR3NkfU41QVZyPTpNd4NETJQ9neIckzOW63rGSlz5xQpvFoKBgGORRXC1JkKbmoxxnHomOisIz1/s3sTvKGgDuPtKOpw44cswEzq4q0Hg4FwSCH4uqM8amxlHwP63GIIjJ+SC4kybOHVVOHTevhROyDrzxZnHljSmAy8FKaqPjMUFxNGJKLIXkZ6HG4sSGJl5KLT6HskUMUniyTAVXFnr3edh21aDyayK3+ilNVyYBBDsWVJEk4fVxyr7Jyu2Xs8U5XTWCQQxS2iUM9fzfJGuQ0Wm3YfrgdgG8KnhITgxyKO/Gm8FGS1uXUt3Wj0+6CSa9DZTF3HycK1wlDPb2lvjySnEGO+IB24vA8lOVlaDwaGgiDHIo7/6XkB5s7tR5O2L7wvjGPLc+BUc8/IaJwTfQGObuOJmfxsVg6fuZ4TlUlOr5DU9zlZRgx3buUXBTvJZMvj3jS1JOGsdMxUSREkLO/sQM2Z3ItQHC43Fizx7Nf1Rmsx0l4DHJIE187oRwA8P6u4xqPJHwikzNpGHccJorE0PwMFGQZ4XTLSdcvZ3NtK6w2J4qzTZgyokDr4dAgGOSQJhZO9AQ5Gw60oL07uTbq8wU5zOQQRUKSJEz07vn2ZZIVH4upqtPHl0LHXccTHoMc0kR1STbGlOXA6dc1NBk0ddhwzNIDSfKl3IkofL66nOQKcj7g0vGkwiCHNOObskqeIEdkcaqLs5FtNmg8GqLklYzLyA80dmBfQwcMOgnzx3LpeDJgkEOaWeSdsvrwqwbYnW6NRxOaL0TR8XDW4xBF44RhvhVWsixrPJrQ/O9LTw3hKaOLkZ9p1Hg0FAoGOaSZqRUFKMkxwWpzYmOSdD9mPQ6ROsaW5cKk16G924FDLV1aDyck73mDnLO8WWhKfAxySDM6nYSFE5JrldWXDHKIVGEy6JQpK9E9OJE1WHuw9VArAOBrJwzReDQUKgY5pClRl/O/L48nfMq6w+ZETZOneSGXjxNFb0pFAQDg87o2TccRilW7GiDLnjEPyWeX42TBIIc0NXdMCTKMOtS3dSd899Md3k+bw/IzUJRt0ng0RMnvJG+fmc+TIJPz3hfHAHCqKtkwyCFNZZr0yioFUdSXqD7zfto8eWSBpuMgShVTRngyojvq2+F0Je7igw6bE5/sawYAnD2JQU4yYZBDmvuad5XVO95PSonqszrPfPzJ3hQ7EUVnVGkOsk16dDtc2NeYuJ2PP9zdALvLjVEl2RhdmqP1cCgMDHJIc187oRx6nYRdRy2obUrcDTuVTE5FobYDIUoRep2EE73tGD6vS9wpq/e+8GSZvzapHJLELsfJhEEOaa4w24RTRxcDAN7acVTj0QR2tL0bxy0275syV1YRqUUUH28/3KbpOIKxOV1Y7e1yfBZXVSUdBjmUEBZPHgoA+O/OxAxyPjvUBgAYV56LLBM7HROpZUqCFx+v3dsEq82J8jwzpnKqOukwyKGEcPakIdDrJOyst+BQc+I1BvvM+ymT9ThE6jrJW3z81TELehwujUfT31ufez54LZ48lBtyJiEGOZQQirJNmDOqCEBiTlmJTA4/yRGpa0RhJkpzzXC4ZGxPsH45PQ6X0uX4/JOGajwaigSDHEoYiTpl5XS5saPek0rn8nEidUmShFlVng84mw+2ajya3j7e04gOmxND8zMwlQsOkhKDHEoYZ08aAp3kmZuvS6C9bL44YkGX3YW8DAPGcPkokepmVHkCiE21ibWHncgqn8epqqTFIIcSRkmOGbOrPaus3k6gKSuxeeis6iK+0RHFwExvJmfLwVa43ImxvUuPw4X3vVNV53GqKmkxyKGEstj7ZvLm50c0HonPBr8gh4jUN2FILrJNelh7nNhzPDG2d/lwdwM67S4ML8jkgoMkxiCHEsp5k4fC4F1lta9B+zc7t1tWUuji0yYRqcug12FapWfKanOCTFm96V1Vdf5JQ9kAMIkxyKGEUpRtwoLxnr2sVm6r13g0wN6GDrR3O5Bp1CudWYlIfeJDxMZa7YuPLT0OZarq/JOGaTwaigaDHEo4F00dDgB4Y9sRuDWen99Y49mUb3plIYx6/rkQxYpSfFzTAlnW9u/+vzuOwuZ0Y2xZDjucJzm+a1PCWTSxHLlmA+rbujVfbcF6HKL4mDayECaDDscsPdjfqO0ediu2erLIF08bwamqJMcghxJOhlGv9MzRcsrK7Zaxbr8nkzObQQ5RTGUY9Zjpzeas3duo2TjqWrqwsaYFkgRcNJVTVcmOQQ4lJDFl9daOo5q1ev/yqAUtnXZkm/RKUSQRxc68MZ56vLX7mjUbg/hgNXd0CYbmZ2o2DlIHgxxKSLOrizC8IBPWHidW7WrQZAwf7fF8mjxldAnrcYjiYN6YEgDA+gPNcLjccb9/WZbx+tbDAICLpw2P+/2T+vjOTQlJp5PwDW8255+bDmkyhjXelPlp40o0uX+idDNpWB4Ks4zosDk12cdq66FW1DZ3Icukx9mThsT9/kl9DHIoYX1rZgUkCViztynuO5N32pzY4t1HZ/7Y0rjeN1G60ukknOrN5qzd1xT3+//HBs8HqvMmD0W22RD3+yf1McihhFVRlKUEGPHO5myoaYbDJaOiKBNVxVlxvW+idDbfG+R8uDu+xcdtXXa85W0AuHT2yLjeN8UOgxxKaEtnVQAAXtl8OK5z9O9764BOG1vKJaREcXTGhDIAwGd1bWiw9MTtfldsrYfN6cbEoXncxiGFMMihhLZwYjlKc81o6rApHUhjze2W8T/vfZ3FeXmiuCrPy8AUb5DxfpwWHciyjBc3HATgyeLwg03qiEmQ8/7772Px4sUoKSlBZmYmJkyYgLvvvhsdHR1hn2v37t145JFHsHjxYgwfPhwmkwl5eXmYOXMmli1bFtE5KXkY9TosmTECgG++PNY+O9yGRqsNuWYDThlVHJf7JCKfs04oBwC89+WxuNzfxpoW7G/sRJZJj4tOZm+cVKJ6kPOHP/wBX/va1/DOO+9g0qRJ+PrXv4729nbcf//9mDFjBpqawismW7hwIW655RasXr0ao0aNwiWXXIIZM2Zg586duOuuu3DyySfj0CFtVt9QfHx75kjoJE8h4u5jsd+0870vPFmcBRPKYDIw2UkUbyLIWbevGR02Z8zvb/m6WgDAhScPQ26GMeb3R/Gj6jv4tm3bcNttt0Gv1+Ott97CRx99hFdeeQX79+/HwoULsXv3bvzwhz8M65zjx4/Hc889h8bGRqxZswYvvfQSPvjgA+zatQuTJk3C/v37ccUVV6j5MCjBVBRlKcs5n19bE9P7kmUZ733h+fQo3miJKL7GlOWgqjgLdpcbH8W4APlQcxfe9f7NX3FqdUzvi+JP1SBn2bJlkGUZV155Jc4991zl9qysLDz33HPQ6XRYsWIFvvrqq5DPuWrVKlx11VXIycnpdXtVVRWeeuopAMDq1atx+PBhdR4EJaRr5nvefFZuq0ej1Raz+/niiAUHmjphMuiU3dCJKL4kScLZJ3o+2Px7e2y3dnn+kxq4ZeC0caUYPyQ3pvdF8adakGO32/HWW28BAJYuXdrv+5WVlZg7dy4AYOXKlarc59SpU5V/19XVqXJOSkzTRhbi5IoC2F1u/G39wZjdzxvelu5fm1jOtDWRhkQz0NVfNaKtyx6T+2jvcuCVzZ5rxw/mM4uTilQLcvbs2YOuLk/DthkzZgQ8Rty+bds2Ve5z7969yr+HDh2qyjkpMUmShB/MHwUA+Pv6g+iyqz9P73LL+Nf2IwB8e2cRkTYmDMnDhCG5sLvceHtHbAqQ/7HxILrsLkwYkqtsKUGpRbUgp6bGUytRUFCA3NzAKb+Kiopex0brgQceAABMmzYNVVVVqpyTEtfZk8oxsigLLZ12/O1T9bM56/Y3odFqQ2GWEaeP41QVkdZENmflNvXLETpsTjz78QEAwLWnjeKy8RSlWpBjtXpWvWRnZwc9RtTVWCyWqO9v+fLlePnll6HX6/Hoo48OerzNZoPFYun1RcnFoNfhpjPHAACe/vgAOlVedfHSRs8qvfNPGsZVVUQJ4IKTh0EnAZtqW7GvQd2VlS+sq0VrlwPVJdm4YAqXjaeqpHwnX7VqFa677joAwIMPPoh58+YN+jPLli1Dfn6+8iWySpRcvjF1OKqKPdmcFz6tVe28R9u78a536fh357ClO1EiGJqfiYUTPasc/6pi9tba48CzazxZnB8vHAuDPikvhRSCsHYgu/322wP2uVm+fLkyRdXZ2Rn050Xjvry8vHDutpe1a9fiwgsvhN1ux69+9SvceuutIf3cnXfe2etYi8XCQCcJGfQ6/HjRWNzy8nY88/EBfHdWJfKzoi8QfmnDIbjcMmZXF2HCkMhfn0SkrstPqcL/vjyOFVsO46dnj1dlQcCza2rQ1uXA6NJsfJ1ZnJQWVpDz2muv4eDB/tH08uXLlZqYtrY2WK3WgHU5YgVUpPUz69atw+LFi9HZ2Ym7774b99xzT8g/azabYTabI7pfSiwXTBmOJz/cjz3HO/CH9/fgngsmRXW+brtL6aZ82SlVKoyQiNQyd0wxxpTlYF9DB17ZfBhXz4tuFVR9Wzee/mg/AOD2s8ZDr2MtTioLK0dXW1sLWZb7fQGepn1ZWZ7dmjdv3hzw58Xt06ZNC3ug69evxznnnAOr1Yq77roL9913X9jnoNSg10n45fmewOZv6w9G3QX5HxsOornTjoqiTJw1iQ0AiRKJJEm4cm4VAOCpj/ajx+GK6nz3v70LNqcbs6uLcM6J3Jsu1ak2EWkymXDeeecBAF588cV+3z948CDWrVsHAPjGN74R1rk3btyIs88+Wwlwfvvb30Y/YEpq88aW4OxJ5XC5ZfzyXzvhdssRnafb7sJTH3nm5m88YwyMnJsnSjiXTq/A8IJMNFpt+HsUfbI+3tOItz4/Cp0E/PLrJ3BFVRpQ9R39jjvugCRJ+Mtf/oJ33nlHub2rqwtXX301XC4XLrnkEkyYMKHXz23cuBETJkzodzvgyf6cddZZsFgsDHCol5+fdwIyjXpsqGmJuAj5qY/2o6nDhhGFmbh42gh1B0hEqjAZfCsrn/xwP9q7HGGfw9LjwM9WfA7AMy09aVi+qmOkxCTJYr5JJX/4wx9w6623QpIknH766SgrK8OaNWtw9OhRjB8/HmvXrkVJSe+mSx9++CHOOOMMAEDf4RQVFaG1tRUFBQW48MILg97vHXfcETBICsZisSA/Px/t7e1RFUKTtv72aS1+8a8vYDbo8NbN8zCmLPS27HUtXVj48EewO914fOlUnH8SCxCJEpXD5cY5j3yM/Y2dWDp7JO7/xuSQf1aWZdz2yna8vq0elcVZ+O+P5yPLFFZJKiWQcK7fqgc5APD+++/joYcewsaNG9HZ2YmRI0fim9/8Ju68886ABckDBTmhphNXr16NBQsWhDxGBjmpQZZlXPb8RqzZ24RRpdlYecNc5GcOvvrC5Zax9Nn12FDTglNHF+Mf18xm6poowa0/0IxvP7MeAPDSD+bglNHFIf2c+DCkk4B/XnsKZlUXxXKYFGOaBznJgEFO6mi02nDh42txpL0H88aU4M+Xz0CGUT/gzzz83m489sE+ZJv0+M/N81FdEryJJREljp+99jle3lyHkhwz3rp5HsrzMgY8ftWu47jub1vgdMu4a/EEXHva6DiNlGIlnOs3qywp6ZXmmvHMZTOQadRj7b4mXPPCZnQM0A35r5/W4rEP9gEA7r3oRAY4REnkngsmYcKQXDR12HDZcxvR1GELeuw7O4/h+r9vhdMt46KThyn731H6YJBDKeHE4fn4y5UzkWXyBDrnP7YGn+5v7nVMh82Je/79BX75ry8AADedOYbFxkRJJtOkx9Pfn46yXDN2H7fioic+wcaall7HWHscuPc/X+KHf98Cu8uNsyeV43eXTuGUdBridBWnq1LKZ3VtuOHvW3CkvQcAMHFoHqaMyIe1x4mP9zbC2uPJ8Ny8cCxuWTSWb3pESepAYwcu/8tG1LV0AwCmVBTghKG5aOm0Y+3eJnTaPf10rpxbhbsWT2R7iBTCmpwQMMhJXW1ddvz+vd14eVMdHK7eL++q4iz86uuTcMaEMo1GR0RqsfQ4sOztXXh182E4+/TKGlOWg7vPm4gzxvNvPdUwyAkBg5zU19xhw5q9TTjU0oVMox6TR+RjVlURdGzjTpRSjlt68PGeRhxt70G22YCTKwowbWQBM7UpikFOCBjkEBERJR+uriIiIqK0xyCHiIiIUhKDHCIiIkpJDHKIiIgoJTHIISIiopTEIIeIiIhSEoMcIiIiSkkMcoiIiCglMcghIiKilMQgh4iIiFISgxwiIiJKSQxyiIiIKCUxyCEiIqKUZNB6AFoRm69bLBaNR0JEREShEtdtcR0fSNoGOVarFQBQUVGh8UiIiIgoXFarFfn5+QMeI8mhhEIpyO1248iRI8jNzYUkSaqe22KxoKKiAnV1dcjLy1P13BQffA6TG5+/5MfnMPnF6jmUZRlWqxXDhg2DTjdw1U3aZnJ0Oh1GjBgR0/vIy8vjH2eS43OY3Pj8JT8+h8kvFs/hYBkcgYXHRERElJIY5BAREVFKYpATA2azGb/61a9gNpu1HgpFiM9hcuPzl/z4HCa/RHgO07bwmIiIiFIbMzlERESUkhjkEBERUUpikENEREQpiUEOERERpSQGOWF4//33sXjxYpSUlCAzMxMTJkzA3XffjY6ODlXOv337dphMJkiShDFjxqhyTupNzedw9+7deOSRR7B48WIMHz4cJpMJeXl5mDlzJpYtW6ba64KAV199FQsWLEBhYSGys7MxZcoUPPjgg3A4HBGdb8uWLbj00ktRXl6OjIwMVFdX46abbkJDQ4PKIydBredw27ZtWLZsGRYuXIjy8nIYjUYUFhZi/vz5eOKJJyJ+TdDg1P479Pf2229DkiRIkoRFixapMFovmULy8MMPywBkSZLk0047Tb700kvlIUOGyADk8ePHy42NjVGd32azySeddJIsSZIMQB49erRKIydB7edw+PDhMgA5IyNDnjdvnvztb39bPuOMM+SMjAzlOTx48GCMHk36+PGPfywDkA0Gg3zWWWfJF198sVxQUCADkOfNmyd3dXWFdb5XX31VNhgMMgB55syZ8pIlS+RRo0bJAOTy8nJ57969MXok6Uut59DhcMgAZAByTk6OfMYZZ8jf/va35Xnz5sl6vV4GIM+aNUtubW2N7QNKQ2r/HfpraWmRhw0bplz/Fi5cqNq4GeSEYOvWrbIkSbJer5fffvtt5fbOzk554cKFMgD5kksuieo+7r77bhmAfOONNzLIiYFYPIdnnnmm/Nxzz8lWq7XX7TU1NfKkSZNkAPIZZ5yhyvjT1cqVK5UL2pYtW5TbGxsb5cmTJ8sA5Ntuuy3k89XX18tZWVkyAPnpp59Wbnc6nfL3vvc9JfBxu92qPo50puZz6HA45OnTp8uvvPKK3NPT0+t7n3/+uTx06FAZgHzllVeq+hjSndp/h31997vflfV6vXz99dczyNHCpZdeKgOQr7nmmn7fq62tlXU6nQxA3rVrV0Tn37hxo6zX6+VLL71UXr16NYOcGIj1c9jXmjVrlE+cdXV1qpwzHc2cOVMGIN933339vid+x2azWW5rawvpfD/96U9lAPKiRYv6fc9qtcr5+fkyAPmdd96JeuzkofZzOJC//e1vMgA5MzNTttvtUZ+PPGL5HL7++usyAPmnP/2p/Je//IVBTrzZbDblk98HH3wQ8Jj58+fLAOT7778/7PN3d3fLEydOlEtKSuTjx48zyImBWD+HgXR0dChBzrp161Q5Z7o5fPiw8js8cOBAwGMqKipkAPKLL74Y0jnHjBkjA5Cff/75gN///ve/LwOQr7322ojHTT6xeA4HsnPnTuX+jhw5EvX5KLbPYWNjo1xWViaPHz9e7u7ujkmQw8LjQezZswddXV0AgBkzZgQ8Rty+bdu2sM//i1/8Art27cJjjz2GsrKyyAdKQcX6OQxk7969yr+HDh2qyjnTjXguioqKUF1dHfCYcJ43q9WKffv29fq5aM5Hg1P7ORyM+LszmUwoKiqK+nwU2+fw+uuvR1NTE5577jlkZGREN9AgGOQMoqamBgBQUFCA3NzcgMdUVFT0OjZU69atw8MPP4wLL7wQ3/nOd6IbKAUVy+cwmAceeAAAMG3aNFRVValyznQjnouRI0cGPSac5622tlb5d7Bzqv06SHdqP4cDkWUZDz74IADg/PPP555XKonVc/jPf/4Tr732Gm666SbMnTs3ukEOgEHOIKxWKwAgOzs76DE5OTkAAIvFEvJ5u7q6cMUVVyA/Px9PPvlkdIOkAcXqOQxm+fLlePnll6HX6/Hoo49Gfb50pfbzJs430DnVfB1QfP/2fv3rX+PTTz9FTk6O8iGDoheL5/DYsWP40Y9+hNGjR+P++++PfpADMMT07BTUHXfcgb179+KFF17gdEYKWbVqFa677joAwIMPPoh58+ZpPCKi1PfXv/4Vv/nNb6DT6fD8889j7NixWg+JBnDttdeitbUVK1asQFZWVkzvi0EOgNtvvx1NTU39bl++fLkyvdHZ2Rn050XTt7y8vJDu78MPP8Tjjz+OxYsX47LLLotgxNRXvJ/DQNauXYsLL7wQdrsdv/rVr3DrrbdGfC6C6s+b/1RlZ2cn8vPzozofDS4ef3uvvvoqrrrqKgDAs88+i0svvTSi81Bgaj+HL7zwAt58801cf/31WLBggSpjHAiDHACvvfYaDh482O/25cuXK/UUbW1tsFqtAWs66urqACDk2os33ngDsizj0KFD/Z7ktrY2AEB9fb3yvUceeQQnn3xySOdOV/F+Dvtat24dFi9ejM7OTtx999245557IjoP+YjnQjw3gYTzvFVWVir/PnToECZPnhzV+Whwaj+Hfb3++utYunQp3G43nn76aSXYIfWo/RyuXLkSALBp06Z+179jx44B8HQkF9/75z//iSFDhoQ3aD8MctC7ILGv8ePHIysrC11dXdi8eTPOOOOMfsds3rwZgKfINBw7d+4M+r2enh589NFHAHyBDwWn1XMIAOvXr8c555wDq9WKu+66C/fdd1/Y56D+pk6dCgBobm5GTU1NwJUd4TxveXl5GDNmDPbt24fNmzcHDHKieR1Qf2o/h/7eeOMNfPvb34bL5cKTTz6JH/zgB9EPmPqJ1XMofiaQtrY25frX09MTznD7U20xegobrJGcaCeuRiM59smJjVg9hxs2bJDz8vJkAPJdd92l1nDJK97NAEWbejYDVE8sGsn9+9//lo1GoyxJkvzUU0+pOVwKIF4NHdkMUCNbtmxRtgT473//q9w+2JYAGzZskMePHy+PHz8+5PtikBMbsXgON23apHTIZYATG8HayTc1NQVtJ//666/L48ePl88888x+5/Pf1uGZZ55Rbnc6nUojQG7roC61n8O33npLNplMsiRJvbbmoNhR+zkMhkGOhvw3d1ywYIG8ZMkSZZ+UYJs7ioAlnIQZg5zYUfs5LCwslAHIBQUF8uWXXx70S62tItLVzTffLAOQjUajfM4558iXXHKJknGZO3duv40BxRtlZWVlwPO98sorSuZu9uzZ8re+9S1u0Bljaj2Hx48fl81mswxAHjFixIB/d9Fumky9qf13GAiDHI3973//k8855xy5qKhINpvN8tixY+U777xTtlgsAY9nkJN41HwOxe2Dfa1evTrGjyr1vfzyy/Jpp50m5+XlyZmZmfKJJ54oP/DAA7LNZut3bChvrps3b5YvvvhiubS0VDaZTHJlZaX8ox/9SD527FgMH0V6U+M5rKmpCfnvrqamJj4PLI2o/XcY7GfUDHIkWZbl8Ct5iIiIiBIbOx4TERFRSmKQQ0RERCmJQQ4RERGlJAY5RERElJIY5BAREVFKYpBDREREKYlBDhEREaUkBjlERESUkhjkEBERUUpikENEREQpiUEOERERpSQGOURERJSS/j/ecgm+79c4zwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import math\n", + "# 在-0.4和0.4之间划分10000个等分。\n", + "x = np.linspace(-0.4,0.4,10000,endpoint=False) # 范围我取的很小是因为在(-0.5,0.5)之外，函数图像就是一个直线，没必要。范围太大你看上去就跟直线似的。可以自己试试。\n", + "y = []\n", + "for i in x:\n", + " if i==0: \n", + " y.append(0) # 这里要注意分母不能为0，要不然会报 domain 错误；\n", + " # 这里我直接让y等于0，因为高数都学过极限:趋近于零时，无穷小乘以有界，为0，\n", + " else:\n", + " y.append(i * math.sin(1/i)) \n", + "plt.plot(x,y) # 输入x,y坐标\n", + "plt.title(\"f(x) = xsin(1/x) \") # 设置标题\n", + "plt.show() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 面向对象画图\n", + "1. 生成画板 `plt.figure()`\n", + "\n", + " - 画板大标题 `fig.suptitle(\"画板标题\")`\n", + "\n", + "2. 快速创建图板和一个子图 `fig, ax = plt.subplots()`\n", + "\n", + " - 在画板里还需要有“图纸”来绘画。也可以理解为坐标系，注意跟下面的axis（坐标轴）要正确区分。\n", + "\n", + "3. 子图上绘画 `ax.plot()`\n", + "\n", + "4. 添加子图 `ax = fig.add_subplot(参数1，参数2，参数3)`\n", + "\n", + " - 参数1 和参数2是用来对画板划分为几部分；参数3指的是第几部分\n", + "\n", + " - 例：ax = fig.add_subplot(2,2,1) # 将画板划分为2*2，ax表示的第一个\n", + "\n", + "5. 其他设置\n", + "\n", + " - 为子图添加标题 `ax.set_title(\"标题\")`\n", + "\n", + " - 添加图例 `ax.legend()`\n", + "\n", + " - 在指定位置添加文本 `ax.text(x,y,\"str\")`\n", + "\n", + " - 网格是否显示 `ax.grid(True)` # 显示\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 例：python自带泰坦尼克号数据集\n", + "\n", + "本例中是结合pandas库作图，需要对目标列使用 `.values_count()` 函数汇总再画图。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting seaborn\n", + " Obtaining dependency information for seaborn from https://files.pythonhosted.org/packages/7b/e5/83fcd7e9db036c179e0352bfcd20f81d728197a16f883e7b90307a88e65e/seaborn-0.13.0-py3-none-any.whl.metadata\n", + " Downloading seaborn-0.13.0-py3-none-any.whl.metadata (5.3 kB)\n", + "Requirement already satisfied: numpy!=1.24.0,>=1.20 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from seaborn) (1.26.0)\n", + "Requirement already satisfied: pandas>=1.2 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from seaborn) (2.1.1)\n", + "Requirement already satisfied: matplotlib!=3.6.1,>=3.3 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from seaborn) (3.8.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (1.1.1)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (4.43.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (21.3)\n", + "Requirement already satisfied: pillow>=6.2.0 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (10.1.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from matplotlib!=3.6.1,>=3.3->seaborn) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from pandas>=1.2->seaborn) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from pandas>=1.2->seaborn) (2023.3)\n", + "Requirement already satisfied: six>=1.5 in /Users/xu/anaconda3/envs/git/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.3->seaborn) (1.16.0)\n", + "Downloading seaborn-0.13.0-py3-none-any.whl (294 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m294.6/294.6 kB\u001b[0m \u001b[31m871.2 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hInstalling collected packages: seaborn\n", + "Successfully installed seaborn-0.13.0\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
survivedpclasssexagesibspparchfareembarkedclasswhoadult_maledeckembark_townalivealone
87513female15.0007.2250CThirdchildFalseNaNCherbourgyesTrue
83511female39.01183.1583CFirstwomanFalseECherbourgyesFalse
43511female14.012120.0000SFirstchildFalseBSouthamptonyesFalse
88803femaleNaN1223.4500SThirdwomanFalseNaNSouthamptonnoFalse
82201male38.0000.0000SFirstmanTrueNaNSouthamptonnoTrue
\n", + "
" + ], + "text/plain": [ + " survived pclass sex age sibsp parch fare embarked class \\\n", + "875 1 3 female 15.0 0 0 7.2250 C Third \n", + "835 1 1 female 39.0 1 1 83.1583 C First \n", + "435 1 1 female 14.0 1 2 120.0000 S First \n", + "888 0 3 female NaN 1 2 23.4500 S Third \n", + "822 0 1 male 38.0 0 0 0.0000 S First \n", + "\n", + " who adult_male deck embark_town alive alone \n", + "875 child False NaN Cherbourg yes True \n", + "835 woman False E Cherbourg yes False \n", + "435 child False B Southampton yes False \n", + "888 woman False NaN Southampton no False \n", + "822 man True NaN Southampton no True " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "!pip install seaborn\n", + "import seaborn as sns\n", + "df = sns.load_dataset('titanic')\n", + "df.sample(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "对分类数据 survived, pclass, sex 画直方图，并在一张图中显示。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 创建一个画板\n", + "fig = plt.figure(figsize=(12, 4)) # 表示创建的画板的宽度为 12 单位，高度为 4 单位\n", + "\n", + "# 创建三个子图，分别用于 \"survived\"、\"pclass\" 和 \"sex\"\n", + "##第一个数字 1 表示总行数。在这个例子中，画板被分为 1 行。\n", + "##第二个数字 3 表示总列数。在这个例子中，画板被分为 3 列。\n", + "##最后一个数字 表示当前子图在这个网格中的位置。\n", + "ax1 = fig.add_subplot(131) # 第一个子图 ax1 被放置在第一个位置。\n", + "ax2 = fig.add_subplot(132) # 第二个子图\n", + "ax3 = fig.add_subplot(133) # 第三个子图\n", + "\n", + "# 绘制 \"survived\" 列的柱状图\n", + "survived_counts = df['survived'].value_counts()\n", + "ax1.bar(survived_counts.index, survived_counts.values)\n", + "ax1.set_title('Survived Count')\n", + "ax1.set_xticks([0, 1])\n", + "ax1.set_xticklabels(['Not Survived', 'Survived'])\n", + "\n", + "# 绘制 \"pclass\" 列的柱状图\n", + "pclass_counts = df['pclass'].value_counts()\n", + "ax2.bar(pclass_counts.index, pclass_counts.values)\n", + "ax2.set_title('Pclass Count')\n", + "ax2.set_xticks([1, 2, 3])\n", + "ax2.set_xticklabels(['1st Class', '2nd Class', '3rd Class'])\n", + "\n", + "# 绘制 \"sex\" 列的柱状图\n", + "sex_counts = df['sex'].value_counts()\n", + "ax3.bar(sex_counts.index, sex_counts.values)\n", + "ax3.set_title('Sex Count')\n", + "ax3.legend()\n", + "\n", + "# 调整子图之间的间距\n", + "plt.tight_layout()\n", + "\n", + "# 显示图表\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "对 alone 列画饼图，并加上图例。" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n", + "findfont: Generic family 'serif' not found because none of the following families were found: SimSun\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# 创建一个画板\n", + "fig = plt.figure(figsize=(6, 4))\n", + "\n", + "# 创建子图 ax\n", + "ax = fig.add_subplot(111) # 使用 1x1 的子图网格\n", + "\n", + "# 绘制 \"alone\" 列的饼图，并根据不同类别使用不同颜色\n", + "alone_counts = df['alone'].value_counts()\n", + "colors = ['aquamarine', 'dodgerblue']\n", + "# 绘制饼图\n", + "pies, texts, autotexts = ax.pie(alone_counts.values, labels=alone_counts.index, autopct='%1.1f%%', colors=colors)\n", + "\n", + "# 设置子图标题\n", + "ax.set_title('Alone or not')\n", + "\n", + "# 添加图例\n", + "ax.legend(pies, alone_counts.index)\n", + "\n", + "# 显示图表\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "git", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}