{ "nbformat": 4, "nbformat_minor": 5, "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.12" }, "lecture_validation": { "status": "executed-top-to-bottom-local-cpu", "cloud_execution": false, "executor": "standard Python exec per cell in fresh notebook namespace; stdout/stderr and plt.show captured", "format_check": "v4.5 required notebook/cell/output fields checked", "code_cells": 6, "figure_inspection": "All eight output figures visually inspected locally as PNG; HTML/notebook frontend not browser-inspected" }, "title": "LAB 10 · 成本目标与结构选择" }, "cells": [ { "cell_type": "markdown", "metadata": { "html_anchor": "cell-1", "deepnote": { "block_id": "041c4994e1a949d5908dbc892cfab616" } }, "source": [ "# LAB 10 · 成本目标与结构选择\n", "\n", "[返回第二讲 · 成本目标与结构选择](https://codingai-lec02.pages.dev/#/frontier-depthwise-convolution-cost/0) · [网页阅读版](https://codingai-lec02.pages.dev/course/lab12.html) · [第二讲导读](https://codingai-lec02.pages.dev/course/guide.html) · [问卷作业 ↗](https://tally.so/r/VLroVv)（右键在新标签页打开，保留当前材料）\n", "\n", "**MAC 更少，会在当前设备上更快吗？** 先用两种 shape 的真实算子结果检验直觉，再让六个训练候选在不同成本目标下参加选择。\n", "\n", "| 课堂中可选一项 | 怎样做 | 留下一句什么解释 |\n", "|---|---|---|\n", "| 不运行，读图讨论 | 第 1 节内逐组比较 standard 与 dw+pw | 为什么同一种分解的延迟排序会翻转 |\n", "| 不重训，改选择规则 | 第 2 节保存表：只改允许的延迟上限 | 可行集为何改变；没有候选时怎么办 |\n", "| 在自己的副本重跑 | 顺序运行；计时或重训另行选择 | 新设备／新运行与保存结果哪些一致、哪些不同 |\n", "\n", "算子部分是 PyTorch CPU 微基准，随机权重用于计时与算术核对；候选部分是 sklearn digits 上的六个实际训练小网络。两者各回答一个问题，不能把算子微基准当成分类精度实验，也不把 CPU 结果称为手机实测。\n", "\n", "保存输出来自 2026-09-18。依赖为 `numpy torch scikit-learn matplotlib`，不需其他 Notebook 内存或下载 checkpoint。运行会写入 `outputs/LAB12-C`；这是历史实验路径，学生材料编号仍为 LAB10。" ], "id": "cell-000" }, { "cell_type": "markdown", "metadata": { "html_anchor": "cell-2" }, "source": "## 先读这次保存运行，再作预测\n\n同一台 CPU、同样的组内 shape：大组 depthwise＋pointwise 的中位数为 104.40 μs，标准卷积为 287.88 μs；小组则分别为 48.98 与 7.22 μs。**更少 MAC 在两种 shape 下没有给出同一种延迟关系。** 六个实际训练候选的验证—延迟表会继续检验：成本目标改变后，你还会选同一个模型吗？\n\n以上是教师保存的本地结果；重新计时会随设备和负载变化，以新输出为准。\n", "id": "saved-reference-findings" }, { "cell_type": "markdown", "metadata": { "html_anchor": "cell-3" }, "source": "## 1. 固定计时范围，再看账本\n\n每组 batch=1，NCHW float32，stride=1，same padding，无 bias；CPU 同步调用。固定 PyTorch 为 1 线程、eval、inference_mode；输入与权重创建排除，Python 调用、算子、输出分配包含。warmup 30 次，3 轮×200 次，轮间随机候选次序。记录每次延迟，报告 p10／p50／p90；共享主机环境不能被解释为独占设备性能。\n\n每次乘加记作 1 MAC。标准核参数为 $9MN$，分解为 $9M+MN$；MAC 再乘 $HW$。激活账本记录输入、输出及 depthwise 中间张量的 float32 字节，**不是峰值内存实测**。两类模块一般函数族不同；先构造可分解核来核对其计算关系。\n", "id": "cell-001" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-4" }, "source": "LAB_ID='LAB12-C'\n\nfrom pathlib import Path\nfrom copy import deepcopy\nimport csv, hashlib, json, platform, sys, time\nimport numpy as np\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\nimport sklearn\nfrom sklearn.datasets import load_digits\nfrom sklearn.model_selection import train_test_split\nimport matplotlib.pyplot as plt\nSEED = 20260918\nnp.random.seed(SEED); torch.manual_seed(SEED)\ntorch.set_num_threads(1)\ntorch.use_deterministic_algorithms(True)\nOUTPUT = Path('outputs') / LAB_ID\nOUTPUT.mkdir(parents=True, exist_ok=True)\nplt.rcParams.update({'figure.dpi':120, 'font.size':10, 'axes.spines.top':False, 'axes.spines.right':False})\ndef save_json(name, obj):\n (OUTPUT/name).write_text(json.dumps(obj,ensure_ascii=False,indent=2))\ndef save_csv(name, rows):\n with (OUTPUT/name).open('w',newline='') as f:\n w=csv.DictWriter(f, fieldnames=list(rows[0])); w.writeheader(); w.writerows(rows)\ndef digest_array(a): return hashlib.sha256(np.ascontiguousarray(a).tobytes()).hexdigest()\ndef print_table(rows, cols=None):\n cols=cols or list(rows[0]); print(' | '.join(cols)); print(' | '.join(['---']*len(cols)))\n for row in rows:\n print(' | '.join(f'{row[c]:.5f}' if isinstance(row[c],float) else str(row[c]) for c in cols))\ncpu_lines=Path('/proc/cpuinfo').read_text().splitlines() if Path('/proc/cpuinfo').exists() else []\ncpu_name=next((line.split(':',1)[1].strip() for line in cpu_lines if line.startswith('model name')),platform.processor())\nenvironment={'python':sys.version.split()[0],'torch':torch.__version__,'numpy':np.__version__,\n 'sklearn':sklearn.__version__,'cpu':cpu_name,'platform':platform.platform(),\n 'torch_threads':torch.get_num_threads(),'device':'cpu','dtype':'float32',\n 'seed':SEED,'exclusive_hardware':False}\nsave_json('environment.json',environment)\nprint(json.dumps(environment,ensure_ascii=False,indent=2))\n", "execution_count": 1, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "{\n \"python\": \"3.12.14\",\n \"torch\": \"2.14.0+cpu\",\n \"numpy\": \"2.3.5\",\n \"sklearn\": \"1.8.0\",\n \"cpu\": \"INTEL(R) XEON(R) PLATINUM 8573C\",\n \"platform\": \"Linux-6.18.44-x86_64-with-glibc2.39\",\n \"torch_threads\": 1,\n \"device\": \"cpu\",\n \"dtype\": \"float32\",\n \"seed\": 20260918,\n \"exclusive_hardware\": false\n}\n" } ], "id": "cell-002" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-5" }, "source": "WARMUP,REPEATS,ROUNDS=30,200,3\nrng=np.random.default_rng(SEED)\ndef modules_for(m,n):\n standard=nn.Conv2d(m,n,3,padding=1,bias=False).eval()\n decomposed=nn.Sequential(nn.Conv2d(m,m,3,padding=1,groups=m,bias=False),nn.Conv2d(m,n,1,bias=False)).eval()\n return {'standard':standard,'dw_pw':decomposed}\n# Exact constructed factorable kernel, not a claim about arbitrary standard kernels.\nsmall=modules_for(2,3); sx=torch.randn(1,2,4,4)\nwith torch.no_grad():\n dw,pw=small['dw_pw'][0].weight,small['dw_pw'][1].weight\n small['standard'].weight.copy_(pw[:,:,0,0][:,:,None,None]*dw[:,0][None,:,:,:])\n max_error=(small['standard'](sx)-small['dw_pw'](sx)).abs().max().item()\nassert max_error < 1e-5\nprint('Factorable-kernel numerical check; max absolute error =',max_error)\n\ndef benchmark_group(modules,x):\n samples={name:[] for name in modules}\n with torch.inference_mode():\n for module in modules.values():\n for _ in range(WARMUP): module(x)\n for run in range(ROUNDS):\n for name in rng.permutation(list(modules)):\n module=modules[name]\n for repeat in range(REPEATS):\n start=time.perf_counter_ns(); module(x); duration=time.perf_counter_ns()-start\n samples[name].append({'round':run,'repeat':repeat,'latency_us':duration/1000})\n return samples\noperator_rows=[]; raw_operator=[]\nfor case,m,n,h in [('large',32,64,32),('small',4,16,4)]:\n x=torch.randn(1,m,h,h); modules=modules_for(m,n); samples=benchmark_group(modules,x)\n for name,module in modules.items():\n values=[r['latency_us'] for r in samples[name]]\n params=sum(p.numel() for p in module.parameters())\n row={'case':case,'module':name,'input_shape':str(list(x.shape)),'output_shape':str([1,n,h,h]),\n 'params':params,'mac':params*h*h,'activation_ledger_bytes':4*h*h*(m+n+(m if name=='dw_pw' else 0)),\n 'p10_us':float(np.percentile(values,10)),'median_us':float(np.median(values)),'p90_us':float(np.percentile(values,90))}\n operator_rows.append(row)\n for r in samples[name]: raw_operator.append({'case':case,'module':name,**r})\nsave_csv('operator-costs.csv',operator_rows); save_csv('operator-timings.csv',raw_operator)\nsave_json('benchmark-protocol.json',{'warmup':WARMUP,'repetitions':REPEATS,'rounds':ROUNDS,'layout':'NCHW',\n 'scope':'Python call, operator and output allocation; inputs and weights precreated','synchronization':'CPU synchronous',\n 'activation_ledger':'input+output+depthwise intermediate, NOT peak-memory measurement'})\nprint_table(operator_rows,['case','module','params','mac','activation_ledger_bytes','median_us','p10_us','p90_us'])\n", "execution_count": 2, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "Factorable-kernel numerical check; max absolute error = 1.4901161193847656e-07\ncase | module | params | mac | activation_ledger_bytes | median_us | p10_us | p90_us\n--- | --- | --- | --- | --- | --- | --- | ---\nlarge | standard | 18432 | 18874368 | 393216 | 287.88050 | 262.55580 | 428.06910\nlarge | dw_pw | 2336 | 2392064 | 524288 | 104.39850 | 97.93900 | 207.23840\nsmall | standard | 576 | 9216 | 1280 | 7.21700 | 6.99890 | 7.79340\nsmall | dw_pw | 100 | 1600 | 1536 | 48.97550 | 47.31290 | 86.28150\n" } ], "id": "cell-003" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-6" }, "source": "fig,axs=plt.subplots(1,2,figsize=(10,3.4))\nfor ax,case in zip(axs,['large','small']):\n vals=[[r['latency_us'] for r in raw_operator if r['case']==case and r['module']==name] for name in ['standard','dw_pw']]\n ax.boxplot(vals,tick_labels=['standard','depthwise +\\npointwise'],showfliers=False)\n ax.set(ylabel='CPU latency (microseconds)',title=case+' shape; 600 measured calls each')\nfig.suptitle('Less arithmetic need not imply less elapsed time',fontsize=12)\nfig.tight_layout(); fig.savefig(OUTPUT/'operator-latencies.png'); plt.show()\nfor case in ['large','small']:\n a,b=[r for r in operator_rows if r['case']==case]\n print(case,': MAC ratio DW/PW / standard =',round(b['mac']/a['mac'],3),\n '; measured median ratio =',round(b['median_us']/a['median_us'],3))\n", "execution_count": 3, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "large : MAC ratio DW/PW / standard = 0.127 ; measured median ratio = 0.363\nsmall : MAC ratio DW/PW / standard = 0.174 ; measured median ratio = 6.786\n" }, { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABKMAAAGVCAYAAAAi4TIGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAASdAAAEnQB3mYfeAAAoYNJREFUeJzs3XdYFNf7NvB76SBdQBEpChYEFbuxYO8RiUKwREWNaIyiqIkl9qix9y/RmIiJxhYbaqLYsfcKahAQFUVRKYoKUs77h+/uj3UXZNkFDNyf6/JKmHNm5pnZ2dlnn505IxFCCBARERERERERERUDrZIOgIiIiIiIiIiIyg4Wo4iIiIiIiIiIqNiwGEVERERERERERMWGxSgiIiIiIiIiIio2LEYREREREREREVGxYTGKiIiIiIiIiIiKDYtRRERERERERERUbFiMIiIiIiIiIiKiYsNiFBERERERERERFRsWo4iIiIiIiIiIqNiwGEVERERERERERMWGxSgiIvokxMXFQSKRwN/fX6X5WrduDYlEUjRBlYDC7ofSasaMGZBIJDh+/HhJh6K29evXQyKRYP369SUdipyi3sel7T2qzKf62hYlTb+uEokErVu31tjyiIjo08ZiFBFRMZNIJKX+i5km+fv7QyKRIC4urqRD0Rh+6fpvK43HJFFRc3JygpOTU0mHQUREnwidkg6AiIgIAOzs7HD79m2YmZmVdCglivuh9Priiy/QtGlT2NralnQoRJ+c27dvw8jIqKTDICKiYsJiFBERfRJ0dXVRs2bNkg6jxHE/lF5mZmYsMhLlgec9IqKyhbfpERF94jZv3ow2bdrA3NwcBgYGcHV1xezZs5GRkaHQ9+TJk+jevTsqV64MfX19VKxYEU2bNsXMmTPl+j19+hTjx49HjRo1UK5cOZibm6NGjRrw9/dHbGxsgeI6duwYAgICUKtWLZiamsLQ0BDu7u6YOXMm0tPTFfrnHpdm06ZNaNKkCYyNjWW3bSgbK0kikeD3338HAFSpUkV2i6OyWz2ysrIwd+5cVKtWDfr6+rC3t8eECRPw7t07hb7S2+SePn2KwYMHo0KFCihXrhyaNWuGkydPAgBev36N7777Do6OjtDX14ebmxv++uuvPPdHQV4n6bgyABAeHi7bHolEghkzZuS5H6TevHmD+fPno2HDhjAxMYGxsTFcXV0RGBiIp0+f5hmb1PHjx2XrunbtGrp16wZzc3MYGRmhVatWOHPmjNL5srKyEBwcjKZNm8LU1BRGRkaoV68eVq1ahZycHKXznD9/Hj4+PqhYsSL09PRgb2+PYcOG4fHjx0r7X758GZ07d4aJiQlMTU3Rvn17nD179qPb9KHct9CtWbMGtWvXhoGBASpUqICAgACkpqbmuf5evXrBxsYG+vr6cHR0xIgRI5CQkCDXT5Vj8kN5jSskvX0pLS0NQUFBsLe3h6GhITw8PLB7924A71+DOXPmoFq1ajAwMICzszNWrVqlsI7cr/HZs2fRvn17mJmZwcTEBJ06dcKlS5c+GmdycjKMjIzg7OwMIYTSPt27d4dEIinQ8vITFhaGrl27wsrKCvr6+nB2dsZ3332HlJQUhb43btxAnz594OTkBH19fVhbW6N+/foYM2YMMjMzZf1evXqFH3/8Ee7u7jA1NYWJiQmcnZ3h5+eHy5cvFzi2pKQkTJo0Ca6urjA0NISZmRnatWuHgwcPFngZ6pwnf//9d9SrVw+GhoawsbHB4MGD8eTJE4V5YmNjERAQABcXFxgaGsLS0hK1a9fG8OHD8eLFC4X+qnymAMCWLVvQoEEDWRz9+/fP832sjPSYvH//Pu7fvy933vvwfP/h7cu598fmzZvRoEEDGBkZoVKlShg7dqws5qNHj6J169YwNTWFhYUF+vfvr3TbASA+Ph4jR45E1apVoa+vj/Lly8PLywsXL14s8DYREZH6eGUUEdEnbPDgwQgJCUHlypXRq1cvmJub49y5c5g6dSqOHDmCQ4cOQUfn/an8wIED6NatG0xNTeHl5QU7OzskJSXh9u3bCA4OxvTp0wG8L2g0b94cMTEx6NChA7p37w4hBO7fv4/Q0FD4+PigatWqH41t/vz5uHPnDpo1a4Zu3bohPT0dp0+fxowZM3D8+HEcPnwY2traCvMtXrwYhw4dQvfu3dGmTZs8iwMAMH36dOzevRvXr1/H6NGjYW5uDgCy/+bWt29fnDx5El26dIGpqSn++ecfLFiwAImJiQgJCVHon5KSgubNm8PExAR9+vRBUlIStmzZgk6dOuHs2bMYNmwYkpKS8PnnnyMzMxObN2+Gn58f7O3t0bRp00K9Th4eHpg+fTpmzpwJR0dHuS9iHxtDKjk5GW3atMH169dRo0YNDB48GHp6eoiJiUFISAh69uyJChUq5LsMqUuXLmHBggX47LPP8PXXX+PBgwfYsWMH2rVrh2vXrqFGjRqyvpmZmejevTvCwsJQo0YN9O3bFwYGBjh27BhGjRqF8+fPY8OGDXLLX7duHQICAqCvrw8vLy/Y29vj7t27+PXXX7F3716cO3cODg4Osv5nzpxB+/bt8e7dO/Ts2RMuLi64du0aWrdujbZt2xZomz70/fffIywsDN27d0fHjh1x7NgxrF27FtHR0Th69Khc33379qFXr14QQsDHxweOjo64fPkyfv75Z4SGhuLUqVOoUqUKANWOSVVkZmaiQ4cOSEpKQo8ePfDu3Tts3rwZvXr1wsGDBxEcHIzz58+jS5cu0NfXx19//YVRo0bB2toafn5+Css7f/48fvrpJ7Rv3x7ffvstoqOjsXPnTpw4cQIHDx5Ey5Yt84zFwsICvXv3RkhICA4fPowOHTrItT98+BD79+9HgwYN0LBhw0Jv88yZMzFjxgxYWlri888/h42NDW7cuIFFixbhn3/+wdmzZ2FqagrgfSGqSZMmkEgk8PLyQpUqVfDy5UtER0cjODgYs2fPhq6uLoQQ6Ny5M86cOSM7vnV0dBAfH49jx46hZcuWaNCgwUdju3//Plq3bo24uDi0bNkSnTt3xuvXr7Fv3z507twZa9aswdChQz+6nMKeJ5cuXYqDBw/Cz88PnTt3xqlTpxASEoLjx4/j/PnzsLa2BgAkJCSgUaNGePnyJbp27YpevXohPT0d9+7dw4YNGzBy5EiUL19etlxVPlOkcYwdOxbm5uYYMGAAzM3NERYWhmbNmhX4Kj8nJydMnz4dy5YtAwCMGTNG1ubh4VGgZaxcuRL79++Ht7c3WrdujYMHD2Lp0qWy90vv3r3RrVs3BAQE4MyZM9i4cSOeP3+O/fv3yy3nypUr6NixI5KSktCpUyf07NkTz58/x+7du9GiRQvs2rULXbt2LVBMRESkJkFERMUKgCjI6TckJEQAEF988YV48+aNXNv06dMFALFs2TLZtJ49ewoA4tq1awrLevbsmez/9+zZIwCIMWPGKPTLyMgQL1++LNB2xMTEiJycHIXpU6ZMEQDEli1blMZsZGQkrly5ojDfvXv3BAAxcOBAuekDBw4UAMS9e/eUxtGqVSsBQNSvX1+8ePFCNj0tLU04OzsLLS0tkZCQIDeP9DUYNmyYyM7Olk3/448/BABhYWEhPv/8c/H27VtZ24kTJwQA4e3tLbcsVV8n6fpbtWqldHvy2g99+vQRAMTw4cPlYhZCiFevXomUlBSly8vt2LFjsm0PCQmRa1u9erUAIL755hul2zBy5EiRlZUlm56VlSUGDx4sAIjdu3fLpv/7779CV1dXODs7i/j4eLllHT58WGhpacntw5ycHFGjRg2F5QghxLJly2TxHjt27KPbJ8T/HS/29vbi/v37sumZmZmiZcuWAoA4f/68bPqrV6+EpaWl0NLSEidOnJBb1rx58wQA0aFDB6XryOuYzIv0WPlw3zs6OgoA4vPPPxfp6emy6dJjzsLCQjRs2FAkJyfL2mJiYoSurq7w8PCQW1bu13jlypVybbt37xYAhIuLi9wxJH2Nc+/jixcvCgCiV69eCtsh7f/LL78UaLul79Hcjh49KgCIzz77TG67hPi//ZT7HDV27Filx4gQQiQlJcm258aNG0rfp0IIkZ2dLZKSkgocs0QiEZs3b5abnpycLOrWrSsMDAzEkydPFGL+8LUt7HlSV1dX4Tw5ZswYAUAMHjxYNm3FihVKzzFCvD8H5j4nqXquunfvntDV1RUWFhZyx3p2drbs80aVrxKOjo7C0dExz3Zl50VpXKampuLWrVuy6enp6aJWrVpCS0tLWFpaiuPHj8vF1759ewFAXL16VTY9MzNTODs7C319fbn+Qgjx6NEjUalSJVGxYkW59yARERUdFqOIiIpZQRN4Dw8PoaOjo/BFTYj3hYDy5cuLRo0ayaZJvxz8+++/+S5XWoyaNGmSyrEXxIsXLwQAMWjQILnp0i8VyopgQqhfjDp06JBC27Rp0wQAsXfvXrnp0qLYh4W3rKwsoaOjIwCImJgYheU5OTkJJycnuWmqvk7S9atSjHr69KnQ0tIStra2Ii0tTel8BSEtVDRv3lyh7d27d0JHR0c0aNBANi07O1tYWlqKihUriszMTIV5kpOThUQiEb6+vrJp0i/M+/btUxqDt7e30NbWlu37U6dOCQDC09NToW9WVpZwdnYuVDFq7dq1Cm3r1q1TKNJs3LhRABB9+vRR6J+ZmSmcnJwEALnCVlEVo6KjoxXmqVKligAgjhw5otDWunVroaOjI1cklL7GHxacpKTvl9xfxpUVo4QQomHDhkJHR0eumJuVlSUqV64sTExMxKtXrwq03cqKUd7e3gKAiIiIUDqPh4eHsLa2lv0tLUaFhYXluy5pMUrZ61lQ165dEwCEj4+P0nZpUe9///ufbFper21ePnaezF1wkkpJSRFmZmbCwMBAVjCRFqPWrFnz0XWqeq6aPXu2ACCmTZum0D8mJkZoaWkVWzFqypQpCv1nzpwpAIj+/fsrtK1fv14AEOvXr5dNk75u48ePV7p+afH777//LtgGERGRWnibHhHRJ+jNmze4fv06rKysZLc2fEhfXx+3b9+W/d2vXz/s3LkTTZo0gZ+fH9q0aYPmzZujcuXKcvO1atUKdnZ2mDdvHq5cuYKuXbuiefPm8PDwUHq7SF5ev36N5cuXY9euXYiKisKrV6/kxpd59OiR0vkaN25c4HWoQtntQvb29gDe3+L2oerVq8PExERumra2NipUqIDXr18rvVXRzs4O58+fl/1dmNepMC5evIicnBx4enqiXLlyai0LUL6vdHV1UaFCBbl9FRUVhaSkJFSrVg2zZ89WuixDQ0O57ZOO8xQeHq50DJbExERkZ2cjKioKDRo0wJUrVwC8Py4/pK2tjRYtWiAmJka1DUTBjwfp+pXdDqijowNPT0/ExcXh6tWrcrcWapq5uTmcnZ0VpleqVAn37t1TemuZnZ0dsrKy8OTJE9jZ2cm1tWzZElpaikODtm7dGuHh4bh69arSfZ7biBEjMHjwYKxbtw6TJ08GAPzzzz+Ij4/HN998A2NjY1U2Uc7Zs2ehq6uLv/76S+lYbO/evcOzZ8/w4sULlC9fHn5+fli+fDm8vb3h4+OD9u3bo3nz5gr7rFatWvDw8MDmzZtx//599OjRAy1atEDDhg2hp6dX4NgAIDU1VTaWW27Pnj0DgAK9rwt7nlT22piZmcHDwwPh4eG4ffs2PDw84OXlhcmTJ+Pbb79FWFgYOnXqhObNm6NWrVqy8emAwp2r8ntvVq1aFfb29rh///5H94EmKHs/V6pUCQDyfG8A78eHkpK+rvfv31f6ut69exfA+9eVt+oRERU9FqOIiD5BycnJEELg2bNnCoOP56Vnz57Yt28fFi9ejHXr1mHNmjUA3ifqP/30k2zcF1NTU5w7dw7Tp0/Hnj17EBYWBgCwsrLCiBEjMGXKFOjq6ua7rszMTLRt2xYXLlyAu7s7/Pz8YG1tLZtv5syZeQ6GW7FixQJtj6qUjdkjHfskOztboS2v8U50dHTybcvKypL9XZjXqTCkgzl/WHAorLzGN9LR0ZHbV9IBgO/evZvv9qWlpSnMs3DhwnxjkM4jHTMsr/GuCnu8FPR4kK7f1tZW6XKk05UNqK1J+R1zebVL23IP3i31sf2Z31htUr1798a4ceOwdu1aTJw4EVpaWvjll18AAMOGDfvo/Pl58eIFsrKyPvq+SUtLQ/ny5dG4cWOcPHkSc+bMwfbt22XjlNWoUQPTp09Hnz59ALwvYB49ehSzZs3C9u3bMWHCBACAiYkJBg4ciJ9++umjRTTpMXzo0CEcOnQo39jyo855sqCvn6OjIy5cuIAZM2bgwIED2LlzJ4D3hdfx48cjMDAQQOHOVQV5bxZXMSq/47+g7w3p65rfgyiAj7+uRESkGSxGERF9gqTJdb169WS/ThdEt27d0K1bN7x+/Rrnz5/Hvn378PPPP+Pzzz/H1atXUatWLQBA5cqV8dtvv0EIgVu3buHo0aP43//+h1mzZiEnJwc//vhjvusJDQ3FhQsX4O/vrzA4eEJCQr5fdnL/Wv9fV9jXSVXSwkpeV1EUFen2ffHFF7IvuQWdJzU1VTb4dEH65/U0QGVPD9Mk6frzWo/0aXoFHaz5U/Gx/VmQ7TE0NIS/v79sMG03Nzfs378fTZo0Qd26ddWKz8zMDDk5OUhKSirwPJ999hn27duHjIwMXL58GQcOHMDKlSvRt29fWFtbo3379gDeD8C+dOlSLF26FNHR0QgPD8eaNWuwatUqpKSkKAy4ryw2AFi+fLmsmFMY6pwnVXn9XF1dsXXrVmRlZeH69es4fPgwVq5cidGjR6NcuXIYMmRIoc5Vud+bbm5uecbyXyHdntDQUHh5eZVwNEREpHj9NhERlThjY2O4ubkhMjJSpS9rUuXKlUPbtm2xZMkSTJ48Ge/evVN4qhDwvjDk5uaGUaNGya4AkD5KPj/R0dEA3l+N9aHw8HCV482P9NZBZVc3lbTCvk5aWloqbU/jxo2hpaWFEydO4PXr14UJtVBq1qwpe9qWsqtvlJE+afDkyZMF6l+/fn0Ayo+b7OxsnDp1qoDRFk69evUAvH/8/IeysrJk2yGNE/i0j0mpU6dOIScnR2G6dDul2/0x33zzDSQSCdasWYPffvsN2dnZal8VBbw/TpKTkxEZGanyvPr6+mjWrBlmzZqFFStWAHhfYFDGxcUFQ4YMQXh4OIyNjfPs92FsQMGP4byoc55U1p6amopr167BwMAArq6uCu06Ojpo0KABJkyYgM2bNwP4v/N5Yc5V+b03Y2Nj8fDhwwItR0pbW7tE3zOael2JiEgzWIwiIvpEjR07Fu/evcPgwYOV3iKUnJws9wv3iRMn5G4hk5L+wm5kZAQAiIyMVPqr+4f98uPk5ARA8Qt8bGys7LYYTZE+lvzBgwcaXa6mqPo6Ae+3SZUvctbW1ujduzcSEhIwfvx4hSJDWlpagW67UpWOjg5GjRqFhIQEBAYG4u3btwp9EhIScOvWLdnfI0eOhK6uLoKCghAVFaXQ/927d3JfBps1a4YaNWrgxIkTCoWCVatWFWq8KFV4e3vD0tISmzdvxrlz5+Tali1bhnv37qF9+/Zy40V96sck8P7WyuDgYLlpoaGhCA8Ph4uLC1q2bFmg5VSrVg3t2rXDvn37sHr1apibm6N3795qxxcUFAQAGDp0KB4/fqzQ/vr1a7nX48yZM0qPvw/PW/fu3UNsbKxCv+TkZGRkZMDQ0PCjsTVs2BAtW7bEzp07sW7dOqV9bt68icTExHyXo855csOGDbh69arctBkzZiA1NRV9+vSBvr4+AODy5ctK3/vKzueqnqv69esHXV1drFy5EnFxcbLpOTk5+O6775QWO/NTvnx5PHv2TOnrWBx69OgBZ2dn/O9//8M///yjtM/Zs2fx5s2bYo6MiKhs4m16REQlxN/fP8+24OBgDB48GJcvX0ZwcDCcnZ3RqVMnODg4ICkpCffu3cOJEycwaNAgrF69GgAQGBiIR48eoXnz5nBycoKenh4uX76Mo0ePwtHRUfYF8tChQ/juu+/w2WefoXr16rCxsUF8fDxCQ0OhpaWF77777qOxd+/eHS4uLliyZAlu3ryJevXq4cGDB9i3bx+6deum0S/p7dq1w8KFCzF06FD06tULJiYmMDc3x8iRIzW2DnWo+joB77dpy5Yt6N69O+rXrw9dXV14enrC09Mzz/WsWrUKERERWL16NY4fP45OnTpBT08P9+7dQ1hYGPbs2YPWrVtrfPumTp2K69evY/Xq1di7dy/atm0LOzs7JCYm4u7duzh9+jTmzJkjuwW0Zs2aWLduHQYPHgw3Nzd07twZ1atXR2ZmJh48eICTJ0/C2toad+7cAfD+6rzffvsNHTp0QK9evdCzZ0+4uLjg2rVrOHLkCDp37owDBw5ofLukjI2NsW7dOvj6+qJVq1bw9fWFg4MDLl++jIMHD6JixYqy8dekPvVjEgA6d+6McePGYf/+/ahbty6io6Oxc+dOGBgYYN26dUoHN8/LiBEjcPjwYTx9+hSjRo0qUEHnY9q1a4d58+Zh0qRJqFatGrp27YoqVaogLS0N9+/fR3h4OFq0aCF77RcsWICjR4+iZcuWqFKlCoyNjREZGYn9+/fDwsICAQEBAIDr16+jZ8+eaNSoEVxdXVGpUiU8e/YMoaGhyMzMLHCxfNOmTWjbti2GDBmCFStWoEmTJjA3N0d8fDxu3LiBiIgInD17FjY2NnkuQ53zZJcuXdC8eXN8+eWXsLW1xalTp3Dq1Ck4OTlh3rx5sn4bNmzAmjVr0KJFCzg7O8PCwgIxMTHYu3cv9PX1MWbMGFlfVc9V0nWNGzcO9erVg5+fH8zMzBAWFoaUlBTUqVMHN27cKND+BN6/5hcvXkTnzp3h6ekJfX191K1bF927dy/wMtShq6uLnTt3olOnTujWrRuaNWsGDw8PGBkZ4eHDh7h48SJiY2ORkJBQoB9liIhITSX5KD8iorIIwEf/5X709t69e0W3bt2EtbW10NXVFRUqVBCNGjUSP/zwg7h9+7as39atW0Xv3r2Fi4uLKFeunDAxMRFubm5i8uTJIjExUdbv1q1bIigoSDRo0EBYWVkJPT094ejoKHr16iVOnz5d4O148OCB6Nu3r6hUqZIwMDAQtWrVEvPnzxeZmZn5PqL7w8fHS927d08AEAMHDlRoW7x4sahZs6bQ09MTAOQeD67ssfFSeT1uXVl8Uvk9fjy/dRX0dRJCiKdPn4o+ffoIGxsb2ePRp0+fLoTIfz+kpaWJ2bNni9q1awtDQ0NhbGwsXF1dxejRo8XTp0+VxpXbsWPH5NZV0G3PyckRf/zxh2jbtq2wsLAQurq6olKlSqJ58+Zizpw54sGDBwrz3LhxQwwcOFA4ODgIPT09YWFhIdzc3ERAQIA4cuSIQv9Lly6JTp06CWNjY2FsbCzatWsnzpw589Hj5kMDBw4UAMS9e/dU2v4LFy4Ib29vYWVlJXR1dYW9vb0YPny4ePTokdL15HdM5iWv47Gwx5yybc29jWfOnBHt2rUTJiYmwtjYWHTo0EFcuHBBYTkf28dZWVnCyspKABAREREf3U5VtuHkyZPC19dX2NraCl1dXWFlZSXq1q0rgoKCxMWLF2X9wsLChL+/v3B1dRWmpqbCyMhIVK9eXYwaNUrExcXJ+j18+FBMmjRJNGvWTFSoUEHo6ekJOzs70blzZ/HPP/+oFPfLly/FnDlzRP369UW5cuWEgYGBcHJyEl27dhVr1qwRaWlpsr55vbbqnCdDQkJE3bp1hYGBgbCyshL+/v7i8ePHcv3PnTsnhg8fLurUqSMsLCyEgYGBcHZ2Fv7+/uLmzZtKt0uVc5UQQmzatEnUq1dP6OvrCysrK9GvXz/x6NGjfF9XZdLS0sTw4cOFnZ2d0NbWVjjPqfq5kdc+FyL/9/rTp0/FhAkThJubmzA0NBTlypUTLi4uolevXmLDhg0iMzOzwNtERESFJxEi1/NliYiIiOg/6/jx42jTpg2mT5+u9PH1hREbGwsXFxc0b96c4+0UsRkzZmDmzJk4duxYkVzpSERE9KngmFFERERElKdFixZBCPFJ3YZIRERE/20cM4qIiIiI5Dx48ACbNm3C3bt3ERISgrp168LX17ekwyIiIqJSgsUoIiIiIpITGxuLSZMmwcjICB06dMDPP/+s0qDnRERERPnhmFFERERERERERFRs+BMXEREREREREREVGxajiIiIiIiIiIio2LAYRURERERERERExYbFKCIiIiIiIiIiKjYsRhERERERERERUbFhMYqIiIiIiIiIiIoNi1FERERERERERFRsWIwiIiIiIiIiIqJiw2IUEREREREREREVGxajiIiIiIiIiIio2LAYRURERERERERExYbFKCIiIiIiIiIiKjYsRhERERERERERUbFhMYqIiIiIiIiIiIoNi1FERERERERERFRsWIwiIiIiIiIiIqJiw2IUEREREREREREVGxajiIiIiIiIiIio2LAYRURERERERERExYbFKCIiIiIiIiIiKjYsRhERERERERERUbFhMYqIiIiIiIiIiIoNi1FERERERERERFRsWIwiIiIiIiIiIqJiw2IUEREREREREREVGxajiIiIiIiIiIio2LAYRURERERERERExYbFKFJbXFwcJBIJ/P39SzqUT8L69eshkUiwfv36kg6F6JP2qZ07nJyc4OTkJDetrLyfy8p2EpFyrVu3hkQikZt2/PhxSCQSzJgxQ+Prk0gkaN26tcaXS1TaKHtvlpQZM2ZAIpHg+PHjctPLyvu5rGxncWIxioiKxJUrV9C3b19UrlwZ+vr6qFChAlq1aoU//vhDaf9bt27hyy+/hI2NDQwMDFCjRg1Mnz4db9++zXMdZ86cQdeuXWFpaQlDQ0PUqVMHy5YtQ3Z2dlFtFhEREZHaUlNTMW3aNNSpUwfGxsYwNTWFu7s7hg0bhszMTIX+b9++xfTp01GjRg0YGBjAxsYGX375JW7fvp3nOpKSkjBmzBg4OTlBX18flSpVwuDBgxEfH1+Um0ZEVCA6JR0AEZU+q1atwujRo2FhYYFu3brBzs4OSUlJiIiIwD///IMBAwbI9T9//jzatm2LzMxM+Pj4wN7eHkePHsWsWbNw5MgRHDlyBPr6+nLzhIaGolevXjAwMICfnx8sLS2xd+9eBAUF4fTp0/jrr7+Kc5OJiIiICuTOnTvo2LEjHj16hPbt26NLly7IzMxEXFwctm3bhsWLF0NXV1fWPyMjAx06dMDp06fRsGFDjB49Gg8fPsRff/2Fv//+G0ePHkWTJk3k1vHixQs0a9YMUVFRaNu2LXr37o07d+4gJCQEf//9N86ePYuqVasW96YTEcmwGEVEGnXw4EEEBgaiQ4cO2L59O0xMTOTaP/y1Lzs7G4MGDcKbN28QGhoKLy8vAEBOTg6+/PJL7NixA0uXLsXEiRNl87x8+RJDhw6FtrY2jh8/joYNGwIAfvzxR7Rt2xbbt2/Hli1b0Lt37yLeWiIiIqKCe/PmDby8vPDq1SucPn0aTZs2lWvPysqCtra23LQlS5bg9OnT8PHxwdatW6Gl9f7mFj8/P3h7e2Pw4MG4efOmbDoATJ48GVFRURg7diwWL14sm75ixQqMHj0aI0aMwIEDB4pwS4mI8sfb9KjIREVFYeLEiWjYsCGsra2hr68PR0dHBAQEKL08OPfYBBcuXEC3bt1gaWkJiUSCuLg4AO9/GZoxYwaqVq0KfX19VKlSBVOmTEFGRkae9/FmZWUhODgYTZs2hampKYyMjFCvXj2sWrUKOTk5Bd6e2NhYBAQEwMXFBYaGhrC0tETt2rUxfPhwvHjxQuk8x44dQ+vWrWFiYgJTU1N069ZN6eXU6uyrs2fPon379jAzM4OJiQk6deqES5cuKY1H1X2RkJCAO3fuIDU1tcD76bvvvoOhoSE2bdqkUIgCIPdLHwCEh4fj9u3b8PT0lBWiAEBLSwsLFiwAAKxevRpCCFnb9u3b8ezZM/Tu3VtWiAIAAwMDzJ49GwDw888/Fyje3OMWxcTEwMfHB+XLl4eJiQk6duyIiIgIAMCzZ88QEBAAW1tbGBgYoFGjRjh27JjSZaq6n9evX49evXqhatWqMDQ0hKmpKZo3b46NGzcqXX5Bj8W87u3/cLtz8/f3h0QiQWxsLFauXIk6derA0NBQ7r2VlJSESZMmwdXVFYaGhjAzM0O7du1w8OBBpfG+evUKY8eOReXKlWFgYICaNWtiyZIlKr3/cjt48CC6d+8OGxsb6Ovrw97eHj169MDhw4dlfd69e4dVq1aha9eucHR0hL6+PiwtLdG+fXvs37+/UOvN7caNG+jTp4/s1gdra2vUr18fY8aMUXp7RV7Onz8PHx8fVKxYEXp6erC3t8ewYcPw+PFjhb6XL1/G6NGjUbduXVhaWsLAwADVqlXDuHHjkJycnOc6tm7dinbt2snmcXJyQp8+ffI8TxT0vEVEH7dnzx60a9cOtra2stukWrVqheDgYLl+0nFhMjMzMWvWLDg7O8tuWV+7dq2s3+rVq1G7dm0YGhqicuXKmD59ukY+VzTh3bt3WLFiBerXrw8LCwsYGRnByclJ4fyc2/Pnz2Wfrfr6+nBzc0NISIjSZat6TpeOA5iamoqRI0fCzs4OBgYGqFWrFlasWCGXV+Smynn5zZs3uHPnDh48eFDg/bR69WrcvXsXP/30k0IhCgB0dHTkxggSQmD16tUAgAULFsgVnHr06IGWLVvi1q1bCA8Pl01PS0vDhg0bUK5cOYUxv0aOHAlHR0eEhYUhNja2QDFr+vgEivbzr6DH4sfGrvzYWGp5fV8BgM2bN6NNmzYwNzeHgYEBXF1dMXv2bGRkZChd15YtW9CgQQMYGhrCxsYG/fv3V7ovCiI+Ph6BgYGoVq2aLE9s3LgxfvzxR7l+x44dQ0BAAGrVqgVTU1MYGhrC3d0dM2fORHp6eqHWLfXq1Sv8+OOPcHd3h6mpKUxMTODs7Aw/Pz9cvny5wMtRJedMTU3FwoUL0bZtW1SuXBl6enqwtraGl5cXzp49m+c67ty5g8GDB8tyOhsbG7Rs2TLP7xIFPW9RAQgiNd27d08AEAMHDpSb/tNPPwkzMzPh7e0tRo0aJcaNGyc6d+4sJBKJqFixooiPj5frf+zYMQFAdOzYUejp6Ym2bduKcePGiYEDB4pHjx6JnJwc0a1bNwFAVKtWTYwdO1aMGjVK2NnZCW9vbwFAtGrVSm6Z7969E506dRIARI0aNcSwYcPE6NGjRZ06dQQA8dVXXxVoGx8/fiwsLS2Fjo6O8PLyEt9//70IDAwU3bt3F0ZGRuLmzZuyviEhIQKA6NWrl9DR0RHdu3cX48ePF127dhUAhLW1tXj27JlG9lXnzp2Fnp6e6Nq1q5g0aZLw9fUV2trawsDAQJw4cULtfTFw4EABQISEhBRoP928eVMAEN7e3iInJ0ccPXpULFy4UCxatEgcPnxYZGdnK8zzww8/CABi7ty5SpdZvXp1AUBER0fLpvXr108AEJs2bVLon5mZKYyMjISOjo5IT0//aMzS47dVq1aifPnyokWLFmLs2LGiZ8+eQiKRiPLly4uoqChRtWpV4eHhIUaPHi369+8vdHV1hb6+vrh//77c8gqznw0MDESDBg3EwIEDxcSJE8XQoUOFnZ2dACCmTJki11eVY3H69OkCgDh27Fie2/3h+1b6mn/++efCzMxM9O3bV0yYMEFMnjxZCCFEXFyccHJyEgBEy5YtxZgxY8TQoUOFra2tkEgk4pdffpFbXnp6umjUqJEAIOrWrSu+//57ERAQIMzNzYWXl5fSGPIzbdo0AUAYGxuLr776SkyaNEkMHDhQVKtWTW45CQkJQktLS7Ro0UIMGTJETJw4UQwcOFBYWloKAGLt2rUKy3Z0dBSOjo5y06Tv59zvgevXrwsDAwNhaGgo/Pz8xMSJE8WIESNEx44dha6urnj16lWBtuW3334T2trawsjISPTu3Vt89913wtvbW2hpaQlbW1uFY2vYsGHCxsZG+Pr6irFjx4oxY8aIli1bCgDC1dVVvHz5Uq5/Tk6O7PW0srKS7YevvvpK2NnZienTpytspyrnLSLK35o1awQAUbFiRTF06FAxadIkMWTIENGoUSPRsGFDub6tWrUSAETPnj2FnZ2dGDp0qBgxYoSwsbGRnYOCgoKEpaWlGDBggBg9erSoUqWKACDmzZunsG5VPldyrz83aa6R+1yRnz59+ggAwt3dXQQGBooJEyaI/v37iypVqohx48bJ9ZV+JlSvXl24u7uLkSNHiqFDhwpzc3MBQKxfv16uf2HP6ba2tqJhw4bCxcVFjB07VowcOVLY2toKAGLEiBEK86h6Xpbuow/zz/w0aNBASCQSkZycLO7duyeCg4PF3LlzxcaNG8Xz588V+t+9e1cAENWrV1e6vLlz5yq8rocOHZLl1MoEBAQIAOLXX38tUMyaPj6L+vOvoMdiXrnQh9ud28e+rwghxKBBgwQAUblyZTF48GAxduxY0axZMwFAtG7dWmRmZsotc8mSJQKAMDc3FwEBAeL7778XdevWFY6OjrL8saAuXrwoe194enqK77//XowcOVK0bdtWaGlpyfXt1KmTcHR0FH369BHjx48XI0eOFPXq1ZPFmZWVJdc/r7zyw/dATk6ObHs/++wzERQUJL777jvRp08fUbFiRbFy5coCbYuqOefZs2eFrq6uaNeunQgICBATJkwQffr0EeXKlRM6Ojpi//79CuvYt2+fMDQ0FFpaWqJr165i4sSJYvjw4eKzzz4TTk5OCtupynmLPo7FKFJbXify+Ph4pcWAsLAwoaWlJYYPHy43XXpyByBWr16tMN8ff/whOxllZGTIpicnJ4saNWooTQakJ82RI0fKnVCzsrLE4MGDBQCxe/fuj27jihUrBACxbNkyhba0tDTx5s0b2d/SL3Xa2tri8OHDcn0nTpwoAIj58+fLTVdnX314Qt+9e7cAIFxcXOSKP4XZF6oWo9atWycAiICAAOHp6SmLUfqvdu3a4u7du3Lz+Pj4CABi+/btSpcpLUD+888/smkNGzYUAMSlS5eUzuPm5iYAiFu3bn00ZunxC0DMnj1brm3WrFkCgLCwsBDDhg2T25/S43HMmDFy8xRmP+cutEllZGSItm3bCh0dHblipCrHojrFqEqVKonY2FiF+Vq1aiUkEonYvHmz3PTk5GRRt25dYWBgIJ48eSKbPmfOHFkCm3v/xcbGCgsLC5WKUWFhYQKAqFKlikKBVgghHj58KPv/9PR0ub+lUlJShJubm7CwsJDbV0IUvBg1duzYPM8dSUlJSouuH/r333+Frq6ucHZ2VtiWw4cPCy0tLeHt7S03PS4uTiExFEKIX3/9VWnCL/0i3KhRI5GSkiLXlpWVJR4/fqywnaqct4gof/Xr1xd6enri6dOnCm0fFnelX3obNmwokpOTZdNjYmKErq6uMDc3F05OTnLni+TkZFG+fHlhZWWl8OVWlc+V3OvPTZViVEpKipBIJKJBgwZKz1MfFlmkn7tDhgyR6x8ZGSm0tbWFq6urXP/CntMBiObNm8vlWC9evBBVq1YVAER4eLhsemHOy6oWo969eyd0dHSEjY2NWLBggdDR0ZHLk8qVKyd+++03uXn27dsn+5FImb/++ksAEF9++aVs2qpVq2S5iDILFy4UAMT3339foLg1eXwW9eefKseiOsWovL6vSD9Pv/jiC4VjUpqX5c7h7t27J3R1dYWFhYW4d++ebHp2drbo2bOnbF0FkZGRISve/PnnnwrtH76HYmJiRE5OjkK/KVOmCABiy5YtSuP/WDHqxo0bAoDC6yjdrqSkpAJtj6o5Z0pKitIfzh4+fChsbW1FzZo15aY/e/ZMmJqaCl1dXXH8+HGl8324naqct+jjWIwitX3sRK5M7dq1RZUqVeSmSU/uHh4eSudp166dQuIgtXHjRoUTYXZ2trC0tBQVK1ZUSNKEeH8ik0gkwtfX96PxSgsAa9as+Whf6YdQv379FNpiY2NlVx8UVH776sOCk5T0w1N6YtXkvsjPvHnzZF9oHRwcxN9//y1SU1NFVFSU+Oqrr2S/7OUuJnbo0EEAEIcOHVK6zL59+wpA/iqoatWqCQAKhS0p6a8xZ86c+WjM0uPXyclJIWm5f/++ACCMjIwUfnXLysoSOjo6onXr1rJpmt7PO3bsEADE77//LpumyrGoTjFKWbHr2rVrAoDw8fFRuj5pIfR///ufbJqLi4vQ0tJS+sVIGl9Bzx2ff/65ACB27txZoP55Wbx4sdJziarFqLCwsELHMGbMGAFA7Nu3T2m7t7e30NbWVjjulMnJyRGmpqaiTZs2ctPd3d0FAHHlypWPLkPT5y0iel+MMjIyKtAXL+nn9ofFYCGEaNOmjQCgUKQQQgh/f38BQMTFxRUoJmWfK7nXn5sqxajU1FQBQDRr1kzpl9sPST9bU1NTFdqkP2YV9CrT/M7pABSuFBfi/855/v7+smmaPC/n5cmTJ7I8SVtbW8ycOVM8fPhQPH/+XPz666/C2NhYSCQSceTIEdk8f/75Z57nZyGEOHjwoADkr4KS/hD0ww8/KJ3nl19+kf14WBCaPD6L+vNPlWNRnWJUXt9XPDw8hI6OjlzRTiorK0uUL19eNGrUSDZt9uzZAoCYNm2aQv+YmBihpaVV4GLU9u3bBQDh5eVVoP55efHihQAgBg0aJDdd1WJUnz59Ch1DYXLO/IwaNUoAkLvqbtGiRQKACAwMLNAyNHneovc4gDkVGSEE/vzzT6xfvx7Xr19HcnIysrOzZe16enpK52vcuLHS6VevXoWWlhaaNWum0NaiRQuFaVFRUUhKSkK1atVk4wh9yNDQsEBjoXh5eWHy5Mn49ttvERYWhk6dOqF58+aoVauWwr3kUrnHMpKyt7cHAIX72wu7r1q2bCk3doBU69atER4ejqtXr6JVq1Ya3Rf5kY4LkJ2djS1btuCzzz4DAJiamuKPP/7AnTt3cOnSJezYsQN9+vRRa12a5uHhoTBgaKVKlQAA1atXVxj/SltbGxUqVJAb06uw+/nBgweYP38+jhw5ggcPHuDt27dy7Y8ePZL9f2GOxcJQ9j6U3m+fmpqqMAYF8H5cLQCy7Xv16hWio6Nhb28PZ2dnhf6tW7fGzJkzCxzTuXPnIJFI0Llz5wL1j4yMxMKFC3HixAkkJCQojH+Qe7+qws/PD8uXL4e3tzd8fHzQvn17NG/eXOk25kW6L8PDw3Hx4kWF9sTERGRnZyMqKgoNGjQA8H7w/zVr1mDLli24desWUlNT5cbiyL09r1+/RkREBCpUqIB69eoVOC5VzltElL9+/fph3LhxqFWrFnr37o1WrVqhefPmsLa2znMeZe9B6WeR9FyQm52dHYD3Y8Q4OjrKpqvyuaIJpqam6N69O/bu3QsPDw/06tULLVu2RJMmTWBkZKR0nmrVqsHU1FRheu5zjrGxsWx6Yc7pOjo6SvNG6TiIV69elU0rzHlZVbnzpGHDhmHatGmytiFDhuDNmzcIDAzE/Pnz0bZt20Ktoyhp4vgs6s+/whyLhaEsT3rz5g2uX78OKysrLFu2TOl8+vr6cnnglStXAACtWrVS6Fu1alXY29vj/v37BYrp3LlzAIAuXboUqP/r16+xfPly7Nq1C1FRUXj16pXcWGqFPU/UqlULHh4e2Lx5M+7fv48ePXqgRYsWaNiwYZ7faT6kas4pdfr0aSxfvhxnz55FYmIi3r17J9f+6NEjODg4AFB9fwGqn7cofyxGUZEZO3Ysli1bBltbW3Tq1Al2dnYwNDQE8H5gzbxOrBUrVlQ6PTU1FZaWltDRUTxsK1SooDBNOpDz3bt38/3Cm5aW9tFtcXR0xIULFzBjxgwcOHAAO3fuBPD+xDN+/HgEBgYqzGNubq4wTRp77kITUPh9pWy7gf/bh9KBxzW5L/Ij3eaKFSvKClFSEokEPXr0wKVLl3DhwgVZMcrMzEwu1g9Jp+fen4WZ52Oky8xN+nopa5O25x6sujD7OTY2Fo0bN0ZycjJatmyJjh07wszMDNra2oiLi8Pvv/8uN9hlYY7FwlD2PpRu36FDh3Do0KGPbp/0dfjYcVpQKSkpsLCwkL038nPu3Dm0bdsWWVlZaNeuHby8vGBqagotLS1cu3YNoaGheQ4i+jGNGzfGyZMnMWfOHGzfvh0bNmwAANSoUQPTp08vUKFVui8XLlyYb7/cx4qfnx927dqFqlWrokePHqhYsSL09fUBAMuWLZPbnpSUFAD/90WgoFQ5bxFR/saOHQsrKysEBwdjxYoVWLZsGSQSCVq1aoWFCxcq/WKv6meRtC33Z5GqnyuasnXrVsyfPx+bNm3C9OnTAbx/sIiPjw8WLVqk8FmQ12e0snNOYc/pVlZWCj80AYp5ElC487Kqcr+GX3zxhUL7F198gcDAQFy4cEFhnpLOk3IvNzdVj8+i/vwDVD8WC0NZDpOcnAwhBJ49e1bgH9sKkisVtBilymd/ZmYm2rZtiwsXLsDd3R1+fn6wtraWPWho5syZhT5PaGtr4+jRo5g1axa2b9+OCRMmAABMTEwwcOBA/PTTTx8t2KiacwLArl274OPjAwMDA3To0AHOzs4oV64ctLS0cPz4cYSHh6udK6ly3qKPYzGKikRiYiJWrFgBd3d3nDlzRuGqks2bN+c5b15Xd5iamiIpKQlZWVkKBamnT58q9Jd+KH7xxReyL+zqcHV1xdatW5GVlYXr16/j8OHDWLlyJUaPHo1y5cphyJAhhVquOvtK2XYDwJMnTwD83z7Q9L7IS40aNQDkfaK2sLAAALlfaKXzREVFKZ3n7t27AN5fnZR7nkuXLin9dTIrKwv37t2Djo4OqlatWrgNKaTC7OclS5bgxYsXCAkJUXiay+bNm/H7778rzFPQY1F61VxWVpbCMqQfwHlR9j6Ubt/y5csLVPSS9v/YcVpQ5ubmePHiBd6+ffvRgtTs2bPx9u1b2ZPhcvvpp58QGhqq0ro/9Nlnn2Hfvn3IyMjA5cuXceDAAaxcuRJ9+/aFtbU12rdvn+/8ub8oKPuF7UOXLl3Crl27ZE+Oyn0OzMnJkT15Ukr6HtT01Q9EpJoBAwZgwIABSElJwZkzZ7Br1y6sW7cOnTp1wp07d/K9SqqwCvO5ogmGhoaYMWMGZsyYgYcPH+LEiRNYv349Nm7ciLi4OJw8ebLQyy7sOf358+fIzs5WKEh9mCfl/v+CnpcLw8jICPb29nj48KHSXEmTeZKq8xSXov78Awp+LOaXJwH550r55Un16tWTXfH0MblzJTc3N4V2VXIlVT77Q0NDceHCBfj7+ys8CS4hIUGlK9eVsbCwwNKlS7F06VJER0cjPDwca9aswapVq5CSkiL7IS8vquacADB16lTo6enh0qVLcHV1lWsbNmyY3BMnAfn9Vbt27QJuGWmS4v09RBoQGxuLnJwcdOzYUaG4Eh8fX+BHyeZWr1495OTk4MyZMwptp06dUphWs2ZNmJub49y5cyo9av1jdHR00KBBA0yYMEFWKNq9e3ehl6fOvjp16pTSR+YeP34cAGS35xTVvvhQ06ZNUa5cOcTFxeH169cK7REREQCAKlWqyKZJL0M/cOCAQv/Y2FhERUXB0dFRrrCU3zwnTpzAmzdv0KxZM9mvZsWlMPs5OjoaANCrVy+Ftg8/ND/0sWNRmtQ+fPhQYd5Lly4VKL7cpI+gLugXChMTE7i4uODRo0eIiYlRaJcep6qsXwih9HX/UHR0NCwtLRW+tAAf36+q0NfXR7NmzTBr1iysWLECAApU6FJ1X0qPEy8vL4Vi/IULFxRuwSlXrhzc3d3x9OlTudtQiKhkmJubo2vXrli7di38/f2RlJSEEydOFMm61Plc0RR7e3v069cPYWFhcHFxwalTp2RXOhRGYc/pWVlZSvPGD/MkQPXzcmFJf6yQ5kS5KcuTnJ2d4eDggKioKNy7d09hnv379wOA3G19TZs2haGhIU6fPo1Xr17J9c/JycHBgwcBAG3atFFza1RX1J9/H8rvWMwvT3r58mWexby8GBsbw83NDZGRkUhKSirQPPXr1weg/DiOjY1VGltepPtWekzkR7pfe/bsqdCm6fOEi4sLhgwZgvDwcBgbGxdJngS836ZatWopFKJycnKUfldUZX9R0WAxioqEk5MTgPfFktyXK6alpWHo0KF5/gKRnwEDBgAApkyZInf/b2pqKn788UeF/jo6Ohg1ahQSEhIQGBio9MMqISEBt27d+ui6L1++rPRSZ+kVH+rcg67Ovrp79y6Cg4PlpoWGhiI8PBwuLi5o2bIlgMLvC39/f0gkEqxfv75A22JkZIQhQ4YgPT0dU6ZMkbvv/ObNm1i/fj10dHTg4+Mjm96qVSu4urrixIkT2LNnj2x6Tk6O7LLe4cOHy/0C5ePjAysrK2zZskWuqCJdLwB88803BYpZkwqzn6Wv/4eFmbCwMPz6668K86tyLErHMwgJCZE7jh4+fIhZs2YVfMP+v4YNG6Jly5bYuXMn1q1bp7TPzZs3kZiYKPt70KBBstcyd+H03r17suJNQY0aNQoAMG7cOKW/+uWe5uTkhKSkJNy4cUOuz2+//YawsDCV1vuhM2fOKH1tVTkfjBw5Erq6uggKClKa7L57904uAcvrOElMTMS3336rdB3SXxKHDRumcMzk5OQgISHho3ESUeEdO3ZM7nNQSnqO1OT4Nbmp+rmiCc+ePcPNmzcVpr9+/RppaWnQ0dEp8FgxyqhzTp80aZLcrTlJSUmycR0HDRokm67qeRl4v48lEonSIllevv32W2hpaWHevHmycW+A9znMDz/8AAByt3tLJBIMHz4cAPD999/LfZaGhobi5MmTqFWrltyYQ8bGxujfvz9ev36tMN7OqlWrEBcXh06dOhX7FeRA0X/+qXIsmpiYoGbNmjh9+rRcbpadnY2xY8d+tNClzNixY/Hu3TsMHjxY6ZVVycnJcldN9evXD7q6uli5ciXi4uJk03NycvDdd98p/dE5L927d4eTkxP27Nmj9M6K3OOc5rVfY2NjZfl3Yd27d0/pj+nJycnIyMgo0HALhck5nZyccPfuXTx+/Fg2TQiBGTNmKP2+N3DgQJiamuLnn39W+uNA7v1FRYO36VGRqFixInr37o0tW7bAw8MDHTt2RGpqKg4dOgQDAwN4eHjg2rVrKi1zwIAB2LJlCw4cOAB3d3d4eXkhMzMTO3bsQKNGjfDvv/8qDOY9depUXL9+HatXr8bevXvRtm1b2NnZITExEXfv3sXp06cxZ84c1KpVK991b9iwAWvWrEGLFi3g7OwMCwsLxMTEYO/evdDX18eYMWNU3EP/R5191blzZ4wbNw779+9H3bp1ER0djZ07d8LAwADr1q2T2x+F2RfSD0Bl43Tl5ccff8SJEyewbNkynD17Fs2bN8fTp0+xc+dOpKenY9myZXIDPWtrayMkJARt27aFj48PfHx84ODggCNHjuDSpUto3rw5goKC5NZhamqKtWvXwsfHB61bt0bv3r1haWmJPXv24N9//4WPjw/8/PwKHLMmqbqfR4wYgZCQEPj6+sLHxweVKlVCREQEDhw4gC+//BJbt26VW74qx2KTJk3g6emJEydOoHHjxmjbti2ePn2KvXv3olOnTir92ia1adMmtG3bFkOGDMGKFSvQpEkTmJubIz4+Hjdu3EBERATOnj0LGxsbAO8LR7t378aOHTtQv359dOrUCSkpKdi2bRs8PT3lCpAf07FjR0yZMgWzZ8+Gq6srvL29YW9vj6dPn+LUqVNo2rSprHA6ZswYhIWFoUWLFvjyyy9hZmaGS5cu4dSpU/Dx8cH27dtV3napBQsW4OjRo2jZsiWqVKkCY2NjREZGYv/+/bCwsEBAQMBHl1GzZk2sW7cOgwcPhpubGzp37ozq1asjMzMTDx48wMmTJ2FtbY07d+4AABo1aoTmzZtj586daNasGVq0aIGnT59i//79qFGjhmwA2dy+/vprnDx5Ehs2bEC1atXQo0cPWFtb4/Hjxzh69CgGDx6sdFBQItKML774AsbGxmjatCmcnJwghMDJkydx8eJFNGjQ4KO38xaWqp8rmvDo0SPUq1cPtWvXRp06dWBvb4+XL19i3759ePLkCQIDAxWu/lZFYc/ptra2yMjIkMsbt2/fjoSEBIwYMQKenp6yvqqel4HC5UkNGjTA9OnTMX36dFlcBgYGCAsLw927d9GsWTN8//33cvOMHTsW+/btw/bt29GkSRO0a9cODx48wF9//QUjIyOFnA8A5s6di+PHj2PJkiW4du0aGjdujNu3byM0NBQ2Njb43//+V+CYNamoP/9UPRa/++47DBkyBM2bN4evry8MDAxw7NgxZGZmom7durh+/bpK2zd48GBcvnwZwcHBcHZ2RqdOneDg4ICkpCTcu3cPJ06cwKBBg7B69WoA7wso8+bNw7hx41CvXj34+fnBzMwMYWFhSElJQZ06dRSKsHnR09PDX3/9hY4dO6Jv375Ys2YNmjZtivT0dNy+fRtHjhyR/TjZvXt3uLi4YMmSJbh58ybq1auHBw8eYN++fejWrRsePHig0nbndv36dfTs2RONGjWCq6srKlWqhGfPniE0NBSZmZkFLnapmnMGBQVh+PDhqFevHnr16gVdXV1ZoVE6qH1uVlZW2LRpE3x8fNCmTRt06dIFderUwcuXL3Hjxg08fPhQ6dWIpEEl9hw/KjXyeizq69evxeTJk4Wzs7PQ19cXlStXFiNGjBDPnz8v9COE3759K6ZOnSqcnJyEnp6ecHR0FJMnTxbx8fECgOjRo4fCPDk5OeKPP/4Qbdu2FRYWFkJXV1dUqlRJNG/eXMyZM0c8ePDgo9t47tw5MXz4cFGnTh1hYWEhDAwMhLOzs/D39xc3b96U66vsUfC54YPHn6q7r86cOSPatWsnTExMhLGxsejQoYO4cOGC0nWrui88PDyEiYlJgR5LndurV6/E5MmTRbVq1YSenp4wMzMTHTp0EGFhYXnOExkZKXx8fET58uWFnp6eqFatmpg2bZp48+ZNnvOcOnVKdOnSRZibmwsDAwPh7u4ulixZIrKysgoc68ce66vs9ZJydHQUjo6OCtNV3c+nT58Wbdq0Eebm5sLY2Fg0b95c7Nq1S+l7QpVjUQghkpOTxddffy2sra2Fnp6ecHNzE2vWrMlzuwcOHCgAiHv37uW5z16+fCnmzJkj6tevL8qVKycMDAyEk5OT6Nq1q1izZo1IS0uT65+amiqCgoJEpUqVhL6+vqhRo4ZYtGiRiImJyXff5+Xvv/8WnTp1EhYWFkJPT09UrlxZeHt7yz0KWwgh9u7dK5o0aSKMjY1lx2B4eHie71Flr6eyvmFhYcLf31+4uroKU1NTYWRkJKpXry5GjRpV4MerS924cUMMHDhQODg4CD09PWFhYSHc3NxEQECAwva8ePFCfPPNN8LR0VHo6+uLqlWrikmTJonXr1/neSwKIcTGjRuFp6enMDU1Ffr6+sLJyUn07dtXXL58Od/tzC2/9wERKffzzz8Lb29vUaVKFWFoaCgsLCyEh4eHmD9/vsJj65V91kvld17O61Hrqnyu5LX+guRlUsnJyWLmzJmiTZs2olKlSkJPT09UrFhRtGrVSmzatEnk5OTI9c/vnJLX9hb2nJ6SkiJGjBghi6tmzZpi+fLlCjFJqXJeXrZsmQAg1q5d+9F99KEdO3aIli1bChMTE6Gvry9q1aolZs+eLdLT05X2f/36tZg6dapwcXERenp6wsrKSvj4+IjIyMg81/HixQsRGBgoHBwchK6urqhYsaIYNGiQePjwoUqxavr4FKLoPv9UPRaFEOLXX38VtWrVEnp6eqJChQoiICBAre8rQrw/Xrt16yasra2Frq6uqFChgmjUqJH44YcfxO3btxX6b9q0SdSrV0/o6+sLKysr0a9fP/Ho0aN8931e7t+/L7755hvh5OQkdHV1haWlpWjcuLGYM2eOXL8HDx6Ivn37ikqVKgkDAwNRq1YtMX/+fJGZman0PZrX6/lh34cPH4pJkyaJZs2aiQoVKgg9PT1hZ2cnOnfuLP755x+VtkXVnDMkJETUrVtXGBkZifLlywtvb29x48aNfI/FiIgI0b9/f1GpUiWhq6srbGxshKenp1izZk2+25lbQfJnUiQRQsn1w0T/MYcOHULHjh0xceJE/PTTTyUdTpE7fvw42rRpg+nTpxfZlQ0pKSkoX748xo0bp3RwSCIiIqJPlfQ2pNy3Pmlaz549cfHiRcTExKh1GyIRUVnEMaPoPyX3PcBSL168wMSJEwEof0wuFc7Jkyehq6uLsWPHlnQoRERERJ8U8f9vuxw3bhwLUUREhcAxo+g/ZezYsbh+/TqaNWsGa2trxMfHY//+/UhKSsKwYcNkAzaT+rp374709PSSDoOIiIjokyORSOQGICciItWwGEX/KT179pQNwJySkgIDAwO4ublhyJAhGDJkSEmHR0REREREREQfwTGjiIiIiIiIiIio2HDMKCIiIiIiIiIiKjYsRhERERERERERUbFhMYqIiIiIiIiIiIoNi1FqSE9PR2RkJJ84RkRERPQB5klERESUFxaj1BATEwN3d3fExMSUdChEREREnxTmSURERJQXFqOIiIiIiIiIiKjYsBhFRERERERERETFhsUoIiIiIiIiIiIqNixGERERERERERFRsWExioiIiIiIiIiIig2LUUREREREREREVGxYjCIiIiIiIiIiomLDYhQRERERERERERUbFqOIiIiIiIiIiKjYsBhFRERERERERETFRqekAyD61Hh5eSEmJuaj/R48eAAAcHBwyLefs7Mz9uzZo5HYiIiIiIiIiltBviMV9PsRwO9IxGIUUaFlZmaWdAhERERERESfBH4/IlWwGEX0gYJW6N3c3AAAkZGRRRkOERERERFRiSrIdyR+PyJVcMwoIiIiIiIiIiIqNixGERERERERERFRsVH7Nr1bt27h1q1beP78OSQSCaysrODq6opatWppIj4iIiKiUo/5FBEREZUlhSpGHT9+HOvXr8fevXuRkpICIYRcu0QigZmZGbp3745BgwahdevWmoiViIiIqNRgPkVERERllUrFqAMHDmDq1Km4fPky3N3d4e/vjwYNGqBq1aqwsLCAEALJycm4d+8eLl++jEOHDmHDhg2oX78+5syZg06dOhXVdhARERH9JzCfIiIiorJOpWKUj48Pvv76a2zYsAE1a9bMs99nn32Gvn37AgDu3LmD1atXw9fXFy9fvlQvWiIiIqL/OOZTREREVNapVIx68OABLC0tVVpBzZo1sWzZMkybNk2l+YiIiIhKI+ZTREREVNap9DQ9VRMnTc1LREREVFownyIiIqKyTu2n6X3ozZs32LJlCzIyMtC1a1c4OjpqehVEREREpRrzKSIiIirN1CpGDRkyBOfPn0dERAQA4N27d2jatKnsbzMzMxw9ehT16tVTP1IiIiKiUoj5FBEREZU1Kt2m96Fjx46hZ8+esr83bdqEiIgI/Pnnn4iIiEDFihUxc+ZMtYMkIiIiKq2YTxEREVFZo1Yx6smTJ3BycpL9vXv3bjRs2BB9+vRBrVq1MHToUJw/f17dGImIiIhKLeZTREREVNaoVYwqV64cUlJSAABZWVk4fvw4OnXqJGs3MTFBamqqWgESERERlWbMp4iIiKisUWvMqPr162Pt2rVo06YN9uzZg1evXqF79+6y9piYGFSoUEHtIImIiIhKK+ZTREREVNaoVYyaM2cOOnXqhIYNG0IIAR8fHzRu3FjWvmvXLjRv3lztIImIiIhKK+ZTREREVNaoVYxq2LAh7ty5gzNnzsDc3BytWrWStaWkpGDEiBFy04iIiIhIHvMpIiIiKmvUKkYBgLW1NXr06KEw3dzcHKNHj1Z38URERESlHvMpIiIiKktUKkY9ePCgUCtxcHAo1HxEREREpQ3zKSIiIirrVCpGOTk5QSKRqLyS7OxslechIiIiKo2YTxEREVFZp1Ixat26dXLJU05ODpYvX4779++jX79+qFGjBgDgzp072LRpE5ycnBAYGKjZiImIiIj+w5hPERERUVmnUjHK399f7u85c+YgPT0d0dHRKF++vFzbjBkz0KJFCzx58kTtIImIiIhKC+ZTREREVNapNYD56tWrERQUpJA4Ae8H4hw6dChWrFiBSZMmqbMaIiIiolKL+RQREZWUWbNmYevWrRpZVkxMDADAzc1NI8sDAD8/P0ybNk1jy6NPh5Y6M7948QJv3rzJs/3Nmzd48eKFOqsgIiIiKtWYTxERUUnZunUroqOjNbIsXV1d6OrqamRZABAdHa2xQhl9etS6Mqpp06ZYtmwZunTpggYNGsi1Xbp0CcuXL0eTJk3UCpCIiIioNGM+RUREJcnFxQWRkZElHYYCTV5hRZ8eta6MWrVqFbS0tNC4cWM0b94c/v7+8Pf3R/PmzdGkSRNoaWlh5cqVmoqViIiIqNQpynzq+PHjkEgkSv+dO3dOru+ZM2fQokULGBkZoWLFiggMDERaWpomNpGIiIhIjlpXRtWqVQs3b97EvHnzsH//fly5cgUA4OjoiNGjR+P7779HxYoVNRIoERERUWlUHPlUYGAgGjVqJDfNxcVF9v/Xrl1Du3bt4OrqiiVLliA+Ph6LFi3C3bt3sX//frXWTURERPQhtYpRAFChQgUsXboUS5cu1UQ8RERERGVOUedTLVu2hI+PT57tkydPhoWFBY4fPw5TU1MAgJOTE4YOHYqDBw+iY8eORRIXERERlU1q3aZHRERERP8Nr169QlZWlsL0ly9f4tChQ/jqq69khSgAGDBgAIyNjbFt27biDJOIiIjKALWvjLp9+zZCQkIQGxuL5ORkCCHk2iUSCY4cOaLuaoiIiIhKraLOpwYNGoS0tDRoa2ujZcuWWLhwIRo2bAgAuHnzJrKysmR/S+np6cHDwwNXr14t9HqJiIiIlFGrGLVhwwYMGjQIurq6qFGjBiwsLBT6fJhMEREREdH/Kcp8Sk9PD7169ULXrl1hZWWFW7duYdGiRWjZsiXOnDmDevXqISEhAQBga2urML+trS1Onjz50fUkJibi2bNnctM09ahwIiIiKn3UKkbNmDED9erVw/79+2FlZaWpmIiIiIjKjKLMp5o1a4ZmzZrJ/vby8oKPjw/q1KmDSZMm4cCBA3j79i0AQF9fX2F+AwMDWXt+goODMXPmTM0FTkRERKWaWsWox48fY/z48SxEERERERVScedTLi4u6NGjB3bu3Ins7GwYGhoCADIyMhT6pqeny9rzM2LECPj6+spNi46Ohre3t0ZiJiIiotJFrWJUnTp18PjxY03FQkRERFTmlEQ+ZW9vj3fv3uH169ey2/Okt+vllpCQgEqVKn10eTY2NrCxsdF4nERERFQ6qVWMWrJkCXx9fdGlSxe5S8CLypw5czBlyhS4ubkhIiJCru3MmTP4/vvvceXKFZiamuLLL7/E3LlzYWxsLNcvIyMD06ZNw4YNG5CcnIw6depg9uzZ6NChQ5HHT0RERPSh4s6nACA2NhYGBgYwNjaGu7s7dHR0cOnSJXz55ZeyPu/evcO1a9fkphERUekT2vEJ8L8mJR2GgtCOT9DjYMWSDoOKiFrFqPnz58PMzAwtW7ZErVq14ODgAG1tbbk+EokEoaGhagUJAPHx8Zg7dy7KlSun0Hbt2jW0a9cOrq6uWLJkCeLj47Fo0SLcvXsX+/fvl+vr7++P7du3Y8yYMahWrRrWr1+Prl274tixY2jRooXacRIRERGpoijzqWfPnsHa2lpu2vXr17Fnzx506dIFWlpaMDMzQ/v27bFx40ZMnToVJiYmAN4PrJ6WlqZw+x0RERGRuiRCjcfdOTk5QSKR5L8CiQSxsbGFXYVM79698ezZM2RnZ+P58+dyV0Z17doV165dw507d2BqagoA+PXXXzF06FCEhYWhY8eOAIALFy6gSZMmWLhwIcaPHw/g/VgI7u7usLGxwZkzZ1SKKTIyEu7u7oiIiICbm5va20j/LdLXPDIysoQjISKi/7KizKfatm0LQ0NDNGvWDDY2Nrh16xZ++eUX6Orq4uzZs3B1dQUAXLlyBc2aNUOtWrUQEBCA+Ph4LF68GJ6enggLCyvUdjFPIiL69H3K32k+5dhIfWpdGRUXF6ehMPJ34sQJbN++HVevXsWoUaPk2l6+fIlDhw4hKChIVogCgAEDBiAoKAjbtm2TFaO2b98ObW1tBAQEyPoZGBhgyJAhmDx5Mh4+fAh7e/ti2SYiIiIioGjzKW9vb/z5559YsmQJXr58CWtra/Ts2RPTp0+Hi4uLrF/9+vVx+PBhTJgwAUFBQTAxMcGQIUPw008/FVlsREREVHapVYwqDtnZ2Rg1ahS+/vpr1K5dW6H95s2byMrKQsOGDeWm6+npwcPDA1evXpVNu3r1KqpXry5XtAKAxo0bA3h/u19exajExEQ8e/ZMblp0dHShtomIiIioOAQGBiIwMLBAfVu0aIHTp08XcUREREREGipGhYeH4++//8b9+/cBAI6OjujWrRtatWql9rJXr16N+/fv4/Dhw0rbpU9+kT4JJjdbW1ucPHlSrm9e/QDk+ySb4OBgzJw5U6XYiYiIiAqqKPMpIiIiZW7dugUAGrmd+sGDBwAABwcHtZcFvL/4I/dVvFS6qFWMevfuHfr06YPdu3dDCAFzc3MAQEpKChYvXowvvvgCmzdvhq6ubqGW/+LFC0ybNg1Tp05VGHxT6u3btwAAfX19hTYDAwNZu7RvXv1yL0uZESNGKAzgGR0dDW9v749uBxEREVFeijqfIiIiKg6ZmZkaXZ6Liwv8/Pw0ukz6dKhVjJo5cyZ27dqF8ePHY9y4cahQoQKA97e0LV68GAsXLsSsWbPw448/Fmr5U6ZMgaWlpcI4UbkZGhoCADIyMhTa0tPTZe3Svnn1y70sZWxsbGBjY1Pg2ImIiIgKoqjzKSIioryo8TwzBRxwnFShVjFq06ZNGDhwIBYsWCA33cbGBvPnz8fTp0+xYcOGQiVPd+/exS+//IJly5bJ3T6Xnp6OzMxMxMXFwdTUVHaLnfR2vdwSEhJQqVIl2d+2trZ49OiR0n4A5PoSERERFYeizKeIiIiIPkVa6syckJCAJk2a5NnepEkTPHnypFDLfvToEXJychAYGIgqVarI/p0/fx5RUVGoUqUKZs2aBXd3d+jo6ODSpUty87979w7Xrl2Dh4eHbJqHhweioqLw8uVLub7nz5+XtRMREREVp6LMp4iIiIg+RWoVoypXrozjx4/n2R4eHo7KlSsXatnu7u7YtWuXwj83Nzc4ODhg165dGDJkCMzMzNC+fXts3LgRr169ks2/YcMGpKWlyY3z5OPjg+zsbPzyyy+yaRkZGQgJCUGTJk3yfJIeERERUVEpynyKiIiI6FOk1m16AwcOxPTp02Fubo6goCC4uLhAIpHg7t27WLZsGf76669CP4HOyspK6eDgy5YtAwC5tjlz5qBZs2Zo1aoVAgICEB8fj8WLF6Njx47o3LmzrF+TJk3g6+uLSZMmITExES4uLvj9998RFxeH3377rVBxEhEREamjKPMpIiIiok+RWsWoyZMnIyYmBr/88gvWrl0LLa33F1rl5ORACIGBAwdi8uTJGgk0P/Xr18fhw4cxYcIEBAUFwcTEBEOGDMFPP/2k0PePP/7A1KlTsWHDBiQnJ6NOnTrYt28fPD09izxOIiIiog99KvkUERERUXGRCA0Mn3/jxg38888/uH//PgDA0dERXbt2RZ06ddQO8FMWGRkJd3d3REREyJ4cQGUHnxZBRESaVNryKeZJRERlC78fkSrUujJKqk6dOv/ZRImIiIjoU8B8ioiIiMoKtQYwv3LlCoKDg/NsDw4OxrVr19RZBREREVGpxnyKiIiIyhq1ilE//PADDh8+nGf70aNHMWXKFHVWQURERFSqMZ8iIiKiskat2/QuX76MSZMm5dnesmVLpYOIExEREdF7zKeIiOhT5+XlhZiYmHz7SNsLMk6gs7Mz9uzZo5HY6L9JrWLUq1evoKOT9yK0tLSQmpqqziqIiIiISjXmU0REVBro6uqWdAj0H6JWMapatWo4ePAgRo0apbT9wIEDqFq1qjqrICIiIirVmE8REdGnjlcxkaapNWbUkCFD8Pfff2Ps2LFISUmRTU9JSUFQUBAOHDiAIUOGqBsjERERUanFfIqIiIjKGrWujAoMDMS1a9ewbNkyrFixApUqVQIAPH78GDk5Oejfvz+CgoI0EigRERFRacR8ioiIiMoatYpREokEISEhGDBgAHbs2IHY2FgAQI8ePdCrVy+0bt1aEzESERERlVrMp4iIiKisUasYJdWmTRu0adNGE4siIiIiKpOYTxEREVFZoZFi1KNHj3DixAkkJiaiV69eqFy5MrKzs5GamgozMzNoa2trYjVEREREpRbzKSIiIior1BrAXAiBsWPHokqVKujXrx/Gjh2LqKgoAEBaWhqcnJywcuVKjQRKREREVBoxnyIiIqKyRq1i1MKFC7F8+XKMHz8ehw4dghBC1mZmZoaePXtix44dagdJREREVFoxnyIiIqKyRq1i1Nq1azFgwADMnTsXHh4eCu116tSR/bJHRERERIqYTxEREVFZo1Yx6uHDh2jWrFme7eXKlcPLly/VWQURERFRqcZ8ioiIiMoatYpRNjY2ePjwYZ7tly9fhoODgzqrICIiIirVmE8RERFRWaNWMapnz55YvXo1YmNjZdMkEgkA4ODBg1i/fj18fX3Vi5CIiIioFGM+RURERGWNWsWomTNnwtbWFh4eHhgwYAAkEgnmz5+PFi1aoEuXLqhTpw4mT56sqViJiIiISh3mU0RERFTWqFWMMjMzw7lz5/D999/j0aNHMDAwQHh4OFJSUjB9+nScPHkSRkZGmoqViIiIqNRhPkVERERljUTkfn4wqSQyMhLu7u6IiIiAm5tbSYdDxUz6mkdGRpZwJERERJ8e5klERESUF7WujMpLbGwsbt++XRSLJiIiIioTmE8RERFRaaVWMWrFihXo3bu33DR/f39Uq1YN7u7uaNiwIRITE9UKkIiIiKg0Yz5FREREZY1axahff/0VFSpUkP0dFhaGP/74AwEBAVi5ciViY2Mxc+ZMtYMkIiIiKq2YTxEREVFZo6POzPfv34erq6vs723btqFKlSr4+eefAQBPnjzBhg0b1IuQiIiIqBRjPkVERERljVrFqA/HPj948CB69Ogh+9vJyQlPnjxRZxVEGjNr1ixs3bpVY8uLiYkBAI0Nyurn54dp06ZpZFlERPTfwXyKiIiIyhq1btOrXr06du3aBeD9JeWPHz9Gly5dZO3x8fEwNzdXK0AiTdm6dSuio6M1tjxdXV3o6upqZFnR0dEaLZQREdF/R3HnU3PmzIFEIoG7u7tC25kzZ9CiRQsYGRmhYsWKCAwMRFpamsbWTURERASoeWXU+PHj0bdvX1hYWOD169dwdXVFp06dZO1Hjx6Fh4eHujESaYyLiwsiIyNLOgwFfOQ1EVHZVZz5VHx8PObOnYty5coptF27dg3t2rWDq6srlixZgvj4eCxatAh3797F/v37NbJ+IiIiIkDNYlTv3r1Rvnx5/PPPPzA3N8eIESOgo/N+kUlJSbC0tET//v01EigRERFRaVSc+dT48ePRtGlTZGdn4/nz53JtkydPhoWFBY4fPw5TU1MA728RHDp0KA4ePIiOHTtqJAYiIiIiifhwoAIqsMjISLi7uyMiIoJXtvwHSF+jT/nKqE8xNiIiKh1OnDiBtm3b4urVqxg1ahSeP3+OiIgIAMDLly9Rvnx5BAUFYcGCBbJ53r17h/Lly8PPzw+//vqrSutjnkRERER5UevKKKnXr18jPDwc9+/fBwA4OjqiVatWSi8BJyIiIiJFRZlPZWdnY9SoUfj6669Ru3ZthfabN28iKysLDRs2lJuup6cHDw8PXL16Nd/lJyYm4tmzZ3LTNDlOIxEREZUuahejVq5ciSlTpiAtLU3uaTAmJiaYM2cORo4cqe4qiIiIiEq1os6nVq9ejfv37+Pw4cNK2xMSEgAAtra2Cm22trY4efJkvssPDg7GzJkz1YqRiIiIyg61ilF//PEHRo8ejc8++wyBgYFwdXUFANy+fRsrV67E6NGjYWZmxnGjiIiIiPJQ1PnUixcvMG3aNEydOhXW1tZK+7x9+xYAoK+vr9BmYGAga8/LiBEj4OvrKzctOjoa3t7ehYqZiIiISje1ilFLliyBp6cnjhw5Am1tbdn0OnXqwMfHB+3atcPixYtZjCIiIiLKQ1HnU1OmTIGlpSVGjRqVZx9DQ0MAQEZGhkJbenq6rD0vNjY2sLGxKVR8REREVPZoqTPzv//+C19fX7nESUpbWxu+vr74999/1VkFERERUalWlPnU3bt38csvvyAwMBCPHz9GXFwc4uLikJ6ejszMTMTFxSEpKUl2e570dr3cEhISUKlSpUKtn4iIiEgZtYpRZmZmiIuLy7M9Li5O9mhgIiIiIlJUlPnUo0ePkJOTg8DAQFSpUkX27/z584iKikKVKlUwa9YsuLu7Q0dHB5cuXZKb/927d7h27Ro8PDwKtX4iIiIiZdS6Ta9bt25YuXIlGjRogN69e8u1bd26FatWrUK/fv3UCpCIiIioNCvKfMrd3R27du1SmD5lyhS8evUKy5cvh7OzM8zMzNC+fXts3LgRU6dOhYmJCQBgw4YNSEtLUxgPioiIiEgdEpH7kS0qevbsGVq1aoV///0XFStWRLVq1QC8vyT8yZMnqFmzJsLDw2FlZaWxgD8lkZGRcHd3R0REBNzc3Eo6HPoI6WsUGRlZwpEo+pRjIyKiolUS+VTr1q3x/PlzREREyKZduXIFzZo1Q61atRAQEID4+HgsXrwYnp6eCAsLU3kdzJOIiIgoL2rdpmdtbY0rV65gyZIlqF27Np4+fYqnT5+idu3aWLp0KS5fvlxqC1FEREREmvCp5FP169fH4cOHYWhoiKCgIPzyyy8YMmQItm/fXuTrJiIiorKl0LfpvX37Fj/88APatGmD0aNHY/To0ZqMi4iIiKjUK6l86vjx40qnt2jRAqdPny6WGIiIiKjsKvSVUYaGhlizZg2ePn2qyXiIiIiIygzmU0RERFQWqXWbXoMGDeTGGiAiIiIi1TCfIiIiorJGrWLUsmXLsGXLFvz666/IysrSVExEREREZQbzKSIiIiprCj1mFAD4+/tDS0sLw4YNQ2BgIOzs7GBoaCjXRyKR4Pr162oFSURERFRaMZ8iIiKiskatYpSlpSXKly+PGjVqaCoeIiIiojKF+RQRERGVNWoVo/J6EgsRERERFQzzKSIiIipr1BozioiIiIiIiIiISBVqFaM2b94Mf3//PNsHDRqEbdu2qbMKIiIiolKN+RQRERGVNWoVo5YuXQp9ff082w0NDbF06VJ1VkFERERUqjGfIiIiorJGrWLUv//+i3r16uXZXrduXdy5c0edVRARERGVasyniIiIqKxRqxglhEBKSkqe7cnJycjMzFRnFURERESlGvMpIiIiKmvUKkbVq1cPmzdvxrt37xTaMjIysGnTpnx/6ctPZGQkfH19UbVqVRgZGcHKygqenp7Yu3evQt/bt2+jc+fOMDY2hqWlJfr3749nz54p9MvJycGCBQtQpUoVGBgYoE6dOti8eXOh4iMiIiLShKLMp4iIiIg+RWoVoyZOnIiIiAi0adMGe/fuRWxsLGJjY7Fnzx60bt0akZGRmDhxYqGWff/+fbx69QoDBw7E8uXLMXXqVACAl5cXfvnlF1m/+Ph4eHp6Ijo6GnPnzsX48ePx999/o0OHDgpJ3Q8//IAJEyagQ4cOWLlyJRwcHNC3b19s2bKl8DuBiIiISA1FmU8RERERfYokQgihzgLWr1+P0aNHIy0tTTZNCAETExMsXboUgwcPVjtIqezsbDRo0ADp6emysRNGjBiB9evX486dO3BwcAAAHD58GB06dMCaNWsQEBAAAHj06BGqVKmCgIAArFq1ShZnq1atcO/ePcTFxUFbW1uleCIjI+Hu7o6IiAi4ublpbDupaEhfo8jIyBKORNGnHBsRERW94synigvzJCIiIsqLjroL8Pf3R8+ePXHo0CHExMQAAJydndGxY0eYmJioHWBu2trasLe3x8WLF2XTduzYgc8//1xWiAKA9u3bo3r16ti2bZusGBUaGorMzEyMGDFC1k8ikeCbb75B3759cfbsWbRo0UKj8RIREREVRHHmU0REREQlTe1iFACYmpqiV69emliUgtevX+Pt27dITU3Fnj17sH//fvj5+QF4f7VTYmIiGjZsqDBf48aN8c8//8j+vnr1KsqVKwdXV1eFftL2/IpRiYmJCuNQRUdHF3q7iIiIiHIrynyKiIiI6FOiUjHqwYMHACC7Ckn698fkvmpJVePGjcOaNWsAAFpaWujZs6fsNruEhAQAgK2trcJ8tra2SEpKQkZGBvT19ZGQkIAKFSpAIpEo9AOAx48f5xtHcHAwZs6cWejtICIiIgJKJp8iIiIi+pSoVIxycnKCRCLB27dvoaenJ/v7Y7Kzswsd4JgxY+Dj44PHjx9j27ZtyM7Olg1M/vbtWwCAvr6+wnwGBgayPvr6+rL/5tcvPyNGjICvr6/ctOjoaHh7e6u8TURERFR2lUQ+RURERPQpUakYtW7dOkgkEujq6sr9XZRq1qyJmjVrAgAGDBiAjh07onv37jh//jwMDQ0BvH/s8YfS09MBQNbH0NCwQP3yYmNjAxsbm8JvCBERERFKJp8iIiIi+pSoVIzy9/fP9+/i4OPjg2HDhiEqKkp2i530dr3cEhISYGlpKbsaytbWFseOHYMQQi7hk85bqVKlYoieiIiIyrpPIZ8iIiIiKklaJR2AqqS306WmpsLOzg7W1ta4dOmSQr8LFy7Aw8ND9reHhwfevHmD27dvy/U7f/68rJ2IiIiIiIiIiIqW2k/Te/36NXbs2IHY2FgkJydDCCHXLpFIsHz5cpWXm5iYqHBbXGZmJv744w8YGhqiVq1aAIBevXrh999/x8OHD2Fvbw8AOHLkCKKiohAUFCSbt0ePHggKCkJwcLBsAHQhBFavXg07Ozs0a9ZM5RiJiIiINKGo8ikiIiKiT5FaxagjR47A19cXKSkpefYpbPI0bNgwvHz5Ep6enrCzs8OTJ0/w559/4s6dO1i8eDGMjY0BAJMnT8Zff/2FNm3aYPTo0UhLS8PChQtRu3ZtDBo0SLa8ypUrY8yYMVi4cCEyMzPRqFEj7N69GydPnsSff/4JbW1tlWMkIiIiUldR5lNEREREnyK1ilHffvstypUrh61bt6JJkyYwNTXVVFzw8/PDb7/9hp9//hkvXryAiYkJGjRogPnz58PLy0vWz97eHuHh4Rg7diwmTpwIPT09dOvWDYsXL1Z4et68efNgYWGBNWvWYP369ahWrRo2btyIvn37aixu+rSFdnwC/K9JSYehILTjE/Q4WLGkwyAiohJQlPkUERER0adIrWLUgwcPMH/+fHTo0EFT8cj07t0bvXv3LlBfNzc3hIWFfbSflpYWJk2ahEmTJqkbHhEREZFGFGU+RURERPQpUqsYVadOHaSmpmoqFqIi1+NgRUQuPV/SYSjo4eZW0iEQEVEJYT5FREREZY1aT9ObP38+goODlT7NjoiIiIg+jvkUERERlTVqXRnVqlUrLFu2DJ999hlcXV1hb2+vMBC4RCJBaGioWkESERERlVbMp4iIiKisUasYtWPHDnz11VfIzs5GfHw8Xr16pdBHIpGoswoiIiKiUo35FBEREZU1ahWjJk6ciBo1amDHjh2oXr26pmIiIiIiKjOYTxEREVFZo9aYUY8fP8Y333zDxImIiIiokJhPERERUVmjVjGqUaNGePDggaZiISIiIipzmE8RERFRWaNWMWrlypXYsmULtm3bpql4iIiIiMoU5lNERERU1qhVjOrXrx+ysrLQp08fmJmZwc3NDXXq1JH7V7duXU3FSkRERFTqFGU+FRkZCV9fX1StWhVGRkawsrKCp6cn9u7dq9D39u3b6Ny5M4yNjWFpaYn+/fvj2bNn6m4eERERkQK1BjC3tLRE+fLlUa1aNU3FQ0RERFSmFGU+df/+fbx69QoDBw5EpUqV8ObNG+zYsQNeXl5Ys2YNAgICAADx8fHw9PSEmZkZ5s6di7S0NCxatAg3b97EhQsXoKenp/HYiIiIqOxSqxh1/PhxDYVBREREVDYVZT7VtWtXdO3aVW7ayJEj0aBBAyxZskRWjJo7dy5ev36Ny5cvw8HBAQDQuHFjdOjQAevXr5f1IyIiItIEtYpRRP8lt27dAgC4ublpZHnSwWalSbs6oqOj4eLiovZyiIiIPkZbWxv29va4ePGibNqOHTvw+eefy32mtW/fHtWrV8e2bdtYjCIiIiKNUmnMqLNnzxZ6RerMS/QpyszMRGZmpkaW5eLiAj8/P40si4iIPm0lkU+9fv0az58/R0xMDJYuXYr9+/ejXbt2AIBHjx4hMTERDRs2VJivcePGuHr16keXn5iYiMjISLl/0dHRhYqViIiISj+Vroxq27YtmjZtim+++Qaff/45jIyM8u2flpaGPXv2YPXq1bh06RLevHmjVrBE6hBCaHR50iusIiMjNbpcIiIq3Uoinxo3bhzWrFkDANDS0kLPnj2xatUqAEBCQgIAwNbWVmE+W1tbJCUlISMjA/r6+nkuPzg4GDNnzlQ5LiIiIiqbVCpGRUVFYdasWejfvz90dXXRpEkT1K9fH1WqVIGFhQWEEEhOTsa9e/dw6dIlXLhwAVlZWRgwYAD+/PPPotoGIiIiov+MksinxowZAx8fHzx+/Bjbtm1DdnY23r17BwB4+/YtACgtNhkYGMj65FeMGjFiBHx9feWmRUdHw9vbu1DxEhERUemmUjHK3t4ea9euxU8//YQNGzYgNDQUwcHBsiRGytDQEA0bNsTs2bPRv39/WFtbazRoIiIiov+qksinatasiZo1awIABgwYgI4dO6J79+44f/48DA0NAQAZGRkK86Wnp8tiyY+NjQ1sbGwKHR8RERGVLYUawNzKygpBQUEICgpCVlYWHjx4gBcvXgAAypcvDwcHB+jocGx0IiIioryUZD7l4+ODYcOGISoqSnZ7nvR2vdwSEhJgaWmZ71VRRERERKpSO8PR0dFB1apVUbVqVU3EQ0RERFTmFHc+Jb0KKzU1FTVq1IC1tTUuXbqk0O/ChQvw8PAolpiIiIio7FDpaXpERERE9N+RmJioMC0zMxN//PEHDA0NUatWLQBAr169sG/fPjx8+FDW78iRI4iKilIYC4qIiIhIXbyXjoiIiKiUGjZsGF6+fAlPT0/Y2dnhyZMn+PPPP3Hnzh0sXrwYxsbGAIDJkyfjr7/+Qps2bTB69GikpaVh4cKFqF27NgYNGlTCW0FERESlDYtRRERERKWUn58ffvvtN/z888948eIFTExM0KBBA8yfPx9eXl6yfvb29ggPD8fYsWMxceJE6OnpoVu3bli8eDHHiyIiIiKNYzGKiIiIqJTq3bs3evfuXaC+bm5uCAsLK+KIiIiIiDhmFBERERERERERFSO1ilHz58/Ho0ePNBULERERUZnDfIqIiIjKGrWKUT/88AMcHR3Rtm1bhISE4NWrV5qKi4iIiKhMYD5FREREZY1aY0bdv38fmzZtwp9//okhQ4Zg5MiR6N69O/r374/OnTtDW1tbU3ESFRsvLy/ExMR8tJ+0j5ubW779nJ2dsWfPHo3ERkREpQ/zKSIiIipr1Loyys7ODt999x2uXbuGGzduIDAwEOfOnUP37t1ha2uLUaNG4fz585qKleiToqurC11d3ZIOg4iI/uOYTxEREVFZIxFCCE0v9OTJk1i2bBl2794N4P2VIQMGDEBAQABsbGw0vboSExkZCXd3d0RERHz06hgiIiIiVfzX8ynmSURERJQXjT5NLz09HVu2bMGCBQuwd+9eaGtro0uXLnB3d8ePP/4IZ2dn7Nq1S5OrJCIiIipVmE8RERFRaad2MUoIgYMHD2LgwIGoUKEC+vbti8ePH2PBggWIj4/Hvn37sHPnTsTFxaFBgwYYN26cJuImIiIiKjWYTxEREVFZotYA5kFBQdi6dSuePn0KW1tbDB8+HAMGDFB6KbatrS2+/vprDBgwQJ1VEhEREZUqzKeIiIiorFGrGLV27Vp88cUXGDBgANq3bw+JRJJv/xYtWiAkJESdVRIRERGVKsyniIiIqKxRqxj19OlTlCtXrsD9nZyc4OTkpM4qiYiIiEoV5lNERERU1qg1ZlRGRgZu3LiRZ/vNmzeRnJysziqIiIiISjXmU0RERFTWqFWMCgoKQkBAQJ7tw4YNw/jx49VZBREREVGpxnyKiIiIyhq1ilFHjx6Fl5dXnu3du3fH4cOH1VkFERERUanGfIqIiIjKGrWKUc+ePYOVlVWe7eXLl0diYqI6qyAiIiIq1ZhPERERUVmjVjHK1tYWV69ezbP98uXLsLa2VmcVRERERKUa8ykiIiIqa9QqRnl7e+O3337Dnj17FNpCQ0MREhKCL774Qp1VEBEREZVqzKeIiIiorJEIIURhZ05NTUWLFi1w69Yt1K1bF+7u7gCAiIgIXL9+Ha6urjh16hTMzc01Fe8nJTIyEu7u7oiIiICbm1tJh0NERET/QaU1n2KeRERERHlR68ooMzMznDt3DlOmTEFmZia2b9+O7du3IzMzE1OnTsX58+f/c4kTERERUXFiPkVERERljVpXRpV1/MWPiIiISDnmSURERJQXta6MIiIiIiIiIiIiUoWOugu4ffs2QkJCEBsbi+TkZHx4oZVEIsGRI0fUXQ0RERFRqcV8ioiIiMoStYpRGzZswKBBg6Crq4saNWrAwsJCoQ/vAiQiIiLKG/MpIiIiKmvUKkbNmDED9erVw/79+2FlZaWpmIiIiIjKDOZTREREVNaoNWbU48ePMXjwYCZORERERIXEfIqIiIjKGrWKUXXq1MHjx481FQsRERFRmcN8ioiIiMoatYpRS5YswW+//YYzZ85oKh4iIiKiMoX5FBEREZU1ao0ZNX/+fJiZmaFly5aoVasWHBwcoK2tLddHIpEgNDRUrSCJiIiISivmU0RERFTWqHVl1I0bN5Ceng4HBwekpaXh1q1buHnzpsK/wrh48SJGjhwJNzc3lCtXDg4ODvjyyy8RFRWl0Pf27dvo3LkzjI2NYWlpif79++PZs2cK/XJycrBgwQJUqVIFBgYGqFOnDjZv3lyo+IiIiIg0oSjzKSIiIqJPkVpXRsXFxWkoDEXz58/H6dOn4evrizp16uDJkydYtWoV6tevj3PnzsHd3R0AEB8fD09PT5iZmWHu3LlIS0vDokWLcPPmTVy4cAF6enqyZf7www+YN28ehg4dikaNGiE0NBR9+/aFRCJB7969i2xbiIiIiPJSlPkUERER0adIIoQQJR2EMmfOnEHDhg3likl3795F7dq14ePjg40bNwIARowYgfXr1+POnTtwcHAAABw+fBgdOnTAmjVrEBAQAAB49OgRqlSpgoCAAKxatQoAIIRAq1atcO/ePcTFxSlcEv8xkZGRcHd3R0REBNzc3DSx2URERESlAvMkIiIiyotat+kBQHZ2NrZs2YJhw4bhiy++kF1Gnpqaip07d+Lp06eFWm6zZs3kClEAUK1aNbi5ueH27duyaTt27MDnn38uK0QBQPv27VG9enVs27ZNNi00NBSZmZkYMWKEbJpEIsE333yD+Ph4nD17tlBxEhEREamrqPIpIiIiok+RWsWolJQUNG/eHH379sXmzZuxZ88e2VhNxsbGCAwMxPLlyzUSKPD+SqanT5/CysoKwPurnRITE9GwYUOFvo0bN8bVq1dlf1+9ehXlypWDq6urQj9pe34SExMRGRkp9y86OlrdTSIiIqIyrrjzKSIiIqKSplYxauLEiYiMjERYWBhiY2OR+44/bW1t+Pj44J9//lE7SKk///wTjx49gp+fHwAgISEBAGBra6vQ19bWFklJScjIyJD1rVChAiQSiUI/AHj8+HG+6w4ODoa7u7vcP29vb3U3iYiIiMq4osyniuKBMERERETqUqsYtXv3bowaNQodOnRQKPIAQPXq1TU2KOedO3fw7bff4rPPPsPAgQMBAG/fvgUA6OvrK/Q3MDCQ6/P27dsC9cvLiBEjEBERIfdv9+7dhd4eIiIiIqBo86n58+djx44daNeuHZYvX46AgACcOHEC9evXR0REhKyf9IEw0dHRmDt3LsaPH4+///4bHTp0wLt37wq7aURERERKqfU0vdTUVFSpUiXP9szMTGRlZamzCgDAkydP0K1bN5iZmWH79u2ygcYNDQ0BQHb1U27p6elyfQwNDQvULy82NjawsbEp/EYQERERKVGU+dTYsWOxadMmuXE4/fz8ULt2bcybN0/2QJi5c+fi9evXuHz5smwczsaNG6NDhw5Yv3697IEwRERERJqg1pVRzs7OuHLlSp7tBw8eRK1atdRZBVJTU9GlSxekpKTgwIEDqFSpkqxNeoud9Ha93BISEmBpaSm7GsrW1hZPnjzBhw8PlM6be7lERERExaUo8ylNPxCGiIiISBPUKkZ9/fXXWLduHbZu3Sor8kgkEmRkZOCHH37AgQMHMGzYsEIvPz09Hd27d0dUVBT27dunkIjZ2dnB2toaly5dUpj3woUL8PDwkP3t4eGBN2/eyCVeAHD+/HlZOxEREVFxK+p86kPqPBAmL3zQCxEREalCrdv0Ro8ejcjISPTp0wfm5uYAgL59++LFixfIysrCsGHDMGTIkEItOzs7G35+fjh79ixCQ0Px2WefKe3Xq1cv/P7773j48CHs7e0BAEeOHEFUVBSCgoJk/Xr06IGgoCAEBwdj1apVAN4nY6tXr4adnR2aNWtWqDiJiIiI1FGU+ZQy0gfCzJo1C0DBHwijbOxNqeDgYMycOVNjMRIREVHpplYxSiKRYO3atRg4cCC2b9+Ou3fvIicnB87Ozvjyyy/h6elZ6GWPGzcOe/bsQffu3ZGUlCQb00Dqq6++AgBMnjwZf/31F9q0aYPRo0cjLS0NCxcuRO3atTFo0CBZ/8qVK2PMmDFYuHAhMjMz0ahRI+zevRsnT57En3/+KRuHioiIiKg4FWU+9SF1HgiTXzFqxIgR8PX1lZsWHR3NJw8TERGRUmoVo6RatGiBFi1aaGJRMteuXQMA7N27F3v37lVolxaj7O3tER4ejrFjx2LixInQ09NDt27dsHjxYoWkad68ebCwsMCaNWuwfv16VKtWDRs3bkTfvn01GjsRERGRqooin8pNEw+EyQsf9EJERESqUGvMKG1tbWzatCnP9q1btxb6iqPjx49DCJHnv9zc3NwQFhaG169fIzk5GRs3bkSFChUUlqmlpYVJkyYhLi4OGRkZiIiIQL9+/QoVHxEREZEmFGU+JaWpB8IQERERaYJaV0Z9WBT6UHZ2NiQSiTqrICIiKhZeXl6IiYn5aL8HDx4AgNxTx5RxdnbGnj17NBIblW5FnU/lfiDM4cOH1XogDBEREZEmqHVlFIA8k6OXL18iLCxM9qQWIiKi0iAzMxOZmZklHQaVMkWVT+V+IMxff/2V7wNh9u3bh4cPH8qmSR8I8+FYUERERETqkoiP/Rz3gZkzZ8qevvIxQggEBgZi2bJlhYntkxcZGQl3d3dERETAzc2tpMMhIqJiID3fR0ZGlnAk9F9WXPnUmDFjsHz5cnTv3h1ffvmlQrt0DM6HDx+iXr16MDc3l3sgTOXKlXHx4sVC3abHPImIiIjyovJteo0bN8aIESMghEBwcDA6dOiA6tWry/WRSCQoV64cGjRogJ49e2osWCIiIqLSoLjyqaJ4IAwRERGRulQuRnXp0gVdunQBALx+/RrDhw9HkyZNNB4YERERUWlVXPnU8ePHC9xX+kAYIiIioqKm1gDmISEhmoqDiIiIqExiPkVERERljVrFKKn4+HhcvXoVqampyMnJUWgfMGCAJlZDREREVGoxnyIiIqKyQq1iVHp6OgYOHIgdO3YgJycHEolE9nji3E+FYfJEREREpBzzKSIiIiprtNSZefLkydi5cyfmzJmD48ePQwiB33//HQcPHkSXLl1Qt25dXL9+XVOxEhEREZU6zKeIiIiorFGrGLV9+3YMGjQIEyZMkD2y187ODu3bt8e+fftgbm6O//3vfxoJlIiIiKg0Yj5FREREZY1axajExEQ0btwYAGBoaAjg/RNhpHr16oWdO3eqswoiIiKiUo35FBEREZU1ahWjKlSogBcvXgAAjIyMYGFhgX///VfW/vLlS6Snp6sXIREREVEpxnyKiIiIyhq1BjBv0qQJTp06hQkTJgAAunfvjoULF8LW1hY5OTlYunQpmjZtqpFAiYiIiEoj5lNERERU1qh1ZVRgYCCqVq2KjIwMAMCPP/4Ic3Nz9O/fHwMHDoSZmRlWrFihkUCJiIiISiPmU0RERFTWqHVlVIsWLdCiRQvZ3/b29rh9+zZu3rwJbW1t1KxZEzo6aq2CiIiIqFRjPkVERERljcYzGy0tLdStW1fTiyUiIiIqM5hPERERUWmmUjHqxIkThVqJp6dnoeYjIiIiKm2YTxEREVFZp1IxqnXr1pBIJAXuL4SARCJBdna2yoERERERlUbMp4iIiKisU6kYdezYsaKKg4iIiKhMYD5FREREZZ1KxahWrVoVVRxEREREZQLzKSIiIirrtEo6ACIiIiIiIiIiKjtYjCIiIiIiIiIiomLDYhQRERERERERERUbFqOIiIiIiIiIiKjYsBhFRERERERERETFhsUoIiIiIiIiIiIqNjqqzvDHH3/k2SaRSGBgYABHR0fUr18fOjoqL56IiIio1GM+RURERGWZytmNv78/JBIJhBB59pFIJLCxscGSJUvQp08ftQIkIiIiKm2YTxEREVFZpnIx6uLFi/m2v3nzBnfu3MGvv/6K/v37w8rKCh06dCh0gERERESlDfMpIiIiKsskIr+f5NTw7t07NGrUCNbW1jh8+HBRrKLERUZGwt3dHREREXBzcyvpcIiIqBhIz/eRkZElHAmVBf/lfIp5EhEREeWlyAYw19PTg5+fHy5fvlxUqyAiIiIq1ZhPERERUWlUpE/TK1++PN6+fVuUqyAiIiIq1ZhPERERUWlTpMWoq1evonLlykW5CiIiIqJSjfkUERERlTZF9qzgPXv2ICQkBKNGjSqqVRARERXIrFmzsHXrVo0sKyYmBgA0NgaOn58fpk2bppFlUenDfIqIiIhKI5WLUV5eXvm2v337FlFRUYiPj0ft2rWZYBMRUYnbunUroqOj4eLiovaydHV1NRDRe9HR0di6dSs/K8sg5lNERERUlqlcjLpx4wYkEkme7QYGBnB1dcW4ceMQEBAAAwMDtQIkIiLSBBcXl0/uCXh8wljZxXyKiIiIyjKVi1FxcXFFEAYRERFR2cF8ioiIiMqyIh3AnIiIiIiIiIiIKLdCFaN++eUXuLq6wsDAAHZ2dggKCkJGRoamYyMiIiIqtZhPERERUVmlcjFq9+7dGD58OOLj41GnTh3k5ORgxYoVGD58eFHER0RERFTqFGc+lZaWhunTp6Nz586wtLSERCLB+vXrlfa9ffs2OnfuDGNjY1haWqJ///549uyZxmMiIiKisk3lYtSSJUvg7OyM6OhoXLhwAQ8fPsSXX36JP//8Ey9fviyKGImIiIhKleLMp54/f45Zs2bh9u3bqFu3bp794uPj4enpiejoaMydOxfjx4/H33//jQ4dOuDdu3cajYmIiIjKNpWLUf/++y+GDRuGChUqAAB0dHQwadIkZGVl4fbt2xoPkIiIiKi0Kc58ytbWFgkJCbh//z4WLlyYZ7+5c+fi9evXOHr0KAIDAzF58mRs27YN169fz/NKKiIiIqLCULkY9ezZM1SqVElump2dHQDgzZs3momKiIiIqBQrznxKX18fFStW/Gi/HTt24PPPP4eDg4NsWvv27VG9enVs27ZNozERERFR2aZTmJkkEomm4yAiIiIqUz6lfOrRo0dITExEw4YNFdoaN26Mf/75J9/5ExMTFcaWio6O1miMREREVHoUqhi1aNEibN68WfZ3ZmYmAOCHH36AlZWVXF+JRILQ0FA1QiQiIiIqfT6lfCohIQHA+1v6PmRra4ukpCRkZGRAX19f6fzBwcGYOXNmkcVHREREpYvKxSgHBwckJSUhKSlJbrqjoyMSEhJkyYzUp/SrHxEREdGn4FPLp96+fQsASotNBgYGsj55FaNGjBgBX19fuWnR0dHw9vbWbKBERERUKqhcjIqLiyuCMIiIiIjKjk8tnzI0NAQAZGRkKLSlp6fL9VHGxsYGNjY2RRMcERERlToqD2BORERERKWL9Pa8D6/Ikk6ztLTM86ooIiIiIlWpXIxKT0/H8OHDsXLlynz7rVixAt98841s/AMiIiIieu9Ty6fs7OxgbW2NS5cuKbRduHABHh4eRbp+IiIiKltULkb98ssvWL9+Pbp165Zvv27duiEkJAS//vproYMjIiIiKo0+xXyqV69e2LdvHx4+fCibduTIEURFRSmMB0VERESkDpWLUdu2bUOvXr1QtWrVfPs5OzvD19dX7ikxqkpLS8P06dPRuXNnWFpaQiKRYP369Ur73r59G507d4axsTEsLS3Rv39/hUcMA0BOTg4WLFiAKlWqwMDAAHXq1FErRiIiIiJVFWc+BQCrVq3C7NmzsW7dOgDA3r17MXv2bMyePRupqakAgMmTJ8PIyAht2rTBypUr8dNPP8HX1xe1a9fGoEGD1Fo/ERERUW4qD2B+8+ZN9OvXr0B9mzVrhr1796oclNTz588xa9YsODg4oG7dujh+/LjSfvHx8fD09ISZmRnmzp2LtLQ0LFq0CDdv3sSFCxegp6cn6/vDDz9g3rx5GDp0KBo1aoTQ0FD07dsXEokEvXv3LnSsRERERAVVnPkUACxatAj379+X/b1z507s3LkTAPDVV1/BzMwM9vb2CA8Px9ixYzFx4kTo6emhW7duWLx4MceLIiIiIo1SuRj17t07ueJOfvT09JQ+laWgbG1tkZCQgIoVK+LSpUto1KiR0n5z587F69evcfnyZTg4OAAAGjdujA4dOmD9+vUICAgAADx69AiLFy/Gt99+i1WrVgEAvv76a7Rq1QrfffcdfH19oa2tXeh4iYjo0xXa8QnwvyYlHYac0I5P0ONgxZIOg0pAceZTQMGf3ufm5oawsDC11kWlm5eX1/9r786joqz3P4C/hwFmEEhUFkUIZFE2E0U0lREFzQVSbnVRs27pMTXUY1nu94pQ6sUNbwsu6XX3BG54U3PrUoxLqJUpuGKCGXpxAQITEOb7+4MfT47DqjjDwPt1Dqcz3/k+3+czE8/w9jvP831w9erVGvtcv34dAKRcXhN3d3f85z//aZDaiIjIeNT7Mj1HR0ekp6fXqW96ejocHR3rXVQlhUKBtm1rD+k7d+5EeHi41h+8AQMGoGPHjkhKSpLa9uzZg4cPHyIqKkpqk8lkePfdd3Hjxg2cOHHiiWslIiIiqit95ikifXv48CFvYkRERDWq95lRAwYMwKZNmzB79mzY29tX2y83NxebNm165gte/vbbb8jNzUX37t11nuvRowf2798vPf7pp59gaWkJb29vnX6VzwcFBT3TeomIyDCGH2qLjPg0Q5ehZbivr6FLIANpbHmKqK7qchaT7/9/tmVkZDzrcoiIyEjVezJq5syZ2LJlC0JCQrBu3Tr07Kl7yUNaWhrGjRuH4uJiTJ8+vUEKrc7NmzcBVFzS97h27drh3r17KCkpgUKhwM2bN+Hg4ACZTKbTDwBycnKq3U9ubq7OguiZmZlPWz4REenB+fPnAfz5D6SnUZ/LT2qTmZkJDw+Ppx6HjE9jy1NEsbGxSExMbJCxKi/ja4jPXAAYMWIE5s2b1yBjERFR41DvySg3NzckJSVh1KhR6N27N9zc3NC5c2dYW1ujsLAQ6enpuHr1Klq0aIEvv/wS7u7uz6JuyYMHDwCgyoU1lUql1EehUEj/ralfdRISEhATE9MQJRMRkRFryEtPPDw8MGLEiAYbj4xHY8tTRImJidje73qd1zKrycOHFWOYmd166rFKS0vx18RETkYRETUx9Z6MAoCwsDCcPXsWcXFx2Lt3L5KTk6XnHB0d8c4772DGjBm13q64IVhYWABAlQt7FhcXa/WxsLCoU7+qREVF6Zwin5mZiYiIiCeqm4iI9EcI0WBj8fITaiiNKU8RnT9/HiLY0tBlEBFRM/FEk1EA4OrqipUrV2LlypUoLCzE77//jueeew7W1tYNWV+tKi+xq7xc71E3b95E69atpbOh2rVrh5SUFAghtC7Vq9y2psVB7e3ta1zTgYiIjFtd7hAF1P3yE94hiuqiseQpIgDwW3kfPj4uNfa5fv16rWeIlpaWAkCdzrIyMzOr9bJnnkFKRNT0PPFk1KOsra0NFprat28POzs7nD59Wue5kydPwt/fX3rs7++PtWvX4sKFC/Dx8ZHa09LSpOeJiIhqYmZmZugSqIkyZJ4iqusZpHWZuK/P2nqcuCciap4aZDLK0F599VVs3LgRv/76K5ydnQEA33zzDS5fvoz3339f6jd8+HC8//77SEhIwGeffQag4g/vqlWr0L59e/Tu3dsg9RMRkeHxH0NERLXjZyURETWERj8Z9dlnnyE/P1+6091XX32FGzduAACmTJmCli1bYs6cOdi+fTv69++PqVOnoqioCEuWLEHnzp0xZswYaSwnJye89957WLJkCR4+fIjAwEAkJydDrVZj69atkMvlBnmNRERERERERETNhUw05Kquz4Crqyuys7OrfO7atWtwdXUFULGQ7LRp03D06FGYm5sjLCwMy5Ytg4ODg9Y2Go0GcXFxWL16NW7evAlPT0/Mnj0bo0ePrndtGRkZ8PPzQ3p6eoPdupaIiIioKWBOIiIiouo0+smoxowhi4iIiKhqzElERERUHRNDF0BERERERERERM0HJ6OIiIiIiIiIiEhvOBlFRERERERERER6w8koIiIiIiIiIiLSG05GERERERERERGR3nAyioiIiIiIiIiI9MbU0AUYs5KSEgBAZmamgSshIiIifXF3d4dSqTR0GY0ecxIREVHzU9ecxMmop/Drr78CACIiIgxbCBEREelNeno6fH19DV1Go8ecRERE1PzUNSfJhBBCD/U0Sfn5+fjuu+/g7OwMhUJh6HJIzzIzMxEREYHk5GR4eHgYuhwi0hMe+8Qzo+qGOan54uckUfPEY58AnhmlFzY2Nhg+fLihyyAD8/Dw4DfkRM0Qj32imjEnET8niZonHvtUF1zAnIiIiIiIiIiI9IaTUUREREREREREpDecjCIiIiIiIiIiIr3hZBTRE7Kzs0N0dDTs7OwMXQoR6RGPfSKimvFzkqh54rFP9cG76RERERERERERkd7wzCgiIiIiIiIiItIbTkYREREREREREZHecDKKiIiIiIiIiIj0hpNRRERERERERESkN5yMInoG3n77bbi6uuplXxs2bIBMJkNWVpZe9kfUkObPnw+ZTGaw/ffr1w9+fn7PbHxDvz4iosaGGYmo7gydI5iT6FniZBQ1Odu2bcOKFSsMXQYRNRI5OTmYP38+zpw5Y+hSiIgMihmJiB7HnESGwskoanIYtIjoUTk5OYiJiTFIyPr73/+OBw8e6H2/RERVYUYioscxJ5GhcDKKqJHTaDQoLi42dBlE9ARMTU2hVCoNXQZkMhk2bNhg6DKIiBoUMxKRcWNOat44GUVGp7CwEO+99x5cXV2hUChgb2+PgQMH4scff0S/fv2wb98+ZGdnQyaTQSaTSesSlJaWYt68eQgICEDLli1haWkJlUqFlJQUrfGzsrIgk8mwdOlSrFmzBu7u7lAoFAgMDMSpU6d06klOToafnx+USiX8/Pywe/fuKuteunQpevfujTZt2sDCwgIBAQHYsWOHTj+ZTIbJkydj69at8PX1hUKhwIEDBwAAGRkZCAkJgYWFBZycnPDxxx9Do9E85TtKpB9Hjx5FYGAglEol3N3dsXr16mr7btmyBQEBAbCwsEDr1q0xcuRI/Prrr1p9Ktcx+OGHH9C7d29YWFigQ4cOWLVqldTn22+/RWBgIABgzJgx0ufC44Hj/Pnz6N+/P1q0aIH27dtj8eLF0nNCCNja2mLatGlSm0ajgY2NDeRyOfLz86X2uLg4mJqaoqioCEDVayEcPnwYQUFBsLGxgZWVFTp16oQ5c+Zo9SkpKUF0dDQ8PDygUCjg7OyMGTNmoKSkpIZ3mIiaO2YkZiQyXsxJFZiTmg9TQxdAVF8TJ07Ejh07MHnyZPj4+ODu3bs4evQoLly4gLlz56KgoAA3btxAfHw8AMDKygoA8Pvvv2Pt2rUYNWoU3nnnHRQWFmLdunUYNGgQTp48CX9/f639bNu2DYWFhZgwYQJkMhkWL16MV155Bb/88gvMzMwAAIcOHcKrr74KHx8fLFq0CHfv3sWYMWPg5OSkU/e//vUvDBs2DKNHj0ZpaSm+/PJL/PWvf8XevXsRFham1fe///0vkpKSMHnyZNja2sLV1RW3bt1C//79UVZWhlmzZsHS0hJr1qyBhYXFM3iXiRrWuXPn8NJLL8HOzg7z589HWVkZoqOj4eDgoNN3wYIF+Mc//oHIyEiMGzcOt2/fxqeffoq+ffvip59+go2NjdQ3Ly8PQ4cORWRkJEaNGoWkpCS8++67MDc3x9ixY+Ht7Y3Y2FjMmzcP48ePh0qlAgD07t1ba4zBgwfjlVdeQWRkJHbs2IGZM2eic+fOGDJkCGQyGfr06YPU1FRpm7Nnz6KgoAAmJiY4duyYdAyr1Wp07dpV+tx5XEZGBsLDw/HCCy8gNjYWCoUCmZmZOHbsmNRHo9Fg2LBhOHr0KMaPHw9vb2+cO3cO8fHxuHz5MpKTk5/mfwURNWHMSMxIZJyYkyowJzUzgsjItGzZUkyaNKna58PCwoSLi4tOe1lZmSgpKdFqy8vLEw4ODmLs2LFS27Vr1wQA0aZNG3Hv3j2pfc+ePQKA+Oqrr6Q2f39/0a5dO5Gfny+1HTp0SADQqeGPP/7QelxaWir8/PxESEiIVjsAYWJiIjIyMrTa33vvPQFApKWlSW25ubmiZcuWAoC4du1a1W8IUSMQEREhlEqlyM7OltrOnz8v5HK5ePRPUVZWlpDL5WLBggVa2587d06YmppqtQcHBwsAYtmyZVJbSUmJ8Pf3F/b29qK0tFQIIcSpU6cEALF+/XqduirH2LRpk9YYbdu2Fa+++qrUtmTJEiGXy8Xvv/8uhBDik08+ES4uLqJHjx5i5syZQgghysvLhY2NjXj//fel7aKjo7VeX3x8vAAgbt++Xe17tXnzZmFiYiLUarVW+6pVqwQAcezYsWq3rU51r5+ImhZmJGYkMk7MSRWYk5oXXqZHRsfGxgZpaWnIycmp13ZyuRzm5uYAKmbU7927h7KyMnTv3h0//vijTv8RI0agVatW0uPKbwp++eUXAMDNmzdx5swZvPXWW2jZsqXUb+DAgfDx8dEZ79Fv5/Ly8lBQUACVSlXlvoODg3XG2L9/P1588UX06NFDarOzs8Po0aPr9PqJDKW8vBwHDx5EREQEnn/+eand29sbgwYN0uq7a9cuaDQaREZG4s6dO9JP27Zt4enpqXPJiKmpKSZMmCA9Njc3x4QJE5Cbm4sffvihTvVZWVnhjTfe0BqjR48e0rEOVBz/5eXlOH78OICKb/ZUKhVUKhXUajUAID09Hfn5+dJnRVUqv63cs2dPtZePbN++Hd7e3vDy8tJ6D0JCQgBA5z143B9//KG13Z07dwAARUVFWm15eXm1vDNEZGyYkZiRyPgwJ/2JOal54WQUGZ3FixcjPT0dzs7O6NGjB+bPn6/1YViTjRs34oUXXoBSqUSbNm1gZ2eHffv2oaCgQKfvo38MAEihq/KDKTs7GwDg6emps22nTp102vbu3YsXX3wRSqUSrVu3hp2dHVauXFnlvjt06KDTlp2dXed9ETUmt2/fxoMHD+r0+3vlyhUIIeDp6Qk7OzutnwsXLiA3N1erv6OjIywtLbXaOnbsCKBibZO6cHJy0lmvoFWrVlohpFu3bmjRooUUqCpDVt++fXH69GkUFxdLzwUFBVW7rxEjRqBPnz4YN24cHBwcMHLkSCQlJWkFritXriAjI0Pn9Ve+rsffg8ctXrxYZ1sAmDJlilZb165d6/T+EJHxYEaqfV9EjQ1z0p+Yk5oXrhlFRicyMhIqlQq7d+/GoUOHsGTJEsTFxWHXrl0YMmRItdtt2bIFb7/9NiIiIjB9+nTY29tDLpdj0aJFuHr1qk5/uVxe5ThCiHrXrFarMWzYMPTt2xcJCQlo164dzMzMsH79emzbtk2nP9c4oOZKo9FAJpPh66+/rvIYrG6NgadRl2PdzMwMPXv2RGpqKjIzM3Hr1i2oVCo4ODjg4cOHSEtLg1qthpeXlxRqqmJhYYHU1FSkpKRg3759OHDgABITExESEoJDhw5BLpdDo9Ggc+fOWL58eZVjODs71/h6/va3v+kEvYEDB2L69Ol46aWXtGohoqaFGYmoaWNOYk5qSjgZRUapXbt2iIqKQlRUFHJzc9GtWzcsWLBAWkSvKjt27ICbmxt27dql1Sc6OvqJanBxcQFQMTv/uEuXLmk93rlzJ5RKJQ4ePAiFQiG1r1+/vl77q8u+iBobOzs7WFhY1On3193dHUIIdOjQQfqGqyY5OTm4f/++1rd+ly9fBgDpLlHVfSbUl0qlQlxcHI4cOQJbW1t4eXlBJpPB19cXarUaarUa4eHhtY5jYmKC0NBQhIaGYvny5Vi4cCHmzp2LlJQUDBgwAO7u7vj5558RGhr6RLW7ubnBzc1Np93HxwcDBgyo93hEZFyYkarfF1FjxJykjTmp+eBlemRUysvLdU7Ztre3h6Ojo3QrT0tLyypP666c1X90Fj8tLQ0nTpx4olratWsHf39/bNy4UWt/hw8fxvnz53X2LZPJUF5eLrVlZWXV624PQ4cOxffff4+TJ09Kbbdv38bWrVufqH4ifZHL5Rg0aBCSk5Nx/fp1qf3ChQs4ePCgVt9XXnkFcrkcMTExOt+wCyFw9+5drbaysjKtWx+XlpZi9erVsLOzQ0BAAABIAezRWws/CZVKhZKSEqxYsQJBQUFSAFKpVNi8eTNycnJqXAcBAO7du6fTVnmXqsrPsMjISPz222/44osvdPo+ePAA9+/ff6rXQURNEzMSMxIZJ+akPzEnNS88M4qMSmFhIZycnPDaa6+hS5cusLKywpEjR3Dq1CksW7YMABAQEIDExERMmzYNgYGBsLKywssvv4zw8HDs2rULf/nLXxAWFoZr165h1apV8PHxQVFR0RPVs2jRIoSFhSEoKAhjx47FvXv38Omnn8LX11drzLCwMCxfvhyDBw/G66+/jtzcXHz++efw8PDA2bNn67SvGTNmYPPmzRg8eDCmTp0q3bbYxcWlzmMQGUpMTAwOHDgAlUqFqKgolJWVScfKo7+/7u7u+PjjjzF79mxkZWUhIiIC1tbWuHbtGnbv3o3x48fjww8/lPo7OjoiLi4OWVlZ6NixIxITE3HmzBmsWbNGur24u7s7bGxssGrVKlhbW8PS0hI9e/asct2RmvTq1Qumpqa4dOkSxo8fL7X37dsXK1euBIBaQ1ZsbCxSU1MRFhYGFxcX5ObmIiEhAU5OTtIp42+++SaSkpIwceJEpKSkoE+fPigvL8fFixeRlJSEgwcPonv37vWqnYiaPmYkZiQyXsxJFZiTmhlD3MKP6EmVlJSI6dOniy5dughra2thaWkpunTpIhISEqQ+RUVF4vXXXxc2NjZatw/WaDRi4cKFwsXFRSgUCtG1a1exd+9e8dZbb2ndYrjytsVLlizR2T8AER0drdW2c+dO4e3tLRQKhfDx8RG7du3SGVMIIdatWyc8PT2FQqEQXl5eYv369Tq3M63cR3W3ZT579qwIDg4WSqVStG/fXnz00Udi3bp1vG0xGYXvvvtOBAQECHNzc+Hm5iZWrVpV5TEgRMVxFRQUJCwtLYWlpaXw8vISkyZNEpcuXZL6BAcHC19fX3H69GnRq1cvoVQqhYuLi/jss890xtuzZ4/w8fERpqamWrfvrRzjcVUdw0IIERgYqHP78Bs3bggAwtnZWaf/46/vm2++EcOHDxeOjo7C3NxcODo6ilGjRonLly9rbVdaWiri4uKEr6+vUCgUolWrViIgIEDExMSIgoIC3Te3FuAti4maPGYkZiQybsxJzEnNjUyIJ1hpkIiIyMD69euHO3fuID093dClEBERETUqzEnU2HHNKCIiIiIiIiIi0htORhERERERERERkd5wMoqIiIiIiIiIiPSGa0YREREREREREZHe8MwoIiIiIiIiIiLSG05GERERERERERGR3nAyioiImoV+/fqhX79+hi4DADB//nzIZDJDl0FEREQEgDmJ9I+TUURERLXYtm0bVqxYYegyiIiIiBod5iR6ElzAnIiImoXS0lIAgLm5eb23DQ8PR3p6OrKyshqklrKyMpSVlUGpVDbIeERERERPgzmJ9M3U0AUQERHpw5OEq2fF1NQUpqb8E0xERESNA3MS6Rsv0yMiokapcr2AixcvIjIyEs899xzatGmDqVOnori4WOpXVlaGjz76CO7u7lAoFHB1dcWcOXNQUlKiNd7jayF8++23kMlkSEpKwoIFC+Dk5ASlUonQ0FBkZmZqbbdv3z5kZ2dDJpNBJpPB1dUVQgjY2tpi2rRpUl+NRgMbGxvI5XLk5+dL7XFxcTA1NUVRUZHWa3vU4cOHERQUBBsbG1hZWaFTp06YM2eOVp+SkhJER0fDw8MDCoUCzs7OmDFjhs5rJSIioqaNOYk5ydhxupGIiBq1yMhIuLq6YtGiRfj+++/xySefIC8vD5s2bQIAjBs3Dhs3bsRrr72GDz74AGlpaVi0aBEuXLiA3bt31zr+P//5T5iYmODDDz9EQUEBFi9ejNGjRyMtLQ0AMHfuXBQUFODGjRuIj48HAFhZWUEmk6FPnz5ITU2Vxjp79iwKCgpgYmKCY8eOISwsDACgVqvRtWtXWFlZVVlDRkYGwsPD8cILLyA2NhYKhQKZmZk4duyY1Eej0WDYsGE4evQoxo8fD29vb5w7dw7x8fG4fPkykpOTn+j9JSIiIuPFnFSBOcn4cDKKiIgatQ4dOmDPnj0AgEmTJuG5555DQkICPvzwQwghsHHjRowbNw5ffPEFACAqKgr29vZYunQpUlJS0L9//xrHLy4uxpkzZ6TT01u1aoWpU6ciPT0dfn5+GDhwINq3b4+8vDy88cYbWtuqVCrMmjULhYWFsLa2hlqthouLCxwcHKBWqxEWFgaNRoNjx45hzJgx1dZw+PBhlJaW4uuvv4atrW2VfbZt24YjR47gu+++Q1BQkNTu5+eHiRMn4vjx4+jdu3ftbygRERE1GcxJFZiTjA8v0yMiokZt0qRJWo+nTJkCANi/fz/2798PAFqngAPABx98AADYt29freOPGTNGa50ElUoFAPjll19q3ValUqG8vBzHjx8HUPHNnkqlgkqlglqtBgCkp6cjPz9fGrcqNjY2AIA9e/ZAo9FU2Wf79u3w9vaGl5cX7ty5I/2EhIQAAFJSUmqtl4iIiJoW5qQKzEnGh5NRRETUqHl6emo9dnd3h4mJCbKyspCdnQ0TExN4eHho9Wnbti1sbGyQnZ1d6/jPP/+81uNWrVoBAPLy8mrdtlu3bmjRooUUqCpDVt++fXH69GkUFxdLzz36Ld3jRowYgT59+mDcuHFwcHDAyJEjkZSUpBW4rly5goyMDNjZ2Wn9dOzYEQCQm5tba71ERETUtDAnVWBOMj68TI+IiIzK4wtaVtdWV3K5vMp2IUSt25qZmaFnz55ITU1FZmYmbt26BZVKBQcHBzx8+BBpaWlQq9Xw8vKCnZ1dteNYWFggNTUVKSkp2LdvHw4cOIDExESEhITg0KFDkMvl0Gg06Ny5M5YvX17lGM7OznV7wURERNRkMScxJxkLTkYREVGjduXKFXTo0EF6nJmZCY1GI92pRaPR4MqVK/D29pb6/O9//0N+fj5cXFwapIaaQpxKpUJcXByOHDkCW1tbeHl5QSaTwdfXF2q1Gmq1GuHh4bXuw8TEBKGhoQgNDcXy5cuxcOFCzJ07FykpKRgwYADc3d3x888/IzQ09KlCJRERETUdzEnMScaKl+kREVGj9vnnn2s9/vTTTwEAQ4YMwdChQwEAK1as0OpT+a1Y5V1anpalpSUKCgqqfE6lUqGkpAQrVqxAUFCQFIBUKhU2b96MnJycGtdBAIB79+7ptPn7+wOAdDviyMhI/Pbbb9ICpI968OAB7t+/X5+XRERERE0AcxJzkrHimVFERNSoXbt2DcOGDcPgwYNx4sQJbNmyBa+//jq6dOkCAHjrrbewZs0a5OfnIzg4GCdPnsTGjRsRERFR6x1i6iogIACJiYmYNm0aAgMDYWVlhZdffhkA0KtXL5iamuLSpUsYP368tE3fvn2xcuVKAKg1ZMXGxiI1NRVhYWFwcXFBbm4uEhIS4OTkJK2h8OabbyIpKQkTJ05ESkoK+vTpg/Lycly8eBFJSUk4ePAgunfv3iCvl4iIiIwDcxJzkrHiZBQRETVqiYmJmDdvHmbNmgVTU1NMnjwZS5YskZ5fu3Yt3NzcsGHDBuzevRtt27bF7NmzER0d3WA1REVF4cyZM1i/fj3i4+Ph4uIihSxLS0t07doVp06d0lp8szJYOTs713oa/LBhw5CVlYV///vfuHPnDmxtbREcHIyYmBi0bNkSQMXp6cnJyYiPj8emTZuwe/dutGjRAm5ubpg6daq0QCcRERE1H8xJzEnGSibqsvIYERGRns2fPx8xMTG4ffs2bG1tDV0OERERUaPBnETGjmtGERERERERERGR3nAyioiIiIiIiIiI9IaTUUREREREREREpDdcM4qIiIiIiIiIiPSGZ0YREREREREREZHecDKKiIiIiIiIiIj0hpNRRERERERERESkN5yMIiIiIiIiIiIiveFkFBERERERERER6Q0no4iIiIiIiIiISG84GUVERERERERERHrDySgiIiIiIiIiItIbTkYREREREREREZHecDKKiIiIiIiIiIj05v8AF6wmN4TyzHgAAAAASUVORK5CYII=", "text/plain": "Matplotlib figure" }, "metadata": {} } ], "id": "cell-004" }, { "cell_type": "markdown", "metadata": { "html_anchor": "cell-7", "deepnote": { "block_id": "fd7bf9e2a2df4bec9999834a2fcf76ad" } }, "source": [ "**先在每一组内部比较，再看是否翻转。** 大组分解后 MAC 约为标准卷积的 0.127 倍、中位延迟约为 0.363 倍；小组 MAC 约为 0.174 倍，中位延迟却约为 6.786 倍。两组输出接口各自保持相同，但组间 shape 不同。\n", "\n", "**同桌讨论。** 一人只拿 MAC 预测排序，另一人只读保存计时。把分歧写成一个可检验解释：算子实现、额外调用、中间张量或小算子的固定开销，哪一项值得再隔离？当前比较不能唯一确定责任来自内存，也不能推成 MobileNet 无效。\n", "\n", "你应带走的判断是：MAC 比值不能直接换成延迟比值，硬件与 shape 是解释的一部分。\n", "\n", "## 2. 用同一小候选集检验选择目标\n", "\n", "六个实际训练的数字分类器：共同 stem 是 1→8 的 3×3 卷积；第二模块为 standard 或 depthwise＋pointwise，宽度 8／16／32；池化后接分类头。每个候选训练 18 轮，Adam 0.003，batch 64，固定源训练数据、划分与训练顺序；以本候选的验证 CE 最低 checkpoint 评价。宽度和结构改变了模型容量，18 轮并不意味着等训练计算。一个 seed 不能决定普遍最优架构。\n", "\n", "选择规则预先定义为：①验证准确率最高；②验证准确率不低于人工基线 `standard-16`，且单图中位延迟不超过该基线时，选延迟最小者；③随机种子固定、只抽两个候选，用同样约束选择。若约束内无候选，明确回退人工基线。测试标签不用于选择。候选计时固定取测试集首图，不读取其标签；这些网络使用固定 shape 的静态算子，这一步不依据图像内容选择计算路径。本次中位延迟只是点估计，若候选的延迟分布重叠，不能据细小中位数差距宣称稳定排名；这里保留本次测量作选择规则演示。这里演示小规模枚举与成本目标，不复现 MnasNet 的软目标。\n" ], "id": "cell-005" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-8" }, "source": "dataset = load_digits()\nX = torch.tensor(dataset.images[:,None,:,:] / 16.0, dtype=torch.float32)\ny = torch.tensor(dataset.target, dtype=torch.long)\nall_ids = np.arange(len(y))\ntrainval_ids, test_ids = train_test_split(all_ids, test_size=0.2, random_state=SEED, stratify=y.numpy())\ntrain_ids, val_ids = train_test_split(trainval_ids, test_size=0.25, random_state=SEED, stratify=y.numpy()[trainval_ids])\nassert not (set(train_ids)&set(val_ids) or set(train_ids)&set(test_ids) or set(val_ids)&set(test_ids))\nassert len(train_ids)+len(val_ids)+len(test_ids)==len(y)\nsplit_manifest={'dataset':'sklearn.datasets.load_digits; 1797 real 8x8 images; pixel/16',\n 'counts':{'train':len(train_ids),'validation':len(val_ids),'test':len(test_ids)},\n 'train_ids':train_ids.tolist(),'validation_ids':val_ids.tolist(),'test_ids':test_ids.tolist(),\n 'input_sha256':digest_array(X.numpy()),'labels_sha256':digest_array(y.numpy()),\n 'split_policy':'stratified random by sample, NOT writer-disjoint', 'test_labels':'evaluation only'}\nsave_json('split-manifest.json',split_manifest)\nprint('Split:',split_manifest['counts'])\n", "execution_count": 4, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "Split: {'train': 1077, 'validation': 360, 'test': 360}\n" } ], "id": "cell-006" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-9" }, "source": "class Candidate(nn.Module):\n def __init__(self,kind,width):\n super().__init__(); self.stem=nn.Conv2d(1,8,3,padding=1,bias=False)\n self.module=(nn.Conv2d(8,width,3,padding=1,bias=False) if kind=='standard' else\n nn.Sequential(nn.Conv2d(8,8,3,padding=1,groups=8,bias=False),nn.Conv2d(8,width,1,bias=False)))\n self.head=nn.Linear(width*2*2,10)\n def forward(self,x):\n x=F.avg_pool2d(F.relu(self.stem(x)),2)\n x=F.avg_pool2d(F.relu(self.module(x)),2)\n return self.head(x.flatten(1))\nmodels={}; search_rows=[]\nfor kind in ['standard','dw_pw']:\n for width in [8,16,32]:\n torch.manual_seed(SEED); model=Candidate(kind,width); opt=torch.optim.Adam(model.parameters(),lr=.003)\n generator=torch.Generator().manual_seed(SEED+10)\n best_loss=float('inf'); best=None\n for epoch in range(18):\n model.train()\n ids=torch.tensor(train_ids)[torch.randperm(len(train_ids),generator=generator)]\n for batch in ids.split(64):\n opt.zero_grad(set_to_none=True); loss=F.cross_entropy(model(X[batch]),y[batch]); loss.backward(); opt.step()\n model.eval()\n with torch.no_grad(): vl=F.cross_entropy(model(X[val_ids]),y[val_ids]).item()\n if vl=base['validation_acc']-1e-9 and r['median_us']<=base['median_us']\naccuracy_best=max(search_rows,key=lambda r:(r['validation_acc'],-r['median_us']))\ncost_best=min([r for r in search_rows if feasible(r)],key=lambda r:r['median_us'])\nrandom_names=np.random.default_rng(SEED+33).choice([r['name'] for r in search_rows],size=2,replace=False).tolist()\nrandom_pool=[r for r in search_rows if r['name'] in random_names and feasible(r)]\nrandom_best=min(random_pool,key=lambda r:r['median_us']) if random_pool else base\nselections={'manual_baseline':base['name'],'validation_accuracy':accuracy_best['name'],\n 'latency_under_baseline_quality_and_cost':cost_best['name'],\n 'random_two_under_same_constraints':random_best['name'],'random_two_names':random_names,\n 'random_fallback_to_baseline':not bool(random_pool)}\n# Selection has finished. Only now calculate held-out test accuracy for all candidates, including nonwinners.\nfor row in search_rows:\n with torch.inference_mode(): row['test_acc']=(models[row['name']](X[test_ids]).argmax(1)==y[test_ids]).float().mean().item()\n row['pareto_validation_latency']=not any(other['validation_acc']>=row['validation_acc'] and other['median_us']<=row['median_us']\n and (other['validation_acc']>row['validation_acc'] or other['median_us']