From c5ebd60476dbd526ac294b7e63e1fd7b3ef7d7ef Mon Sep 17 00:00:00 2001 From: Ziming Liu Date: Wed, 13 Nov 2024 13:38:26 -0500 Subject: [PATCH] add __init__.py --- .ipynb_checkpoints/LICENSE-checkpoint | 21 + .ipynb_checkpoints/__init__-checkpoint.py | 0 .ipynb_checkpoints/hellokan-checkpoint.ipynb | 4 +- .ipynb_checkpoints/setup-checkpoint.py | 31 ++ __init__.py | 0 hellokan.ipynb | 4 +- model/0.0_cache_data | Bin 0 -> 355 bytes model/0.0_config.yml | 41 ++ model/0.0_state | Bin 0 -> 8275 bytes model/history.txt | 2 + pykan.egg-info/PKG-INFO | 2 +- ...xample_1_function_fitting-checkpoint.ipynb | 395 ++++++++++++++++++ .../Example/Example_1_function_fitting.ipynb | 3 +- tutorials/Example/model/0.0_cache_data | Bin 0 -> 355 bytes tutorials/Example/model/0.0_config.yml | 29 ++ tutorials/Example/model/0.0_state | Bin 0 -> 5779 bytes tutorials/Example/model/history.txt | 2 + .../Interp_1_Hello, MultKAN-checkpoint.ipynb | 347 +++++++++++++++ .../Interp/Interp_1_Hello, MultKAN.ipynb | 39 +- 19 files changed, 884 insertions(+), 36 deletions(-) create mode 100644 .ipynb_checkpoints/LICENSE-checkpoint create mode 100644 .ipynb_checkpoints/__init__-checkpoint.py create mode 100644 .ipynb_checkpoints/setup-checkpoint.py create mode 100644 __init__.py create mode 100644 model/0.0_cache_data create mode 100644 model/0.0_config.yml create mode 100644 model/0.0_state create mode 100644 model/history.txt create mode 100644 tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb create mode 100644 tutorials/Example/model/0.0_cache_data create mode 100644 tutorials/Example/model/0.0_config.yml create mode 100644 tutorials/Example/model/0.0_state create mode 100644 tutorials/Example/model/history.txt create mode 100644 tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb diff --git a/.ipynb_checkpoints/LICENSE-checkpoint b/.ipynb_checkpoints/LICENSE-checkpoint new file mode 100644 index 00000000..2c83bbe2 --- /dev/null +++ b/.ipynb_checkpoints/LICENSE-checkpoint @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Ziming Liu + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/.ipynb_checkpoints/__init__-checkpoint.py b/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 00000000..e69de29b diff --git a/.ipynb_checkpoints/hellokan-checkpoint.ipynb b/.ipynb_checkpoints/hellokan-checkpoint.ipynb index 19a5a2d0..da122205 100644 --- a/.ipynb_checkpoints/hellokan-checkpoint.ipynb +++ b/.ipynb_checkpoints/hellokan-checkpoint.ipynb @@ -119,7 +119,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "cuda\n", + "cpu\n", "checkpoint directory created: ./model\n", "saving model version 0.0\n" ] @@ -528,7 +528,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/.ipynb_checkpoints/setup-checkpoint.py b/.ipynb_checkpoints/setup-checkpoint.py new file mode 100644 index 00000000..bc175730 --- /dev/null +++ b/.ipynb_checkpoints/setup-checkpoint.py @@ -0,0 +1,31 @@ +import setuptools + +# Load the long_description from README.md +with open("README.md", "r", encoding="utf8") as fh: + long_description = fh.read() + +setuptools.setup( + name="pykan", + version="0.2.7", + author="Ziming Liu", + author_email="zmliu@mit.edu", + description="Kolmogorov Arnold Networks", + long_description=long_description, + long_description_content_type="text/markdown", + # url="https://github.com/kindxiaoming/", + packages=setuptools.find_packages(), + include_package_data=True, + package_data={ + 'pykan': [ + 'figures/lock.png', + 'assets/img/sum_symbol.png', + 'assets/img/mult_symbol.png', + ], + }, + classifiers=[ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + ], + python_requires='>=3.6', +) diff --git a/__init__.py b/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/hellokan.ipynb b/hellokan.ipynb index 19a5a2d0..da122205 100644 --- a/hellokan.ipynb +++ b/hellokan.ipynb @@ -119,7 +119,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "cuda\n", + "cpu\n", "checkpoint directory created: ./model\n", "saving model version 0.0\n" ] @@ -528,7 +528,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/model/0.0_cache_data b/model/0.0_cache_data new file mode 100644 index 0000000000000000000000000000000000000000..4c80d366b6c0ef644f4ef786c1b78380f075bf6e GIT binary patch literal 355 zcmWIWW@cev;NW1u09*_b3}lpI(4BI|uKjt+had7(h4x zrSG5n85to0AS%F{l?}vW0z!~_ Gh*|(G!zmyD literal 0 HcmV?d00001 diff --git a/model/0.0_config.yml b/model/0.0_config.yml new file mode 100644 index 00000000..fe806931 --- /dev/null +++ b/model/0.0_config.yml @@ -0,0 +1,41 @@ +affine_trainable: false +auto_save: true +base_fun_name: silu +ckpt_path: ./model +device: cpu +grid: 3 +grid_eps: 0.02 +grid_range: +- -1 +- 1 +k: 3 +mult_arity: 2 +round: 0 +sb_trainable: true +sp_trainable: true +state_id: 0 +symbolic.funs_name.0: +- - '0' + - '0' +- - '0' + - '0' +- - '0' + - '0' +- - '0' + - '0' +- - '0' + - '0' +symbolic.funs_name.1: +- - '0' + - '0' + - '0' + - '0' + - '0' +symbolic_enabled: true +width: +- - 2 + - 0 +- - 5 + - 0 +- - 1 + - 0 diff --git a/model/0.0_state b/model/0.0_state new file mode 100644 index 0000000000000000000000000000000000000000..5330a3bb8736dc294587deff0d39df6c7252807e GIT binary patch literal 8275 zcmeI133L=i8i0F}Ofs1$XMk{ogs?~u5@vEvG%z8s(X|D~MqmtJm`o-Ib1h~*ry$>| zex@kHQe?@PkYnc6z>MHP5pE1XbbdjGB`rP2WKGk6mzggpGG|Ao74tc{R&`pDCA~N& zHzSR=?iG~o0 z2^BFz2quhThVt+$4u-k)t`;7VA!1-SA{0D?69j6HAU}^%#7G`SaS-9&Ct8SA|GKvnKKuRDFPZEk3t1gA#uxeIO3QtiI z%fr(gOmrie3oMy1Nk&S5XONW0gMpHitZx}S%MNCJSw$Iels1`%=Qx<+M$0o<=fG4K z%?rnaRs+)zr{=*Z;!5FpR!JO7rKssV%-~?AF%WAvH<6B?bd%KrFUWyfNTa}6E})45 z(<#u*Lk0&HW3Lu~)Dug@dKCAZQ~cK`502cES)2?)dpF2=I@pLj9CVu~ z&#M&Pz)6Aa-As9J^6(Z1ZyWn~@=TeTIr$c-kP{Q&9VCYHP$?2wpE7utRk1!~R&1fv z_jq`pgDOuiwUL6CTV>2B4OG)s*AS+HRhGgwI`nEOZ#xe=IN0gwr8ZLZa+jQ_h22QR zRp0}WNW83L1F4sLDD}5I?B!rzu?_Yc{jvRNc^2M8c11WKY%B-EjabUSAsZYP_N=*< zA}j8N@FAt?9xeXeHo5j}jNCWGq zy3pU6+86DT%h2j6L&e01r;O2>lw?hdXN(q(9j+p5K!+0XsBX;Po5Ha+x!Uq5%;}Lf zC3$c=9#P}h_3cSw|Lmw8=i0aL&kS+d$1VwO+ky7%cJ@B;^ND+^nFdr8u2v)G&m_3~ z#Eyz>+fP@(-2REyUCigJFX?|gA2DQ8zi%CioR6EHi#Y5UIph44Z%3YX{Nq%wwOw7^1&}z)veYe)n zL&==Gl4Zg2{cGY4>rnRfWrpuU*>I%jpG)xm+U=Xa+JX7dTTKh+h8%0Jvo-2P&Nur7|tDqq*R z{U^R%`@d}abse-%y?7A6WPDr>8d~1D{UhOL%)bZW_5Ut|#B1WT<2#dZtt40L^I65H zo%0#DdtY%nceLk-osOL!CFi%Oj-KDz_o8d|@m$uS^JDw=|5G(cyUmmRYAewJasWL(5f>~*{n zM+v#w8kes5hudMt=U@4?15d4XF!q!8?)^y4gC|0|{cRIU!x=+aEy{-cFT+TlsabYD z6Xh-A*T+_3{lOapuJ6Qr&48b{a+I2#_B&O2hMC13`d2mPnezF}T9i|R?OWb(FiAc8 zS6`{ayz;7l++M8LP!eAAKIW57Xl_=ZWNxpq&q3+^u6h644yJNSY~O2pF~7~Ut8l*_ z&#PxIogrL%UiS>bWel}1a9G|Dy(n-3<`;j@W)))Ie(4S$jWTia#i2w$NtblL67$UL z&l*;vYz#g(+m7X58uyu(p=8hOnL+&SG2M~1AM=Kg$9IwX_L{N!wI~M-2+hR2{otX4 z{fHl%SEN=Q#(IT*OA_{Bp1JXKgurKfZw|uzsCP;hk#qCu_wJtFjxuPWY1LaOXX%EA z2>o(pNj2$b#y)9D8A|27z@`n@Kf(TEUm^Xox#Ip-;T&JMr?!gJJ5e*4oZlJyoU7xo z->+5`+lA`Iu)8Y^y5~)|C|2KUHK+A@9%0WndLVxV~vg-$SX%4Owdb!sV_f-R;S$ z*qkykOZ7%;+_j|dc;s5Qo3*s=TGBTzkpnfh}9>YVrUdpvJK`t$i(IH&}@`T&3}Q)B%vPpBG3E~LVg(r*K#aV`jY>H@Q>7|b^i^q=CL{e literal 0 HcmV?d00001 diff --git a/model/history.txt b/model/history.txt new file mode 100644 index 00000000..c3fab35f --- /dev/null +++ b/model/history.txt @@ -0,0 +1,2 @@ +### Round 0 ### +init => 0.0 diff --git a/pykan.egg-info/PKG-INFO b/pykan.egg-info/PKG-INFO index 3136e8cb..005e7ee5 100644 --- a/pykan.egg-info/PKG-INFO +++ b/pykan.egg-info/PKG-INFO @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: pykan -Version: 0.2.6 +Version: 0.2.7 Summary: Kolmogorov Arnold Networks Author: Ziming Liu Author-email: zmliu@mit.edu diff --git a/tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb b/tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb new file mode 100644 index 00000000..81259edb --- /dev/null +++ b/tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb @@ -0,0 +1,395 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5d904dee", + "metadata": {}, + "source": [ + "# Example 1: Function Fitting\n", + "\n", + "In this example, we will cover how to leverage grid refinement to maximimze KANs' ability to fit functions" + ] + }, + { + "cell_type": "markdown", + "id": "94056ef6", + "metadata": {}, + "source": [ + "intialize model and create dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0a59179d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cpu\n", + "checkpoint directory created: ./model\n", + "saving model version 0.0\n" + ] + } + ], + "source": [ + "from kan import *\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "print(device)\n", + "\n", + "# initialize KAN with G=3\n", + "model = KAN(width=[2,1,1], grid=3, k=3, seed=1, device=device)\n", + "\n", + "# create dataset\n", + "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "dataset = create_dataset(f, n_var=2, device=device)" + ] + }, + { + "cell_type": "markdown", + "id": "cb1f817e", + "metadata": {}, + "source": [ + "Train KAN (grid=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a87b97b0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 4.16e-02 | test_loss: 4.35e-02 | reg: 9.79e+00 | : 100%|█| 20/20 [00:03<00:00, 6.03it" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "model.fit(dataset, opt=\"LBFGS\", steps=20);" + ] + }, + { + "cell_type": "markdown", + "id": "52294efd", + "metadata": {}, + "source": [ + "The loss plateaus. we want a more fine-grained KAN!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3f1cfc9d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.2\n" + ] + } + ], + "source": [ + "# initialize a more fine-grained KAN with G=10\n", + "model = model.refine(10)" + ] + }, + { + "cell_type": "markdown", + "id": "f3cc5079", + "metadata": {}, + "source": [ + "Train KAN (grid=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "898b1794", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 6.96e-03 | test_loss: 6.10e-03 | reg: 9.75e+00 | : 100%|█| 20/20 [00:02<00:00, 7.32it" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "model.fit(dataset, opt=\"LBFGS\", steps=20);" + ] + }, + { + "cell_type": "markdown", + "id": "bcdc0d3d", + "metadata": {}, + "source": [ + "The loss becomes lower. This is good! Now we can even iteratively making grids finer." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a1c25e8a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "checkpoint directory created: ./model\n", + "saving model version 0.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 1.46e-02 | test_loss: 1.53e-02 | reg: 8.83e+00 | : 100%|█| 200/200 [00:10<00:00, 19.67\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.1\n", + "saving model version 0.2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 2.84e-04 | test_loss: 3.29e-04 | reg: 8.84e+00 | : 100%|█| 200/200 [00:15<00:00, 13.09\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.3\n", + "saving model version 0.4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 4.21e-05 | test_loss: 4.04e-05 | reg: 8.84e+00 | : 100%|█| 200/200 [00:09<00:00, 21.22\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.5\n", + "saving model version 0.6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 1.02e-05 | test_loss: 1.24e-05 | reg: 8.84e+00 | : 100%|█| 200/200 [00:10<00:00, 18.76\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.7\n", + "saving model version 0.8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 1.64e-04 | test_loss: 1.74e-03 | reg: 8.86e+00 | : 100%|█| 200/200 [00:17<00:00, 11.72" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "grids = np.array([3,10,20,50,100])\n", + "\n", + "\n", + "train_losses = []\n", + "test_losses = []\n", + "steps = 200\n", + "k = 3\n", + "\n", + "for i in range(grids.shape[0]):\n", + " if i == 0:\n", + " model = KAN(width=[2,1,1], grid=grids[i], k=k, seed=1, device=device)\n", + " if i != 0:\n", + " model = model.refine(grids[i])\n", + " results = model.fit(dataset, opt=\"LBFGS\", steps=steps)\n", + " train_losses += results['train_loss']\n", + " test_losses += results['test_loss']\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "6be8ba55", + "metadata": {}, + "source": [ + "Training dynamics of losses display staircase structures (loss suddenly drops after grid refinement)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "156f68a2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(train_losses)\n", + "plt.plot(test_losses)\n", + "plt.legend(['train', 'test'])\n", + "plt.ylabel('RMSE')\n", + "plt.xlabel('step')\n", + "plt.yscale('log')" + ] + }, + { + "cell_type": "markdown", + "id": "6ed8d26b", + "metadata": {}, + "source": [ + "Neural scaling laws (For some reason, this got worse than pykan 0.0. We're still investigating the reason, probably due to the updates of curve2coef)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8301085c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'RMSE')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_params = 3 * grids\n", + "train_vs_G = train_losses[(steps-1)::steps]\n", + "test_vs_G = test_losses[(steps-1)::steps]\n", + "plt.plot(n_params, train_vs_G, marker=\"o\")\n", + "plt.plot(n_params, test_vs_G, marker=\"o\")\n", + "plt.plot(n_params, 100*n_params**(-4.), ls=\"--\", color=\"black\")\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.legend(['train', 'test', r'$N^{-4}$'])\n", + "plt.xlabel('number of params')\n", + "plt.ylabel('RMSE')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c521e5e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/Example/Example_1_function_fitting.ipynb b/tutorials/Example/Example_1_function_fitting.ipynb index ba369ab8..81259edb 100644 --- a/tutorials/Example/Example_1_function_fitting.ipynb +++ b/tutorials/Example/Example_1_function_fitting.ipynb @@ -28,7 +28,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "cuda\n", + "cpu\n", "checkpoint directory created: ./model\n", "saving model version 0.0\n" ] @@ -37,7 +37,6 @@ "source": [ "from kan import *\n", "\n", - "\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "print(device)\n", "\n", diff --git a/tutorials/Example/model/0.0_cache_data b/tutorials/Example/model/0.0_cache_data new file mode 100644 index 0000000000000000000000000000000000000000..4c80d366b6c0ef644f4ef786c1b78380f075bf6e GIT binary patch literal 355 zcmWIWW@cev;NW1u09*_b3}lpI(4BI|uKjt+had7(h4x zrSG5n85to0AS%F{l?}vW0z!~_ Gh*|(G!zmyD literal 0 HcmV?d00001 diff --git a/tutorials/Example/model/0.0_config.yml b/tutorials/Example/model/0.0_config.yml new file mode 100644 index 00000000..fd1053d2 --- /dev/null +++ b/tutorials/Example/model/0.0_config.yml @@ -0,0 +1,29 @@ +affine_trainable: false +auto_save: true +base_fun_name: silu +ckpt_path: ./model +device: cpu +grid: 3 +grid_eps: 0.02 +grid_range: +- -1 +- 1 +k: 3 +mult_arity: 2 +round: 0 +sb_trainable: true +sp_trainable: true +state_id: 0 +symbolic.funs_name.0: +- - '0' + - '0' +symbolic.funs_name.1: +- - '0' +symbolic_enabled: true +width: +- - 2 + - 0 +- - 1 + - 0 +- - 1 + - 0 diff --git a/tutorials/Example/model/0.0_state b/tutorials/Example/model/0.0_state new file mode 100644 index 0000000000000000000000000000000000000000..f53d599836a644c0672bfe9d0e0ec1af58813b78 GIT binary patch literal 5779 zcmbuD*?$vN6vroB(ll%ZS}Y2-1;v68GTnY-}KRQ=1wN}PMX@%>F0Jj%kO*6z31F>Z>L$y z&QTPXOG!K2O0nWy+!0^_PtTTUQ)8jBVVI*oD;SJLqoE*+#Jc0|wY?po-cZNtNRYWf znXiMR+&2Ny-La04zdaI&`@N7AWU=00*yHbGk!alQ?+vy0MWP*k7V3`2di`4~+>l*f z?#n}29N!FV3PBE+xSOJ}09(gzx*^x+z<0dh^kw5Y*wY7jnuCF>MN>4#cF3n+?ww(B zV*-PTI!y9SO!^WJ2BIN!W^x#9g>%B3rNWf3!6+~pQ;9K+Go~{r)S<{XnH=kD7rQh= zqEx_ToKkF3W)kIcPPu}?EFEV1rU;azGgnHON+{u&QWH}~m^mCXm%&v!Tx}a%73N8Z zD!7It%1y+4LM-5jYZ)xmVUc}IRPacQYFNw}UX!5`qk=Ok8C2;|ojxWi)JT*XsO6M8 zlTuHVC7f~{gQYqw8)i&YST12|VFkxDn3$D>Y2=ty3|8xKz2QtC$o!ps-5#%JQ*WdL znj}gc+<=rq1~(EVOLGsvO`2PC48YBtq%pWfhcz}*Fc#{BTP0FGtVPm92F;x0(42$N zqB-%$F$g-Rtz*!tLz|7(6^L(v^%gA)^Fj5(ZHUWa;4^UpaJ%Lp$2M@(9SrW&;Vxex zzMbkK&!6@{JOp>kKo$HPxX}UzIIx`qgA6)!2>GTB1B~}Tr;MwBO&k}ta1oB%%yC;7 zM0Mzrx~lRJbjzqph#|_&podTniUIH#^m0_30n?$+hB9KXRYq08J&1BLxR;}hAZ$wp z;XaPLpTPqx0eP5odpR#_0A9pNfl2og=e^9}6&+sn6{Yh6ot=^H5bTqQ_3#=JT@3b{ zL@j3!4rnedhi1j=ocacXH+6U`-AmPDc=@)(tnk7?-s^X)UcbwGeTehkV{ll9Bk5kM z9@ESBWuginATfu*hbED{Jc>RVUVg->A2awwhfn(w@R=_k`|s}xu>dWK@VT+Dd{OSh zy9#`nfUk@tYip=Cj!PjN(;RW*hB-~)cmhs@jl0CLCNG>!z$t!To`W=^f4num_0GbIrQAx(qim z3bm2UIg{qprp7EZrzrg^NWXdWfy4i=&sTCSJ^JfV41JQZyTy5dMw(h?AM%xz76YAF zHugTJdcR>qtmWLYu9l-Gs1FAR%QlbAe#N-$Q{OMW|CQsm?@$^}uWu{DcHtEIaq7^a zLnpBhwxR}nr-8<&_Rrso%P}_8Mv70F6`!i6#@Qps2T>={)-pvoeH^KH-hYCw z$zI8-l7eDmcKPd{(4*X7`fB>+dsKu%l}#{|1Zsc zovFvcF~%p)6}dPkG`9S$A9wz6>zRL3-;T7oXO`kC)H27>r7TFs5vSF>QHBwb$Q*6` z66#Myvi@AE9&3+LzsQ5sLB6zU$Nnn7ThvDC?~-JHaT?c*vcKcYUzcLlZ=9OEevhU9 zf*z;Z*z3Qb$LTXJ`#62ZWgn*x=|@}tM*AMczg63%HB;gh(T;eX?G1OBZn#pihLKS};|ui0_di#Mrd&d+>hCg!KP9cyYV8a_cQ-9-F# z-=;SD2aH;?=Ae`HO+?(txaom(q`r{Yb>fbMs#@xxBFA-$y>^wj50O>pQ!3T25_cZ7 zyG$L0cxl>F(~OB523baX-K1;`*8UJ=6?P}Z<=18n$2DoK(k>HMQCaq{Agi*=#DSD$ zVf-MKv{r4GiR+*&J1@v;?6S<(3UQO2v{q}Ei7TFLtyPfK*=6E_B+K>+vUvx?A literal 0 HcmV?d00001 diff --git a/tutorials/Example/model/history.txt b/tutorials/Example/model/history.txt new file mode 100644 index 00000000..c3fab35f --- /dev/null +++ b/tutorials/Example/model/history.txt @@ -0,0 +1,2 @@ +### Round 0 ### +init => 0.0 diff --git a/tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb b/tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb new file mode 100644 index 00000000..985eb3ad --- /dev/null +++ b/tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb @@ -0,0 +1,347 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c982abca", + "metadata": {}, + "source": [ + "# Interpretability 1: Hello, MultKAN!" + ] + }, + { + "cell_type": "markdown", + "id": "30fde2f3", + "metadata": {}, + "source": [ + "Motivation: The original KAN has some level of interpretability, but sometimes not fully interpretable (fully interpretable = convert the network to a symbolic formula). The biggest limitation is the lack of multiplications operators. The original KAN only has addition operators. Although multiplication can be expressed as addition and single-variable functions (which is the core idea of Kolmogorov-Arnold representation theorem), we still hope to explicitly have multiplications in the KANs so that multiplications can be more easily read out from KANs. " + ] + }, + { + "cell_type": "markdown", + "id": "72377ee4", + "metadata": {}, + "source": [ + "We first show how multiplications can be represented by addition and single variable functions. Usually KAN would find solutions leveraging linear functions and quadractic functions (the solutions are not unique). $$xy=((x+y)^2-(x-y)^2)/4=((x+y)^2-x^2-y^2)/2=\\cdots$$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "76538154", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'kan'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mkan\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;241m*\u001b[39m\n\u001b[1;32m 2\u001b[0m torch\u001b[38;5;241m.\u001b[39mset_default_dtype(torch\u001b[38;5;241m.\u001b[39mfloat64)\n\u001b[1;32m 4\u001b[0m device \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mdevice(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcuda\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcuda\u001b[38;5;241m.\u001b[39mis_available() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'kan'" + ] + } + ], + "source": [ + "from kan import *\n", + "torch.set_default_dtype(torch.float64)\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "print(device)\n", + "\n", + "model = KAN(width=[2,5,1], device=device)\n", + "\n", + "f = lambda x: x[:,0] * x[:,1]\n", + "dataset = create_dataset(f, n_var=2, device=device)\n", + "model.fit(dataset, steps=20, lamb=0.001);" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "939224b9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2ec84826", + "metadata": {}, + "source": [ + "This network seems to be using the equality $xy=((x+y)^2-(x-y)^2)/4$ but not exactly." + ] + }, + { + "cell_type": "markdown", + "id": "b33ecf62", + "metadata": {}, + "source": [ + "Now we want to explicitly introduce multiplication operators, called MultKAN. Note that MultKAN and KAN are actually the same class in implementation, so you can use either class name. If you dig into MultKAN.py, there is a line 'KAN = MultKAN'. KAN is just a special case of MultKAN. To inlcude multiplications, you only need to modify the width parameter. For example, [2,5,1] KAN means 2 inputs, 5 hidden add neurons, and 1 output; [2,[5,2],1] MultKAN means 2 inputs, 5 hidden add neurons and 2 hidden mult neurons, and 1 output." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d8f94f0f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "checkpoint directory created: ./model\n", + "saving model version 0.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACH5ElEQVR4nO2dd5hU5dnG7+mzO9tne4cFBHbpXcUaMWoUrICAFUURsEf91MQSozFWSowKaqQIdk1iSUgsEOltWZZetreZ3en9nPf7g7wns8vM7pQzbX1/18WV71t3Z54zc865z9MlhBACBoPBYDBERBprAxgMBoPR/2DiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgBAghBDabDWwzOIPRN0xcGIw+6OzsxEMPPYTMzExoNBpkZmbioYceQmdnZ6xNYzDiFglhj2EMhl86OzsxZcoUHD9+HBzHCT+XyWSoqKjAli1bkJWVFUMLGYz4hHkuDEYv/P73vz9DWACA4zgcP34czz//fIwsYzDiG+a5MBh+IIQgMzMTRqPR7++kp6ejq6sLEokkipYxGPEPExcGww82mw0ajabP37NarUhOTo6CRQxG4sDCYgyGH5KSkpCent7r76SnpyMpKSlKFjEYiQMTFwbDDxKJBPPnz4dMJvP532UyGe644w4WEmMwfMDCYgxGL7BqMQYjNJjnwmD0QlZWFrZs2YL7778fKSkpAICUlBTcf//9TFgYjF5gnguDESC7du3C+PHjsXPnTowbNy7W5jAYcQ3zXBiMAKG5FZZjYTD6hokLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDEQAcx8FgMAAAXC5XbI1hMBIACSGExNoIBiOe2bRpE5YtW4b29nYYDAZkZmZi1qxZuOWWW6BSqWJtHoMRlzBxYTB6Yd26dfjzn/+M5557Dnq9HidOnMCMGTPw3nvvoaGhAW+//TbkcnmszWQw4g4mLgyGH1paWnDRRRfh+++/R25uLm699VasWbMGRqMRSUlJeOaZZ1BSUoLbb7891qYyGHEHy7kwGH549913sXDhQkilUuh0OjgcDgCATqeDXq/HPffcg+XLl8fYSgYjPmH+PIPhh82bN+Ohhx7CuHHjAACdnZ3gOA7nnnsuJBIJHnjgAchkMrhcLiiVyhhby2DEF0xcGIweWCwWbN++HXV1dfB4PJg8eTIAYPv27bDZbJgwYQLkcjmKiorg8XjAcVyMLWYw4g8mLoyfPR6PB9XV1diyZQu2bNmCffv2wePxAAC++uorrF+/HgBw2223Yc2aNfjLX/4CjUaDpqYmcByHPXv2oLi4GCkpKVCr1VCpVJDJZLE8JAYj5jBxYfzsIITg1KlTgpjs2LEDFosFKSkpGDVqFBYuXIiJEyciKysLV155JTZv3oypU6dCJpNBLpdDKpXCarViwYIFmDt3Ltra2tDU1ISsrCzk5eUhIyMDCoUCKpVKEBuJRBLrw2YwogqrFmP8LOjs7MTWrVsFQWlra4NcLsfIkSMxZswYVFVVYdCgQUhJSYFGowHHcXA6nTh16hSWLFmCadOmoby8HCaTCXl5eVi1ahUOHToEuVyOP//5zygvL0d9fT0sFgvUajUKCgqQmZkJiUQCiUQCpVIpiA3LzzB+DjBxYfRLnE4ndu/eLYjJoUOHAACDBg3C5MmTMWbMGAwePFjwRqioSCQSmM1mcByHlJQUKJVK6PV6fPjhh9i0aRNaWlowYcIE3HTTTSguLsbtt9+OH374Ac8++ywWLFgAnU6Huro6tLW1QSqVIj8/H3l5eVCr1XA4HCCEQCqVdvNqWJ8Moz/CxIXRL+B5HocPH8aWLVvw008/Yc+ePXC5XMjJycHkyZMxZcoUjB07FklJSbBarSCEICkpCSkpKUhKSgIAuN1umM1mSCQSpKWlnZE3MRgM+O6773DRRRchPT0dwOmxMM888wyWLVuGWbNm4ZVXXhGEpL6+HnV1dXA4HMjIyEBpaSlyc3PhdrvhcDiEMTJyubyb2EilrEOAkfgwcWEkLC0tLYJnsm3bNnR1dUGtVmP8+PGYMmUKzj77bAwcOBB2ux1msxkulwsymQwpKSlISUnpJh4OhwNWqxUKhQKpqak+cyRGoxHff/89LrjgAkFcKB999BGWLFmC4cOHY/Xq1SgsLARwOr/T3t6OU6dOob29HXK5HMXFxSgrK0NKSgqcTiecTiccDodQRNAzhMbyNYxEhIkLI2GwWCzYsWOH4J3U1dVBKpWisrISU6ZMwZQpUzBy5EgolUq43W5YLBZYrVbwPA+1Wo3U1FTBS6EQQmC1WuF0OqFWq6HRaPy+f2/iAgD79u3D3Llz4XK58P7772PSpEnd/rvdbkddXR3q6+vhdDqRmZmJ8vJyFBQUQCaTgeM4OBwOQWx4nodEIunm1SgUCnE+TAYjwjBxYcQtHo8H+/fvF7yT6upq8DyP4uJiQUwmTZqEtLQ0AKeFwmazwWKxwOl0QiaTQaPRICUlxWdeg+d5Ib+i0Wj6HELZl7gAQEdHB2699Vbs2LEDf/jDH3DLLbf4fN+2tjbU1dWho6MDCoUCJSUlgjdDoeEzGkIjhEAmk3UTG1byzIhXmLgw4gbvEuGtW7di+/btsFqtSE1NFfImU6ZMQXFxcbe/8+Wl0FyKv5CSx+OB2WwGAKSmpgaUVA9EXKg9jz/+OFauXIlbbrkFL7zwgt8KMavVivr6etTX18PlckGr1aKsrAwFBQXdci+EkG4hNLfbDQCs5JkRtzBxYcSUrq4uwTPZunUrWltbIZfLMXr0aEFMKisrz0hyE0Jgt9thsVjgcDgglUqFXEpfQuF0OmGxWCCXy5GamhpwAj1QcaGsXr1aGB/zl7/8BTk5OX5/l+d5tLa24tSpU9Dr9VAqlYI34ytUx/N8txAax3Gs5JkRVzBxYUSV3kqEqZiMGzcOycnJPv/e4/HAYrHAYrGA53moVCohlxLIU7vVaoXD4egzv+KLYMUFAHbs2IF58+ZBJpNhzZo1GDNmTJ9/Y7FYUFdXh4aGBrjdbmRnZ6O8vBx5eXl+hdDj8XQTG1byzIg1TFwYEcW7RHjLli3YvXs3XC4XsrOzBTGZPHlyr0/1vrwUmksJNMHN8zwsFgvcbjc0Gg3UanXQxxKKuACnq9rmzZuHAwcO4LXXXsPMmTMDtrm5uRl1dXXo7OyESqVCaWkpSktL/YovcPrz6pmvAVjJMyO6MHFhiE5ra2u3UJevEuGKioo+PQ2PxwOr1QqLxQKO46BSqZCSkoLk5OSgcguh5Fd8Eaq4AKc9tgcffBDr1q3DwoUL8dRTTwVlh9lsRl1dHRobG+F2u5Gbm4uysjLk5eX1+VnwPM9KnhlRh4kLI2x8lQhLJJJuJcKjRo0KOAdAvRS73Q6pVIrk5GSkpqaGVIbrdDphtVohk8mCyq/4IhxxAU57FG+99RaeeOIJnHvuuVi1ahWysrKCeg2O49DU1IS6ujoYDAao1WqUlpairKwsYG+MlTwzogETF0bQ+CsRLioq6lYiHMwNmOM4IZfCcRyUSmW3kSyhYLPZYLfboVKpwnodSrjiQtm0aRNuvfVWpKamYu3atRg+fHjI9tTV1QnTmfPy8lBWVoacnJygjpWVPDMiARMXRp8QQlBXVyeISaAlwoHgcDhgNptht9shkUiEXEo4lU6EEJjN5rDyK74QS1wAoL6+HnPnzsWJEyfwxhtv4Morrwz5tTwej+DN0BXMZWVlKCkpCfrYWckzQyyYuDB80tXV1W2KcKAlwoHAcZyQS/F4PIKXkpycHHaSmeM4mM1m8DwfcijNH2KKC3Das1q8eDE+++wzPPjgg3jsscfCPn6DwSB4MzzPIz8/H2VlZcjOzg5JEFjJMyNUmLgwAIRfIhwIDocDFosFNpsNEokEycnJSElJ6bMzPlBcLhcsFgukUilSU1NFD+WILS7AaU9h6dKleOaZZzBt2jS8+eabwsSBcHC73WhsbERdXR3MZjM0Gg1KS0tRUlIS1udNS56p4LCSZ4Y/mLj8TOlZIrxnzx44nU5kZ2cLoa7JkycjNzc37PehuRSPxwOFQiHkUsQshaX5FeoFRSJsEwlxoWzcuBHz589Hbm4u1q1bh0GDBon22p2dnairq0NzczMAoKCgAGVlZdBqtWG9LiEELpdL8GpYyTPDGyYuPyP6KhGeMmUKBg0aJMqNmXbB22w2ABDdS6EQQmCxWOByuZCcnHzGYEoxiaS4AMDx48cxZ84ctLS04O2338a0adNEfX23242GhgbU1dUJmzdpbkaM8GFvJc9UaFjJ888HJi79GO8S4S1btuDUqVNhlQj3Bc/zQi7F7XYLS7hSUlIi8vTqnV8JtwggECItLsDpfpa77roL33zzDR5//HHcf//9EbkZ6/V61NXVoaWlBQBQWFiIsrKyoEuje4OVPP+8YeLSj6AlwjQRv2/fvrBLhAOhp5dCl3CJVaXlC7rYK1L5FV9EQ1yA0yL94osv4sUXX8T06dOxYsWKsHJdveF0OtHQ0ID6+nqhArCsrAzFxcWi3/hZyfPPCyYuCUxvJcKTJk0SBKWkpET09+Z5HjabTSj59V4VHOkbhN1uh81mi2h+xRfREhfKX//6V9x9990YMGAA1qxZg7Kysoi9FyFEWNHc2toKqVSKoqIilJWVISMjIyLvx0qe+zdMXBIMfyXCo0aNEsSkqqoqYklUWpFFVwXTXEokvRSK92KvpKSkiD3N+yPa4gIABw8exJw5c2AymfDOO+/gvPPOi/h7OhwOITdjt9uRnp6OsrIyFBUVRawSjOO4bmLjXfLsna9hJA5MXOIcp9OJPXv2CGJy8OBBAP8rEZ48eTLGjx8f0RstvanTxLm/VcGRxHuxVzTyK76IhbgApx8obr/9dmzatAnPPPMM7rrrrqg80RNC0NHRgbq6OrS1tUEmkwneTKSPn5U8Jz5MXOIMnudx5MiRblOEnU4ntFpttynC4ZYIBwL1Umw2G3ieF3IpkazI8gXNr0gkkrAGT4ZLrMQFOH2zffrpp7FixQrMnj0br7zyiuiVd71ht9uFpWYOhwMZGRmCNxPpBwxW8pyYMHGJA3yVCKtUKkyYMEH0EuG+8LUqmOZSYnFTdzgcsFqtUCgUSE1NjWkMPpbiQvnoo4+wZMkSDB8+HKtXr0ZhYWFU358QIqxobm9vh0KhQHFxMcrKypCamhoVG1jJc2LAxCUG+CsRHj58uCAmo0ePjmroJ5RVwZHEO78SymKvSBAP4gIAe/fuxbx58+ByufD+++9j0qRJMbHDZrMJ3ozT6URWVpawojmaVV+05JmG0FjJc3zAxCUKcBzXbYowLREuLCzE2WefjSlTpmDixIkRqcrpDV9eCh0cGct4tnd+RaPRRDX80xvxIi4A0NHRgVtuuQU7d+7Eiy++iJtvvjlmtvA8L3gzHR0dUCgUwormlJSUqNvTM4TGSp5jAxOXCEAIQX19PX766Sds2bIFO3bsEDqie5YIx8Ir6LkqONZeSk/bxFjsFQniSVyA0zfRxx9/HKtWrcKtt96K559/PuYVVVarVVjR7HK5oNVqBW8mFjmR3kqeqdCwkufIwMRFJLxLhLdu3YqWlhbIZLIzpgjH6onJ16pgWvEVLzdw2owpl8vDXuwVCeJNXCjvv/8+Hn74YYwfPx7vvfderyujowXP82hpaUFdXR30ej2USqWwojmWIU5W8hw9mLiEiL8S4YqKCkFMIl0iHAjUS7FarWGtCo40VqsVDocDarU67myjxKu4AMC2bdtw0003QaFQYM2aNRg9enSsTRKwWCyCN+N2u5GTkyOsaI71A4Tb7RaEhpU8iwsTlwDprUTYe2FWNEqEA4HmUqiXQnMp8ZbYpFOTxV7sFQniWVwAoKWlBXPnzkVtbS2WLl2K66+/PtYmdYPjOMGb6ezshEqlElY0R7u83Res5FlcmLj0QltbmyAmW7ZsEUqEvacIDx48OG6esj0ej9DsGM9eCsU7vxKPwteTeBcX4LRH/cADD+CDDz7AwoUL8dRTT8Xlk7fJZEJdXR0aGxvh8XiQm5sreDPxcq6ykufwYOLihXeJ8NatW3Hy5MmYlwgHAs2l2O12SKVSYSRLvNnpjdPphNVqhUwmi8v8ii8SQVyA00/gb775Jp588klMnToVq1atQmZmZqzN8gnHccKKZoPBALVajbKyMpSWlsadF8tKnoPjZy0uPUuEq6urwXFczEuEA4HjOCGX4r0qWKPRxP2TFF3spVKpEsJeSqKIC+XHH3/EbbfdhrS0NKxZswbDhw+PtUm9YjQaBW+G53nk5eWhrKwMOTk5cXmOsJLn3vlZiUu8lwgHQs9VwTSXEs9eCoUQIkxRjvRir0iQaOICAHV1dZg7dy5OnjyJN954A1deeWWsTeoTj8eDpqYmnDp1CiaTCcnJyUKlWbz0PPWElTyfSb8Xl66uLmzbtk3wTmiJ8KhRowTvJJYlwoHAcZyQS6GrglNTU5GcnJwQ4SSg+2Kv1NTUhAwfJKK4AKc9xUWLFuHzzz/Hww8/jEceeSRhzpuuri5hRTPP88jPz0d5eTm0Wm1c36hpyTMNof0cS577nbg4nU7s3btX8E4OHToEQggqKiqEqq7x48fHxTiRvqBeit1uBxC5VcGRhg7AjOZir0iQqOICnH6yfv311/Hss8/i0ksvxZtvvhm1WWBi4Ha70djYiLq6OpjNZmg0GmFFcyLcpH+OJc8JLy6JViLcF7Q019tLobmURHna9CZWi70iQSKLC+Wf//wn7rjjDuTl5WHdunWoqKiItUlB09nZKXgzAFBQUICysjJotdoYWxYYP5eS54QUF+8S4a1btwo18/FaIhwIPVcFJ6qXQiGECPtfEjG/4ov+IC4AcOzYMcyZMwdtbW14++23cckll8TapJBwuVxobGzEqVOnYLVakZKSIngziRR27a8lzwkhLlartdsUYVoiPGzYsG4lwol2I+Z5XsileK8KTklJSeinFu/8SqIUGwRCfxEX4HSfyV133YVvv/0WTz75JO69996Eu3l5472iGQAKCwtRXl4etyXYveHxeLqF0BK15DkuxYXjONTU1HSbIkxLhKmYTJw4MSFPHOD0E5fZbIbNZov6quBIQxd7JXp+xRf9SVyA0w83L7zwAl566SXMmDEDy5cvj/m4onBxOp3CimabzYa0tDRhqVki3JB9kaglz3EnLmazGdOmTTujRHjy5MkoLS1N6KcrANDr9bBarYKXotFo4vLECAUqmvGw2CsS9Ddxofz1r3/F3XffjWHDhuHbb79NaK+ZQgjp5s1IpVKce+65SEtLi7VpYeGv5DktLS3uji2m4nLzzTfjueeeO6Nyi3bq+nuSTwSPheM44f/u7OyEXC5HWloanE4nAPgN4SWK0PA8f8bPaKLS17HxPC88ScY79Dvqic1mQ01NDaqqqro94TudTlRXV+Pcc8+Nlokho9frff6c4zhwHHdGCLOmpgYvvfQS/vrXv0bDvLD5z3/+g3HjxnUTSJfLBb1ej/z8fL8PPIkQuu3o6EBWVla3n9F8jVwu9+uZxeqeElNxMRgMWLRoEd56662Ed8f90dXVhZSUFGHib6K65uHgdrvhcDgStuKNQsd/qNVqyGQyEELQ3t6OU6dOYcyYMQlxgwoUQgjWrVuH7du343e/+13ClC07nU7s3LkTZ599dr/znOksvoyMjIQ4tpiHxTo7O7FkyRKsWrUq4RLygdDc3IzCwkIQQtDU1ITi4uJYmxQ1qAvP83xcLCITC0IITCYTTp48ieTkZAwaNCihRbMnhBD84Q9/QGpqKhYuXJhw35vJZMKRI0cwbty4hLO9L+ga8kQo64+5uABAe3s7Hn74YaxatapfNRK5XC7IZDLBLTWZTP0yF+ELukKZJh77wzFTT6W5uRlJSUkoLS3tV6IJnD7GZ599FoMHD8bs2bNjbU7IdHR0oK2tDZWVlf3q+wEg9MClpaXF9UNNXIgLcHoG0vPPP4833nij35wMjY2N3TwVmmSMh02BkYT2uPSnMKDNZkNtbS2ysrJQXFwMhULRb85Tb1599VVkZ2dj3rx5sTYlbBoaGuBwODB48OBYmyI6tC8uOTkZarU6Ls/FuJG9srIyLFq0CI888gjiRO/CpucXLpFI4HA4/P4+baBMZOhwyqSkpH4jLCaTCfv370dVVRUGDhyYkA1tgbBhwwYA6BfCAkAYQFtXVxdrU0RHpVIhKysLHMehq6tLGCkTT8SNuABAVVUVrrzySvzhD3+Iuw8qWAghyMvLO+Pnubm5fo+tq6sr0mZFFCosGo2m34Q33W43qqurMWHChH7Rh+SPrVu3YuvWrbjvvvtibYqoVFRUwGazoampKdamiI5EIkFKSgoyMjLgdDphNBrj6r4ZV+ICAFOnTsWwYcOwcuXKWJsSFnq93ucNVqVSob29/Yyf+xOjRMFbWBKlnDoQfvzxR0yZMiWuY9vhUldXhz/+8Y945ZVX+p1HJpFIMHToUHR1daGlpSXW5kQE2rCclJQEvV4fNwITl1fM9OnToVQq8cEHH8TalJDp7QumjU/e0F6YRKS/CktjYyNGjx7dr46pJyaTCbfddhs2bNjQ74SFIpFIUFlZCb1eLwy77G/Q8TAZGRnQ6XRxITBxKS4AcNNNN8FoNOKjjz6KtSkhkZ2d7fe/5ebmdmuyBBI330KT98nJyf3qJkwIwYEDBxJm0m4oOJ1OXH311fjiiy8S9sEmUKjAdHV1oaGhIdbmRAy5XI709HQYjcZYmxK/4iKRSLBgwQJ0dnZizZo1caHEwdDbU6BSqURbW5vw/xNCkJKSEg2zRIeuK+5vN6dTp07h/PPPj7UZEcPj8eC6667D6tWrE/bcCxaJRILhw4fDZrPhxIkTCXdPCRTazNvzATbaxK24AKdPhjvvvBMSiQSvv/66z5EjiYpCoRBOboPBgIyMjNgaFAIul0vYrtffOHjwYL9N4LvdbsyePRsvv/wyCgsLY21OVJFIJBgyZAikUikOHjzYbwUmPT3dZ243msS1uACnT4Y5c+Zg1KhRePTRRxM2fNST7OxsdHR0gOd5OByOhIt3U7v74w1Yr9fjvPPOi7UZEcFsNuPGG2/Es88+iyFDhsTanJggkUiEVcm7d+8W9qf0JyQSCTIzM4VFZDGxIZZNlCaTKajfP3nyJF599VW89957kTFIRALxsmw2GxwOBzIyMoRqpESpSjKZTCGFUxLh+L7//nucffbZQf9dInhwV1xxBZ5//nmUlpYG9XeJ4lkHezO1Wq04ePBgSN93tAklcqPT6WK2hTem4uKv9pxO1/XVrOZ0OjFw4MBomBcW/p6GCCHweDyQy+U+vZVEyV34iucSQsDzPKRSqV9PLBGS/lar1af9PM/DbrcjKSnJp0gmwvDVI0eO+PQ2CSHgOA4ymcznsQcrRrHCV2Sjr++N47iEGMzZ2z2lt+8uVveUuBn/4s3Bgwdxww034MMPP8SwYcNibY6ouFwutLa2Ij8/PyGedIPB4/HAaDQiPT09YUQyGPrrPhcA2LdvHy688EJ89913GDVqVKzNERWj0Ygff/wR5513Xr/73oDTObS2tjbk5eXF1VSM+I9RMBgMBiPhYOLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMPo1HMfBZDKhvb0dTqcz1uaICsdx0Ov16OjoiLtjk8faAF8QQsDzPAghsTZFdAghsNvt/fbYbDYb0tLSYm1KRCCEwOl09tvvzvt/+wubNm3CK6+8go6ODqxduxZSqRRXXnklbrnlFqhUqlibFxabNm3CsmXLYDAYIJFIIJfLcdVVV8XPsZE4Qq/XkwcffJCkpKQQACQlJYU8+OCDRK/Xx9q0sKHHlpaWRgCQtLQ0dmwJQn8+vv58zb355ptk4sSJ5KuvviImk4nY7XZy7Ngx8thjj5FbbrmFuN3uWJsYMmvXriXnnnsu+frrr7sd2yOPPEJmz54dF8cWN+Ki1+vJkCFDiEwmIwCEfzKZjAwZMiShT3Z2bIlLfz6+/nxsBw4cIEVFRWTjxo1k6tSp5Pjx48Rut5Pbb7+dPPbYY+TJJ58kK1eujLWZIdHc3EzOOussv8f2xBNPkNdffz3WZsaPuDz44INnnOTeJ/tDDz0UaxNDhh1b4tKfj68/H9u5555Lli5dSj7//HOiUqnI0KFDydy5c4lEIiFz584lJpOJjB49OtZmhsRzzz1Hli1b1uuxFRcXx9rM+BAXnudJenq6z5Oc/ktPTyc8z8fa1KBhx5aYx0ZI/z6+/n5scrmc1NbWEp7nyZtvvikc06WXXkpsNhvheZ6MGzeOOJ3OWJsbNJdddlmfx1ZVVUUcDkdM7YyLajG73Q6j0djr7xiNRtjt9ihZJB7s2BLz2ID+fXz9/dg8Hg9sNhucTie2bt0KAJDL5Thx4gRaWloAAB6PB1JpXNwCg0KlUvV5bA6HI+bVY3HxySYlJSE9Pb3X30lPT0dSUlKULBIPdmyJeWzA6eNLTk7u9XcS9fh4nodSqez1dxL12Pbt2weJRILVq1dj+fLleO+99zB79mz8+c9/Rn19Pa655hqcOnUKWVlZkMvjsmC2V6655po+j62hoQGpqamxNTSmfpMX/Tn+++CDDxKpVNovj+2+++7zG1ZJ5GPjeZ688sorRCKR9Lvj+/rrr0l5eTmRy+V+jy8Rj2337t3kiiuuIACIVqslKpWKrFu3jtx///1CuOi9994jy5YtI5dffjn5z3/+E2uTQ6KpqYloNBq/xzZt2jQye/bsWJsZHzkXQv5XudLzZO8PlSt6vd5nfDvRj43neTJnzhwC4AzxTORjs9vt5KabbiIAyOLFi8ngwYP7RUVVa2srmT17NgFAfvGLX5CdO3f2i2qx2tpact111xEAZPDgwWTdunWkoaGBKBQKkpqaSn7zm9+Q7du3k5qaGrJhwwZy9tlnk9deey3WZodEe3s7GTNmDElNTSVZWVlnHNvkyZNJXl5eXHx3cSMuhJy+CWdnZxOlUikkFB966KG4+KDC4ciRI0Qmk5Hzzz9fEJn+cGxPP/00AUBWrFhBHnrooX5xbI2NjWTChAlErVaTtWvXEkJOn5eJfHw8z5NVq1aRzMxMotVqyfvvvy8k6hP52I4dO0bmzZtHpFIpKSsrI++8847Q3/HAAw8QpVJJZs6cSdRqNVEoFCQlJYVMmTKFbN68OcaWh0ZTUxMZNmwYyc3NJfv27SNHjx4lv/jFL0hSUpJwjDfffHPcfHdxJS5Op5PI5XKybNkyYrVaE7JSxRezZs0iRUVFgvvaH47t3XffJQDIs88+K/ws0Y/tp59+Ivn5+aS4uJjs3LnzjP+eiMd3+PBhcsEFFxAA5KabbiIdHR0+fy+Rjq2+vp7ceeedRC6Xk4KCArJixYpulVEbN24kAMhLL71ECDl9bBaLhXg8nliZHDYnTpwgAwcOJCUlJeTw4cPd/pvH4yFZWVnkt7/9bWyM80NciUt1dTUBQH744YdYmyIae/bsIQDIW2+9FWtTROPbb78lcrmczJ8/PyFuRoHwzjvvEKVSSc455xzS2toaa3PCxul0kmeffZaoVCpSUVFB/vnPf8bapLBpbW0l9957L1GpVESr1ZKXXnqJWK3Wbr+j1+tJUVERufDCCwnHcTGyVFwOHjxIioqKSEVFBTl16pTP37ngggvItddeG2XLeieuxGXt2rUEAOns7Iy1KaJx+eWXk8GDB8fFOAYx2Lt3L0lNTSWXXXZZvzgmt9tNlixZQgCQO+64IyH7Hnryn//8hwwfPpzI5XLy2GOPEZvNFmuTwkKv15NHH32UJCcnk/T0dPLss88Sk8l0xu/xPE9uuOEGkpGRQerr62Ngqfjs2bOH5OTkkMrKStLc3Oz39xYvXkyGDBkSRcv6Jq7E5dFHHyVFRUWxNkM0Nm3aRACQ9evXx9oUUaivryeFhYVk7NixxGw2x9qcsNHpdOSiiy4icrmc/OlPf0p4L8xgMJC7776bACCTJk0i+/bti7VJYWE0GsnTTz9N0tLSiEajIf/3f//Xaz5h9erV/ep6++mnn0hGRgYZP3480el0vf7uW2+9RaRSaVw9SMSVuFxxxRXkl7/8ZazNEAWe58m5555LRo8e3S/c866uLlJVVUXKyspIS0tLrM0Jm+rqajJgwACSnZ1Nvv/++1ibExY8z5OPP/6YFBQUkNTUVLJs2bKEzi9YrVbyhz/8gWRlZRGVSkXuv/9+0tbW1uvfnDx5kqSlpZG5c+dGycrI8q9//YtoNBoydepUYjQa+/z9LVu2EAA+c4WxIq7EpbS0lDz88MOxNkMU/v73vxMA5Kuvvoq1KWHjdDrJhRdeSDIzM0ltbW2szQmbTz75hGg0GjJq1Ci/MexEob6+nlx11VUEALnqqqtIQ0NDrE0KGYfDQZYuXUry8vKIXC4nd911F2lsbOzz7zweD5k6dSopLS0lBoMhCpZGlr/+9a9EpVKRadOmnZFT8ofJZCIAyLvvvhtZ44IgbsTFYDAQAOT999+PtSlhw3EcGTVqFJk6dWrCh1p4nidz584lSqWS/Pjjj7E2Jyw4jiO//e1vCQByww03EIvFEmuTQsbj8ZClS5eSlJQUUlBQQD755JOEPddcLhd5++23SUlJCZFKpeTmm28mJ06cCPjvn3/+eSKRSPpFIdD69euJXC4nV199ddCzwQYMGEAeeOCBCFkWPHEjLps3byYAyJ49e2JtSth88MEHBEDC1tN783//93/9Io5tMpnIjBkziEQiIb///e8T9kZMCCH79u0jEydOJBKJhCxcuDBhn9Y9Hg9Zs2YNGTRokCD4Bw8eDOo1du3aReRyOXn00UcjZGX0WLlyJZFIJGTevHkhFctcddVV5JJLLomAZaERN+Ly5z//mchksphP8gwXl8tFBg0aRK644opYmxI2dOLqH//4x1ibEhbHjh0jlZWVJDU1lXz55ZexNidkrFYreeSRR4hMJiOVlZUJO76E53nyySefkMrKSgKAXHnllWTv3r1Bv47VaiVDhw4lY8aMSfgqv9dee40AIHfddVfIOdrHH3+cFBQUiGxZ6MSNuNxzzz1k2LBhsTYjbOgNOZSLJZ7429/+RqRSKVm0aFFCP+X/85//JJmZmWTQoEEJnS/6xz/+QQYOHEhUKhX53e9+l5A3U57nyVdffUXGjh1LAJBLLrmEbN26NeTXu+eee4harU7o75XnefLss88SAOThhx8O61pbv349AdBnZVm0iBtxOe+888gNN9wQazPCwmazkcLCwrgYGhcOO3bsIMnJyWT69OkJW3XE8zx59dVXiVQqJZdeemnC9k61t7eTefPmEQDkwgsvPKM7O1H47rvvyDnnnEMAkHPOOSfsCj1aMLN8+XKRLIw+PM+TX//618Kki3Af4g4cOEAAkO+++04cA8MkLsSF53mSmZnZbZRIIvLHP/6RyOVycvTo0VibEjInTpwgubm5ZNKkSQFXqsQbdrud3HzzzcLTYCIKJM/z5C9/+QvRarUkKyuLvPvuuwnpQW7ZsoVcfPHFBAAZN24c+frrr8M+jvb2dpKXl0d++ctfJuRnQsjp4hLak/Tqq6+K8poul4solUqydOlSUV4vXOJCXBobGwkA8vnnn8falJAxGAwkKyuLLFiwINamhIxOpyNnnXUWqaioIO3t7bE2JySamprIxIkTiUqlIqtXr461OSFx9OhR4YY8Z86cPns84pE9e/aQX/3qVwQAqaqqIp999pkoQsDzPJk+fTrJzs5O2H4rt9tN5s2bRyQSCXn77bdFfe1Ro0aRO+64Q9TXDJW4EJevv/6aACDHjx+PtSkh8+STTxK1Wh1QXX48YrfbyTnnnEOys7PJkSNHYm1OSGzZsoUUFBSQoqIismPHjlibEzQul4v8/ve/J2q1mgwYMIB88803sTYpaGpra8n111/fbfy9mJ7j22+/TQCQzz77TLTXjCYOh4Ncc801RC6Xkw8++ED01587dy6ZPHmy6K8bCnEhLi+++CLRaDQJ28ne1tZGNBpNwjaAchxHrr/+eqJWq8mWLVtibU5IvPvuu0SpVJKzzz47IZ9ot2zZQkaMGEFkMhn59a9/nXAhyePHj5ObbrqJSKVSUlpaSlatWiX67LkjR46Q5ORkMn/+fFFfN1pYrVbyy1/+kqhUqohVLf7hD38gKSkpcXEvjQtxmTdvHpk0aVKszQiZe++9l6SlpcVNlUawPPjgg0QikZBPP/001qYEjdvtJvfeey8BQG6//faEK2U3Go1k0aJFRCKRkPHjxydcn1dDQwNZsGABkcvlJD8/nyxfvjwi34HL5SITJ04kFRUVCTnXzmg0kvPOO48kJyeTjRs3Rux9vvrqKwIgqCbUSBEX4jJ69OiEfRo5deoUUSqVCVuMsHTpUgIgbpKAwaDT6cjFF19MZDIZWb58ecIldz/77DNSVFRENBoNee211xKq8KC1tZXcd999wvj7P/7xjxH1tn77298SmUyWkJ61TqcjEyZMIOnp6RHvTWpoaCAAyBdffBHR9wmEmIuL2+0mKpWKvP7667E2JSRuvfVWkpubm5BPU59++imRSCTkwQcfjLUpQbN//34ycOBAotVq46b0MlAaGxvJ1VdfTQCQK664gtTV1cXapIDxHn+flpZGnnnmGZ/j78Xkp59+IjKZjDz11FMRfZ9I0NLSQqqqqkh2djbZvXt3xN+P53mSkZFBfve730X8vfoi5uJSW1tLAJB///vfsTYlaGpra4lUKk1IYfzpp5+IWq0mN9xwQ1zEZ4Ph008/JRqNhowcOZKcPHky1uYEDMdxZMWKFSQ1NZXk5eWRDz/8MGG8LaPRSJ555hmSlpZGkpOTyWOPPRaVdbomk4lUVFSQSZMmJdz+oFOnTpFBgwaRwsLCqDZ6Tp06lcycOTNq7+ePmIvLhg0bCAC/61fjmWuvvZaUlpYmXJz/yJEjRKvVkqlTpxK73R5rcwKG4zjy9NNPEwDkuuuuS6jBk/v37ydTpkwhAMidd96ZME2dVquVvPjii0Sr1RKVSkXuu+++qG7qvP3224lGo0m43rEjR46QkpISMmDAgKhXwS5cuJAMHz48qu/pi5iLyxNPPEHy8/NjbUbQ7NixgwAg77zzTqxNCYq2tjZSUVFBhg4dGpUnT7Ewm83kmmuuIQDI7373u4R54rfb7eTxxx8ncrmcDBs2jGzatCnWJgWEw+Egy5YtI/n5+UQul5MFCxZEfZz/p59+SgCQlStXRvV9w6W6uprk5eWRoUOHxqQ14Y033oiLOY0xF5fp06fH1STPQLnkkkvI0KFDE8pVt1qtZOLEiSQvLy+hwknHjx8nVVVVJDU1NS4SlYHy73//mwwePJgolUry9NNPx/xiDwS3201WrlxJSktLiVQqJTfddFNM+s+am5uJVqslM2bMSJgHCUII2bZtG8nMzCSjR4+OWSMynTAf6/mGMReXgQMHxtUOgkD497//TQCQjz/+ONamBIzH4yHTp08nycnJcbWtri82btxIsrKySEVFBTlw4ECszQkInU5HbrnlFgKAnHfeeUGPkY8FHo+HrF27ttv4+1gNhOR5nlx66aUkLy8voSZFfP/99yQlJYVMmTKFdHV1xcwOuhsr1hMqYiouZrM57ran9QXP82TSpElk/PjxCfNExfM8ueeee4hUKiV/+9vfYm1OQPA8T15//XUik8nIJZdckhAhPJ7nyZo1a0h2djbJyMggK1eujPtiCZ7nyaefftpt/H2se22WLVuWcFtcv/76a6JWq8nFF18cF5WjpaWl5Ne//nVMbYiZuHg8HvLtt98SAOSnn36KlRkB4fF4iE6nI62treSjjz4iAMg//vGPWJvlE29baRjmxRdfJADIm2++GWPruuPLVkJOx/tvvfVWAoA8+OCDcRF69Gcr5fjx42TatGkEAJk5c2ZMpwT0ZSshp0Xl66+/JuPGjSMAyC9+8YuY9JD0tPXAgQNErVaTe+65J+q29IW/z/Xjjz8mCoWCXHnllXFTIHP55ZeTiy++uNdzINJICCEEUWbTpk1YtmwZGhsbYbPZUFhYiOnTp+OWW26BSqWKtjm9Qm01Go2Qy+XYt28fNBoN9u3bB7VaHWvzuuFtq0KhAADk5+dj1apV+L//+z8899xzMbbwf/iy9corr8Sll16K2bNnY8+ePXj77bcxb968GFvq39ZbbrkFUqkUr776Kp566ink5OTgjTfewOWXXx6XttJr64cffsATTzyBzZs34+yzz8Zzzz2HCy64IOa2EkKwf/9+JCUlYc+ePUhOTo66Tf7w97nKZDIsWLAAN9xwA95//33hv8WSTZs24e677wbP8xg4cCCAM8+BqBBtNVu7di2ZOnUq+fHHH8lnn31GXn75ZXL8+HHy5JNPkltuuSUunlIp/mx94oknEsbWxx57jAwaNIi4XK5YmyjQ2+dKd8Jv37491mYSQno/X6+88koycuRIIpVKyQMPPBDzcEhf19bmzZvJL37xCwKAjB07lnz11VcxC+32dr5eddVVCXFtPf7440Qmk5HbbrstbqYrUFt/+OGHmN9foyouzc3NZOjQoaS1tZXwPE9uvvlmIpPJiMViIRzHkd/+9rdxU3bIbI0Mfdn6m9/8hrz00kuxNpMQEpitpaWlcVEgEYitAEhlZSX59NNPY5ov7G/nq9hj80Ml3j5XafR8JODdd9/FwoULIZVKodPp4HA4AAA6nQ56vR733HMPli9fHk2T/MJsjQx92bpo0SKsWbMmxlaeJhBbs7KyMG7cuBhbGpitFRUV2LdvH66++mpIJJK4tTXRztcVK1bE2MrTxNvnKo/aOwHYvHkzHnroIeFi7OzsBMdxOPfccyGRSPDAAw9AJpPB5XJBqVRG0zRmK7O139uakZEBjuMgk8ni3tZE+lyZrb6JqrgkJyfD4/Fg8uTJAIDt27fDZrNhwoQJkMvlKCoqgsPhQE1NDSorK2Oa3A/EVo/HAxL9eogzCMRWjuMglUbVUfUJszUyqFSqhLCVEJIwtrrdbiiVyri3leM4OJ1OKBSK+LI1agE4Qsjq1avJfffdRziOIxzHCTFBk8lEOI4j9fX1pKCggPzqV78iM2bMIA8//DB57733yM6dO4nNZoumqQHZevbZZ5O6ujrS0tJCurq6iN1uj0ksOxBbzzvvPGKz2YjT6Yxp78XKlSvJvffe26utY8aMIQcPHoxZgpznedLR0UGee+65Pm0tLy8np06diomdHMeRtrY2Ul1dTZ544ok+bb3gggtiZqfNZiOdnZ2ktbWVLFu2rE9bL7zwwqjb6fF4iNVqJV1dXaStrY20tLSQFStWxJ2tbre7m53Nzc2kubmZ/OlPf+rzPhBNW6Mqt9dccw2+++47bN68GRKJBDKZDHK5HFKpFFarFYsXL8ZHH32E5cuXY/78+dBqtdi4cSOeeuopzJw5Ew888ADeeecdbNu2DRaLJea2vvDCC9BqtVAoFLBarWhvb0djYyM6OjpgNpvh8XgiaiPliiuuwMaNG3u19Xe/+x2kUik8Hg/sdjtsNhtcLhc4jouKjW63G62trZgyZUqftj788MNobm7G5s2b8dNPP6G+vh5utzviNvI8j9bWVuzZswdHjx7FL3/5S/zrX//ya+vdd98Nt9uN8ePH44477kB1dXXEbQQAk8mEo0ePYtu2bThy5AgA4Pbbb+/1fF20aBFuvfVWdHR0RMXb5jgONpsNnZ2daG9vh9FoBCEEKSkpuPnmm/H999/7tfWee+7BE088EXEbCSFwOp0wmUzQ6XTo6OiAyWQCx3FITk6GVqvFLbfc0qut9NqKJG63G1arFV1dXWhra0NHRweMRiM8Hg/UajWysrKQl5eHm2++uc97VqRt9SbqfS61tbWYP38+pk2bhgEDBsBkMiEvLw/vvfcerrnmGsyfP7/b7xNC0NzcjJqaGuGfTqeDRCJBWVkZRowYgaqqKlRWViI9PV1UW2tqarBgwQJMmzYN5eXlfdrqcrngcDjgcDjgdDpBCIFcLodarRb+ie2S2mw2uN1unDhxAosWLQrIVo7jwHGcENbzPhHFjsfzPA+DwQCTyQS5XI6srCycOnUKd9xxR6+28jyPjo4ONDU1oaOjAxKJBLm5uSgqKkJ2draoCWmPx4PW1la0tLTA4/EgOzsbhYWF0Gg0qK2t7dXWOXPmYN26dVi+fDnq6+txwQUXYMmSJTjvvPNEtdHpdKK9vR3t7e2w2+1Qq9XIzc1Fbm6u0G/Vm63Tp0/H5ZdfDp1Oh6SkJBQXFyMlJUU0+4DT5xU9/+nDgEqlgkqlOuPc92fru+++i6qqKlx66aUYO3YssrKyRLXR4/HA6XTC6XTC7XaDEAKZTAalUgmVSgWlUnnGNdqbrTNmzMCCBQtEtdHtdsPlcgn/eJ6HRCKBQqGAUqkU/vk6v/o6X3vesyJJTJoof/zxR9x///2oqKiAXC5HRUUFZs6ciaqqqj7/lhCC9vZ2QWgOHDiAlpYWAEBJSQkqKysxYsQIVFZWQqvVhmwjOV2mja6uLnz44YfYunUr3G53wLYSQoQLzW63C14MvdCSkpLCSqoRQmC1WoWnLIVCAb1eH7StPM/D4/GA4zjhJJbJZMK/cG6QFosFnZ2d4HkeGRkZSE9PF14vGFtdLheam5vR2NgIi8UClUqFoqIiFBUVQaPRhGyf0+lEc3Mz2tvbAQC5ubkoLCw8I9cXiK0ejwdffvklli1bhurqaowcORKLFy/GVVddBbk8tNQmz/PQ6/Vob29HV1cXpFIpsrOzkZeX5/dBqi9bbTYbGhsbYbVakZmZiaKiorAa/zwej3CeezweSCQSQVBUKlWvD1P+bD3rrLOwZ88edHZ2oqqqCsXFxSHbx/M8XC6XICj0HKc3aJVKFdD348vW6dOnY+jQodBoNCFfJ4SQM8SEPvApFApB8BQKRcDv4W2r0+lEeXk55s6dG9D9VUxiIi4bNmzAP//5T7z11lsAEPbTvE6nw4EDBwTBaWxsBAAUFBSgsrISVVVVGDFiBHJycgL6gqiwSCQS4ffpz0K1lV6EdrtdOMmlUqkgNGq1OmCvgYYcCCHQaDRn/F2otvI8L3g0PM8DQDePJtCT2+VyQa/Xw+FwQKPRICsry+8FHKytJpMJjY2NaGlpgdvtRkZGBoqKilBQUBDwTdxqtaK5uRk6nQ5yuRwFBQXIz8/v8+8DsZUQgh9//BFLly7F999/j7KyMtxzzz248cYbkZSUFJB9ZrMZ7e3t6OjogMfjQVpaGvLy8pCdnR3wOdKXrZ2dnWhqagLP88jPz0dubm7A36/b7RYEheM4SCQSqNVqQVCCvdH6spUQgtraWtTX16O8vBxDhw4N6vyjgkI9KLlcLtgXzI26N1vpA55UKg14moC3mHh7T96CF6yY9PZeLpcLbrdbdC81EGIiLk899RRSU1Px4IMPRuT1jUZjtzDaqVOnAADZ2dmCV1NVVYXCwkKfXyB9uolULwD90u12OxwOB1wuFwBAoVAIQuPvInW73bDb7cIJHanKD0KI4NHQvAz1ZuRyud/PraurCyaTCQqFAlqtNuAbarDwPI/29nY0NTVBp9NBKpUiLy8PRUVFyMrK8mmf0WhEU1MTjEYjVCoVCgsLkZubG7HPsLq6GsuWLcPnn3+OjIwM3HHHHbj99tt9etQulwsdHR1oa2uDzWaDUqlEXl4ecnNzI/YZchyH1tZWdHR0QKlUori4GGlpaT5/1zvk6/1gRJ+sI3Wt1NXV4eDBg8jOzsbo0aN9PgDQail6w6Y3f+qZ9OVBhQN90KOfQ0/otU7/UTGh9nmLSSTgeR42mw1JSUlRL0GPuri43W7ceuutuPHGG6M2g8lsNqO2tlYIox07dgyEEGRmZnYLo5WWlgJAWB5KKPA8L3g13k+DKpVKEBuFQgGn0wmHwyGIULQa4QghgkdDhUYqlQoejVQqhdlsRldXFwghyMjIQFpaWtTsczqdaGpqQlNTE6xWK9RqtRA2S0pKgl6vR3NzM6xWKzQaTa8CFAnq6urwpz/9CWvWrIFEIsHcuXOxcOFClJSUoLOzE21tbejq6oJEIoFWqxXCXtGyz+FwoKGhARaLBenp6SguLoZCoRAEhXraMpmsm6BEC51Ohz179kCtVmPcuHFISkrqFuqi56R3qCuaM76osCUnJ0MikcDtdgs/o55TtMTEF1arVcjXRJOoi8uhQ4fw29/+Fi+88AIGDBgQzbcWsNlsOHjwoODZHD16FBzHITU1FcOHD0dVVRVGjhyJ8vLymNSvU+/E+8J2u92Qy+VIT09Henp6zOrqqdBQsXE6nejq6oLH40FGRkZQoZtIYDAYBKHR6XSCXQMGDEBpaanoRR/BoNfrsWrVKrz11lvo6urC1KlTMWPGDIwZMwa5ubnIyckJOT8jBp2dnTh58iRsNhsyMjKg1WqhVCoFQYnlUEaDwYBt27bBarVi2LBhyMzMhEwmE4QulHCcGNCcjsFgEHpNaN7SW0xi+b06HA4QQiLmAfsj6uLy2Wef4YsvvsA777wT8yYpitPpxKFDh1BdXY0DBw7gyJEjcLvd0Gg0GD58uBBGowUI0YQmdW02W7eLhxYG0As/2nAch66uLhgMBkilUmRkZAgXOPVoYiEytPKrsbER7e3tcLvdkMlk0Gg0yM/PF7yWaON2u4WwV2dnJ/71r3/hiy++QGtra8QqzAKB53nBI6al6Z2dnTCbzUhOTkZ5eXlMBJnaRT0UWnhy6NAhWCwWjB49GuXl5TG1y+VyCYU6EokEHo8HycnJSE9Pj/kUBG+ordHOu0RdXJ5//nkAwGOPPRbNt+0TmsCWSqVwu904cuSI4NkcPHgQTqcTarUaQ4cORVVVFaqqqjBkyJCIPs3ReC5wultcJpN1q87pGf+mxQGRPLEJIUIIDAAyMzORmpoKiUTSLXRGk5TREpreKr/sdjuam5vR1NQEm82G5ORkIWwWybUJtNqQCgoAoSchMzMTHMedUWG2ZMkSXHnllRF9iKE5Cu98n7eHIpPJ4HQ60djYCJPJhLS0NBQXF0f0IYYmunuGk2g4x9tzOnjwIOrq6lBWVoZhw4ZFVJA5juuWM6FiIpfLu3kmMplMKHSgYex4geM42O32qOddoiouPM/jtttuw4wZMzBjxoxovW2f9FVZ4/F4cPz4cSFnc+DAAdhsNigUCpx11lmC2AwdOlS0C9A7cd9bqSO9SdAQGnD6gqRCI2a4wOFwQK/Xw+VyITU1VQhN+CJavTTBVn7RKqnW1lZwHAetVouioiLk5eWJZpfNZkNbW5vgOWk0GuTl5SEnJ8fnTYcQgh9++AFLly7FDz/8EFKFWV/QEGbPHhQqKP7OfaPRiMbGRrjdbuTm5iI/P1+0iAMVOSoo9Br0DnX5e6/6+nrU1tZCq9Vi9OjRot3MPR5PNzGh+RwqJv56YSi0JDuSxTahQEv4oyl6URWXkydP4tFHH8XTTz+NoUOHRutte8VX2XFf8DyPkydPduu1MZvNkMvlGDRokCA2w4YNC2nhUaiJe1oYQIsDvAsDqNiEcnLRUAk9QbVabVAi2rOXBkA3jyYU8Qu38otWSjU1NaGzs1MQpqKiImRkZARtj8fjEcJeFosFcrkcubm5yMvLC6oXx7vCLDMzU6gwCyWURz2Bnj0ovVUj+oJW5rW1tUEmk6GoqAiZmZlB20M74mmoyzsR793PESh6vR579uyBUqnEuHHjQup58icmPRsWAz2vCCFCCDuelp3Z7XahZDxaRFVcvvrqK6xbtw7vvvtu3LiNYpQdE0JQX1+PAwcOYP/+/aipqYHBYIBEIsGgQYOEnM3w4cORmpra6+vY7Xa43W5RcinUTae9NbQb2bu3pq+eDZPJJBwLDYGFQzi9NISQMyq/CgsLodVqw/r+bDabUARAe3No2Ky374AQAoPBIIS9aAViXl5e2NVo/irMaEWjP+iNm1YdUk9ArVaHXTLscrnQ2NgIo9GIlJQUlJSU9Hmz8g510RAcTcSLUcZss9mwc+dOuFwujBkzps/GaV/d7wDOaFgMx+ug4WwqmvEADTWG03QcLFEVl5dffhlmsxlPPfVUtN6yV8JtjOztdenIGio43iNrqGdTVVUlJEtpPTrP8yF7GH3ZRG86VMCA00+NVGi8L3S73Q69Xg+32420tDRkZmZG5HMKpJeGPjk3NzfD6XQiPT0dRUVFoieaCSHdwmaEEGRnZ6OoqKibV2S324WwFy1BpWEvscs99Xo9Vq5ciZUrV8JoNGLGjBlYtGgRRo4cKdjsLSg9c3CRKD+ljawulws5OTnIz88XQoo04U0FhT68eYe6xI77u91u7N27F3q9HsOHD+8mwOGMUgkH+p3QXGmsoXmXaIbroiYuhBDccccduOSSSzBz5sxovGWf9gQbDgvnvTo6OgSvxntkTXFxMYYPH46KigoMHz4cJSUlUTkZ6RwoWvJMb0pyuVwYV5OSkiKUo0YaX700PM9Dp9Ohvb0dPM93m/kVaTweD1paWtDU1CRUxNGYNc/zkMvlyMnJQV5eXlSqcGw2G9atW4cVK1agvr4e5513Hu644w6MGzeum0carWQyHcPU0tICnueh1Wqh0WiEhLe3JxCt8+fgwYM4duwYCgoKMHDgwG7d76GOUgkH+rAYzngYMYl23iVq4tLU1IQHHngAjz/+uPDUFUsi3YXfF3q9HgcOHMDevXtRXV2NpqYmyOVy5Ofnd/NsghnLEQ5OpxOtra1ob28XekPS09MFr0atVke9qY8m3XNyclBUVITk5GRhymu0MBgMOHXqFA4dOoT29naoVCoUFxdj2LBhKC4ujlpjGvUIrFYrvvzyS6xcuRKHDh1CVVUVlixZghkzZkStTJ4WB7hcLlitVrS0tMBkMgn9RBkZGVH5jnyNUmlsbMSRI0eQk5OD8ePHQ6PRRE1MfNlntVohk8mi3mPii2jnXaImLhs3bsSqVavw7rvvRjWp5AvvsuNYQiu8FAoF3G53tzBaXV2dEJbxFht/I2vCwWazQa/Xg+M4pKWlIS0trdu4j57J4EiFW2jll16vh0wmEyq/aA9BtEqcHQ6HMIHY4XAgKSlJmO1lNpvR1NSE9vZ2EEKQk5OD4uLigOfWBQMt0KBhJuB/lYAqlQqbN28WKszKy8uxcOFCUSvMvO2gN3Ca9Pb2BlQqlfBA4HA4kJ2dHdSst0AJdJSK2WzG7t27oVAoBIGJFXTFRTyUJ0c77xI1cVm2bBlaWlrw+9//Phpv55dI5VmCtaGvxD0dWUMHctKRNRkZGd3EprS0NOSbmtvtRmdnpzB7iO6m6Qm9QKjY9AzDBDN00xfBVH5FqsSZ4zjo9Xq0tbXBaDRCJpMhJycHubm5Pudtud1utLS0CL0gSqUShYWFKCoqCqvogYYr6Y0cOLMHpSdiVph5H5/3aHrgzHLcnucdIQQ6nU4I+YZbbEEnU4QySsVms2HXrl1wOBwYM2YMsrOzQ7JBDGj5t0ajiel9h/bIRSvvEjVxWbhwIaZMmYJ58+ZF4+18Es08iz9CTdx7j6w5cOAAjh49Co/Hg9TUVKEaraqqCgMGDOjzxKFVTvQmmpWVFfDTjHdhgK8mvEDLXL2T56FWfvlbFxCM0JhMJrS1tUGn04HjOKSnpyMvLw9arTbg16DeTHNzM1wul9B0WFBQEND3Sy96eiOnE3L76kHpyalTp/CnP/0Ja9euDarCDPhfs6AYiXiPxyOUeCcnJ6O4uDig84t6SN6eCYCQR6l4PB7s3bsXOp0Ow4YNQ1lZWUB/FwmsVisAxNSLomG6aOVdoiIuHR0dWLRoER5++GGMHz8+0m/nl1jnWTiOg9VqFWrgw3nSdjqdOHz4sFAkcPjwYbjdbiQnJwvz0XyNrLFarejs7BRupBkZGWF9Ht4Loux2u/AZe08M8H7/SFV+BVPiTBdvtbW1CR3VPRdvhQIt3KDbSHtbcEbLxJ1OZ1g9KL7Q6XRYtWoV3n77bZhMJlx99dVYtGgRRowY0c1W79H0PRPxYtyArFYrGhsbYbPZkJWVhaKiojPOBV+jVLzFJNzqMkIIDh8+jJMnTwr7nmI1g8xqtca8PNlmswml4JEmKuLy448/YsWKFVi5cmXYfRKhEus8i9vtFr7YSFSP0JE1NGdz6NAhOBwOqFQqDBs2DEOHDkVxcTHy8/ORkZGBrKysiDy90FwN7a0BTodT5HI5jEajsDwskpVfvoRGIpHAaDRCp9PBaDQGtHgrHOiCs6amJpjNZqhUKmRnZyM7OxtyuVz0HhRf9Kwwu+CCC3DnnXdi/PjxQlixry2M4eLdm8RxHLKyspCeng63293rKBWxaWxsRE1NDTIzMzF27NiY5D+okPd84IomtHk1Gg2eURGXN998E0eOHMHLL78c6bfySazzLPQJlfaURAM6sqa6uhq7d+/G/v37hbp7b8/mrLPOiliBBc/zMJlMOHnyJJqamoRxK6WlpcjIyIhYYYA3JpNJSMDTsTUFBQXIy8uL+CRd6h10dHTg5MmTaG1tFYS1vLwcZWVlEb3J0DCT1WrFF1980a3CbOHChZgxY0ZEi2u8u99tNhuam5vR2dkJjUaD8vJyocw9WtdlV1cXdu/eDblcjnHjxsVkgRadnBGr8mQago3G+0dFXO6//35UVVXh9ttvj/RbnUEs8yxid9wHi/ea4bS0NHR1dQk5m5qaGpjNZshkMgwePDjskTU96Vn5lZ+fj+zsbKGZK9xtnL3hcrmEai+6yImOtFcqlb3upQkX75xUz6kISqUSXV1dwjoAiUSCvLw8FBcXi7ZfprctjAqFAlu2bMGyZcsiUmEWyCgVj8cjTFgQY81ysNjtduzatQt2ux2jR49GTk5O1N4b+F/eI5jtlZF4f7VaHXHvKeLiYjQaceedd+Lee+/F2WefHcm38kms8izeiXvanxEtAlkz3NvImoqKCkFs+hpZ0xOj0Yjm5mYYDIZeK7/C2cbpCxp+ofvm+1q85b2XhpY4S6VSIU8TjNB4d6VTQZHL5ULeydd339uCs2BuOn1tYfQXZtq3bx+WLVuGL774IuQKs0BGqfgL94WzZjlcPB4P9u3bh46ODpx11llR3yvV1/bKSBOtvEvExWXr1q149dVX8cYbb0R9j0aswmFiJu6DIZw1w3RkDfVq6MgaACgvLxfEprKy8ozBjmJVfnmXO3vvZu+t89xisQheCq2eoz0pwQh6sOsCvIeEegtjKKXZdMFZS0sLPB4PMjMzhfxYz9fxHvfinQQPdQtjzwqzefPm4e677/ZZYdazYTHcUSrBrFkWG0IIjhw5ghMnTqC4uBiVlZVRvU94b6+M9niYaOVdIi4u7733Hnbv3o2lS5dG8m3OIFbhMPo0LpfLhbWn0SASa4bb29uxf/9+QXC8R9ZQryY3N1dI4os588u7ibOnNyCTyWA2m9HR0SFU4NBqLzEuGH+9NHSFrffYeu8S7HBvThzHob29HY2Njd3Cibm5uUhJSenW++K9hVGMvIVOpxNmmJlMJsyYMQN33XUXhgwZIngm9LPo2WMS7nnma81ytJ7om5qaUFNTg/T0dIwdOzaqnoTNZgMhJKr3CSB6eZeIi8sjjzyCsrIyLFy4MJJvcwaxCIfFInHvdDqh1+vhdDqRkpKCrKysiD0J0ZE1+/btw44dO3Dy5EkQQlBYWIjx48dj3LhxERlZQ3NXdMNkR0cHAAj5ivz8/Iglpl0uFywWC2w2G1wuFyQSCZKSkqDRaCL21MnzPIxGI+rq6lBXVwer1Yrk5GSUlpairKwM6enpEel+d7vdMBgMWLt2LVatWoXm5macffbZuOuuu3D++ecLXlGkrimaj+I4TlhXEA1vgib6ZTIZxo0bF7WKVho6pw9N0YK+b6TzLhEVF5vNhttuuw0LFizAhRdeGKm3OYNolx3THQ4ejydqiXu6ZthsNkOpVEKr1Ub8BO257VGtVqOzsxNHjx5FTU0NTp061W1kTWVlJUaMGBHWyJqei7eogKampgo9NmJv46TeiXd4jnoJtIw42HUBvUFv7D070Wki3mq1Cn05Yi046zlKhXpENF8jlUrxzTff4I033sD+/fsxatQoLFmyBL/61a8iXuFGZ9wpFAoUFxdHZc0yTfTbbDaMHj0aubm5EX9P4H/nWrTHw1itVuH8ihQRFZc9e/bghRdewOuvv478/PxIvU03op1niXbinvhYMxzpOLWvyq/8/PwzLoZARtZUVlairKys1xtxz8VbCoVCmEDsqy/Ge5VAz/xHoNs4aRiOxqP76kEJdF2AP/xtYaR5E1+d+eEsOAt1lAr575bM119/HT/++GNEZ5h5E+01y8Dpz3ffvn1oa2vD0KFDo5boj8X2SjrGKZLfYUTFZd26dfjhhx/w5z//OSrhqWjnWTwej7B1Lhpzg4JZMywGgVZ++YOOrKFi4z2yZvjw4RgxYgQqKysxcOBASCQSYfGWXq8HgJAWb/W2jZNWoSkUCuHJnQoKz/NCHiPY/htf6wJ6Co13Il6MLYz+FpwVFhZCrVaLPkoFOLPC7M4778Rtt90W0UKdSK5Z9gUhBEePHsXx48dRVFSEqqqqiF/XNPIRze2V9EEjknmXiIrLk08+Ca1Wi/vuuy9Sb9GNaOZZopm4D3fNcDCIUfnlD++RNQcOHMDhw4dht9shlUpRWFgojOcYN24cCgoKREmuem/j9DXlOSUlpZvohIu30HiPd6Hi5T1eRYyufPp9NTQ0oKGhAW63G6mpqcjNzUV2dna3Si6xFnXRCrM1a9ZAKpX2WmEmBmKtWQ6G5uZm7N+/P2qJ/mhvr6QRl3BDyL0RMXFxOp249dZbcfPNN+PSSy+NxFt0I5rhsGgl7kkE1gz7g17ALS0told+9YTjOHR0dKCpqQm1tbWoq6tDW1sbGhsb4fF4hJE1dCDnkCFDQr64aQ8K/c5oHoWeK3T0iHdvTaj42sLIcZzgwVDvJJRemp7QQZPec7k8Hg/0ej10Oh2sViuSkpJQXFwcse+xZ4XZ1VdfjcWLF6Oqqkr09wJOP9DR5W0pKSkoLi6O6PVnMBiwe/duSKXSqCT6o7290mq1Cg8fkSBi4nLgwAE888wz+OMf/xixJxpKtMJh3on7pKSkiD7NRGPNMHA6tNfa2ir0WNBkcSRmfhkMBrS3t0On04Hn+W5hL6lUKoysoWG02tpa4QI466yzhJzN0KFDey1eoPmMnlObaciLXrh0WgD1aHoWBvRVTeOdiO85/NE73OVtV6h7afx1v/ccg0/PEavVKoTNaCVhcXExCgsLRT9vbTYb1q5dixUrVqChoQEXXXQRlixZgnPPPTci16P3mmW6OyZSN2OHw4Fdu3bBarVi1KhRyMvLi8j7UKK5vTLSeZeIicvHH3+Mr776CqtWrYr4hxSNcBidakrr0iOVuPd4POjs7BS6tiO1ZtjpdKKlpQVtbW0AgNzcXBQUFIhecUYXb7W1tQlD++i++b68BJ7ncerUqW69NnRkzaBBgzBixAhhZA1dWOXdg0LDT4H2oHhPDPAeuum9jbPnaHrqAXmHugJ5r7720niLCc0JATijYTGQ9Qo6ne6MBWdFRUXIyckR9YHF4/Hgiy++wNKlS1FTUyNUmF155ZWi3/zJf9cst7a2CmFVrVYr6ntQOI5DdXU1WltbMWTIEFRUVETkfYDobq+kD0aRmrEWMXF59tlnoVQq8cgjj0Ti5QWiUXYcjcQ9IQRGo1HY156VlRWRLz3Qyq9wCHbxVqAQQtDQ0ICamhrU1NSguroaer0ehBCUlpZi6NChGDlyJEaOHIns7OywvidaGGCz2WAymYQZcbQnISUlBampqVCpVGE/aNDpBFTY6E4X74VswXa/+yJSC856QgjB999/j6VLlwoVZvfccw9uvPFG0R9e3G43mpqa0NXVBY1Gg+Li4ogkxQkhOHbsGI4dO4bCwkKMGDEiYvecaG2vjHTeJSLiwnEcbr31Vlx33XW46qqrxH55gWjkWaKRuO+5ZjgSO8jDrfwKhJ6LtzIyMpCbmxvU4q2+8O5B8Xg8aG9vx4kTJ3DkyBEcOnSo28ga7yVqfZXq9nyPnlsYCSHgeV74XwDdbv5JSUlBfZb+RqnQEBnNB/X0aMQ6/3wtOKPVZmLe0LwrzLKysnDHHXdEpMLMYrGgsbERdrs9YmuWAaClpQXV1dVIS0vD2LFjI5Z8j9b2ykjmXSIiLseOHcPjjz+O5557DoMGDRL75QFEJ89C+yYilbgPdM1wqESy8osSqcVb3niPgvHOi/iquGpvbxc8G++RNUVFRULpc1VVVbe1t8FuYfSefEw9GuB/o2BoPo7aRXMz3jmTQEaphNtLEwh0wRkNm/W24CwcTp48iTfeeEOoMLvppptw9913o6SkRJTXB8Rfs+wPo9GIXbt2QSKRYNy4cRHpM6P5XSCy2yvtdjsAROT+FhFx+fLLL/Hxxx/j3XffjViiLZJ5lkgn7kmPNcNarVZUV95X5VdhYWFQT+99vT4Ne9EwnpiLt/z1oHgLSqDQkTVUbBoaGgAA2dnZOOusszBkyBAMGjRIGMfvPa8rUHpu46S5FKlUKkxapl5HqHO5fPXSiL0uwNeCMxo2EytE27PC7JprrsGiRYtErTCjY/31ej2SkpJQUlIi+g3a4XBg9+7dsFgsGDlyZESaxKOxvZL2QEVCwCIiLi+++CKcTieefPJJsV8aQGTzLJFO3Iu9ZtibSFd+mc1mIezl8XiQlpYmTCAO9yHC1x4Umt8QY+Wux+OB0+mETqfD/v37cfDgQRw5cgSNjY2QSqXIyckRQmhVVVUoKioK6sbv7ZVYLJZuCX+6RiA1NVWYGBDOueu9LoBWqIW6LsAftCKrpaUFbrcbGRkZKCoqEi0/Z7PZsGbNGqxYsQKNjY0RqTDruWZZ7JAfx3HYv38/WlpaMHjw4IhEaSK9vZJWTEZiOoDo4kIIwe23347LL78c1113nZgvLbx+pPIskUzcu91u6PV64YvUarWinSyRrPzyt3grLy8v7Nf37kHxvhFTQQnn86Ed6vQmTzv1vRsK5XI5LBYLamtrBc/m+PHj4HleGFlDw2jeI2v8db/7GqVCj5Em66kYeE8MCNcz9lfiLIbQUC+454KzoqIiUUJObrcbX3zxBZYtW4aamhqMHj1amGEmRtSDhoabm5vB8zwKCgqQk5MjasTj2LFjOHr0KAoKCjBixAjRozWR3l5Jm7PFLh4QXVzq6+vx8MMP4ze/+Q0qKyvFfOmI5lkilbjneR4GgwEmkwlyuRxZWVmihcAiVfnF8zw6OzvR1taGrq4uSKXSXhdvBYO/HhQqKOFcmL1tYQy02sput+PgwYOC2Bw9elQIGwwZMkR4Qi0tLe0mJIGOUqGd+1Rs6IOSd7lzOJ9BOL00fUEHlzY2Noa14MwXtMLs9ddfx6ZNm0SvMOM4Ds3NzdDpdFCr1SguLha1Qq61tRXV1dVISUnBuHHjRA1j0fLkSG2vtNvtwu4kMRFdXL799lv85S9/wbvvvit6nDBSeZZIJe691wxnZGSEfWOmRKryy2KxoK2tDR0dHWEt3uoJDUn17EGhghKq3aFuYQzkdalQmc1mHD58GIcOHcKRI0dw8uRJeDweaDSabtVogwYNCvozouG0nts4vXfEBLON09dx9NZLEw6+FpzRsFm4HvnevXuxbNkyfPnll6JXmNntdjQ0NAhrlsVsKjWZTNi1axcIIRg3bpyoUxEiub0yUnkX0cXltddeg16vx7PPPivmy0YkHBapxH0ga4ZDsTUSlV9ut1sIe4m5eIuW8/ac5RXODdN7+KP3FkbveV2heG2+RqkA/+t+p/9kMhncbrewYqCmpgYHDx6Ew+GASqXC0KFDBbEJZWSNd2FAMNs4A4HnecGjoTlLb48mHAHzteCMzv8K59yMZIVZpNYsO51O7Nq1CxaLBSNGjEBBQUHYr+n92pHYXhmpvIuo4kIIwd13343zzjsPN954o1gvG7FwmNlsFj1xb7FY0NHRAYVCgezsbNFczerqalitVlErvzo7O3Hw4EEAgFarRW5ubtg3BPq6Lperz7H1weByuYRNm2JuYezq6oLD4QDgf5RKb3g8Hpw4cUIQG++RNc8//zzOOuuskG3ztY2TlnqHA515RgdqAgg7HAecrqCiI2dsNhsyMjIwefLksF4TOLPC7J133sGvfvWrsF/Xe82yWq3GWWedJcr9heM41NTUoLm5GSNHjkRRUVHYr0mh2yvF9DJo2E3svEvI4vLb3/4W99xzzxk3z46ODmFLny96qwnvzRQqLr5+3tdNgF5ANBELnL6YvMtFfdHX69KS0J7vZbPZfCbfaE9Bb08zNGzUE6PR6Ddsd+jQIYwYMaJXW6urq1FWVtbte6ELxzIyMvyKa28nG/1ce+JwOITwlDd0CkFf4Q1fr0sT4wqF4gxbaWl3b+M/dDqdT+GkwuJPTPo6Bx599FHMmjULAwcOFGyx2Wwwm83Iycnxe8Pu7TrwdV7RajoAZ1xzNEfW19wrX9cX7aXx1zfjcDh6DRXT66knFosFbrf7jOnFdGdKX6JD1y70tNXpdPr0fO12O+6880589dVXfl+TeqQ9oQ2zPb8Tj8eD+vp6DBkypFdb/X0G7e3tPqMWHMdh7969mDJlit/X9Hdt0UpBX9erw+HoM9pAN1D2/PzcbnevJe2hiG7I4mIymfDyyy/joYceitpaUG+C8WboF0JL+uhJGq3dCdSG1tZW5ObmiurS0jxGX9+Bx+PBqVOnoFQqUVRUFJWpq94QQtDV1YX09HRR35uGC/sa7ElvwGI31VmtVqxduxYajQbXX399VHewA6dvCl1dXaJOQaA4HI6wPUNveJ7Htm3bMG7cOFE/J5fLhSuvvBJr167t1hwbDk6nE/X19RgwYICoJcAcx2H79u2ifgb0gSaQKRF0rFFSUlLEZz6GFRYzm8147bXXMH/+fFFji954m+fd8dzzZ71BqyG8n3gsFktUJo9S9Ho9NBqN6BUZO3bswIQJEwL6Xeo5NDc3o6ysLKKdvz0xmUyilN16E6xgcRwHg8EQ1PKxQO2oqanBZ599hrvvvhs5OTmivXZvOJ1OmEwmaLVa0UvzaRGAWGESnuexY8cOjBw5UtSiGY7jcPXVV+NPf/oTiouLRXlNWtgyYMAAUT9XjuOwY8cOjB49WrT7ACFEmEMWqK00x+jLgxGTsHMuDocDy5cvx7Rp0zBy5Eix7ALwP++E0vODCKbJrefv0+RwpBfzEHJ6LTHQeygk1Nc+ePAghg8fHtTfcRyHI0eOoKioKOIrkgEIYyzE9BTJf3fdJCcnB3UDdLvdMJvNouSWemKxWPCHP/wB9957r2hP0P6wWq1wOp0ROQ5CSJ/hsGBfb+fOnRg+fLioDzQ8z2Pu3Ln4zW9+g6FDh4b9evRhxWw2o7S0VNTP1ePxYNeuXaKKK/VCghEWb3vo7qS43kTJ8zxWr16NnJwcXHbZZaLNPPKVZ/H+WbjvYzQaI7JECfif/SaTCQBEG73ijU6nE3ahBAshBAcOHMCgQYNE96a834NWi4kdOqV1/6FcqC6XC1arVdTpCBS3242HHnoIL730UkQm2hJCYLFYhAkPkRAWu90uWtiEEII9e/agoqJC1GuN53nMnz8fCxcuxPjx48N+PUIIWlpaIJVKkZeXJ+rn6nA4sG/fPowaNUqUa42G+V0uV1jfU6QFRhSfj5YJqlQqrFq1ym8yKhi88yn+/oULzb+ICb04DQYD9Ho9lEplxATs2LFjIbvtEokElZWVOHDggOifAfC/ChSO40RfHUDnjYX6BKhUKqHRaITqMzFRKBR47rnn8Nhjj0Xkc6UVjpESFqfTKVq4hBCC/fv3o7y8XPSejzvuuAPz588XRVjo3iCNRiO6sHR2dqKmpgZjx44VTVhouXy4DwByuRwKhUIYCCs2ove5HDhwAF9//TXuu+++sMd3RHplMU2EieWq00Vf3j0J4Xz51D46SqTnf6uvr0dZWVlYNrvdbhw6dAhVVVWi3VBof0vP6cBi4Ha7YbFYRPE63G43TCZTRLZ80rLkG264QbTXpOHVlJQU0XNGPM/D7XYLa5jFeM3a2lrk5uaKmoNyuVy47bbbcN9994kiLBzH4cSJEygpKRHVgyeEoK6uDjabDUOHDhXl/KKRADraR8wpIrQSU8y1DqLfvSsrK3HDDTfghRde8FlSGQj+yo7FRiKR+C1PDBZCTm/G02q1SEtLE+Wm2tLSgq6uLhw/flwoQ6WcOHFClPXRCoUChYWFwpjycKBhQJ7nkZ6eLrq7zXEcTCaTaOEshUKB9PR0dHV1hXyu+qOqqgo6nU6YwhwuFosFhBCkpqaK+pnS8nyO48Iev0OhuUCtViuqsFgsFsyaNQtPPvmkaMJy7NgxlJeXiy4stbW1kMlkGDZsmGjCYrfbhV4UMc8BusKCngti+RsRcQ1KS0tx22234fnnnw/J0GiJC3A6ySzGh9na2oq8vDxRl2LZ7XYUFRVhyJAhOHTokGAn7esQ6zPSarWwWCywWq0hvwZNhtIeJ7G/v0hVesnlcmRmZsJgMIguMHfffTdeeOEFv71LgUKnSIidt/J4PIK3ItYNiwpLVlaWqGPoDQYDbrzxRixdujSsxlQKIac3S1ZUVIi+Q2n//v3IyclBSUmJaJ9poKXGoSKRSATPhTbshg2JIMeOHSOvv/464Xk+4L/heZ5wHBdBq87EZDKF9fc2m42YzWaRrDnNzp07u31uLpeLHDhwgHg8HlJXV0dcLpeo78fzPNmzZw9xu90h/a1erycej0dUmyhut5vo9fqgzqNg4Xme6HQ60Y/BbDaThx9+OORz2m63R+TYXS4XcTqdor4uz/Nk//79pLW1VbTXJIQQvV5PLrvsMqLT6UR7zePHjxOHwyHa61EOHTok6vHzPE8sFktEz/2eeDweYrfbw37PiCY1KioqMGHCBPz1r38N+G9IFL0WikQiCVmpCTm9/U7MpLXD4TjjqUehUKC0tBSnTp2CTCYTfzy2RIIRI0agpqYm6Cd4s9mM1NRU0Zv4yH/zN5EqHfZGIpEgKytL9BBZSkqK4MEEmzSNVNk0nS8mZniF53ns3bsXBQUFfU4KCIauri7MmTMH69ev73UCQzB0dHQgMzNT9DaE5uZmKJVKUY9fzAKLQKHz5sL1uCObMQcwZcoUGAwGYYZVIERbXDQajTCzJ1g6OztRWFgoqj3Ure5JSkoKBgwYIPr7UWQyGYYPHx6UwDidzoiIHflvtZnL5YpIybAvJBIJtFoturq6RK2eGTBgAGbMmIEXX3wx4BwfLQ4Rc9Uw8L8ci5iFFhzHYffu3aioqBBNAIDTobDZs2djw4YNovVj2Ww22O32M8bShIvZbEZ7ezvKy8tFe006nira0zSA0w+z5L8lz6EScXEBgHnz5mH9+vVCz4c/YuG1AP+LN9JRKnQXRl/QwX9ifvl2ux3l5eV+PwepVBrRz0ipVGLo0KE4cOBAnzdCurVT7DE6dAeOXC4XvTKqL6gHQ1cliMXw4cNx3XXX4bnnnhOaSv1B10iLNamXQj1BMZ+E3W630CApZkOu0WjErFmzRBUWj8eDhoYGUaYqe+NyubB//36MGjVKVE/Q5XJFpFcqUJRKZVj5l5BLkS0WS1C/z3EcXnnlFTz99NN+f4fuawmWQGaLBQLdf0EVu68S5ZaWlpAm1PYmRvv378ewYcOCfs2+yr6DrYpzuVw4duxYr1MXOjs7Q2oO7SspqdfrkZaWFrRo9zVbLBiowPXVaR/sddDe3o633noLL7zwgt/faWtrC2mkS1+/T6uNgr3Gevv9bdu2oaqqKuixPn3dNK+44gosX748aA+jt/PxyJEjGDBgQNDH39e1tXXrVowePTro87W3z8DfgMm+EOte6P37gQzE9GlLqOLS3t7u9+dpaWk+S/s8Hk+vIZ3eTOnNq+nrA/V3Y+ltEij572j33vAVk6S7EXrLwfR2UtEpvb7s8TcRFjhzUm4gr8txnDDM0ddnwPN8rycV3dPSE6fTCalU6vc4+/pc/Qkh7Rz3R283AX+v6Xa7QQjxe3Ps68ZCV0t7Q/oYUupyuXp9ena73X4/VwB+cwV92drbddDbOdmbaFksFp//3WazCeNpfNHXzerIkSM+z2n64OevH6O38nyHw+F38nNvw1/7ys34+wz8TUWm9PYZ+Puu6LoEf99XoBPie9LXVORQqtREbaJ0Op144IEH0NnZiQsuuADXXnutKDOWSAT3uQCncy5ilfjZbDa0tbWJtsOeYrVaUV1djZEjR4rW9NnQ0ICGhgaMHz9etIGSTqcTBoMBarVatK5st9sNg8EAnueRlZUlSqiAbpmkA/zEjMEfPXoUjz76KBQKBa655hpcddVVopwLer0eVqsVqampouWheJ6H3W6HTCYT9Xw9ePAgmpubcf7554s6Vbi6uhoXXnghvvvuO9FmGR47dgwej0eU+WSUo0ePCp6/WPtc6AI+iUQiauO3y+UCz/Oi73MRNeeiUqnw6quvYs6cOdixYwfuvfdevPvuuzAYDGG9LhUV8t9OYrH0kH5BVqtVtPh6cnIylEoljEajKK8XKTiOQ1NTE/Ly8kTdwGkwGKBUKkWJk5P/Dv3U6/WQSqXIzs4O++R3u93o7OyEXq8Hz/PIzMwUPbk7ePBgvP3227jwwgvxwQcfYP78+fjiiy/87v0IFK1Wi8zMTFgsFrS2tob9esD/GujoFkyxGDBggJDjiGfo7h0xe3JOnDiBY8eO4ayzzhJFWMh/Gyhpd74YOU6PxwObzSbsXgp2AGwgiJ7QVyqV+NWvfoVly5bh2muvxY8//oglS5Zg3bp1QcenvZFIJEIym3oy4SKVSrsJjFiilZ6eDpvNJsrFHylaW1vBcZxoY8rpXhGFQiHKUzWtlqJP6uHuK/F4POjq6oJOpwPHccjIyEBOTk7EhnZmZWVhwYIFePPNNzFx4kS88847uPPOO/HNN9+ENRUiNTUV+fn5kEgkaG1t7bNIJhCo10J3HomBWq1GUVERTp48KXpzqpi0trZCpVKJ5mXX1dXh8OHDGDRokLBALhw8Ho8woy8pKSnsYgyO4wRRkUgkwmtGojkzYtViSUlJuOaaa7B8+XJcfvnl+Oabb7Bo0SJ8/PHHsNvtIb+u2F4MFRha+iqGwGg0Gsjl8rA9tkjB8zyampqQm5srSq0/9QYUCoUoPRlWqxV6vR6EEGi12rBCALSzv6OjA263G+np6cjJyRF1p0hv5ObmYsmSJfjTn/6EyspKrFixAnfffTe+++67kL1lhUKBvLw8pKWlwWAwoK2tLewxRlRgPB6PaAIzcOBAuN1uNDU1ifJ6YmO322E0GgWxDpeGhgbU1tZiwIABGDx4cFivRRPpNGRJ7ymhQnPBdLdVUlISkpKSIlrmHPFSZI1Gg1mzZmHZsmW48MIL8fnnn2Px4sX461//GvKTvdhejFQqRUpKilBaG+7rSSQSZGRkwGq1ht2IFAna29vhcrlE8VqoR0DHqIT7VNXZ2Qmz2Yzk5GRotdqQXXWO42A0GtHe3i6ssM3JyYnq9lFvioqK8PDDD2PZsmUoKyvDK6+8gkWLFuGnn34K6Xyj51heXh44jkNLS0tYkQHgtMCoVCrRBCY5ORn5+fk4ceJERKbuhktbWxuUSqUoYdGmpibU1NSgrKws7NwN9S48Hg/UanVY049pTs1ut4MQIrxeNHpnRJ+K3Bd6vR6ffvopvvvuO6SlpeGaa67BRRddFLIqe4tLuK4dx3HCnpBwt1QSQtDY2Ai1Wi3K8D6xEvqEEOzatQspKSlhXwQ0dCWTycKeLGy322EymSCVSpGenh5yHojneVgsFthsNiHxGc2No4Fy5MgRrF69Gnv37kVFRQXmzZuHsWPHhmQn+e9cN4vFgqSkJGRlZYUdQqRTcsPNx1ksFmzevBlVVVWiPMyIldB3Op2ora1FSUlJ2EVHra2t2Lt3L4qKisKeLu50OuFyuQRPMtRrivbJ0EZMpVIpamFFIERdXChtbW346KOPsHnzZmRnZ+O6667D1KlTQ74o6JNRuBVlVGBkMlnYAxhNJhP0ej1KSkrC/mLFEpf29nYcOXIEY8aMCTvcRBPtoS4sA05/byaTSRjRn5qaGvLyM+/hmxqNJuoNmKFQU1OD999/X9goOm/ePFRVVYX0Wna7HZ2dnSCEICsrKywvze12C0184QrMnj17YDabMXXq1LC/D7HEpb6+HiaTCcOHDw/roai9vR27d+9GQUEBRo4cGbaHQau2wnm48hYVOpQ0FsRMXCiNjY3YsGEDtm/fjsLCQtxwww2YPHlyyE9wYngxtJKCxjpDhRCChoYGJCcnh/10JJa47Nq1C0lJSUGvRvaGhq9oN3uon7XT6RSq6vz1RvUFzZXRcGZycjJSUlIivgtITAgh2L17N1avXo3jx49j9OjRuOmmm0KK2/M8j87OTmFPUTgeJRUYX/uEgsFkMuGnn37CqFGjUFBQEPLrAOKIi8vlQm1tLQoLC0NqgqbodDrs2rULOTk5GDNmTMjC4nK5hN6wUCcfk/8uEaM9UuF+Z2IQXT/JB8XFxXjwwQdx4sQJbNiwAa+99hrKysowa9asoL8w6rXwPC90+4fyhdNyP6vVCpvNFvIToEQiEZKumZmZMZkR5I1Op4PdbseQIUNCfg168wIQ8o2LlhjbbDahUifY1yH/HUNusViEZs+UlJSYf8ahIJFIMG7cOIwdOxZbtmzBmjVr8MADD2DSpEmYO3duUPOqaMm21WpFV1cXHA4HtFptSMJNb040NxrqzSotLQ3Z2dk4ceKEaMnzcGhvb4dMJgvrga+zsxO7d++GVqvF6NGjQzomnufhcDjAcRyUSmVIxTU9RUXsXpVwiLnn0pNDhw5h/fr1OHjwIAYPHoxZs2aFFCYQo/GSlgEqFIqQBYbneTQ0NCA1NRVZWVkhvQYgjueyZ88eKBSKkMMuVFho2CWUG7l3Q2RqampInysVFVqeGYmJzLGE53n88MMPWLduHdra2jB16lTMmTMn6IGlNCfmcDjCarykN69wnoa7urqwbds2jB07NixvIVzPxe1248CBA8jPzw+5t8VgMGD79u3IyMjA+PHjQ3rA8m6IVKvVQZ+/hBC43W6hYEjMnTxiEXfiAvxv4c4HH3yAEydOoKqqCjNnzgz6ids7TBaqyLjdbmHVcKjlq11dXTAajSgpKQn5JhiuuHR2dqK2thYjRowIqaafCgvtkg82h+SdE6G9MMF+Fna7HRaLRaiiSU1NjXqSMpp4PB5s3LgR69evR1dXFy6++GLMnj076AIRs9ksDALVarUhxfOpwKhUqpA/8+3bt4PjOEyZMiWkvwfCF5empibo9XpUVlaGdC2aTCZs27YNqampmDBhQkii4HA44PF4oFAogp715i0qdGxRvIkKJS6vTIlEgpEjR2LEiBHYuXMnNmzYgCeffBJjx47FzJkzAw4TePfEeItMMFCvhU6yDUVg0tPTYTQahX3tsaChoQFpaWkhCQutRgpVWDweD4xGozC/KVhxdDgcMJvN8Hg8UKlUyMjIiBvXP5LI5XL88pe/xEUXXYSvv/4aH330Eb777jtcdtlluP766wM+l1JTU6FWq6HX69Ha2oqMjIygJygolUphvh21LVgGDhyInTt3Qq/XizqaP1A8Hg90Oh1ycnJCEhaz2Yzt27dDo9Fg/PjxQb+Gx+MRpiAkJSUF/RnSHBghRCi0iEdRocSluFAkEgkmTJiAcePG4aeffsJHH32ERx55BJMnT8YNN9wQ8GgF+gWEGipTKBRISkoSGpCCjV9LpVKkpaXBZDKFlF8IF6PRCLPZjMrKyqD/lgqLx+MJSVisVissFgtkMlnQfSt0URgNyYT61J3oKJVKTJ8+HZdeeim+/PJLfPrpp/j2229x1VVX4Zprrglo/TFtvDQajTAYDLDb7dBqtUF9nzQnEKrAZGdnIz09HcePH4+JuHR0dABASGE5q9WKHTt2ICkpCRMmTAjq2Kkou91uyOXyoLvsE01UKHEZFvMHx3H44Ycf8PHHH6OzsxPnnXcerrvuuqBOlnByMS6XSxhbHqzAcByHhoYGZGRkhDSmPpywWE1NDTweD0aPHh3U31FhcbvdQQ+MpE2MLpcr6LJg76GSCoUCaWlpP0tR8YfFYsFnn32GL7/8ElKpFDNmzMD06dMDzl85nU7o9XpwHIfMzMygt6g6nU4hNBns03tbWxv27NmDSZMmheTFhxoW4zgOBw4cgFarDXrel91ux9atWyGXyzFp0qSgzkU6s40QEnSy3XuopFwuh1KpTKgqyMSxFKc7iC+66CK8/vrruPnmm7F3717cd999WLVqFbq6ugJ6jZ7jY4JBqVRCrVbD6XQG3cEsk8mQmpoKo9EY1W5lGm8PtoGNEAKDwQC3243MzMygLgq73S7M8MrKykJqampAwuI9VJIWDWRnZzNh6UFKSgrmzZuHlStX4pJLLsFHH32E+fPn49NPPw3ovFSpVCgoKIBGo0FnZyc6OjqCmv+lUqkgk8mESqdgyM3NRUpKCo4fPx7U34WLTqcDz/NBey0OhwPbtm2DVCrFxIkTgzoXnU6n0MwbzGBIX0MlIzX/K5IklrX/RaFQ4LLLLsOyZcswc+ZM/Oc//8HixYuxevVqYYx+b9DxMQCCnk9GvRaHwxG0wKSnpwtluNEi1D4b6nVkZmYGfEHRBVtGoxFqtTrgMFbPoZKZmZnIzs4Wfcd5fyM9PR3z58/HW2+9hXPOOQfvv/8+7rzzTvz973/vc9YY7VHKycmBy+VCS0tLnxsyvaFeS7ACI5FIUFFRAZ1OJ8rQzUDgeR7t7e0hhWW3b98OAJg4cWLA5yMdI+VyuaBSqZCcnByQMPQcKpmookJJTKv/i0qlwvTp07F8+XJMnz4dGzduxKJFi/Dhhx8GdKF4zycLxptQqVRQqVRwOBxBzUeja3uNRqNoE5h7w2q1orOzM2ivxWAwwOFwICMjI2BhcTqd0Ol0ws77QHJLHo+n21DJSE8q7q9kZ2fjnnvuwRtvvIFRo0bhzTffxIIFC7Bx48Y+b/xJSUnC7iGdTiesIggEKjBOpzOo6yc/Px/JyclR815oCDAvLy/gv3G5XNi+fTs8Hg8mTpwYcCGPy+XqNiUikOvH31DJRBUVSmJb/1+Sk5Nx/fXXY/ny5bjkkkvw5ZdfYtGiRfj888/79C5C9WLUajWUSiXsdntQApOeng6O48IeMhgIDQ0NQc82MxqNgrAE8qRGCIHJZBLG7WdnZ/cpDjQf09HRAafTGfVJxf2VgoICPPDAA1ixYgUGDRqE119/Hffccw82bdrU63lNGy+1Wi3sdjtaW1sD3u1CS2kdDkfAAiORSDBw4EC0tbVF/DoghKCtrS0oD9ztdmPHjh1wuVyYNGlSQLksnueF7ZtKpTKgBYTeokIIicqk4mjSL8SFkpqairlz52LZsmU455xz8OGHH2Lx4sX4+uuv+5xOHMqU5aSkJEFgAp1+rFAooNFoYDAYIuq90LxHcXFxwIl0k8kEu92O9PT0gLwHt9stdP2npaX12bFP54h1dHTA4XAgLS0Nubm5Yc9wY3SnpKQEjz32GF599VXk5+fjxRdfxL333ovt27f3es5pNBrk5+dDLpejvb0dXV1dfZ6jtHoyWIEpLCyEWq3GiRMngjq2YOns7ITb7Q7Ya/F4PNi5cyfsdjsmTpwYUPEM7YWj44f6eiijnfnek4qTk5P7jahQEqpaLFg6Ojrw8ccf44cffkBWVhauu+46nH/++b1+iaE0XtpsNrjd7oCTdi6XC01NTcjJyQm4UifYarEjR47AYDAE3EFsNpthtVqRlpbW55NasA2RNAZNwwUpKSlxOam4v1JbW4vVq1ejpqYGZ511FubNm4dRo0b1+jfBNl7S5kB6swzknKuvr8fBgwcxderUgCvdgqkWI4Tg4MGDSEpKwoABA/p8bY7jsHPnTphMJkycOLHPnrBgGyLjYVJxNOnX4kJpamrCRx99hC1btiA/Px/XX389zjnnnF5PhGBLlqnABLrUp62tDW63O+B8SDDi4nA4sGvXLgwYMCCgkSEWiwUWiyUgYfFuiExJSelVHOlQSRr6oOPvEz2WnIgQQrBv3z68//77OHr0KEaOHIl58+b1unbB7XZDr9cLS9b6arz0FphAdpDQ1oK8vLyAe7CCEZeuri6cOnUKQ4cO7TPkyvM8du3aha6uLkyYMKHPMmnvhki1Wt3rNR+PQyWjwc9CXCinTp3Chg0bsHv3bpSUlGDmzJkYP36834sgWC8mGIFxOp1obm5Gbm5uQJ5IMOJy/Phx6HS6gLqIrVYrzGZzQJ3z3g2R6enpfi8Q76GSiTqpuL9CCMH27duxevVq1NXVYcKECZg7d67flbyEEGG6hEql6rPxku57BxCQwJw8eRJHjhzB+eefH1AoNhhxOXjwIJRKJSoqKnr9PZ7nsWfPHuh0OkyYMKHXGYDBNET+XEWF8rMSF8qRI0ewYcMG1NTUYODAgZg1a1avuxiC8WLovmuNRtPnjZ3usQ+kqStQcXG5XNi5cydKSkpQUlLS62vabDaYTKY+PZBAGyLpjYUOlUzkScX9HUIINm3ahLVr16K5uRnnnnsu5syZ49eTDqbxkp4H3vkYf3g8Hvzwww8oLCzEsGHD+rQ7UHExGAw4efIkhgwZ0uv1QgjB3r170d7ejnHjxvVash9oQySd/+VyuSCRSOJyqGQ0+FmKC6Wmpgbr16/H0aNHMXToUMyePdtvmCDQXTH0qT0QgXE4HGhpaUFeXl6f4ahAxeXkyZNoa2vD+PHje33CpMKi0Wh6HR8S6IZIu90Os9ksTCpOSUnp1/Hk/gLHcfj3v/+NdevWQa/X46KLLsLs2bN9JsCD2XhJk9aBCMyxY8dw8uRJnH/++X3mdgIVl8OHD0Mqlfa6E4cQgurqarS0tPQ5rTmQDZGJMKk4mvysxQU4fULs2bMH69evR11dHUaNGoVZs2b5DRMEsvGS5hp4nu9TYFpaWkAI6TM3Eoi40BLKoqIilJWV+X0tu90Oo9GI5ORkv3H0QDdEeg+V/DlMKu6vuN1ufPPNN/jwww9hNpsxbdo0zJw50+cMsEA3XgYqMG63G99//z3Kysr6nHweiLiYTCYcP34cgwYN6vXBqaamBo2Njb0uMQt0QyQNfyXa/K9I8rMXFwohBFu3bsWHH36I5uZmTJw4ETNnzvQZJgjEi/EWmN7yDbSvID8/v9ekYyDiUldXh6amJkyYMMGvy+5wOGAwGJCUlOS3GiaQDZHeQyVVKhVSU1N/VvHk/orD4cDf/vY3fPLJJ3C5XLj88stx3XXXnXGuBLrxkgqMVCrttZrq8OHDaGhowPnnn9/reRSIuBw9ehSEkF6Fqra2FnV1dRg5cqTfsHQgGyITdahkNGAZ1v8ikUgwZcoUvPTSS7j77rtx8uRJPPTQQ1i2bBlaW1vP+N2+Gi8lEolQGUVFxhe0V4bezEPF4/GgpaUFBQUFfi9Op9PZq7AE0hDpcrmg1+uFNcdarTbooZaM+EWtVuO6667DypUrcc011+Cbb77B/PnzsXbtWqGUHAi88VIqlUKtVoPn+V4bmgcMGACe51FfXx+W/bTysbe+lsOHD6Ourg5VVVU+hSWQhki32w2r1Qqn0wmZTCb0tzBh+R9MXHogk8lwwQUX4LXXXsNtt92GAwcO4P7778dbb70FvV7f7Xf7arykAgOgV4HJyMiA3W4PelaZN62treB53u9TGBUWtVrtU1j6aoj0NVTy5zoC/+eARqPBnDlzsGrVKlx22WX49NNPMX/+fHz88cfdRCSQxkvqtdCEuC+USiVKSkpw6tSpoIdhetPa2tqrV37s2DGcOHECw4YN81nw0ldDJB0q6S0qiTz/K5KwT8QPcrkc06ZNw9KlSzFnzhxs374d9957L/7yl7908zJ6TlnueWEFIjAajQYKhQIGgyEkWzmOQ1NTE/Ly8nze7F0uFwwGA5RK5RkXHW2I1Ov1wtOodwzd7XazoZI/Y9LS0nDbbbfh7bffxvnnn4+1a9di/vz5+PLLL4WxR3K5HLm5ucjMzITFYkFra+sZI5FoIrw3gRkwYAA8Hk/I3ovNZoPZbPbrtZw8eRJHjx7FkCFDzlg4SCvcHA4H5HL5GR3z3pOK+8NQyWjAPpk+UCqV+NWvfoVly5bh6quvxnfffYfFixfjgw8+EMIENEzmz4uRSqXdBMaXl5ORkQGbzRbUnDJKW1sbPB6PT6+FigPtpPd22+mOdYvFgpSUFGi1WuGCokMldTodGyrJQFZWFu666y68+eabmDBhAlauXIkFCxbg22+/FSYwp6amIj8/HxKJBG1tbWdMPfYWGF9eulqtRlFREU6dOhXSWorW1lZhU2lP6urqcOjQIVRUVJzR9+LxeIQWgqSkpG7FB3T+FxWV/jJUMhqwTyhAkpKScO2112L58uW47LLL8PXXX2PRokX49NNPhaax3rwYKjA00d9TYGjjZbDeC8/zaGxs9Hnjp6EshUKBzMzMbsJitVqFEJdWqxX6FryHSrpcLqSnpyM3N5cNlWQAOL2P5d5778Ubb7yBYcOGYfny5Vi4cCG+//578DwvbLxMTU2FwWAQHnwoMpkMKpUKHo/Hp8AMHDgQLpcLjY2NQdlFKyCpuHnT2NiI2tpaDBgwoFuSn04UsNvtkMlk3ZqfvYdKAuh3QyWjAROXIElJScHs2bOxdOlSnH/++fjkk0+wePFi/O1vfxOapvx5MVRg6Kwt7/8mkUiQkZEBq9Ua8BBMAGhvb4fL5Tojfkx3pMjl8m7CwnEcOjs7YTabkZycLOy44HkeRqMR7e3twlDJnJycgGc+MX5eFBUV4de//jWWLl2KkpISvPzyy1i8eDG2bNkC4LQnnpeXB47j0NLS0m36sVwuFwSmp6eenJyM/Px8nDhxIqjBrm1tbVAqlWeMbWlubsb+/ftRWlrarYeN7k6hJfR0mgAtPfYeKslEJTRYKXKY6HQ6fPLJJ/j++++Rnp6Oa6+9FhdeeCHkcrnfkmWO42C1WoWEIL3xE0LQ0NCApKSkM8bk+ypFJoRg165dSElJ6Xbh0HCXTCbrlpj31RDJ8zwsFouwMY/O/2JVL4xgOHz4MFavXo19+/Zh8ODBmDt3LsaMGQMAfhsvqfdCS3gpFosFmzdvxogRI84I9foqRXY6naitrUVJSUm3DvvW1lbs3bsXRUVFqKqqEs5pXw2RP7ehktGAiYtItLS04OOPP8Z//vMf5OTk4Prrr8e5554rnLhA98ZLfwJjMpmg1+tRUlLS7eT2JS7t7e04cuQIxowZI/yMeiZ00yB9/54NkRKJRJhsDLChkgxxqK6uxurVq3Ho0CFUVlZi3rx5qKys9Nt4SftEegrMnj17YDabMXXq1G4POr7Epb6+HiaTCcOHDxfO346ODuzatQv5+fkYNWpUN6/EuyHSW1R+jvO/IgkTF5Gpr6/Hhx9+KHTK33DDDZg0aRIAnOHF0AoUGu+lv+NrNbEvcdm9ezfUajWGDx8O4H/CAgBarRZSqfSMhkiVSiWMv2dDJRmRgBCCnTt3Ys2aNThx4gTGjh2LuXPnoqKiwmfjJRUY7xu70WjEli1bzuie7ykuLpcLtbW1KCwsFMa36PV67Ny5Ezk5ORgzZgwkEskZDZH0Zz/XoZLRgPl9IlNaWoqHHnoIx48fx/r16/Hqq6+ivLwcM2fOxJgxY4Rkv0QiEUoerVYrbDab4MGkpaXBYDAgMzPTb6xXp9PBZrMJs5NoxzRwurJHIpHAZDLBZrNBpVIhLS0NDocD7e3t4HmeDZVkRAyJRIIJEyZg/Pjx+M9//oO1a9figQcewJQpUzBnzhxkZ2ejq6sLTqcTWVlZQiEKzb8oFAqkp6cjOzsbJ06c8Jmkp7S3twsl9MDpENyuXbug1WoxevRoocSY4zgolUoolcozRIX1akUG5rlEmIMHD2L9+vU4dOgQhgwZglmzZmH48OHdpizTUkiFQoHk5GTwPI+GhgakpqYK4797ei579+6FXC5HVVWVICw05MDzPAwGA3ieF2Yr0UnFNCzGRIURLTiOw/fff49169aho6MD5513HmbOnAmlUgmn04nU1FRkZGQIQx+pF9HV1YVt27Z1Gyrp7bkMGzYMBw4cQH5+PvLz82EwGLB9+3ZkZGRg3LhxwlQAiUQClUoFnufZUMkowsQlCtBFTRs2bMCJEydQVVWFWbNmCfX2VGBsNhuUSiWSkpLQ1dUFo9GIkpISyGSybuLicrlw4MABjBgxAqmpqejq6hIaHJ1OJywWi7AZz263s6GSjLjA4/HgH//4BzZs2ACDwYBLLrkEV1xxBeRyubDxEoAwr04ul2Pbtm3geR5TpkwB0F1ctFot9Ho9KisrYbVasX37dqSkpGD8+PFwu93weDyQy+WQSqXweDwghAjCxUQl8jBxiSKEEOzYsQMbNmxAY2Mjxo0bh5kzZ6KkpOQMgVGpVKivr0d6ejoyMzO7icvx48dBCMHIkSPR2dkJjuOQlpYmlDFTAWFDJRnxiMvlwt///nd8/PHHsNlsmDZtGi666CIkJycjPT1dKFNWqVQwGAzYuXMnJkyYAK1WK4jLxo0bIZVKkZOTg7S0NGzbtg1JSUkYO3as0Fcjk8mEfjM2VDL6MHGJATzP46effsKHH36ItrY2TJkyBddddx0KCwvhdrvhcDigUqmEcRYlJSWw2+2orq5GWVmZMBtJIpEIAuJ0OoUySuD0ZIHU1FQWT2bELXa7HV988QU+++wzeDwe/OIXv8AFF1yArKwsoalXrVZj27ZtkMvlmDhxoiAuH374IbKzs1FeXo5du3ZBoVBg9OjRAE4/xNHrgIlK7GDiEkNoLPqTTz5BZ2cnzjvvPFx77bXIyMgQZhx1dHQgIyMDcrkcO3bsELqIy8vL4XA4IJPJ4HQ6wfO8kJxMTU1ls78YCYPZbMZnn32GL7/8EhKJBBdeeCEuueQSIdlvNBpRXV2NSZMmob6+HhdeeCHefPNNjBkzBg0NDZBIJEK5sUQigUwmg1wuh1KpZFWQMYSJSxzgdrvxz3/+E59//jnMZjMuvvhiXH755dBoNGhsbMTrr7+O9evXw2w2IykpCbNnz8bixYuRlpYmhA/o+mE2+4uRqBgMBnz00Uf4+9//LgyOvfjii5GdnY0ff/wRH374IT7//HNYLBao1WpcccUVuPHGG3H22WcLYkL/MVGJPUxc4giHw4FvvvlGmDg7ceJEvPLKK6ivrz9jFEZJSQk+/vhjlJWVIS0tjc3+YvQbdDod1q9fj2+++QZJSUk499xz8fLLL6OxsfGM66C8vBwbN25EYWEhlEolq4KMI5i4xCFWqxV/+9vf8PTTT+PgwYM+f0cikWDJkiV47bXXomscgxElWlpasGbNGqxYsQJ1dXU+f0cikeD+++/Hyy+/HGXrGH3BxCVOIYQgIyPjjLHl3qSnp6Orq4slKxn9FkII0tPTYTab/f4Ouw7iEyYucQodkdEXVquVTS5m9FvYdZC4sKxXnNLbqlZKeno6y7Uw+jXsOkhcmLjEKRKJBPPnz/eboJTJZLjjjjtYKIDRr2HXQeLCwmJxTGdnJ6ZMmYLjx4+D4zjh5zKZDBUVFdiyZYswe4zB6K+w6yAxYZ5LHJOVlYUtW7bg/vvvF0ID6enpuP/++9kFxfjZwK6DxIR5LgkCHR1Od1EwGD9H2HWQODBxYTAYDIbosLAYg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwRIeJC4PBYDBEh4kLg8FgMESHiQuDwWAwROf/AeJTCanyg2zeAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = KAN(width=[2,[5,2],1], base_fun='identity', device=device)\n", + "model.get_act(dataset)\n", + "model.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4b39ad0c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 6.34e-02 | test_loss: 7.16e-02 | reg: 7.99e+00 | : 100%|█| 20/20 [00:04<00:00, 4.79it\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.1\n" + ] + } + ], + "source": [ + "model.fit(dataset, steps=20, lamb=0.01, lamb_coef=1.0);" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4c0314b5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2af1c553", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.2\n" + ] + } + ], + "source": [ + "model = model.prune()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "aac1fb1c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6dklEQVR4nO3deXhMd//G8fvMTPZFiMRSVVnEUmJfUlu1lqKPPZowg9LaqyhKqYSgtiJU1FbLRIRKUUVstZYWobGHSImICCJkTybz/f2Rmh9dNBg5k8n9ui7X9dRk8nxOOPN2dkkIIUBERGRECrkHICIi88O4EBGR0TEuRERkdIwLEREZHeNCRERGx7gQEZHRMS5ERGR0jAsRERkd40JEREbHuBARkdExLkREZHSMCxERGR3jQkRERse4EBGR0TEuRERkdCq5ByAqDoQQuH//PtLT02Fvbw9nZ2dIkiT3WEQmi1suRM+QmpqK4OBgVK1aFS4uLnBzc4OLiwuqVq2K4OBgpKamyj0ikUmS+CRKon+2e/du9OjRA5mZmQAKtl4ee7zVYmtri4iICLRv316WGYlMFeNC9A92796NTp06QQgBvV7/r1+nUCggSRJ27NjBwBA9gXEh+ovU1FRUqlQJWVlZzwzLYwqFAjY2NkhISICTk9OrH5CoGOAxF6K/WLt2LTIzMwsVFgDQ6/XIzMzEunXrXvFkRMUHt1yIniCEQNWqVREXF4fnWTUkSYK7uzuuXr3Ks8iIwLgQPeXevXtwcXF5qfc7OzsbcSKi4om7xYiekJ6e/lLvT0tLM9IkRMUb40L0BHt7+5d6v4ODg5EmISreGBeiJzg7O8PDw+O5j5tIkgQPDw+UKVPmFU1GVLwwLkRPkCQJn3zyyQu9d+TIkTyYT/QnHtAn+gte50L08rjlQvQXTk5OiIiIgCRJUCievYo8vkL/hx9+YFiInsC4EP2D9u3bY8eOHbCxsYEkSX/b3fX492xsbLBz5060a9dOpkmJTBPjQvQv2rdvj4SEBCxcuBDu7u5Pvebu7o6FCxfi1q1bDAvRP+AxF6JCEELgwIEDePfdd7F//360bt2aB++JnoFbLkSFIEmS4ZiKk5MTw0L0HxgXIiIyOsaFiIiMjnEhIiKjY1yIiMjoGBciIjI6xoWIiIyOcSEiIqNjXIiIyOgYFyIiMjrGhYiIjI5xISIio2NciIjI6BgXIiIyOsaFiIiMjnEhIiKjY1yIiMjoGBei/5CXl4dbt27h0qVLAIBr164hJSUFer1e5smITBcfc0z0L1JTUxEREYH169fjwoULSEtLQ25uLqytreHi4oIWLVpg4MCBaNasGVQqldzjEpkUxoXoHxw/fhyjR4/G2bNn0ahRI3Tq1Ane3t6wt7dHamoqoqKisH37dsTGxuKDDz7A9OnT4eLiIvfYRCaDcSH6iz179qB///6wt7fHV199hY4dOyI3Nxfh4eHIycmBo6Mj/Pz8kJeXh/DwcAQGBuLNN9+EVqtFuXLl5B6fyCQwLkRPuHLlCt577z3Y2dkhPDwcNWvWhCRJiIuLQ/369fHw4UO4ubkhKioKpUuXhhACR48eRe/evfH2229j5cqVsLKyknsxiGTHA/pEf8rPz8fMmTPx4MEDfPPNN4awPIskSWjevDnmzJmDbdu2ITIysoimJTJtjAvRn2JjY7F9+3Z0794dzZs3/8+wPCZJErp27YqmTZtixYoV0Ol0r3hSItPHU1yI/nTs2DGkp6ejR48euH79OjIyMgyvJSQkID8/HwCQm5uLCxcuwNHR0fB6xYoV0b17dwQGBiIpKQmVKlUq8vmJTAnjQvSny5cvw9bWFu7u7hg8eDB++eUXw2tCCOTk5AAAEhMT0bZtW8NrkiTh66+/Ru3atZGZmYnExETGhUo8xoXoT1lZWVCpVLCyskJOTg6ys7P/8euEEH97TafTwcbG5qkIEZVkjAvRn1xdXZGVlYXU1FQ0adIEdnZ2hteysrJw7NgxQ0Teeustw4WTkiShcuXKSE5OhkKhQOnSpeVaBCKTwbgQ/alBgwbIy8vDiRMnMHv27Kdei4uLQ6NGjfDw4UOUK1cOGzduhJOTk+F1SZLwxRdfoHz58twlRgSeLUZk0LhxY7i7u2Pt2rXIyMiAUql86tdjkiRBoVAYfl+hUOD27dvYvHkzOnXqhFKlSsm4FESmgXEh+pOzszNGjBiB06dPY9GiRYU+pTgnJwdBQUHIysrC4MGDC30KM5E5424xoif0798fhw8fxuzZs2Fra4uhQ4fC2toaAKBSqaBSqQxbMUIIpKWlYcaMGQgPD8eCBQtQrVo1OccnMhm8/QvRX9y9exfDhw/HTz/9hPbt22P06NGoUaMGYmJioNfrYWlpCU9PT5w4cQLz5s3D77//jmnTpmHo0KFP7T4jKskYF6J/kJGRgRUrVmDRokW4c+cO3N3dUbVqVTg4OODBgweIiYlBYmIiGjRogICAALRq1QoKBfcyEz3GuBA9Q1JSEvbv349Dhw4hOjoaJ06cQIsWLdCsWTO0a9cOTZo0ga2trdxjEpkcxoWokE6ePInGjRvj5MmTaNiwodzjEJk0bscTFZJSqTSchkxEz8a1hIiIjI5xISIio2NciIjI6BgXIiIyOsaFiIiMjnEhIiKjY1yIiMjoGBciIjI6xoWIiIyOcSEiIqNjXIiIyOgYFyIiMjrGhYiIjI5xISIio+PzXIgKSQgBvV4PhUIBSZLkHofIpHHLheg58FkuRIWjknsAImPIy8tDfHw89Hq93KO8NEmSULlyZVhaWso9CtELY1zILCQkJGDYsGFo0KCB3KO8tKioKISEhMDDw0PuUYheGONCZkEIAW9vb8yYMeNvvx8TE4OdO3fi8uXLsLGxQZMmTdCmTRu4urrKNO2zTZgwATwUSsUd40JmR5IkCCGQkZGBefPmYcmSJUhJSTG8HhISAjc3N4wfPx4ajQZWVlYmc4CeUSFzwbiQWUpPT8fIkSMRGhoKIQSqVq2Khg0bIj09Hb/++ivi4uIwYsQIHD9+HPPmzUPp0qVNJjBE5oCnvpDZ0el0mDZtGkJDQ6FUKjFq1CgcPXoUWq0WEREROHr0KDQaDQBg3bp1GDhwIFJSUrjVQGREjAuZne3btyMkJAQAMGrUKMycORNly5aFJElQKpXw8PDAsmXLEBQUBCsrK2zfvh0jRoxARkaGzJMTmQ/GhczK3bt3ERgYiOzsbLRp0waTJk362ym9kiTBysoKY8aMQVBQECwsLLB582ZMnz4deXl5Mk1OZF4YFzIbQggsX74cFy5cQJkyZTBjxgzY29v/69erVCqMGDECI0eOBAAsXrwYmzZt4u4xIiNgXMhs6HQ63Lt3D7a2thg4cCDq1q37nwfpLS0tMXnyZHTq1AnZ2dmYMGECLly4wMAQvSTGhcyGhYUF5s2bh3379mHMmDGFvlWLvb095s+fDw8PDyQmJmLcuHE8/kL0khgXMitKpRKNGzd+rgskJUmCm5sb5syZAxsbG+zbtw/ffvutWdxKhkgujAsRCgLz/vvvo3///tDr9Zg7dy6io6O5e4zoBTEuRH9SqVSYNGkSatasiXv37mHy5MnIysqSeyyiYolxIXpC+fLlERQUBGtra+zdu9dwhT8RPR/GhegJkiShU6dO8PX1RX5+Pr766iv88ccfDAzRc2JciP5CpVLhyy+/xOuvv474+HjMmDEDOp1O7rGIihXGhegvJEmCu7s7JkyYAKVSiY0bN2LPnj3ceiF6DowL0T+QJAlqtRpvv/02srKyEBAQ8NRt+4no2RgXon9hZ2eHqVOnolSpUvj999+xZMkSXvtCVEiMC9G/kCQJjRs3xqBBgwAU3Hvs999/5+4xokJgXIieQalUYvTo0ahZsyZSUlLw5Zdf8toXokJgXIj+g6urK6ZNmwYrKyte+0JUSIwL0X+QJAkdO3ZEr169kJ+fj+nTp+PKlSsMDNEzMC5EhWBhYYGAgABUqVIFt27dwuTJk5GTkyP3WEQmi3EhKgRJklClShVMmzYNlpaW+PHHH6HVarn1QvQvGBeiQpIkCT179kTPnj2h0+kQGBiIc+fOMTBE/4BxIXoOlpaWmD59Ory8vJCUlIQxY8bg4cOHco9FZHIYF6LnIEkSKleujLlz58LOzg4HDx7EV199xXuPEf0F40L0nCRJQocOHfDpp59CkiQsWbIEmzdv5u4xoicwLkQvQKlUYty4cWjfvj2ysrLw2Wef4dSpUwwM0Z8YF6IX5ODggEWLFqFatWpISkrC4MGDkZCQwMAQgXEhemGSJMHNzQ0hISFwdnZGdHQ0hg0bhocPHzIwVOIxLkQvQZIktGzZEvPmzYONjQ127dqFcePGITs7W+7RiGTFuBC9JIVCgd69e2PixIlQKpVYu3YtgoKCkJubK/doRLJhXIiMQKVS4bPPPsPgwYMhhMD8+fOxYMECnqJMJRbjQmQk1tbWmDFjBvz8/KDT6TBt2jQsXbqUgaESiXEhMiJ7e3ssWrQIXbp0QXZ2NiZOnIgVK1YgPz9f7tGIipRK7gGIzIkkSXBycsKyZcuQm5uLnTt3Yvz48RBCYNCgQVCpuMpRycAtFyIjkyQJzs7OWLVqFTp06IDMzEyMHz8eS5Ys4S4yKjEYF6JXQJIkuLi44LvvvkOnTp2QlZWFiRMn4uuvv+ZZZFQiMC5Er8iTgenWrRtyc3MRGBiIoKAgXgdDZo9xIXqFHu8iW7FiheEssjlz5uDzzz9HRkYGr+Qns8W4EL1ijw/yL126FAMHDoQQAiEhIRg+fDhvFUNmi3EhKgKSJMHe3h7z58/H6NGjoVQqERoaioEDB+Lu3bsMDJkdxoWoiEiSBFtbW0ybNg0BAQGwsrLC1q1boVareTdlMjuMC1ERs7Kywrhx4wxPs9y/fz/8/PwQFxcn92hERsO4EMlApVJh8ODBCAkJgZOTE3799Vf4+vri4sWL3IIhs8C4EMlEqVSid+/eWLlyJcqWLYvo6GiMHTuWpymTWWBcyOwIIYrNL0mS0LVrV2i1WjRp0gSBgYGwtraW+0dI9NJ4oyMyC5Ik4dy5c5g6darco7wQIQR8fHywa9cunD17FpIkyT0S0UuRBHfwkhnIzc1FXFycWdx9WKFQwMPDA5aWlnKPQvTCGBciIjI67hYjKqQn/x3G3VZEz8YD+kSFdObMGSiVSpw5c0buUYhMHuNCRERGx7gQEZHRMS5ERGR0jAsRERkd40JEREbHuBARkdExLkREZHSMCxERGR3jQkRERse4EBGR0TEuRERkdIwLEREZHeNCRERGx7gQ/Qe9Xo+UlBTEx8dDCIHbt28jIyND7rGITBofFkb0L7Kzs/Hzzz9j3bp1OHnyJJKTk5Geno5SpUrBzc0N7dq1Q79+/VCjRg0+34XoLxgXon8QFxeH8ePHY8eOHahYsSJat26NevXqwdHREffv38epU6dw4MAB5OXlYcyYMRg5ciRsbW3lHpvIZPBJlER/cfHiRfj7++PmzZv44osv8PHHH8PV1RWSJEGSJAghIIRAfHw8FixYgJkzZ+L69euYP38+A0P0J8aF6An379/HoEGDkJiYiNWrV6NRo0ZISEhAuXLlntr1lZubi5MnT+LLL79EzZo1MX78eFSsWBGTJ0+GQsFDmURcC4iesHTpUpw6dQozZsxAw4YN0b9/f3Tp0gV79+41bLHk5ORg2rRp0Gg0GDNmDHr27IlPPvkEixYtwu+//y73IhCZBB5zIfpTcnIyfHx8ULlyZWzduhWjRo3CmjVrAAAVKlTAmjVr0KJFCwQFBWHevHnIy8uDUqlEcHAwfH198fbbb6NVq1YICQnhAX4q8bjlQvSnkydP4ubNm1Cr1XB0dMSQIUPg4eEBALh9+zb69++PAQMGGMIiSRJ69uwJf39/uLi4oHv37ti3bx9SU1PlXRAiE8C4EP3pzJkzsLS0RKNGjSBJEho3boz169fD3d0dQEFgwsPDDWHx9fVFSEgISpcuDUmS0KxZMyQnJ+PWrVsyLwmR/BgXoj8lJyfD2toaZcqUAQBDYFavXg0nJ6envrZly5ZYunSpISwA4OrqCr1ezy0XIjAuRAZWVlbQ6/XIy8sDAMPB+8jISKSnpz/1tTExMTh16tRTv5ebmwshBCwsLIpsZiJTxbgQ/cnDwwMZGRm4fv36U2eFzZs3DzqdDpIkGa5jSUpKQv/+/Z86i+zKlSuwtrZGuXLlZF4SIvkxLlTiPXjwAMuWLcOyZcuQm5uLXbt2IS8vD9OnT3/q4L2vry+2bNny1DGY/v37Y//+/dDpdPjpp59gaWlpuAcZUUnGuFCJlJOTgy1btqB79+4oX748hg0bBhcXF9SqVQsbNmxAbGwssrKyIIQwhGXp0qVo27YtwsLCDGeRPXjwADExMThx4gT27NmDzMxMtGrVCl5eXpg6dSpiY2NlXlIimQiiEkKv14sjR46IwYMHi9KlSwsAol69emL+/Pni9u3bQggh9u3bJxwcHES3bt1EYmKiGD16tOjdu7e4f/++0Ov1hu/z22+/iTfffFPMmTNHXL9+XTRt2lQ0aNBA3L17V+zbt0/069dP2NvbCwDCx8dHLFmyRNy7d0/OxScqUowLmb3Lly+LyZMnCzc3NwFAvP7662LixIni/Pnzf/tanU4npk2bJiwtLYWfn5+IjY0V6enphrA8ptfrxa1bt8S5c+fEO++8I5ydncUvv/zy1NdkZGSIsLAw0bFjR6FUKoWFhYXo3Lmz+P7770VWVtYrXWYiufEKfTJLycnJ2LhxI7RaLU6ePAlHR0f4+vpCo9GgRYsWz7z/V05ODmbNmoVZs2bhjTfewPDhw9GhQweUL18eFhYWyM3NRXx8PLZu3Ypvv/0W+fn50Gq1ePfdd//1e965c8cwz6lTp1CqVCn4+vpCrVb/5zxExRHjQmYjMzMTP/74I0JDQxEZGQlJktCxY0eo1Wq8//77sLGxKfT3ys/PR2RkJKZPn47Tp0/Dzs4OFStWhJ2dHR4+fIjbt29Dp9Ohe/fuCAgIgKenZ6G/9+XLlxEaGorQ0FDcuHEDlStXRp8+faDRaFCjRo0XWXQik8O4ULGWn5+PQ4cOQavVIiIiAmlpaWjatCk0Gg169eqFsmXLvtT3z8zMxKlTp3D48GFcuHABaWlpcHV1RePGjdG6dWt4enpCqVS+0PfW6/U4duwYtFotNm3ahNTUVNSvXx8ajQZ+fn4oX778S81OJCfGhYqlc+fOITQ0FOvXr8etW7fg4eEBtVoNtVr9XFsRz0v8efaYseXk5GDHjh0IDQ3FTz/9hPz8fLRr1w5qtRpdu3aFnZ2d0f8/iV4lxoWKjcTERISFhSE0NBTR0dEoU6YM/Pz8oFar0bRpU7O5E3FKSgq+//57aLVa/PLLL7Czs0P37t2h0WjwzjvvvPCWElFRYlzIpKWlpWHLli3QarXYv38/LC0t8b///Q8ajQbvvfceLC0t5R7xlYqLi8P69euh1Wpx9epVVKhQAb1794ZarUadOnXMJqhkfhgXMjk6nQ579+5FaGgotmzZgqysLLRq1QpqtRo9e/b8200kSwIhBE6ePInQ0FBs2LAB9+7dQ61ataBWq9GnTx9UqlRJ7hGJnsK4kEkQQiAqKsrw4ZmcnIwaNWpAo9Ggd+/eeOONN+Qe0WTk5eVhz5490Gq12LZtG3JycvD2229Do9GgR48ecHR0lHtEIsaF5HX9+nWsX78eoaGhuHz5MsqVKwd/f39oNBrUq1ePu33+w6NHjxAREYHQ0FAcOHAAVlZW6Ny5MzQaDdq3b887NJNsGBcqcg8ePMDmzZuh1Wpx5MgR2Nraolu3blCr1WjTpg1UKpXcIxZLN2/exIYNG6DVanH+/HmULVvWcMJD48aNGWoqUowLFYnc3Fzs3LkToaGh2L59O3Q6Hd59911oNBp069YN9vb2co9oNoQQOHv2LLRaLcLCwnD79m1UrVrVcKr247s6E71KjAu9MkIIHD9+3HCRYEpKCurWrQu1Wg1/f39UrFhR7hHNXn5+Pn7++WeEhoYiIiICGRkZaNasGdRqNXr16mV46iaRsTEuZHRXr1413N4kLi4OlSpVQp8+faBWq1GrVi25xyuxMjIysG3bNmi1WuzZswdKpRKdOnWCRqNBp06dYGVlJfeIZEYYFzKKu3fvYuPGjQgNDcVvv/0GBwcH9OzZExqNBq1ateKNGU1MUlISwsPDERoaiqioKDg5OaFXr15Qq9Vo1qwZ/7zopTEu9MKysrKwfft2aLVaREZGAgDee+89qNVqdO7c+bluFEnyuXTpkmFLMz4+HlWqVDFsaVavXl3u8aiYYlzouej1ehw6dAihoaHYvHkzHj16hCZNmkCtVuODDz6Ai4uL3CPSC9Lr9Th69Ci0Wi2+//57PHz4EA0bNjQcI3N1dZV7RCpGGBcqlAsXLkCr1WL9+vVISEiAu7u74epwLy8vuccjI8vOzsaOHTug1Wqxc+dO6PV6tGvXDhqNBl26dIGtra3cI5KJY1zoX92+fdtw3cTvv/+O0qVL44MPPoBGo4GPjw+vmygh7t+/j02bNkGr1eL48eOwt7dHjx49oFar0bp1a95Ik/4R40JPSU9Px5YtWxAaGop9+/ZBpVLhf//7H9RqNTp06MAzikq4a9euGW6kGRsbi4oVK6J3797QaDTw9vaWezwyIYwLQafTYf/+/dBqtdiyZQsyMzPRokULaDQa9OzZE6VLl5Z7RDIxQgicOHECWq0W4eHhuH//PmrXrm24F9xrr70m94gkM8bFxKWnpyMxMREpKSmwsLCAq6srypUr99K3mhdC4MyZM4YbRSYlJaFatWrQaDTo06cPqlSpYpwFILOXm5uL3bt3IzQ0FNu2bUNubi7eeecdqNVq9OjRAw4ODi/9/5GXl4fk5GTcuXMHubm5cHBwQIUKFeDk5MTTpk0U42Ki4uLisHLlSvz444+4efMmdDodAMDW1ha1a9dGv3790L179+decW/cuGF44NbFixfh6uoKf39/qNVqNGjQgMdR6KU8fPgQERER0Gq1OHjwIGxsbNClSxdoNBq0bdv2uW+kmZqaioiICKxfvx4XLlxAeno6AECpVMLZ2RktWrTAwIED0axZM96TzsQwLiYmPz8fGzZswBdffIGsrCx06NABbdu2ReXKlaHX6xEbG4tdu3bhwIEDqF+/PhYvXoyaNWs+83s+XkG1Wi0OHToEGxsbdO3aFRqNBm3atOGdc+mViI+PR1hYGLRaLS5evAgXFxfDP2QaNmz4n/+QOX78OEaPHo2zZ8+iUaNG6NSpE7y9vWFvb4/U1FRERUVh+/btiI2NxQcffIDp06fzVHhTIshk5OfniyVLlgg7OzvRoUMHER0dLXQ6nTh27JgIDg4WwcHB4tKlSyI3N1ccOnRINGzYUFSrVk2cO3fub98rJydHbNu2Tfj6+gorKyshSZJo06aNWLNmjXj06JEMS0cllV6vF6dPnxZjxowR5cuXFwBEtWrVRFBQkIiLi/vH9+zevVtUqFBBVK1aVWzevFlkZmaK1NRU8e2334rg4GCxevVqkZWVJR49eiSWL18uKlasKNq2bSuSkpKKeOno3zAuJuTAgQPCyclJ9OzZU6SkpAi9Xi+EEGLy5MkCgAAgtFqtEKJghb1x44Z46623RPPmzcWDBw+EXq8Xx48fF8OGDRPOzs4CgPD29hZz584VCQkJci4akRBCiLy8PLF7926hVquFra2tACCaN28uli1bJlJSUoQQQsTExAg3NzdRq1Ytcf78ecN6cO3aNVGqVCkBQLi5uRm+Xq/Xi8OHD4tKlSoJtVotsrOzZVs++n+Mi4nIzMwUrVu3FtWqVRM3b940rFBC/HNchChYqaKiooSrq6vo0KGD8PT0FABExYoVxbhx40R0dLQci0JUKGlpaUKr1Yr27dsLhUIhLC0tRbdu3UTr1q2Fk5OTOHjw4FPrwb/FRYiCdSEsLEw4ODiIrVu3yrE49Bc8zcJEREVF4ddff8WwYcPw2muvFerAuiRJqFu3Lnr27Indu3ejadOm2LdvH+Lj4zFnzhxed0Amzd7eHmq1GpGRkUhISMCsWbNw+fJlHDhwAN27d0fz5s0LfYKJJEno2rUrmjZtihUrVhhOgCH58PQKE3Hw4EFYWVmhTZs2uHTp0lMrx507dwz/Oz4+HmfPnjX8t5OTE7p3746wsDBMnDjxPw/uE5miChUqYPTo0XBycsKQIUPQo0cPXL9+HRkZGYavSUhIQH5+PoCC058vXLgAR0dHw+sVK1ZE9+7dERgYiKSkJFSqVKnIl4P+H+NiImJiYuDq6goLCwu0adMGycnJhteeDE1gYCCCgoIM/+3v748pU6ZApVIhPj6ecaFi7fLly7C1tYW7uzsGDx6MX375xfCaEAI5OTkAgMTERLRt29bwmiRJ+Prrr1G7dm1kZmYiMTGRcZEZ42IChBDIzs6GlZUVlEolsrOzkZ2d/Y9fm5eXh7y8PMN/5+bmwtLS0vA+ouIsKysLKpUKVlZWyMnJ+de/04/XmSfpdDrY2Ng8FSGSD+NiAiRJQtmyZXHixAnk5+ejdevWSE1NNbx+9epVxMXFAQBq16791OOBvb29kZqaipycHD6yloo9V1dXZGVlITU1FU2aNIGdnZ3htaysLBw7dswQkbfeestw4aQkSahcuTKSk5OhUCh4yyITwLiYiAYNGmDt2rVISkrC+vXrn3ptypQpmDlzJgBg7Nix6NOnj+E1SZKg1WphbW0NDw+PIp2ZyNgaNGiAvLw8nDhxArNnz37qtbi4ODRq1AgPHz5EuXLlsHHjRjg5ORlelyQJX3zxBcqXL89dYiaAZ4uZgOTkZPz222/IysrC2rVrIYSAUqk0/Hry3kkKheKp17Kzs7Fu3To0b94c5cuXl3EpiF5e48aN4e7ujrVr1yIjI+Opv+tP3tpfkqSn1gWFQoHbt2/j+++/R40aNZ460E/yYFxkdO/ePUyYMAHu7u7YuHEjmjZtik2bNmH37t0Qhbgrj16vx5o1a3DmzBl88sknfK4GFXvOzs4YMWIETp8+jUWLFhX6lOKcnBxMmzYNCQkJ2LZtG9566y1ERkYWaj2iV4NxkcH9+/cxadIkuLu7IyQkBKNHj8b169exZcsWVK9eHUOHDsXPP/8MvV4PoGBrRaVSwcLCApIkQQgBnU6HsLAwBAQEYOjQoWjWrJnMS0VkHP3790eXLl0we/ZsLFq0CFlZWYZIqFQqqFQqwz+khBB49OgRAgICsHHjRixduhR79+6FUqlEx44d0bx5c+zdu5eRkYNMF2+WSCkpKeLLL78Ujo6Owt7eXkycOFHcvXv3qa+5cOGCqF+/vihTpoyYNGmSiI2NFVeuXBEHDx4UBw8eFDdu3BBnz54VQ4YMEaVKlRLDhw8XGRkZMi0R0auRnJwsfH19hY2Njejatas4dOiQSE5OFkeOHBGHDh0Sx48fF3fv3hU7duwQrVu3FqVLlxaLFy8WOp1OCFFwxX5kZKRo0qSJkCRJtGjRQvz8888yL1XJwrsiF4HU1FQEBwdjwYIFyMvLw4gRIzB27Nh/vYPrrVu3EBQUhI0bN0KlUqFmzZp4/fXXkZ+fj+vXryMmJgbOzs74/PPPodFo+HRIMksZGRlYsWIFFi1ahDt37sDd3R1Vq1aFg4MDHjx4gJiYGCQmJqJBgwYICAhAq1at/vZsFyEEdu3ahYCAAERFRaFVq1YIDAxEq1atZFqqkoNxeYUePXpkiEp2djaGDRuGcePGoVy5cv/53vz8fFy6dAk7duzAiRMnkJycDAsLC7i5uaF169Zo164dXF1di2ApiOSVlJSE/fv349ChQ4iLi0N2djZKly6NWrVqoV27dmjSpAlsbW2f+T2EEPjpp58QGBiIM2fO4J133kFgYCCaN29eREtR8jAur0BaWhoWL16Mr7/+GpmZmRgyZAjGjx+PChUqvND3E0IgPz8fkiTxoD2VaPn5+RBCQKFQvNATKIUQ2LZtGwIDA3H27Fm0bdsWgYGB8PHxeQXTlmw8oG9E6enpmD17Ntzd3TFt2jT06dMHsbGxWLBgwQuHBSg47fLJg5hEJZVSqYRKpXrhRxs/vsHl6dOn8f333yMxMRHNmjVDx44dceLECSNPW7IxLkaQmZmJefPmwd3dHVOmTIGvry+uXr2KRYsW4bXXXpN7PCL6C4VCgR49eiA6Ohrh4eG4ceMGmjZtiv/973+IioqSezyzwLi8hKysLCxYsADu7u744osv0K1bN1y5cgUhISF4/fXX5R6PiP6DQqFAr169cPbsWaxfvx6xsbFo1KgRunbtijNnzsg9XrHGuLyA7OxsLFq0CB4eHhg/fjzef/99xMTEYNmyZXjjjTfkHo+InpNSqYS/vz/Onz+PdevW4eLFi2jQoAF69Ojx1CMuqPAYl+eQk5ODJUuWwNPTE2PGjEH79u1x+fJlrFy5Em5ubnKPR0QvSalUQq1W4+LFi1i9ejWio6NRt25d9OrVC+fPn5d7vGKFcSmE3NxcfPvtt6hatSo+/fRTvPPOO4a/fLxZJJH5UalU6NevHy5duoSVK1fi1KlTqFOnDvz9/XHp0iW5xysWGJdnyMvLw4oVK+Dl5YXhw4ejZcuWhs1mLy8vuccjolfMwsICAwYMwOXLl/Htt9/i+PHjqFWrFtRqNWJiYuQez6QxLv8gLy8P3333HapXr44hQ4bAx8cH586dQ2hoKKpXry73eERUxCwtLfHxxx/jypUrWLJkCQ4fPow333wT/fr1w9WrV+UezyQxLk/Q6XRYu3YtatasiY8++ggNGjRAdHQ0NmzYwMcHExEsLS0xZMgQXL16FcHBwdi/fz9q1qyJAQMGGB7oRwUYFxRc9RsaGoo333wTH374Iby9vXHmzBls2rQJtWrVkns8IjIxVlZWGD58OGJjY/H1118jMjIS1apVw8cff4zr16/LPZ5JKNFxyc/Px4YNG1C7dm307dsXNWrUQFRUFCIiIlCnTh25xyMiE2dtbY2RI0fi2rVrmDNnDrZv3w4vLy8MGTIE8fHxco8nqxIZF71ej02bNqFOnTro06cPPDw8cOLECWzduhX16tWTezwiKmZsbGwwevRoXLt2DTNnzsQPP/yAqlWrYvjw4UhISJB7PFmUqLjo9XpERESgbt268PPzQ+XKlXH8+HFs374dDRs2lHs8Iirm7OzsMHbsWMTFxWHatGnYuHEjPD09MXLkSCQmJso9XpEqEXERQmDr1q2oX78+fH19UaFCBfzyyy/YuXMnmjRpIvd4RGRm7O3t8fnnn+OPP/7AlClTsH79enh4eGD06NG4ffu23OMViRJxy/2ffvoJnTt35jMciEgWDx8+xKJFizB//nx4enri5MmTco/0ypWIuDxeREmSZJ6EiEqykvRZVCLiQkRERUsl9wB5eXmIj4+HXq+Xe5SXJkkSKleuDEtLS7lHIaLnxM8i45I9LgkJCRg2bBgaNGiAzMzM/3wWtimLiopCSEgIb2ZJVAw9+VlUXD3+DDWFzyLZ4yKEgLe3N3r27IkxY8ZgypQpaN26tdxjvZAJEyaAexmJiqfHn0UzZsyQe5QXcvDgQUydOhVff/01dDqd7J9FJnEqck5ODiZPnowjR46gX79+OHz4MICCTbvi8ouIzIfcnyfP+9nz888/Q6PR4MiRI5g8eTKys7Nl/gmaSFysrKwwa9YseHl5ITExEX379sWxY8dkLy8RkSkTQmDv3r3o27cvbt++jerVq2PWrFmwtraWezTTiAsA1K5dG2FhYfDw8EBCQgL69u2LU6dOMTBERP9ACIHIyEj069cPSUlJqFmzJsLDw+Ht7W0Se1NMJi4AULduXaxfvx5VqlTB9evXoVarER0dzcAQET1BCIEdO3bgww8/RHJyMmrVqoXw8HCTuou7ScVFkiQ0bNgQWq0WlSpVQmxsLNRqNS5dusTAEBGh4B6J27dvx8CBA3H37l14e3sjPDwcNWvWNIktlsdMKi5AQWB8fHywZs0alC9fHpcuXYJarca1a9cYGCIq0fR6PbZu3YqBAwfi3r17qFu3LsLDw1G9enWTCgtggnEBCgLz9ttvY9WqVShbtiyio6Oh0WgQHx/PwBBRifT4ru6DBg1CSkoK6tevj/DwcHh5eZlcWAATjQtQEJj27dtj2bJlKF26NE6cOIG+ffsiMTGRgSGiEuXxM6gGDx6MBw8eoFGjRggPD4enp6dJhgUw4bgABYHp3LkzlixZAkdHRxw9etRwAIuBIaKSQK/XY8OGDRg6dCgePnyIpk2bYsOGDXB3dzfZsAAmHhcAUCgU8PX1xcKFC2FnZ4f9+/fjo48+wv379xkYIjJr+fn50Gq1GD58OB49eoRmzZohLCwMVapUMemwAMUgLkBBYNRqNebOnQsbGxvs3LkTgwYNwoMHDxgYIjJL+fn5WLNmDUaOHIm0tDS0bNkS69evR+XKlU0+LEAxiQsAKJVKDBw4EDNnzoS1tTV+/PFHDBkyBKmpqQwMEZmV/Px8rFq1CqNHj0Z6ejpat26N0NBQVKpUqViEBShGcQEAlUqFYcOGYerUqbC0tMQPP/yAYcOG4eHDhwwMEZkFnU6HZcuW4bPPPkNGRgbatm0LrVaLihUrFpuwAMUsLkBBYD799FMEBATAwsIC33//PQNDRGZBp9MhJCQE48ePR2ZmJt577z2sXbsW5cuXL1ZhAYphXADAwsICY8aMwZdffgkLCwts2rSJu8iIqFjLy8vD4sWLMXHiRGRlZaFTp05YvXo1XF1di11YgGIaF6AgMOPGjcOUKVNgYWGBzZs3Gy4uYmCIqDjJy8vDggULMGnSJOTk5KBz58747rvv4OLiUizDAhTjuAAFgRk7dqzhGMyWLVvQv39/3Llzh4EhomIhNzcXc+fORUBAAHJzc9GtWzesXLkSzs7OxTYsQDGPC1AQmNGjR+Orr76CtbU1du7cCbVajZs3bzIwRGTScnNzMXv2bAQFBSEvLw89evTA8uXLUaZMmWIdFsAM4gIUBGb48OGYP38+7O3tceDAAfTq1QtXrlxhYIjIJOXk5GDGjBmYMWMG8vLy4Ofnh2XLlsHJyanYhwUwk7gABWeRDRw4EEuXLkXp0qVx8uRJ9OzZE6dPn2ZgiMikZGdnY9q0aZg9ezby8/PRp08fLFmyBKVKlTKLsABmFBeg4EJLPz8/rFmzBuXKlcPFixfRs2dPHDhwgIEhIpOQnZ2NgIAAzJs3D/n5+ejbty+++eYbODo6mk1YADOLC1Bwq5hOnTohPDwcbm5uiI+PR+/evREREQG9Xi/3eERUgmVlZWHSpElYuHAh9Ho9PvzwQwQHB8Pe3t6swgKYYVyAgrspt2jRAhEREfD29sbdu3fx0UcfYcWKFdDpdHKPR0QlUGZmJiZOnIjFixdDr9fj448/xoIFC2BnZ2d2YQHMNC5AQWC8vb0RERGBli1bIi0tDWPGjMGsWbOQnZ3N3WREVCSEEMjIyMD48eMREhICABg6dCjmzZsHW1tbswwLYMZxAQoC4+bmhvDwcHTt2hU5OTkICgrC559/joyMDAaGiF6px2H57LPPsGzZMgDA8OHDMWvWLLMOC2DmcQEKAuPq6orvvvsOAwYMgBACISEhGDJkCK/mJ6JXRgiB9PR0jBo1CqtWrYJCocCnn36KmTNnwtbWVu7xXjmzjwtQEBhHR0cEBwdj7NixUKlUCA8PR9++fXH79m0GhoiMSgiBtLQ0jBw5EmvXroVCocCYMWMQFBQEGxsbuccrEiUiLkBBYGxsbBAYGIgZM2bAxsYGkZGR+OCDDxAXF8fAEJFRCCHw6NEjjBgxAlqtFkqlEuPHj0dgYCCsra3lHq/IlJi4PGZpaYlPP/0UixcvRqlSpXDs2DH07NkTFy5cYGCI6KUIIfDw4UMMHToUYWFhUKlUmDhxIr788ktYWVnJPV6RKnFxAQoutuzbty9WrlyJsmXL4uzZs/D19eXV/ET0woQQSE1NxeDBg7Fp0yZYWFhg8uTJmDhxIiwtLeUer8iVyLgABRdbduvWzfCEtytXruCDDz7Ar7/+ysAQ0XMRQuDBgwcYNGgQIiIiYGlpiSlTpuDzzz8vkWEBSnBcgILjMG3btsWGDRvwxhtv4I8//oC/vz+OHDnCwBBRoQghcP/+fXz00UfYsmULLC0tMXXqVIwdOxYWFhZyjyebEh0XoCAwzZo1Q3h4ODw8PHDz5k2o1WocOnSIgSGiZxJC4N69e/joo4/w448/wsrKCtOnT8eoUaNKdFgAxgVAQWAaNWqE8PBweHl54datW9BoNLzhJRH9KyEEkpOTMWDAAGzfvh3W1taYOXMmRo4cWeLDAjAuBpIkoV69etiwYQOqVauGxMRE9O3bl4Ehor8RQuDOnTvo378/du7cCRsbG8yaNQvDhw+HSqWSezyTwLg8QZIk1KlTB+Hh4ahWrRpu376Nvn374uDBgwwMEQEoCMvjz4Y9e/bA1tYWc+fOxZAhQxiWJzAufyFJEmrXrv23wBw+fJiBISrhhBCGvRr79++HnZ0d5s+fj0GDBjEsf8G4/IPHgdmwYQO8vLwMf5mOHj3KwBCVUEIIJCQkQK1W48CBA7C3t0dwcDAGDBgApVIp93gmh3H5F49v2R8WFgZPT08kJCRAo9Hg+PHjDAxRCSOEMJxJevjwYTg4OGDx4sXo27cvw/IvGJdnkCQJdevWRVhYGNzd3Q1/uX777TcGhqiEEELgxo0b6N27N44ePQpHR0csWbIEarWaYXkGxuU/SJKE+vXrY/369XBzc8ONGzegVqtx6tQpBobIzAkhDBdXHz9+HKVKlcLSpUvh7+8PhYIfn8/Cn04hPL4OJjQ01HAlf58+fXDmzBkGhshMCSFw7do1+Pv748SJE3BycsKyZcvQq1cvhqUQ+BMqJEmS0KRJE4SGhuL111/HtWvX0Lt3b0RHRzMwRGZGCIGrV6/C398fp06dQpkyZbB8+XL06NGDYSkk/pSegyRJ8PHxgVarxWuvvYarV6+id+/eOHfunNyjEZERxcTEwM/PD6dPn4azszNWrFiBbt26MSzPgT+p5yRJEpo3b45169ahQoUKiImJQe/evXHx4kW5RyMiI7h06RL8/PwQHR2NsmXLYtWqVejcuTPD8pz403oBkiShVatWWLt2LcqXL49Lly5h7NixyM7Olns0InoJOTk5GDt2LM6dOwdXV1esXr0a77//PsPyAkzqJyaEKDa/AOCdd97B6tWr0aRJEwQGBpa4J80RmRsrKysEBgaiSZMmWLNmDTp06ACg+H02mQLZ71cgSRLOnTuHqVOnyj3KCxFCwMfHB7t27cLZs2chSZLcIxHRC3j8WWRnZwcfHx8cO3YMx48fl3usFxIdHS37Z5EkZE5dbm4u4uLikJ+fL+cYRqFQKODh4VFinzxHVJzxs8i4ZI9LUXi8iHKXnIhKtpL0WST7brGiotfrARQUvST8wRKR6fjrMZGScNsYkzqg/yr99NNPaNiwIZRKJdq1a4djx47JPRIRmbm0tDTMmDEDZcuWhZ2dHcaNG4e7d+/KPVaRKBFxkSQJXbp0QVRUFDZv3oykpCQ0b94cHTp0wG+//Sb3eERkZtLT0zFr1iy4ubkhKCgIarUa165dw/z581G+fHm5xysSJSIujykUCnTv3h2///47Nm7ciJs3b8LHxwfvv/8+Tp06Jfd4RFTMZWRkYO7cuXB3d0dAQAD8/PwQGxuL4OBgVKxYUe7xilSJistjCoUCvr6+iI6ORlhYGOLi4tC4cWN06dIFp0+flns8IipmMjMzMX/+fHh4eGDSpEno0aMHrl69im+++QaVKlWSezxZlMi4PKZUKuHn54dz585Bq9UiJiYGDRs2RPfu3REdHS33eERk4rKyshAcHAxPT098/vnn6Ny5M65cuYKlS5eicuXKco8nqxIdl8eUSiX69OmD8+fPY82aNTh37hzq1asHX19f3pSSiP4mOzsb33zzDTw9PTF27Fh06NABMTExWL58OapUqSL3eCaBcXmCSqVC3759cenSJaxatQqnT59GnTp14OfnxxtTEhFycnKwdOlSeHl5YdSoUWjbtq3h88Ld3V3u8UwK4/IPVCoVPvzwQ1y+fBnLly/Hb7/9htq1a6NPnz64fPmy3OMRURHLzc3F8uXL4eXlhREjRqBVq1a4cOEC1qxZA09PT7nHM0mMyzNYWFjgo48+QkxMDEJCQnD06FHUqlULGo0GV65ckXs8InrF8vLysGrVKlSrVg1Dhw5Fs2bNcP78eWi1WlSrVk3u8Uwa41IIlpaWGDx4MK5cuYJFixbhwIEDqFmzJvr374/Y2Fi5xyMiI9PpdFizZg1q1KiBjz/+GI0bN8bZs2cRFhaGGjVqyD1escC4PAcrKysMGzYMsbGxWLBgAfbs2YMaNWpg4MCBiIuLk3s8InpJOp0OWq0WNWvWxIABA1C3bl3DdXFvvvmm3OMVK4zLC7C2tsYnn3yCa9euYe7cudi5cyeqV6+OQYMG4caNG3KPR0TPKT8/H2FhYahVqxb69euHN998E6dPn8bmzZvh7e0t93jFEuPyEmxsbDBq1Chcu3YNX331FbZt2wYvLy8MHToUN2/elHs8IvoPer0eGzduhLe3N9RqNby8vHDy5Els2bIFdevWlXu8Yo1xMQJbW1t89tlniIuLQ1BQEDZv3oyqVavik08+wa1bt+Qej4j+Qq/XY/PmzahTpw78/f1RpUoV/Prrr/jxxx/RoEEDucczC4yLEdnZ2WH8+PGIi4tDQEAAwsLC4OnpiVGjRuH27dtyj0dU4gkhsGXLFtSvXx+9evXCa6+9hl9++QU7duxA48aN5R7PrDAur4CDgwMmTpyIP/74A5MmTcK6devg4eGBzz77DHfu3JF7PKISRwhh2Crp0aMHXFxccOTIEURGRsLHx0fu8cxSiXgSpdxSU1MRHByMhQsXIjc3F8OHD8fYsWPh6upaqPcLIXD//n2kp6fD3t4ezs7OfOAZlTgvsh4IIbBz504EBgYiKioKb7/9NgIDA9GyZcsimroEE1RkUlJSxJQpU4Sjo6Ows7MTEyZMEHfv3v3Xr3/w4IFYuHCh8PDwEAAMvzw8PMTChQvFgwcPim54Ipm8yHqg1+vFrl27RJMmTYQkSaJly5bi559/LvrhSzDGRQb3798XkyZNEg4ODsLBwUFMmjRJ3L9//6mviYyMFHZ2dkKSJCFJ0lMr1ePfs7OzE5GRkTItBdGr97zrgV6vF3v27BE+Pj5CkiTRrFkzsXfvXqHX62VekpKHcZHR3bt3xYQJE4SdnZ1wdHQUU6ZMESkpKSIyMlIolUqhUCieWpn++kuhUAilUsnAkFl6nvVAoVCIWbNmiebNmwtJkkTTpk1FZGQkoyIjHnMxAcnJyZg3bx6WLFkCCwsLZGZmQqfToTB/NAqFAjY2NkhISICTk9OrH5aoCKSmpqJSpUrIysqCXq8v9Pvq16+PoKAgdOjQgcclZcazxUyAq6sr5syZg2vXrqFevXrIy8srVFiAgvP1MzMzsW7dulc8JVHRWbt2LTIzM58rLADQt29fdOzYkWExAdxyMSFCCFStWhXXrl17rvdJkgR3d3dcvXqVKxUVe4/Xg7i4uEL/IwvgemBqGBcTcu/ePbi4uLzU+52dnY04EVHR43pgHrhbzISkp6e/1PvT0tKMNAmRfLgemAfGxYTY29u/1PsdHByMNAmRfLgemAfGxYQ4OzvDw8PjufcXS5IEDw8PlClT5hVNRlR0uB6YB8bFhEiShE8++eSF3jty5EgexCSzwPXAPPCAvol53vP7eZ0LmSOuB8Uft1xMjJOTEyIiIiBJEhSKZ//xKBQKSJKEH374gSsUmRWuB8Uf42KC2rdvjx07dsDGxgaSJP1tM//x79nY2GDnzp1o166dTJMSvTpcD4o3xsVEtW/fHgkJCVi4cCHc3d2fes3d3R0LFy7ErVu3uEKRWeN6UHzxmEsxIIRASkoK0tLS4ODggDJlyvCgJZU4XA+KF8aFiIiMjrvFiIjI6BgXIiIyOsaFiIiMjnEhIiKjY1yIiMjoGBciIjI6xoWIiIyOcSEiIqNjXIiIyOgYFyIiMjrGhYiIjI5xISIio2NciIjI6BgXIiIyuv8DmFX/trhTdPsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "97851f1f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 1.37e-07 | test_loss: 1.66e-07 | reg: 6.31e+00 | : 100%|█| 20/20 [00:02<00:00, 6.90it\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.3\n" + ] + } + ], + "source": [ + "model.fit(dataset, steps=20);" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f27281df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fixing (0,0,0) with x, r2=0.9999999997931204, c=1\n", + "fixing (0,0,1) with 0\n", + "fixing (0,1,0) with 0\n", + "fixing (0,1,1) with x, r2=0.99999999995849, c=1\n", + "fixing (1,0,0) with x, r2=0.9999999918922519, c=1\n", + "saving model version 0.4\n" + ] + } + ], + "source": [ + "model.auto_symbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fd45a429", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| train_loss: 1.43e-16 | test_loss: 1.28e-16 | reg: 0.00e+00 | : 100%|█| 20/20 [00:00<00:00, 37.98it" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving model version 0.5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "model.fit(dataset, steps=20);" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ffb84f4c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle x_{1} x_{2}$" + ], + "text/plain": [ + "x_1*x_2" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sf = model.symbolic_formula()[0][0]\n", + "nsimplify(ex_round(ex_round(sf, 3),3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "900f7788", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb b/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb index a226b496..985eb3ad 100644 --- a/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb +++ b/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb @@ -26,38 +26,19 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "76538154", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.73e-03 | test_loss: 4.96e-03 | reg: 6.68e+00 | : 100%|█| 20/20 [00:04<00:00, 4.77it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" + "ename": "ModuleNotFoundError", + "evalue": "No module named 'kan'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mkan\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;241m*\u001b[39m\n\u001b[1;32m 2\u001b[0m torch\u001b[38;5;241m.\u001b[39mset_default_dtype(torch\u001b[38;5;241m.\u001b[39mfloat64)\n\u001b[1;32m 4\u001b[0m device \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mdevice(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcuda\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcuda\u001b[38;5;241m.\u001b[39mis_available() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'kan'" ] } ], @@ -358,7 +339,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.10.12" } }, "nbformat": 4,