From 466cdb63bda006dd40a7824bba1feabf523f9cfb Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Thu, 28 Aug 2025 11:53:52 +0200 Subject: [PATCH 01/17] WIP: reconstruction of numerical phantom --- .gitignore | 2 + README.md | 15 + src/__init__.py | 0 src/__pycache__/__init__.cpython-311.pyc | Bin 0 -> 190 bytes src/__pycache__/plotSubspace.cpython-311.pyc | Bin 0 -> 8444 bytes src/customStyle.mplstyle | 19 + src/plotSubspace.py | 110 +++++ tutorial.ipynb | 406 +++++++++++++++++++ 8 files changed, 552 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 src/__init__.py create mode 100644 src/__pycache__/__init__.cpython-311.pyc create mode 100644 src/__pycache__/plotSubspace.cpython-311.pyc create mode 100644 src/customStyle.mplstyle create mode 100644 src/plotSubspace.py create mode 100644 tutorial.ipynb diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..033df5f --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.venv +__pycache__ diff --git a/README.md b/README.md new file mode 100644 index 0000000..dd4ddee --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +# Subspace Tutorial for ISMRM DACH-NORDIC 2025 +Demonstrate subspace reconstruction for inversion recovery FLASH acquisition both on numerical phantom and data acquired with pulseq sequence generated with `bart seq`. + +## Requirements +``` +bart version v0.9.00-1128-g995d362 +``` + +Install python packages in virtual environment. +``` +python3 -m venv .venv +source ./venv/bin/activate +pip install -r requirements +``` + diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/__pycache__/__init__.cpython-311.pyc b/src/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86e6ef6bd5fe5a8a98284d224a7a80fcaddbffa1 GIT binary patch literal 190 zcmZ3^%ge<81ZQm5WPs?$AOZ#$p^VRLK*n^26oz01O-8?!3`I;p{%4TnuR#5b{M=Oi zvXa!C)T-=E{h-u>{9=9gqWsc=Vtq&V_|Vkk?9?Lt;?ktzg2d$15JUa){G#mQjQj%c z%+wqs10z%Y;-X~z`1s7c%#!$cy@JYL95%W6DWy57c15f}8$fO-<_8iVm>C%vKQO?E IB4(f%0N4R9_5c6? literal 0 HcmV?d00001 diff --git a/src/__pycache__/plotSubspace.cpython-311.pyc b/src/__pycache__/plotSubspace.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72a6b2c7e11e527925daeeb442aac0c3c22b9da4 GIT binary patch literal 8444 zcmd5>U2GdycAgF~!S&n7Njub^dbRx-;)=oEB$Cm#T$+F;BcG`I3dMVCGqRk&^ zW@JkYwaXaZUBwU(x>XRi*ag@{k;S|uGr%zaju$({QLem5LgfpF zXLvTrTw~$vNHQtMH79HE$TdRST-V&Z^B!}}!xNw!?*i)O-9UZ32dJOtfCl(F-gl3^ z7UUy*5Y8dE4#7FhhoQBOXD66w{WiXOJj&|s*~QspMvj+@8F&5nYb&T5p=8EYZEL zv>3IVllR=BtC4fSJ~BTq(;S&{HkqBjgdUH~HCuASSS<51yD>ah0y(NJIl{A9VB6=! zdwE}iUH99cPG=gdeFnqi-14CcpAS?$Ew~=C?>Eb={MIHP;hnqfJB^YIau*)o#_ioE zKpr}_aUvq_%|llAOeLnJL{`v)()^?}8;c7!L?NEhIWd#Ck%~#TL|mL~-I~GTteo+`^M6gHOa|olJ|d#i(O^dXSbECm%X=5>LfufhH5FXr1ny zP0Bh4Z$u@Kbe9;rEhP1DY*HFY#ioVxVkULw{Fq)R3bCY(;}z2LDM5_Mg6@+9`No2r zh~JWo`l3;Hq-S+UDy9c;^a6k5&Ws=mx)*!P2{|d~?x~EJipjb=k&ja;svkBc1ThN`bI1-9%t5Lqa+BcI)34OO^At_{U zCHgK4vl*#xSj^1NN_|7aH?9itTY}iPv&2{W`|f1KTkxjY3ke}PaCG2UpCrcna5W~% z+t53^s5chIG0UHP+Hk%Ps-2ZvV=KWE&ov#dcs zbuF{Y1Dl-hv*7(;VN&IqG_FbEnrb;)p}G~}S*Z1CsI|1OH20fV*4o!%_}gIVuWe0O zKca??X`y4wPP{#EKcF;rJ!|ZJ+St1`w-I?Lsf~kLT;s+SZu}eQ z?7iQ~Gun8g%7^C{x{c4{c2-}*4VLe@bT%5Fe2M2jXR}qrw|6K zk!=Z)?VQG)Q|JN6rjdOr*{_lP3fW%;bYc%ImksF9oTEGV;sC7S%Ybg(X;+^A&2`+x zU1Ll5rkYaQ)8QdYD&%_Ta>xlJzaO($IsdwWfOdNRYi}Xictqu#%-Ji zRYu(<_k(|8C>AT$10Te_qD~dnp*m%%iJ=(IiegZ0knp)6`G(MYsnGX>?G}FseAE=i2L`vkL+?EhE=X{-8Gqv#czQZ>WXKQ8Bup%=1(ICkh3nY#NAed9own`^Y6smH5h{D>v~1C#o924wssfS{fk)I7yN=lRWCDEp z@u-X13Z0-Mt~=vXN!ru}c|phu)b&p!g)}Ulgu^%Fo*EuXjss6Z+W>3k53aoR z`QYk1#RavYTWjck)^PM`!%?+iKx-IK{ezl+P$7f=?^Z$_hSBe=g%hF_aReCRD3S|E z#(-GoPEi8MUtmLJ?#DlGUwxxEqt^OB~G1V$OEnhcSPSb3pDRR}}@U2kkor zv3^$$qxjG`^%xVSU$9J+g+LX8?`*i&j4E#!!S{q9_kYWwf7beA>ALQg64U8eGTS}@ zv1uIrt=1_BuUjV)sre*?y?pCgh}nT16Bn!e%s+qo)0@AS|90V|_#+s0G-P0bTa2ao zObUPi&WW_F2NKqpoxLKSg5Kf~kaCQkj7>sxPviAPTBjbT?vB9|rUl&z*dgL#>I6+? z)JuIxolS!?oaPtAi`e8brXf+=tP`A`;cs4rRtW_H46acOv&-SLaB3nCjW_}6KY$n* z^uuTVmZ$!f;`_zhYeR~^MfLY;{@(oA&EVnudt1S#BA|IYAbV+u{`k^)E%=5O?8y&r zc>^nl3b!@yVdzcVzr1+&V&RBN4r%0&LJsY4x>eGwk!FQ7BWLXHm=Zbu*c zD!HVQOA5KPwM0z zt{zH0-_a!xktjq=a*hpIac2_f@Ma@82EDax9F?0x|}W zRK42``(PPoWs!4kKDb-JN}-`{JlilUCerc5Y%JLt&p?EghD=>HA_~b~xK7JrVv+`1 z*_NSre11puFP#}`wd9wiDgekjd;2D~{~L;t1$5rZ^kgCV2Tz1-U~g;ByR9F;-8;C{ zVS9y$PEyn{{r7)|<##8ijY)iSG8>F72ok_gi~k#hq{E3&y*I-QXL#iAYqG+b$%j`$O7WGCot6Z0u_{9wQ% zfF`=HdAgcLnWOW=~PIk zsqlS|k36~j_*GQ+5si!}WMqrmSGcNj%^KI7ANo@;yz*gT?$eJ}KB7M3@>JpS%1xCV z$e-V;t6%jN+loUELaU+t2tIN6?(p(R;dXJdI9Hrp&6bX-B&w09LZX|I!Do@TpGMw( zeC$c**Ny+yqgL@ds;ml^Ch*ufz?Z?_6I5+2`DCORZPglS#nJl zh38~5TMky(VFikp+I=sz`_A3JLGZo`+yK;I5~f@LUH~pD-&eplIALb-nBDVXIcLrd zz5&Tqtr|cJriN-t&IMosT>G2AlK_A15&Vq;p2WL*c_a2vp#0q+G@cFZq-$DF$D~9x zK!{i1$s(Fygo>*aCBzSqH-S8YUkYgQ3nK0lz|mdQ{(~z)^}C|(RMW5Fji~O1n*TM{ zP9YgWg6nHheRoor7SeoK@yi;2Rg7aVjNdKZ0ooLsZxEp&c{vYd%3mpp|u* z3P$dZd~)I5g*^QkaTd(iEND}y`qzWV?iF#q{1c=#9?h}VaDaEOd#d5Ws@l-oY8}Cy zU$3#PRvQle{S~F-xm}(Pv)CyWf1z5`ZQ+3#$W-^DAJPKlRPI~w)JiJX5c^BOi?UP@ z4Ua2=42PJ+zCQu7jc^C@T1hMM*ffU(#ZMeW(hdafdL8Q>K&*KPo!Y0JFGM10{0w&a z1c;eVf-gbGmGFQX9?-%AMnY+e1ePZXk(Cb$F@+oe8>5i}P}w4Ng@(fWtNV*{rPB%l zv(}}NE~spg#zMTMML%9#3sxL(`=cMdBNnckChWT6WN2v@ypA_B|e+rkl z{Zyf!J6V?9WDY1h$0qZ-Vm~$+U!MLpnR;dCc-CoLi5*~x1@w(dD&CkM?}R$h)Zx)A>Zsxf>Y literal 0 HcmV?d00001 diff --git a/src/customStyle.mplstyle b/src/customStyle.mplstyle new file mode 100644 index 0000000..5cf008a --- /dev/null +++ b/src/customStyle.mplstyle @@ -0,0 +1,19 @@ +savefig.dpi : 300 +savefig.bbox : tight +axes.titlepad : 20 +axes.facecolor : w +axes.edgecolor : grey +axes.grid : False +grid.color : grey +grid.linewidth : 1 +grid.alpha : 0.5 +xtick.color : k +ytick.color : k +xtick.bottom : True +xtick.major.size : 5 +ytick.major.size : 5 +font.size: 12.0 + +legend.frameon : True +legend.edgecolor : grey +legend.facecolor : w diff --git a/src/plotSubspace.py b/src/plotSubspace.py new file mode 100644 index 0000000..d864682 --- /dev/null +++ b/src/plotSubspace.py @@ -0,0 +1,110 @@ +import matplotlib as mpl +from matplotlib import pyplot as plt +import cfl +import numpy as np + + + + +def plotCoefficientMaps(): + fig, axs = plt.subplots(1,4, figsize=(12,4)) + axs =axs.ravel() + img = absImageFromCFL("subspace_reco") + mask = realImageFromCFL("roi_mask") + for i, ax in enumerate(axs): + ax.set_xticks([]) + ax.set_yticks([]) + roi = np.ma.masked_where(mask==0, img[:,:,i]) + ax.set_title("Coefficient # {}".format(i+1), fontdict={'fontsize':12}) + # ax.imshow(roi, cmap=ps.createNewMap("gray"), clim=(None, 1.2)) + ax.imshow(roi, cmap=createNewMap("gray"), clim=(None, 1.2)) + plt.show() + +def plotTemporalEvolution(): + fig, axs = plt.subplots(1,4, figsize=(12,4)) + axs =axs.ravel() + timesteps=[0,100, 200,600] + img = absImageFromCFL("imgs") + mask = realImageFromCFL("roi_mask") + for i, ax in zip(timesteps,axs): + ax.set_xticks([]) + ax.set_yticks([]) + roi = np.ma.masked_where(mask==0, img[:,:,i]) + ax.set_title("t={}".format(i), fontdict={'fontsize':12}) + ax.imshow(roi, cmap=createNewMap("gray"), clim=(None, 0.125)) + plt.tight_layout() + plt.show() + +def plotT1Map(): + fig, axs = plt.subplots(1, figsize=(4,3)) + axs.set_xticks([]) + axs.set_yticks([]) + img =absImageFromCFL("t1map") + axs.imshow(img, cmap=createNewMap("gray")) + plt.show() + +def createNewMap(mapName): + newmap = mpl.colormaps[mapName].copy() + newmap.set_bad(color="black") + if mapName == "RdBu_r": + newmap.set_bad(color="white") + return newmap + +def realImageFromCFL(filename): + return np.real(cfl.readcfl(filename).squeeze()) +def absImageFromCFL(filename): + return np.abs(cfl.readcfl(filename).squeeze()) + + +def plotDict(ax, n=5): + indx = np.random.randint(0,100000, size=n) + filename="./subspace_dict" + signals= imageFromCFL(filename)[:,indx].T + cmap=mpl.colormaps["Set1"] + ax.set_xlabel("time [s]") + ax.set_ylabel("signal") + ax.set_title("Selection from Simulated Dictionary",fontdict={'fontsize':12}) + time =np.arange(0, len(signals[0])) * 6e-3 + for i,signal in enumerate(signals): + ax.plot(time, signal, color=cmap(i)) + + return ax + +def plotPCACoeff(ax,nCoef=4,n=30): + ax.set_xlabel("principal component") + ax.set_ylabel("rel. contribution") + ax.set_title("Accumulated PCA Coefficients",fontdict={'fontsize':12}) + S = imageFromCFL("./S") + + cumSum = np.cumsum(S) + cumSum /= cumSum[-1] + coeffIndx = np.arange(0,n) + ax.plot(coeffIndx, cumSum[:n], 'ko-') + annotation = "{} coeff. -> {:.3}% contribution".format(nCoef, cumSum[nCoef]*100) + + ax.annotate(annotation,xy=(0.1,.5), xycoords="axes fraction") + + return ax + + +def plotTemporalBasis(ax, n=5): + ax.set_title("Temporal Basis",fontdict={'fontsize':12}) + ax.set_xlabel("time [s]") + ax.set_ylabel("signal") + U = imageFromCFL("./U").T[:n] + time =np.arange(0, len(U[0])) * 6e-3 + cmap=mpl.colormaps["Set1"] + for i,signal in enumerate(U): + ax.plot(time, signal, color=cmap(i), label="# {}".format(i+1)) + + ax.legend() + + +def plotSubspace(): + fig, axs = plt.subplots(1,3, figsize = (12,4)) + plotDict(axs[0],n=5) + plotPCACoeff(axs[1], nCoef=4, n=17) + plotTemporalBasis(axs[2],n=4) + plt.tight_layout() + plt.show() + \ No newline at end of file diff --git a/tutorial.ipynb b/tutorial.ipynb new file mode 100644 index 0000000..c3fd170 --- /dev/null +++ b/tutorial.ipynb @@ -0,0 +1,406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1f4124b4", + "metadata": {}, + "source": [ + "# Non-Cartesian T1 | Subspace-Constrained Reconstruction\n", + "This tutorial uses the [`BART`](http://mrirecon.github.io/bart/) command-line interface (CLI) and presents how to work with radial data using BART, with the goal of implementing a full processing pipeline from raw data to T1 maps.\n", + "\n", + "\n", + "## Outline\n", + "1. Bart Setup\n", + "2. Simulation IR radial FLASH\n", + "4. Reconstruction Simulation PICS?\n", + "5. Prepare Subspace Reconstruction\n", + " 1. Subspace basis generation\n", + " 6. Subspace reconstruction\n", + " 7. Postprocessing\n", + "\n", + "\n", + "**Author**: [Vitali Telezki](mailto:vitali.telezki@med.uni-goettingen.de)\n", + "\n", + "**Institution**: University Medical Center Göttingen\n", + "\n", + "Based on previous material written by [Daniel Mackner](mailto:daniel.mackner@tugraz.at), [Moritz Blumenthal](mailto:blumenthal@@tugraz.at) and [Jon Tamir](mailto:jtamir@utexas.edu)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90fab0a9", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import src.plotSubspace as ps\n", + "import numpy as np\n", + "import importlib\n", + "\n", + "mpl.rcParams.update(mpl.rcParamsDefault)\n", + "plt.style.use(['ggplot', 'src/customStyle.mplstyle'])" + ] + }, + { + "cell_type": "markdown", + "id": "638eb164", + "metadata": {}, + "source": [ + "## Bart Setup Check\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "decdec9a", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "echo \"# BART used in this notebook:\"\n", + "which bart\n", + "echo \"# BART version: \"\n", + "bart version" + ] + }, + { + "cell_type": "markdown", + "id": "525c7c4b", + "metadata": {}, + "source": [ + "## Simulation: inversion-prepared radial FLASH \n", + "Using `bart phantom`, we will create a a numerical phantom with the inversion-prepared radial FLASH sequence with the following parameters. We use `bart signal` to simulate signal curves from individual vials and background and join them in one file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37a12f00", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Define Sequence Parameters\n", + "TR=0.006 # [s]\n", + "DIM=384 # Readouts\n", + "SPOKES=1\n", + "REP=700 # Repetitions\n", + "NC=8 # Number of Coils\n", + "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", + "\n", + "# create trajectory\n", + "bart traj -x $DIM -y $SPOKES -t $REP -c -r -G - | bart transpose 5 10 - tmp_traj\n", + "bart scale 0.5 tmp_traj traj\n", + "\n", + "echo dimensions of trajectory\n", + "head -n2 traj.hdr\n", + "\n", + "# create geometry basis functions\n", + "bart phantom -s$NC -T -k -b -t traj tmp_basis_geom\n", + "#create phantom in plane mask \n", + "bart phantom -x $BR -T roi_mask\n", + "\n", + "# check the dimensions\n", + "echo dimensions of geometry basis functions\n", + "head -n2 tmp_basis_geom.hdr\n", + "\n", + "# create signal tubes and background\n", + "bart signal -F -I -n$REP -r$TR -1 0.2:2.2:10 -2 0.045:0.045:1 tmp_basis_simu_tubes\n", + "bart signal -F -I -n$REP -r$TR -1 3:3:1 -2 1:1:1 tmp_basis_simu_water\n", + "\n", + "bart join 6 tmp_basis_simu_water tmp_basis_simu_tubes tmp_basis_simu\n", + "# check the dimensions\n", + "echo dimensions of signal basis functions\n", + "head -n2 tmp_basis_simu.hdr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f459b704", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# create simulated dataset\n", + "bart fmac -s $(bart bitmask 6) tmp_basis_geom tmp_basis_simu simu_ksp\n", + "\n", + "# add noise to the simulated dataset \n", + "# bart noise -n1 simu_ksp simu_ksp\n", + "# check the dimensions\n", + "echo dimensions of simulated phantom \n", + "head -n2 simu_ksp.hdr\n", + "\n", + "## remove tmp files\n", + "rm tmp_*" + ] + }, + { + "cell_type": "markdown", + "id": "a68b191f", + "metadata": {}, + "source": [ + "## Subspace Reconstruction\n", + "Now, we aim to reconstruct the simulated phantom data. First, we create a signal dictionary, then we perform a SVD and finally create the temporal basis used in subspace reconstruction.\n", + "\n", + "The signal model according to Look-Locker in voxel $r$ at time $t$ is\n", + "$$ \n", + "M(t,r)~=~M_{ss}(r)~-~\\left[M_{ss}(r)~+~M_{0}(r)\\right]~e^{-tR_1^*(r)}.~\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2060b295", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "bart show -m simu_ksp" + ] + }, + { + "cell_type": "markdown", + "id": "69753496", + "metadata": {}, + "source": [ + "### Create Signal Dictionary\n", + "Using `bart signal` we create our signal dictionary with `nR1s` values for R1star and `nMss` values for steady-state magnetization. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f46a35cc", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "## signal parameter\n", + "nR1s=1000\n", + "nMss=100 \n", + "REP=700\n", + "TR=0.006\n", + "\n", + "bart signal -help\n", + "\n", + "bart signal -F -I -n $REP -r $TR -1 5e-3:5:$nR1s -3 1e-2:1:$nMss tmp_dict\n", + "# reshape the dicc to have all the elements on the 6th dimension\n", + "bart reshape $(bart bitmask 6 7) $((nR1s * nMss)) 1 tmp_dict tmp_dict1\n", + "head -n2 tmp_dict1.hdr\n", + "# squeeze the dicc1 before SVD\n", + "bart squeeze tmp_dict1 subspace_dict\n", + "head -n2 subspace_dict.hdr\n", + "# perform SVD on dictionary\n", + "bart svd -e subspace_dict U S V" + ] + }, + { + "cell_type": "markdown", + "id": "2ea6095b", + "metadata": {}, + "source": [ + "### Visualize simulated dictionay and PCA coeffcients" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f506260", + "metadata": {}, + "outputs": [], + "source": [ + "importlib.reload(ps)\n", + "ps.plotSubspace()" + ] + }, + { + "cell_type": "markdown", + "id": "796024a0", + "metadata": {}, + "source": [ + "\n", + "### Estimate Coil Sensitivities Using Subspace\n", + "We realized, that 4 PCA coefficients contribute to more than 99% of the observed signal. Hence, we can reduce our basis to only contain the first 4 eigenvectors. We create a subspace basis spanned by those 4 eigenvectors.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4af968a", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "nCoe=4 # use 4 coefficients\n", + "\n", + "# create the temporal basis\n", + "bart extract 1 0 $nCoe U subbasis\n", + "# transpose the basis to have time on the 6th dimension and coefficients on the 5th dimension\n", + "bart transpose 1 6 subbasis - | bart transpose 0 5 - subbasis \n", + "head -n2 subbasis.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "afee5df8", + "metadata": {}, + "source": [ + "\n", + " Now, we estimate coil sensitivities using `bart ncalib` and reduced subspace basis in one go. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d735922", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "DEBUG_LEVEL=4 bart ncalib -N -i8 -t traj -B subbasis simu_ksp sens_ncalib" + ] + }, + { + "cell_type": "markdown", + "id": "1800164c", + "metadata": {}, + "source": [ + "### Perform reconstruction \n", + "\n", + "Using estimated coil sensitvities, we can now perform parrallel imaging reconstruction with `bart pics`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4c42af8", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "DIM=384 # Readouts\n", + "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", + "ITER=100\n", + "REG=0.0005\n", + "# # reconstruction with subspace constraint\n", + "bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n", + "\n", + "# resize the coefficient maps to the original size and multiply it with the roi_mask\n", + "# bart resize -c 0 $BR 1 $BR subspace_reco - | bart fmac roi_mask - subspace_reco_masked\n", + "# visualize subspace maps for 4 nCoe\n", + "# bart reshape $(bart bitmask 1 6) $((BR*nCoe)) 1 subspace_reco_masked subspace_maps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df606d77", + "metadata": {}, + "outputs": [], + "source": [ + "ps.plotCoefficientMaps()\n" + ] + }, + { + "cell_type": "markdown", + "id": "edd72a17", + "metadata": {}, + "source": [ + "### Temporal Signal Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "bart fmac -s $(bart bitmask 6) tmp_basis_4 subspace_reco imgs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92b113c5", + "metadata": {}, + "outputs": [], + "source": [ + "ps.plotTemporalEvolution()\n" + ] + }, + { + "cell_type": "markdown", + "id": "74857a61", + "metadata": {}, + "source": [ + "### T1 Map from Reconstructed Images\n", + "Using `bart mobafit` we obtain T1 parameter map via pixel-wise fitting. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb9b6bbe", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "TR=0.006 # [s]\n", + "REP=700 # Repetitions\n", + "\n", + "### create vector with inversion times nREP*TR\n", + "bart index 5 $REP - | bart scale $TR - TI\n", + "\n", + "bart mobafit -g -B tmp_basis_4 -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79442445", + "metadata": {}, + "outputs": [], + "source": [ + "ps.plotT1Map()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73525ec5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 314531b66775755778be7938c2ac1f6523736b38 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Thu, 28 Aug 2025 11:54:09 +0200 Subject: [PATCH 02/17] WIP: reconstruction of numerical phantom --- requirements.txt | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..480ca61 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,38 @@ +asttokens==3.0.0 +comm==0.2.3 +contourpy==1.3.3 +cycler==0.12.1 +debugpy==1.8.16 +decorator==5.2.1 +executing==2.2.0 +fonttools==4.59.1 +ipykernel==6.30.1 +ipython==9.4.0 +ipython_pygments_lexers==1.1.1 +jedi==0.19.2 +jupyter_client==8.6.3 +jupyter_core==5.8.1 +kiwisolver==1.4.9 +matplotlib==3.10.5 +matplotlib-inline==0.1.7 +nest-asyncio==1.6.0 +numpy==2.3.2 +packaging==25.0 +parso==0.8.4 +pexpect==4.9.0 +pillow==11.3.0 +platformdirs==4.3.8 +prompt_toolkit==3.0.51 +psutil==7.0.0 +ptyprocess==0.7.0 +pure_eval==0.2.3 +Pygments==2.19.2 +pyparsing==3.2.3 +python-dateutil==2.9.0.post0 +pyzmq==27.0.2 +six==1.17.0 +stack-data==0.6.3 +tornado==6.5.2 +traitlets==5.14.3 +typing_extensions==4.14.1 +wcwidth==0.2.13 From 61c4ff03638051b3977850f736cde3a12e1312bb Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Thu, 28 Aug 2025 12:03:28 +0200 Subject: [PATCH 03/17] FIX: refactoring issues --- src/plotSubspace.py | 6 +- tutorial.ipynb | 433 ++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 399 insertions(+), 40 deletions(-) diff --git a/src/plotSubspace.py b/src/plotSubspace.py index d864682..30a4d40 100644 --- a/src/plotSubspace.py +++ b/src/plotSubspace.py @@ -59,7 +59,7 @@ def absImageFromCFL(filename): def plotDict(ax, n=5): indx = np.random.randint(0,100000, size=n) filename="./subspace_dict" - signals= imageFromCFL(filename)[:,indx].T + signals= realImageFromCFL(filename)[:,indx].T cmap=mpl.colormaps["Set1"] ax.set_xlabel("time [s]") ax.set_ylabel("signal") @@ -74,7 +74,7 @@ def plotPCACoeff(ax,nCoef=4,n=30): ax.set_xlabel("principal component") ax.set_ylabel("rel. contribution") ax.set_title("Accumulated PCA Coefficients",fontdict={'fontsize':12}) - S = imageFromCFL("./S") + S = realImageFromCFL("./S") cumSum = np.cumsum(S) cumSum /= cumSum[-1] @@ -91,7 +91,7 @@ def plotTemporalBasis(ax, n=5): ax.set_title("Temporal Basis",fontdict={'fontsize':12}) ax.set_xlabel("time [s]") ax.set_ylabel("signal") - U = imageFromCFL("./U").T[:n] + U = realImageFromCFL("./U").T[:n] time =np.arange(0, len(U[0])) * 6e-3 cmap=mpl.colormaps["Set1"] for i,signal in enumerate(U): diff --git a/tutorial.ipynb b/tutorial.ipynb index c3fd170..4eae780 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "90fab0a9", "metadata": {}, "outputs": [], @@ -55,10 +55,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "decdec9a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# BART used in this notebook:\n", + "/home/vtelezki/Repos/Groups/AG_Uecker/barts/bart/bart\n", + "# BART version: \n", + "v0.9.00-1128-g995d362\n" + ] + } + ], "source": [ "%%bash\n", "echo \"# BART used in this notebook:\"\n", @@ -78,10 +89,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "37a12f00", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dimensions of trajectory\n", + "# Dimensions\n", + "3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 \n", + "dimensions of geometry basis functions\n", + "# Dimensions\n", + "1 384 1 8 1 700 11 1 1 1 1 1 1 1 1 1 \n", + "dimensions of signal basis functions\n", + "# Dimensions\n", + "1 1 1 1 1 700 11 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], "source": [ "%%bash\n", "# Define Sequence Parameters\n", @@ -120,10 +147,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "f459b704", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dimensions of simulated phantom\n", + "# Dimensions\n", + "1 384 1 8 1 700 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], "source": [ "%%bash\n", "# create simulated dataset\n", @@ -155,10 +192,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "2060b295", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Type: complex float\n", + "Dimensions: 16\n", + "AoD:\t1\t384\t1\t8\t1\t700\t1\t1\t1\t1\t1\t1\t1\t1\t1\t1\n" + ] + } + ], "source": [ "%%bash \n", "bart show -m simu_ksp" @@ -175,10 +222,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "f46a35cc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Usage: signal [-F] [-B] [-T] [-S] [-M] [-G] [-C] [-A] [--fat] [-I] [-s] [--short-TR-LL-approx] [-0 f:f:f] [-1 f:f:f] [-2 f:f:f] [-3 f:f:f] [-4 f:f:f] [-5 f:f:f] [-6 f:f:f] [-r f] [-e f] [-i f] [-f f] [-d f] [-t f] [-n d] [-b d] [--av-spokes d] [-m d] [--freq-samples d] [--pulsed] [-l f] [-a f] [--acquisition-only] \n", + "\n", + "Analytical simulation tool.\n", + "\n", + "-F FLASH\n", + "-B bSSFP\n", + "-T TSE\n", + "-S SE\n", + "-M MOLLI\n", + "-G MGRE\n", + "-C IR MGRE\n", + "-A ASL\n", + "--fat Simulate additional fat component.\n", + "-I inversion recovery\n", + "-s inversion recovery starting from steady state\n", + "--short-TR-LL-approx Short TR approximation for analytical LL model.\n", + "-0 min:max:N range of off-resonance frequency [Hz]\n", + "-1 min:max:N range of T1s [s]\n", + "-2 min:max:N range of T2s [s]\n", + "-3 min:max:N range of Mss\n", + "-4 min:max:N range of T1 values for fat [s]\n", + "-5 min:max:N range of FA values [°]\n", + "-6 min:max:N range of CBF values [ml/100g/min]\n", + "-r TR repetition time\n", + "-e TE echo time\n", + "-i TI inversion time\n", + "-f FA flip ange\n", + "-d FF fat fraction\n", + "-t T1 relax T1 relax period (second) for MOLLI\n", + "-n n number of measurements\n", + "-b heart beats number of heart beats for MOLLI\n", + "--av-spokes d Number of averaged consecutive spokes\n", + "-m multi echos number of multi gradient echos\n", + "--freq-samples d Samples in frequency-/z-domain for FSE model based on generating function formalism\n", + "--pulsed Pulsed Arterial Spin Labeling\n", + "-l lambda Blood-brain partition coefficient\n", + "-a Delta t Arterial transit time (ATT) in Buxton model\n", + "--acquisition-only only return the Buxton model signal during image acquisition\n", + "-h help\n", + "# Dimensions\n", + "1 1 1 1 1 700 100000 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "700 100000 \n" + ] + } + ], "source": [ "%%bash\n", "## signal parameter\n", @@ -210,10 +307,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "3f506260", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "importlib.reload(ps)\n", "ps.plotSubspace()" @@ -231,10 +339,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "e4af968a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -258,10 +375,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "0d735922", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Est. image size: 192 192 1\n", + "ksp : [ 1 384 1 8 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [ 48 48 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: low-mem mode\n", + "NUFFT: Toeplitz mode\n", + "\n", + "Model created (non Cartesian, nufft-based):\n", + "kspace: [ 1 384 1 8 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "images: [ 48 48 1 1 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "coils: [ 16 16 1 8 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "trajectory: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "pattern: [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "basis: [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "mask: [ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "coilimg: [ 48 48 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "\n", + "NUFFT: Toeplitz mode\n", + "ksp : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [ 48 48 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: low-mem mode\n", + "Scaling: 0.000137\n", + "Step: 0, Res: 100.000008\n", + "\t cg: 2\n", + "Step: 1, Res: 99.987431\n", + "\t cg: 0\n", + "Step: 2, Res: 99.837300\n", + "\t cg: 0\n", + "Step: 3, Res: 96.891624\n", + "\t cg: 1\n", + "Step: 4, Res: 80.109700\n", + "\t cg: 2\n", + "Step: 5, Res: 60.551751\n", + "\t cg: 2\n", + "Step: 6, Res: 12.282041\n", + "\t cg: 4\n", + "Step: 7, Res: 2.849885\n", + "\t cg: 9\n", + "Total time: 1.26 s\n" + ] + } + ], "source": [ "%%bash\n", "DEBUG_LEVEL=4 bart ncalib -N -i8 -t traj -B subbasis simu_ksp sens_ncalib" @@ -279,10 +447,176 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "e4c42af8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Basis: [192 192 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "Max: [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "GPU reconstruction\n", + "[ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "[192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: Toeplitz mode\n", + "psf_dims: [192 192 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [384 384 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "Scaling: 3231.860596 (max = 6739.995117/p90 = 3231.860596/median = 477.148560)\n", + "Inverse scaling of the data: 3231.860596\n", + "Maximum eigenvalue: 1.419121e+00\n", + "Maximum eigenvalue: 1.42e+00\n", + "l1-wavelet regularization: 0.000500\n", + "Regularization terms: 1, Supporting variables: 0\n", + "FISTA\n", + "lsqr: add GPU wrapper\n", + "#It 000: 1.000000 \n", + "#It 001: 0.265382 \n", + "#It 002: 0.106763 \n", + "#It 003: 0.062998 \n", + "#It 004: 0.045892 \n", + "#It 005: 0.036046 \n", + "#It 006: 0.027813 \n", + "#It 007: 0.021099 \n", + "#It 008: 0.016300 \n", + "#It 009: 0.013111 \n", + "#It 010: 0.010909 \n", + "#It 011: 0.009308 \n", + "#It 012: 0.008172 \n", + "#It 013: 0.007376 \n", + "#It 014: 0.006745 \n", + "#It 015: 0.006140 \n", + "#It 016: 0.005512 \n", + "#It 017: 0.004872 \n", + "#It 018: 0.004250 \n", + "#It 019: 0.003675 \n", + "#It 020: 0.003172 \n", + "#It 021: 0.002766 \n", + "#It 022: 0.002470 \n", + "#It 023: 0.002274 \n", + "#It 024: 0.002150 \n", + "#It 025: 0.002062 \n", + "#It 026: 0.001982 \n", + "#It 027: 0.001893 \n", + "#It 028: 0.001790 \n", + "#It 029: 0.001673 \n", + "#It 030: 0.001547 \n", + "#It 031: 0.001420 \n", + "#It 032: 0.001299 \n", + "#It 033: 0.001192 \n", + "#It 034: 0.001100 \n", + "#It 035: 0.001028 \n", + "#It 036: 0.000972 \n", + "#It 037: 0.000929 \n", + "#It 038: 0.000893 \n", + "#It 039: 0.000861 \n", + "#It 040: 0.000829 \n", + "#It 041: 0.000797 \n", + "#It 042: 0.000764 \n", + "#It 043: 0.000731 \n", + "#It 044: 0.000699 \n", + "#It 045: 0.000670 \n", + "#It 046: 0.000642 \n", + "#It 047: 0.000618 \n", + "#It 048: 0.000596 \n", + "#It 049: 0.000575 \n", + "#It 050: 0.000555 \n", + "#It 051: 0.000537 \n", + "#It 052: 0.000521 \n", + "#It 053: 0.000505 \n", + "#It 054: 0.000491 \n", + "#It 055: 0.000477 \n", + "#It 056: 0.000466 \n", + "#It 057: 0.000456 \n", + "#It 058: 0.000446 \n", + "#It 059: 0.000437 \n", + "#It 060: 0.000428 \n", + "#It 061: 0.000419 \n", + "#It 062: 0.000409 \n", + "#It 063: 0.000399 \n", + "#It 064: 0.000389 \n", + "#It 065: 0.000378 \n", + "#It 066: 0.000368 \n", + "#It 067: 0.000358 \n", + "#It 068: 0.000349 \n", + "#It 069: 0.000340 \n", + "#It 070: 0.000332 \n", + "#It 071: 0.000325 \n", + "#It 072: 0.000319 \n", + "#It 073: 0.000315 \n", + "#It 074: 0.000309 \n", + "#It 075: 0.000305 \n", + "#It 076: 0.000300 \n", + "#It 077: 0.000297 \n", + "#It 078: 0.000292 \n", + "#It 079: 0.000288 \n", + "#It 080: 0.000285 \n", + "#It 081: 0.000281 \n", + "#It 082: 0.000278 \n", + "#It 083: 0.000275 \n", + "#It 084: 0.000272 \n", + "#It 085: 0.000269 \n", + "#It 086: 0.000266 \n", + "#It 087: 0.000263 \n", + "#It 088: 0.000261 \n", + "#It 089: 0.000259 \n", + "#It 090: 0.000257 \n", + "#It 091: 0.000257 \n", + "#It 092: 0.000256 \n", + "#It 093: 0.000256 \n", + "#It 094: 0.000256 \n", + "#It 095: 0.000256 \n", + "#It 096: 0.000257 \n", + "#It 097: 0.000257 \n", + "#It 098: 0.000258 \n", + "#It 099: 0.000259 \n", + "\n", + "\t\tFISTA iterations: 100\n", + "Total Time: 5.600155\n", + "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", + "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", + "Freeing 8 bytes.\n", + "Freeing 8 bytes.\n", + "Freeing 8 bytes.\n", + "Freeing 16 bytes.\n", + "Freeing 16 bytes.\n", + "Freeing 2304 bytes.\n", + "Freeing 25088 bytes.\n", + "Freeing 25088 bytes.\n", + "Freeing 86528 bytes.\n", + "Freeing 86528 bytes.\n", + "Freeing 86528 bytes.\n", + "Freeing 320000 bytes.\n", + "Freeing 320000 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1233248 bytes.\n", + "Freeing 2359296 bytes.\n", + "Freeing 9437184 bytes.\n", + "Freeing 9437184 bytes.\n", + "Freeing 18874368 bytes.\n", + "Freeing 37748736 bytes.\n", + "Freeing 37748736 bytes.\n", + "Freed 127326872 bytes.\n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -301,10 +635,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "df606d77", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ps.plotCoefficientMaps()\n" ] @@ -319,20 +664,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "%%bash \n", - "bart fmac -s $(bart bitmask 6) tmp_basis_4 subspace_reco imgs" + "bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "92b113c5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ps.plotTemporalEvolution()\n" ] @@ -348,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "cb9b6bbe", "metadata": {}, "outputs": [], @@ -360,26 +716,29 @@ "### create vector with inversion times nREP*TR\n", "bart index 5 $REP - | bart scale $TR - TI\n", "\n", - "bart mobafit -g -B tmp_basis_4 -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" + "bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "79442445", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ps.plotT1Map()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "73525ec5", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 0c1c0c493718414f224168649283d74d86b46521 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Thu, 28 Aug 2025 12:04:40 +0200 Subject: [PATCH 04/17] Add hdr and cfl --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 033df5f..98e05d8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,4 @@ .venv __pycache__ +*.hdr +*.cfl \ No newline at end of file From f30ad8ea6f3aa4d9557e63c5c8c752e7ab3077b5 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Fri, 29 Aug 2025 16:35:28 +0200 Subject: [PATCH 05/17] WIP pulseq reco --- tutorial.ipynb | 907 +++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 719 insertions(+), 188 deletions(-) diff --git a/tutorial.ipynb b/tutorial.ipynb index 4eae780..6b81f7d 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -12,11 +12,16 @@ "## Outline\n", "1. Bart Setup\n", "2. Simulation IR radial FLASH\n", - "4. Reconstruction Simulation PICS?\n", + "4. Reconstruction Simulation PICS\n", "5. Prepare Subspace Reconstruction\n", " 1. Subspace basis generation\n", " 6. Subspace reconstruction\n", " 7. Postprocessing\n", + "6. Reconstruction Pulseq Data\n", + " 1. Prepare data\n", + " 2. Subspace reconstruction\n", + " 3. Postprocessing\n", + " \n", "\n", "\n", "**Author**: [Vitali Telezki](mailto:vitali.telezki@med.uni-goettingen.de)\n", @@ -120,8 +125,8 @@ "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", "\n", "# create trajectory\n", - "bart traj -x $DIM -y $SPOKES -t $REP -c -r -G - | bart transpose 5 10 - tmp_traj\n", - "bart scale 0.5 tmp_traj traj\n", + "bart traj -o 2 -x $BR -y $SPOKES -t $REP -r -G - | bart transpose 5 10 - traj\n", + "# bart scale 0.5 tmp_traj traj \n", "\n", "echo dimensions of trajectory\n", "head -n2 traj.hdr\n", @@ -167,7 +172,7 @@ "bart fmac -s $(bart bitmask 6) tmp_basis_geom tmp_basis_simu simu_ksp\n", "\n", "# add noise to the simulated dataset \n", - "# bart noise -n1 simu_ksp simu_ksp\n", + "bart noise -n1 simu_ksp simu_ksp \n", "# check the dimensions\n", "echo dimensions of simulated phantom \n", "head -n2 simu_ksp.hdr\n", @@ -287,7 +292,7 @@ "bart signal -help\n", "\n", "bart signal -F -I -n $REP -r $TR -1 5e-3:5:$nR1s -3 1e-2:1:$nMss tmp_dict\n", - "# reshape the dicc to have all the elements on the 6th dimension\n", + "# reshape the dictionary to have all the elements on the 6th dimension\n", "bart reshape $(bart bitmask 6 7) $((nR1s * nMss)) 1 tmp_dict tmp_dict1\n", "head -n2 tmp_dict1.hdr\n", "# squeeze the dicc1 before SVD\n", @@ -307,13 +312,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "3f506260", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -339,7 +344,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "e4af968a", "metadata": {}, "outputs": [ @@ -375,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "id": "0d735922", "metadata": {}, "outputs": [ @@ -410,23 +415,23 @@ "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", "NUFFT: low-mem mode\n", "Scaling: 0.000137\n", - "Step: 0, Res: 100.000008\n", + "Step: 0, Res: 100.000000\n", "\t cg: 2\n", - "Step: 1, Res: 99.987431\n", + "Step: 1, Res: 99.987423\n", "\t cg: 0\n", - "Step: 2, Res: 99.837300\n", + "Step: 2, Res: 99.837287\n", "\t cg: 0\n", - "Step: 3, Res: 96.891624\n", + "Step: 3, Res: 96.891500\n", "\t cg: 1\n", - "Step: 4, Res: 80.109700\n", + "Step: 4, Res: 80.109092\n", "\t cg: 2\n", - "Step: 5, Res: 60.551751\n", + "Step: 5, Res: 60.550970\n", "\t cg: 2\n", - "Step: 6, Res: 12.282041\n", + "Step: 6, Res: 12.281537\n", "\t cg: 4\n", - "Step: 7, Res: 2.849885\n", + "Step: 7, Res: 2.849144\n", "\t cg: 9\n", - "Total time: 1.26 s\n" + "Total time: 1.24 s\n" ] } ], @@ -447,7 +452,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 22, "id": "e4c42af8", "metadata": {}, "outputs": [ @@ -455,134 +460,636 @@ "name": "stderr", "output_type": "stream", "text": [ - "Basis: [192 192 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "Max: [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "bart: src/pics.c:478: main_pics: Assertion `basis_dims[TE_DIM] == ksp_dims[TE_DIM]' failed.\n", + "bash: line 7: 710779 Aborted bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "DIM=384 # Readouts\n", + "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", + "ITER=100\n", + "REG=0.0005\n", + "# # reconstruction with subspace constraint\n", + "bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n", + "\n", + "# multiply it with the roi_mask\n", + "bart fmac roi_mask subspace_reco subspace_reco" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "df606d77", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7YAAAEHCAYAAACa89phAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXecVNX5/z/T207Z3gu79N47UhVBVBCxRg1fS+zfJMRU8zUxxmjURBNijbElmgRLgoIFRBFBQEFp0qS37W12p8/c3x/7e47n3rl3ZnZZYBfO+/Wa1+7ceu6de+5znnp0kiRJEAgEAoFAIBAIBAKBoJuiP9MNEAgEAoFAIBAIBAKB4GQQiq1AIBAIBAKBQCAQCLo1QrEVCAQCgUAgEAgEAkG3Rii2AoFAIBAIBAKBQCDo1gjFViAQCAQCgUAgEAgE3Rqh2AoEAoFAIBAIBAKBoFsjFFuBQCAQCAQCgUAgEHRrhGIrEAgEAoFAIBAIBIJujVBsBQKBQCAQCAQCgUDQrRGKbSfy3nvvYejQobBardDpdGhsbAQAvPLKK+jbty9MJhM8Hg8AYMqUKZgyZUq7z6HT6fCrX/2q09osEAjiEX1ZIOj+iH4sEJwdiL4sSJWzTrHdt28fvve976G8vBxWqxUulwsTJkzAE088Ab/ff8rOW1dXhyuuuAI2mw1/+ctf8Morr8DhcGDXrl347ne/i4qKCjz33HN49tlnT1kbOotXX30Vjz/+eIf3nzdvHq6++moAgCRJSE9Px4svvpjSvhs3bsTtt9+OESNGwGQyQafTdbgdgu6N6Msnz5nqy7FYDC+++CIuueQSFBcXw+FwYODAgXjggQcQCAQ63B5B90P045PnTMrk5557DpMnT0Zubi4sFgt69OiBhQsX4uDBgx1uj6B7IvryyXMm+zJPOBxG//79odPp8Oijj3a4PV0S6SzinXfekWw2m+TxeKS7775bevbZZ6XFixdLV111lWQymaSbb775lJ373XfflQBIK1askC1/6qmnJADS3r17ZcuDwaAUDAbbfR6/3y+Fw+GTamsyLrroIqm0tLTD+xcUFEiPP/64JEmStGPHDgmAtHPnzpT2ve+++ySTySSNGDFC6t27t3SWPaKCFBF9uXM4U33Z6/VKAKSxY8dKDzzwgPTss89KCxculPR6vTRlyhQpFot1uE2C7oPox53DmZTJt912m3TDDTdIjz76qPT8889L9957r5SbmytlZWVJx44d63CbBN0L0Zc7hzPZl3kee+wxyeFwSACkRx55pMPt6YoYz4AufUo4cOAArrrqKpSWlmLVqlXIz89n6+644w588803WLZs2Sk7f3V1NQCwUIhky81mc4fOY7VaO7Tf6eLo0aM4fvw4xo4dCwD47LPP4Ha70adPn5T2v+222/CTn/wENpsNd955J/bs2XMqmyvogoi+3DU4mb5sNpuxdu1ajB8/ni27+eabUVZWhvvuuw8ffvghZsyYccraLjjziH7cNThZmfzkk0/GLZs7dy5GjhyJl19+GT/96U87tb2Crofoy12Dk+3LRHV1Ne6//3785Cc/wf/93/+diqaeWc60Zt1Z3HrrrRIAae3atSltHw6Hpfvvv18qLy+XzGazVFpaKv3sZz+TAoFA3LbLly+XJk6cKNntdiktLU2aPXu2tH37drZ+8uTJEgDZ54YbbpBKS0vjlt93331sn8mTJ8vO4/f7pfvuu0/q1auXZLFYpLy8PGnevHnSN998w7bhj0EcPXpUWrhwoZSTkyOZzWapf//+0vPPPy/b5qOPPpIASP/617+kBx54QCosLJQsFos0bdo0mbVL7VqSWZcCgYBUU1Mj1dTUSC+//LJkMpmkY8eOSTU1NdL1118vTZo0ia2PRqMJj8Vzxx13CI/tOYjoy2dfXya2bt0qAZD+9Kc/tXtfQfdC9OOztx/X1tZKAKSf/OQn7d5X0P0Qffns6ssLFy6URo8eLe3fv/+s9NieNVpDYWGhVF5envL2N9xwgwRAuvzyy6W//OUv0vXXXy8BkObOnSvb7uWXX5Z0Op104YUXSn/+85+lhx9+WCorK5M8Ho904MABSZIk6YMPPpBuueUWCYB0//33S6+88oq0bt066a233pLmzZsnAZCeeuop6ZVXXpG2bNkiSVJ8x4tEItL06dMlANJVV10lLV68WPrd734nTZs2TfrPf/7DtlN2vMrKSqmoqEgqLi6W7r//fumpp56SLrnkEgmA9Mc//pFtRx1v2LBh0ogRI6Q//vGP0q9+9SvJbrdLo0ePZtt98MEH0tChQ6WsrCzplVdekV555RXprbfeSngvX3jhhbjOqvWhe5YKQrE9NxF9+ezry3ybAEivvvpqu/cVdC9EPz67+nFtba1UVVUlff7559LFF18sAZA++OCDlPYVdG9EXz57+vKGDRskvV4vrVu3Tjpw4IBQbLsqTU1NEgDp0ksvTWn7r776SgIg3XTTTbLlP/rRjyQA0qpVqyRJassT83g8cbkDlZWVktvtli2nh+/zzz+XbXvfffdJAKSamhrZcmXH+9vf/iYBkP7whz/EtZfPR1N2vBtvvFHKz8+XamtrZftcddVVktvtlnw+nyRJ33a8fv36yXIPnnjiCQmAtG3bNrasvTkAx48fl1asWCGtWLFCKi0tla6//nppxYoV0muvvca8M7Te7/enfFyh2J57iL58dvZlYsaMGZLL5ZIaGhrava+g+yD68dnXjy0WCxtAZ2ZmiqiLcwTRl8+evhyLxaTRo0dLV199tSRJ0lmr2J4VVZGbm5sBAE6nM6Xtly9fDgD44Q9/KFu+aNEiAGC5AitWrEBjYyOuvvpq1NbWso/BYMCYMWPw0UcfddYl4I033kBWVhbuuuuuuHValYElScIbb7yBiy++GJIkydo4c+ZMNDU1YfPmzbJ9Fi5cKMs/mDRpEgBg//79HW57fn4+ZsyYgZEjR+LIkSO49tprMWPGDBiNRlitVtxyyy2YMWMGZsyY0eVzGARnFtGXz96+/OCDD2LlypV46KGH4nKiBGcXoh+fff343XffxfLly/HYY4+hpKQEra2tHW6foPsg+vLZ05dffPFFbNu2DQ8//HCH29MdOCuKR7lcLgCA1+tNaftDhw5Br9ejZ8+esuV5eXnweDw4dOgQAGDv3r0AgGnTpiU8b2ewb98+9OnTB0Zj6j9JTU0NGhsb8eyzz2qWOafkeqKkpET2PT09HQDQ0NDQzha3EQ6H0dTUBAB4//33odfr0bdvX9TW1uL999/HsGHD4PV64fV64Xa7YTKZOnQewbmB6MtnZ1/+17/+hXvvvRc33ngjbrvttg61T9B9EP347OvHU6dOBQDMmjULl156KQYOHIi0tDTceeedHWqnoHsg+vLZ0Zebm5vxs5/9DPfccw+Ki4s71J7uwlmj2BYUFGD79u3t2i/ZHKmxWAxA2wTQeXl5cevb00lOBdS+73znO7jhhhtUtxk8eLDsu8FgUN1OkqQOtWHt2rVM4BGlpaWy79nZ2QCAjz76qEOTZgvOHURfPvv68ooVK3D99dfjoosuwtNPP92htgm6F6Ifn339mKeiogLDhg3DP/7xD6HYnuWIvnx29OVHH30UoVAIV155JZuD+ujRowDaFO+DBw+ioKCgwxWluxJnhWILAHPmzMGzzz6Lzz77DOPGjUu4bWlpKWKxGPbu3Yt+/fqx5VVVVWhsbGQPTkVFBQAgJyfnlE9NUVFRgQ0bNiAcDqdsQc3OzobT6UQ0Gu3U9iV7IfEMGTIEK1asANA2Vc/YsWNxww03oKmpCZdffjmeeOIJ9O/fn20rECRD9OWzpy9v2LAB8+bNw8iRI/Hvf//7jA9WBKcP0Y/Pnn6sht/vRzAY7PD+gu6D6Mvdvy8fPnwYDQ0NGDBgQNy6Bx98EA8++CC+/PJLDB06NPWL6aKcFTm2APDjH/8YDocDN910E6qqquLW79u3D0888QQAYPbs2QCAxx9/XLbNH/7wBwDARRddBACYOXMmXC4XHnzwQYTD4bhj1tTUdFr758+fj9raWixevDhunZa1x2AwYP78+XjjjTdUrWkdbZ/D4WDhD8lIT0/HjBkzMHHiRBw+fBjz58/HjBkz4HA4YDAYcOONN7L4fwrLEAgSIfry2dGXd+7ciYsuughlZWV45513YLPZOnQNgu6J6Mfdvx9HIhHVMMqNGzdi27ZtGDlyZIeuR9C9EH25+/flu+++G2+99Zbs88wzzwAAvvvd7+Ktt95Cjx49OnRNXY2zxnxeUVGBV199FVdeeSX69euH66+/HgMHDkQoFMK6deuwZMkSfPe73wXQZtm44YYb8Oyzz6KxsRGTJ0/Gxo0b8dJLL2Hu3LnM9e9yufDUU0/huuuuw/Dhw3HVVVchOzsbhw8fxrJlyzBhwgTVjtIRrr/+erz88sv44Q9/iI0bN2LSpElobW3FypUrcfvtt+PSSy9V3e+hhx7CRx99hDFjxuDmm29G//79UV9fj82bN2PlypWor69vd1tGjBiBf/3rX/jhD3+IUaNGIS0tDRdffHHCfb744guEQiGMHz8eALBu3ToMHjwYDoejXec+dOgQXnnlFXZMAHjggQcAtFkCr7vuuvZejqCbIfpy9+/LXq8XM2fORENDA+655x5WMISoqKhIavkXdG9EP+7+/bilpQXFxcW48sorMWDAADgcDmzbtg0vvPAC3G43fvnLX7b7WgTdD9GXu39fHj58OIYPHy5bRiHJAwYMwNy5c9t1HV2a01+I+dSyZ88e6eabb5bKysoks9ksOZ1OacKECdKf//xn2eTQ4XBY+vWvfy316NFDMplMUnFxseYE0h999JE0c+ZMye12S1arVaqoqJC++93vSl988QXb5mTLkUuSJPl8PukXv/gFa1NeXp50+eWXS/v27WPbAPETSFdVVUl33HGHVFxczPabPn269Oyzz8quAYC0ZMkS2b5U7vuFF15gy1paWqRrrrlG8ng8EpB8AmlJkqSHHnpIqqioYN9nzJgh3XHHHUn3U0LtVPso75fg7Eb05e7bl6ktWp8bbrihXccTdF9EP+6+/TgYDEr/+7//Kw0ePFhyuVySyWSSSktLpRtvvLFD81gLujeiL3ffvqzG2Trdj06SOpjVLBAIBAKBQCAQCAQCQRfgrMmxFQgEAoFAIBAIBALBuYlQbAUCgUAgEAgEAoFA0K0Riq1AIBAIBAKBQCAQCLo1QrEVCAQCgUAgEAgEAkG3Rii2AoFAIBAIBAKBQCDo1gjFViAQCAQCgUAgEAgE3Rqh2AoEAoFAIBAIBAKBoFsjFFuBQCAQCAQCgUAgEHRrhGIrEAgEAoFAIBAIBIJujVBsBQKBQCAQCAQCgUDQrRGKrUAgEAgEAoFAIBAIujVCsRUIBAKBQCAQCAQCQbdGKLYCgUAgEAgEAoFAIOjWCMVWIBAIBAKBQCAQCATdGqHYCgQCgUAgEAgEAoGgWyMUW4FAIBAIBAKBQCAQdGuEYisQCAQCgUAgEAgEgm6NUGwFAoFAIBAIBAKBQNCtEYqtQCAQCAQCgUAgEAi6NUKxFQgEAoFAIBAIBAJBt0YotgKBQCAQCAQCgUAg6NYIxVYgEAgEAoFAIBAIBN0aodgKBAKBQCAQCAQCgaBbIxRbgUAgEAgEAoFAIBB0a4RiKxAIBAKBQCAQCASCbo0xlY18Ph/27dsHj8cDozGlXQSCc45IJILGxkZUVFTAbref6eaoIvqyQJCcrt6XRT8WCJLT1fsxIPqyQJAK7enLKfWiffv24c033+yUxgkEZzuXXXYZBg0adKaboYroywJB6nTVviz6sUCQOl21HwOiLwsE7SGVvpySYuvxeAAAb7zxBmpra0+6YQLB2UhWVhbmz5/P+ktXRPRlgSA5Xb0vi34sECSnq/djQPRlgSAV2tOXU1JsKTyitrYWJ06cOKnGCQRnO105nEj0ZYEgdbpqXxb9WCBIna7ajwHRlwWC9pBKXxbFowQCgUAgEAgEAoFA0K0Riq1AIBAIBAKBQCAQCLo1QrEVCAQCgUAgEAgEAkG3Rii2AoFAIBAIBAKBQCDo1gjFViAQCAQCgUAgEAgE3Rqh2AoEAoFAIBAIBAKBoFsjFFuBQCAQCAQCgUAgEHRrhGIrEAgEAoFAIBAIBIJujVBsBQKBQCAQCAQCgUDQrRGKrUAgEAgEAoFAIBAIujVCsRUIBAKBQCAQCAQCQbdGKLYCgUAgEAgEAoFAIOjWCMVWIBAIBAKBQCAQCATdGqHYCgQCgUAgEAgEAoGgWyMUW4FAIBAIBAKBQCAQdGuEYisQCAQCgUAgEAgEgm6NUGwFAoFAIBAIBAKBQNCtEYqtQCAQCAQCgUAgEAi6NUKxFQgEAoFAIBAIBAJBt0YotgKBQCAQCAQCgUAg6NYIxVYgEAgEAoFAIBAIBN0aodh2Y3JyclBQUHCmmyEQCE6SiRMnYsaMGWe6GQKB4CTIz89HcXHxmW6GQCA4SQwGAwwGw5luhqADGM90AwTfotfrMWLECDgcDtjtdpjNZhgMBuj1euj1euh0Ouj1bbYISZLgcDgAAI2NjbLjxGIxxGIxSJKEWCwGv98Pv98Pn8+Hbdu2IRKJnO5LEwjOKSwWC/7v//4PWVlZKW1fUVEBk8mEBQsWpLR9VVUVfv/736OlpeVkmikQCBJgMBgwevRoOBwOOBwOJpONRiP0ej0MBgN0Oh2ANrlLMrm+vh4A2LpoNIpoNAqgTXb7fD72+eqrrxAOh8/A1QkE5xYWiyVuTE0ffsys0+lY347FYrJjkLKr7NM01haceYRie4ZIT09Hjx49kJaWBrvdDoPBAJPJhN69e8NiscBkMsV1PkmSIEkSE5YEdSr+O/83HA4jFAohGAyiuLgYwWAQkUgEgUAAfr8fR44cQU1Nzem7eIHgLGLw4MG49NJLYbVa2TKz2YybbroJHo+nXcc677zzUtqurq4OTqcTPp+PLQsEAnj//fexcePGdp1TIBAAGRkZ6NmzJ9LS0uBwOGAymWA2m9G3b19YrVaYTCbZoJgGwkpITvNymN9Or9cjFAohFAohEAigtLQUgUAA4XCYyeSDBw+iurr6tF27QHA2YTAYYDab2fiZFFAyTPFIksSMVfSdxtjKsTY/FjcajcxJxI/NaR8al4fDYXZ+welBKLanicLCQmRmZsJms8FsNiMrKwsVFRWw2+3MimQwGGRKqtKKpBSiSuFJ+yg7psViYYPunJwcZmkKBoMIBAI4dOgQKisrEQ6H4ff70djYiKNHj56uWyMQdCtmzpyJnj17MkE4fPhwLFiwADab7bS1ITMzE9///vdly3w+HwYNGoS1a9cCACKRCA4cOIDly5eftnYJBN2F4uJiZGZmsuio3Nxc9OrVCw6HA1arFUajkfVxioIyGAxMFis/hNpyPtpKp9PBZrPBZrPB5XIhNzcX0WgUkUgEwWAQPp8PBw4cwPHjx5lMrq+vx+HDh0//TRIIugHUV0lp1ev1MJvNcU4h6rvKcTJ5aQG5Msv3azWvrtJgZbFY4vY3mUyIRCJsv1gsJqImTzFCsT2FFBcXw+VywWg0on///igqKoLT6WQdDgATaNFolAk/evAjkQgOHTokU3T1ej3S09ORlpYGk8nEQqKAts5J+xNKIQyAWbFsNhvsdjsyMjIgSRJCoRBaW1tRVVWFHTt2IBKJwOv1CoEqOOeZM2cOnE4ndDodbrvtNowaNQoWiyXl/YPBIN566604y+3gwYPRs2fPTlGK7XY7FixYwMKZA4EAtmzZAo/HA0mS0NraiqVLl570eQSC7kppaSncbjeMRiMGDRqE4uJiOJ1OWCwWJkd5mRwOh5lnJhQKIRqNYv/+/ZAkSRaKrJTJpACTMkzynQa3/ECXwh4NBgMLec7KymLeHp/Ph+PHj2Pr1q0IhUJoaWnB/v37z/CdFAjOLBRBodPpYDabWd8DEBfBSONtch7R30gkwjy6NFYmJVnpfeWh5fTOoGV8eDJFdlgsFlgsFtbvY7EYgsFg3PaCzkMotp1Mbm4uswBPmDABRUVFzCMLgAkr6ngk0Ej4tba24sSJE2hoaEBDQwPWrFkTF+Pfo0cPFBUVISMjA06nE+np6cjIyJAJZr5TKv8HILNeUac1Go3IzMxEVlYW+vXrh0AggMrKSnzyySdM6a2trT31N1Eg6AJMnDgRNpsNOp0OTz75JAoLC2WCLBGSJMHr9eKzzz4DAHi9Xlx//fVxuXTXXXcdZs2ahYyMDABAXl4ehgwZ0intt1qtGDNmDP7xj38gFouhqqoKgUAAQFtevghZFpwLFBQUwGazwWKxYPLkySgpKYHFYpGFHpK3FABTTMnT0tzcjKNHj6KxsRF1dXX48MMP42Ryr169UFpaiszMTLjdbqSnpyMrK4t5eZRRWPQ/hTYT0WhUJptNJhOys7ORk5ODwYMHo7W1FZWVlVi5ciX8fj9aW1tFGpHgnIFPBaDoR71ez8ax5Anl0/h4b61er0ckEkE4HGaOGyVKJZk/rzK9QDkeoHMSyugN6vMOhwM6nY6lJAglt3MRim0nkZ2dDaPRiFmzZiE/Px/p6ensQaUPKZjU6ehBj0aj8Hq9OHLkCA4ePMhCCbU4cOAADhw4wL4XFxdjypQpyM7OhsfjkR1bLc+HV26VVqlQKCRTusvKylBeXo6GhgYcOXIEa9asQSgUQl1dnWp+kUDQndHr9Rg2bBgA4NVXX0VRUVFcnk0iqA9t2bIFe/fuxXe+852E27/yyit45ZVX2PcZM2bgd7/7Hex2O/r379+xi1BBr9cjPz8f77//PiRJwvbt23HjjTciFovhq6++EgJVcNaRk5MDo9GIefPmoaCgABkZGUxhpIgoQqfTsYGsXq9HOByG1+vFvn37cPjwYXz88ccJz7V3717s3buXfe/RowdmzpyJrKwseDweZrg2mUxMvqqFMVNbyBAuSRL8fr9MJpeXl+PWW29FVVUVjh49ilWrViEYDKK2tlbIZMFZCXlQrVYry5OliArgW0WWVyyVea8GgwGtra2qyiwPKZv8uW02myw6khRkirhQhiXzqK2n72azGVarFQaDgRV5lSRJyOOTRCi2J4Fer4fL5YLZbMZVV12FjIwMuN1uZkmlTkZhD4DcU6rT6RCJRFBbW4s9e/bggw8+6FA7jhw5gldeeQWZmZm44oorkJOTwwSjWlU3tXwggheqFDIRjUbhdDoxcuRI9O3bFzU1NXjrrbfg8/ng9Xrjji8QdDeMRiNKS0ths9nwxRdfdOgYgUAAR44cwdGjRzFt2rQOHWPlypVYuXIl+vXrh3fffRelpaUdOk4idDodBg0axDy2I0eORGNjI44cOSIT6AJBd0Ov18Pj8cBsNuM73/kOMjIykJ2djUAgwKIVaDu+pgUvByORCGpqarB79+4Oh+4fOHAATz/9NLKzs/Hd734XOTk5AL41JvNeWyVqhSB5z5Df70cwGERmZibKy8sxcOBAHDt2DK+//jobuIuBseBsgMbQ1KdDoRBLC+BzagllgVXq34FAAK2trR1qA3l29Xo9KyqndA5pFZxSjq35dbSfXq9n0SIejwfRaBRNTU0AIMbWHUQoth1Ar9fDarXC7XbjhhtuYBbZQCCAxsZGFqNPD7Va4SedTodwOIxdu3bh3//+d9w5qHiFsjMAYBYd6uREXV0dXn75ZcyfPx+9evVi+UG0D7+/FmrFqIxGI8LhMBobG6HT6ZCXl4e77roLdXV1WLJkCWpqalj+kUDQnTCZTPB4PCgpKemwQgu05dB++OGHmDNnTty67OzspPu3trbKKhzv3LkTkyZNwqZNm5CZmZlyCHRHoOueNm0atm/fjubmZiZoBYLuAMnk9PR03HrrrUhPT4fJZILf70dDQ0OcLOW9pjyRSARff/01Xn755bhz8PmzauGGsVgsTg7W1NTg6aefxg033ICKigoEg0GYTCbZcRPJYz6UkralgpBUQZm8uL/4xS9w7Ngx/OMf/0B1dTUzSgsE3Q2KbKSaNOFwGC0tLcwrS+NrvugT752lTzAYRENDQ9Jz8Wj1x1gshpaWFrhcLpY7z4+/tfZTG3srlWAap1OItMPhgMViQVNTE8vHF6SOUGzbASl5xcXFWLBgATIzM1mJfko6N5lMssrGapAndPv27XEWYRKc11xzDQYNGoSMjAw2Nx4pw62trTh27Bg++OADbNy4URab39raitdeew1z5szBiBEj4Pf7VZVb+p6oUyu3pxDnYDCIYDCItLQ03HzzzfB6vXjnnXewd+9eloQvEHRljEYjzGYzpk6dinfeeeekjhUOh7F06VJcccUVsuV2ux16vR5VVVVJw5kfeOAB/O53v2PVyoG2SIzevXtj27ZtKCwsbFdIdEdYtWoVAOD666/HG2+8gXA4LObXFHRpyPNaVlaGa6+9FllZWYhEIixqivLl+CgpNSRJQiAQwNatW+MMzVQDY8qUKRg0aBBKSkrgdrvZer/fD6/XixMnTmDNmjXYsmWLTA56vV48++yzWLBgAUaNGoXW1lYmkxP1abXQRWWEFXmsKLzS4/HgrrvugtfrxRtvvIFdu3YJmSzoNuh0OphMJrhcLjbepTQ+3iCkpSDSOjIykedTCRmnKJeelvEFnqiAHI8kSWhubmZpDfzYWtkmZVv5a+Q9vfx+ZDyjdAmPx4NYLAav1yuiqdqBUGxTRKfTYfDgwbjggguYQkuhDXw+TCqWlVAohM2bN+O9996TLbdYLPjOd76DqVOnwu12s3xXCqGiY1ssFvTt2xcDBw5EXV0dVqxYgSVLlrD1NNC22+3o3bs3q/xGpOq91crRJWgqAqPRiCuvvBKBQACrV69mBXOElUnQ1SCL7x133IHHH3/8pI8Xi8Xw0ksv4eabb5Ytz8jIQF1dXcrHuffee3HvvfdiyZIluPrqq5lAbWxsRK9evVBfX3/aphN6+eWX8fLLL+OBBx7Ar3/9a1nxG4Ggq6DX6zFkyBDMnj2bTZnT2tqKWCzGBoh8tJQyz40PCw4Gg9i4cWOcodlsNuPiiy/GlClT4HQ6EQgE4PP5ZAWbLBYLPB4PsrKyMGTIEFRWVuLDDz/EypUr2flCoRD++c9/wm63o2/fvgiFQnHFaFK9Zl4W8wNvnU4Hv9+PcDgMk8mE6667DoFAAB9++CHWrFmT8vhEIDgTpKWlwe12IxqNIhAIsLlo+al1UlEajUYjAoGAqlJL0/HQcfn+Fw6HYTAYYLVaWe0bmhJTec66ujq4XC52TlqeKNc2UZv55XxOMP3vdrshSW0zG/j9/oTHFwjFNiXGjx+PiRMnMmuwz+eLC2tKxZtC23z++edx+bQulwv33nsvBgwYgKamJjQ1NTFLMT89EBGLxeDz+eB0OjF//nyUlpbikUceYeuj0SheffVV3HHHHcjJyUE4HFZtozIfQQ21begvWbuo80+fPh3jx4/Hpk2b8NFHHyW9JwLB6WTx4sX43ve+1ymhvZIk4ZFHHsFPf/pT2fKCggIcO3asQ8ekSJDp06ezZYFAAE6nU7MPnyp4ZVvpjRYIziTjx4/H1KlTUVBQgFgshtbWVlkoIlVAJfjcO6WcMxgMWL9+fVzkhsPhwO23344+ffqgtbUV1dXVrIAMyWTyrDQ2NiIcDkOSJNhsNlx22WXo378/nnjiCXa8aDSKv/71r/jZz36GrKyslKIh1KKsgHhPFRmfKEyZik4BwIUXXohJkyZh/fr1WLlyZaq3WCA4LbhcLtjtdlawzWQywWq1yvLQEym1yuXNzc2q+bSUG2symWSpNvxYPhQKsQhMUpJdLhczminP43Q6ZdWX1dqjhfJ9pFSQ+Wsk7HY77HY7gsEgWlpaUjrPucipS9w6C5gwYQLuvvtuzJw5EzabDU1NTcyS1B740OSqqipUVlbK1ufm5uLBBx9Ev379UFtbK5ufNhaLsepv/IcqLAJtntMhQ4bggQceiDvv4sWLVeeyJVLpkGrLlbm/5AmLRqNsqqMf/OAHHS6iIxB0Ji+88AIaGxtx6623dppy2NraGifs+vbti6NHj57UcadOnYrNmzfLlkWjUZmH53Ry+eWXo6mpCa+99tppP7dAwDN58mT8+Mc/xrx58+B2u9HY2IiWlhYmL5VV/rW8lFSnglIFlDI5MzMTP/rRj9CrVy9WbZjkLR/q7PP5mPfVZrOxtKGWlhaUl5fHGb0kScKDDz4Y5y06WfjZFug71fqIRqOwWCyYMmUKfv7zn6vWARAITjdpaWnIycmB3W5n4cY0vR5Ne5UsolAZVRgKheIMRmTsIcVWzaDEj9EpvYHG36FQCJIkwWq1xu3n9XpZH0v0vkkFZTQJGavof369zWZDRkaGbEoiwbcIxVaD73znO7jwwguRkZHBHmyaj1YtPp5/qJUfIhqN4ssvv8TWrVvZsuLiYnz/+99HQUEB6urqkJaWxjoeb7FSCm3qcHwnLS0txe9///u4a9myZQvsdnvC9rX3WrQg4RqLxeBwODBx4kTccMMN7br3AkFnsnnzZlx//fUsb6ezFNv7778fv/3tb9n3cePGYdu2bSd9fJ1Oh6FDh8qmDyGqq6tPu3Kr0+ngdDpxxRVX4Jtvvjmt5xYIiBtvvBEXX3wxMjIy4PP5EIlE2PQfapX/lQZdpQwjQ+yGDRtkhePy8/Nxyy23oLS0FA0NDWzgTR9lyCAvk2mAToPdvLw8/PKXv4y7lq+++gpWqzVuQJxINieKqKL20HXxCi4V26FZHCZNmoSbbrqpQ7+BQNAZeDweNpcrwSuRqUB9glf+AoGALBeVwo75YlPK/ZX9mt+Xnz7IYrHAbrfHtYPG4GoF5ZKNoxNdK399lCdPy8LhMGKxGNxuNzIyMlK6X+cSQrFVMGfOHNxzzz0oKytjwpOEBF+EQc26kkgA6fV6HDp0SGYZLiwsxLx589CnTx94vV44HI64fFr6X61j8JZpEqi5ubn41a9+JTv30qVL0drayiq4JRKcyV4qqaznFf9IJILS0lL8+Mc/xqxZsxLuKxB0JmvXrkVDQwMGDx4cN3H6yXLkyBFUVVWx98GsWbPw4YcfdpoFVafToby8HIcOHZItLy8vPyMFnUjI9+jRA42NjazQlEBwqpk3bx5+9atfoaKigslks9nMFFO1Ai/KQa/aoBUA9u3bh+PHj7PlOTk5mD59Onr06IHKykqYzWYWmqiG0lCmDCGMRqNwu9246667ZPv985//RDAYZINw3juj1f72DpLV6mpQ9FevXr1w3333Ye7cuRp3XSDofJxOJ7Kzs2VFVpXGIgBJIxr4/gFAU75TQVcau6calcj3a5J9JHctFots2+bmZllO7MmQ6pic0hRp24yMDDidzpM699mEUGw5rrrqKgwbNow9uDRFAKHsaMmsrMC3ob6xWAzbtm3DwYMH2fEyMzMxePBgBINBWK1WBIPBuA6ayjlIkaSXQUVFBWbOnMmOEY1GmZDWmhw+mfBsjwWZ34YmsjYYDBg5cqSwFAtOC4cOHcKoUaPgdrvbnTqQCr/73e9k1VNpEvfORK/Xo6ioSPbO4KcEOhOQ12fixIkyhUAgOBVce+21GDlyJKtsTGk6yjBEgpdRWkot8O3A+csvv8S+ffvY8vT0dPTv35+FN/NGpGRGXV6pJUWVPmVlZZg8eTLbNhKJ4MSJE7BYLLIpQ2j/9srhRPJYuZ7mzTQajRg3blyc0i0QnAqysrJY5CA/XlWG2Sr/V0ZG0HLlGNvn88XlzlL0oNKpw6PMV1cqtQBkkRVKvQD49n2SSHFWuw41UnFq8d/JmG42m4Vy+/8Riu3/57bbbkOfPn1k1qP2CBfl9vSdL/lPFRsBoKioCOPHj4fT6ZSFX/CWKD4Egf+oCW1ekdTpdBg1apTs+g4cOCDLXSA6otwq91dam3mosxsMBkSjURQWFuKWW27phF9MIFBn165dKCoqkk2k3tm0tLSw6IrLLrsMTz/99Ck5j16vj5sH9/33348bDJ9OqABHXl4e9uzZc8baITi7+eEPf4hhw4YxGUKRU0oZycsffj2hJb+am5vR0tLCPL45OTkYNmwYPB4PgsEgM4glqnSaSLHkB96xWAxjxoyRrd+9ezeTi0pjtVa7tWQwf0/Ii628L/z2FJ4cDodRWlqKu+++O5WfRCDoEFSAieSWWpV9pTKp/J9Q64ta3lqaa7Yjxm1lO/j2mc1m2bbUz5RFKU829YnPnVfzSisLa+n1emRmZnb4fGcL57Riq9PpMG3aNNx+++1IT09HKBSKKzxBaCl/aqht09jYKCvTnZWVhZ49e7LwCDVPqlp4cyJFlIRaJBJBfn6+rE0bN25EMBiU5QanIii1UFNotYQzf8xIJIKsrCzccsstmDRp0inxpgnOPYxGI5YsWYKNGzeid+/enVL1WIu6ujpZX3a5XCgoKDhl51Py/e9/P24KgjOBTqdDr169sHHjRrz88sunbToiwdmLTqfDzJkzsWjRImRkZMDv9yeUWakYVpV/advGxkZZP/J4PCgqKmLVxxNNcdVew28kEokzUH366adsoJ/sGrXGAWrXy48FEuUZ03ydwWAQOTk5uOuuuzBt2jQhkwWdhsPhgNvtZkqmGmoeUrWqwMpnnfajMGHl1Fe0j9Y4tj1eVGV7+Dl1AaimECY7lhp8H+XbpqXUErSe7vG5Hpp8zpbUMhqNmDFjBvr37w+bzRYnAJUPsprVVsuSq6zUZjAYsHXrVlRVVbFtbDYbXC4Xy+GlHFk1QcyjtZwnFovFVXBraWmBz+dDWlqaZq5BIkVdmeTPW5G0FG+1lwsdKy8vDy6XC2azGWvWrBGTTws6jN1ux5tvvomJEyeyqqSnkoceegiffPLJKT+PFvv37+9S88qOGjUKffr0QWZmJq677jrU19ef6SYJuiFGoxFz5szBgAEDkJaWhkgkwpQ0tdBjpZyh/9VkplJx1Ov12Lx5syyc3uFwsGKRFMKoJeP5wacW/DaSJMV5ebxeL/x+P8s3TGVQrHWeWCzGcvx4mUzr+PsDyEMnaZ+ioiJ4PB7odDohkwUnjd1uh9VqZWNcLSVVzVPLk6yf6XQ6BINBWRQTVTZOdFxap6UwK9ug9j+hVntHC60xPq/Iar3b1K6FlFp+XB+LxWA2m5Geno7GxsYOv1u6K+ekx9ZisWDGjBkYNGgQbDabrPqwkmReS63lSuuo0jpsNBphsVhkHtuOWGuVy+mvyWTC1KlTZe3y+/1xQq89Fia+YwUCATQ2NqKmpgaVlZWora1Fc3Mz8wpTHoKaBZuErdVqxdChQ3HBBRecFoVEcPaRnp6OF1544bQ+Q9u3b0d1dfVpORfQljvz8ssvn/LzBINBNDc3d2hA63K5cMEFF+C55547rd5rwdmBxWLB7NmzMXjwYDgcDtkgVU2+aQ00E8lkPmxZp9Ohvr5eFnlhsVjgcDg0p9ZKJHO1tlF6YJThyEqZrETLS8OHHlIhmWAwiKamJtTU1ODEiROoq6tDS0sLC8UkL5NaTiPdH5vNhvHjx+Oiiy5CWlqa6r0UCBKh0+mYUitJEqtITCQbc6bSzwDIKn8rU+wo1J6MWGpKodp4XysMmjcC0Xel1zbRcbWukd5HymVa22m9J5T3l1eO09LSTmkEW1fknPPY2mw2jBs3DoMGDYLZbFa1BvEPMf9gqSl4/D5aaAks8tRqKada+yayINP/er0evXv3xkcffcS2IUt0Ki8WAGxbKgDl9XqxefNm2by6FO5EwtVkMsFkMiE9PR3l5eWseI/y/lF7bTYb+vXrh2g0irVr16K5uTlh2wQCIjc3F7/5zW9wxRVXnOmmnFKMRiOuvvpqXH/99Z1yPHqf3XPPPTIhGolEEA6HYTabZWFj/fr1w1VXXQW32520nZdddhm8Xi9+9atfyYpeCQRa2O12TJo0CcOGDVOdugeAzCOp5YVUDjzVvEJa34G2SqM0GCZjM5/Xq4XWGEJ5PkmSUF5ejg0bNrDllMsbDodlCrDaOQDIPMkkkzds2ABJ+nYOT8qx5eWx0WhERkYGevXqBY/HI5PJ/PUCbWOkgQMHIhqNYvXq1WhqatK8doGAR6drm4uWrxysFUXBr1ceI1kxJtpfLYecjqGmzCVTZpO1kX+/UL9VtjsVJZLuCT/GjsViKRWHpJBjrXusvG9kYPD5fF0q0utUck4ptmlpaRg5ciRGjhzJlDXe6gPIwwLI0nM63PiJvK9aIVhqx+AFv7LD8kptMkFNnS0ajaKhoQE7duyA1+vFli1bUroel8uFqqoqZGdno7y8HOnp6UyY8u2hSpdDhw5FNBrFxo0b0djYmNI5BOcuRUVFWLRoEW6++eYz3ZRugyRJ8Hq9WLx4MWKxGB5//PGU3m29e/fGwYMHUVJSgrlz58bl7yu54YYb4Pf78dhjj4l5bwUJcTqdGDNmDMaOHcsGivygVBn1w6e/qM1dqzRIJ0JNGVV6UPi/yv/5cyq3VwshJJnKQxVNlbJfbSBN+4fDYTQ1NWHr1q1oaWmRzcGbCLfbjcrKSuTm5qKiogKZmZmseBVPJBKByWTCiBEjEI1GsW7dOjQ0NKR0DsG5i16vh91uh9lsjnNiAPEpAfx63ijFeyZ5gxZ/DPo/1XGs2jhaSTJPq7KtymOp5fhqQe8BqvZOSidf1TnZ/pS+aLFYYDAYZPeU/tK1U2riuaLcnjOKrdPpxJAhQzBq1ChWDZCPS1daWyKRCPvwYQ5k1aX5sUg5Iwup8uFKpISqCVAtYZpIoKptr9ZJzGZzXIiXVjw/0BZuvGPHDtTW1mLz5s3aN1eF5uZmbNmyBVarFTU1NSgqKkLfvn1l4Rt8BzMajRg+fDgkScKmTZtEnp5Ak5KSEtx22234/ve/3679AoEAWltbEY1GWSrAuRIC7/P58I9//AMNDQ34xS9+0a599+zZg4ceegjZ2dk4fvw4evfujeuuuy7hPrfeeivC4TAWL14sKicLVHG5XBg2bBjGjBkj836QHCJDKMnkWCyGcDgsk8u0Hcljq9XKZLmWTAbUZSo/p6YyPFBrUKwm57Vkt06nk4U+A23eUbpuNY8tb6iWJAl+vx9ffvklampqUlZoiaamJnzxxRewWq2orKxEaWkpBg4cyMKZ6Ty8UWHMmDHQ6XRYv349amtr23U+wbmDwWBg4ccEP75W86wqoy54o0+y/pZsGe/caa+BK5VzaCm2ZKjSOi8p2nS8UCiUsqeWJxaLIRAIsHtrNBrZ3N58DRz+3WOxWBCNRhEMBs965facUGydTicGDx6MsWPHAvg2/EcZakDhtTU1NWhpaYHf70cgEGAPn07XNs2FzWaD3W6H0+lETk4OrFZrnCVWaVlyu92wWq0szzYajSIUCjGLDW2n9pc/ZrLvfIjG3r17ZevpwVY7h9Ky5vf7sXfvXnzwwQeq99TtdsNisbAORIMCum9EIBDAli1bsGPHDkQiEZSXlyMrKytuUm4ahIwePRo6nQ6ff/65sBIL4igpKcH3vvc9/PSnP026bWNjI9avX88MPM3Nzaivr0c4HIbJZILL5UJGRgaAtnCdMWPGwOPxJD3ugAEDsGnTJtTU1JzUtaRKNBrF22+/3eH9vV4vXn/9dc1pti688MK4wjZA23Qku3fvZt9ramrwwAMPIC0tDR6PB5MmTUp4v2h+zD/96U/CcyuQQYbmiRMnQqfTIRAIyGQy/Y1EIggGg6ipqUFrayv8fj+Ty+SxMJvNcDgcsNvtcLlcyM3NZV4MOpbSiB2NRpGRkQGbzcbkFZ2LpgghuZYILQOzmqFZr9fL5swF2ozNfOFI5ZiEj+QKBALYtWsX3n33XdW2ZGdnw2q1ykK2o9EompqaZCk+gUAAmzZtwtatWxEOh1FeXo68vDwWDs0rBCaTCRMmTAAArFu3ThicBXEYDAY2Jqb+ovSS8n0kHA7HTV3JR0jyxZCMRqOsH/L/K6MrefhQZvL6KvtyKgpsIqVYbco9pVGKPwZfy4fG/62trZrH5+9dIgdZMBhktW34mQmUY3qqa6PX69n782zlrFds09LSMHjwYIwZMwZGoxGRSCTOcxmNRuH3+3HixAkcPXoUmzZtSqmAisViwbBhw1BcXIyysjIYDIY4KwnRt29fVFVV4ejRowDalOuWlhZkZGS0O/RJeWy1fUOhED799NO49qrlDakptTt37sSqVavirjkzMxMmkwl9+vSB2+2G2WyG0WhENBpFIBDAkSNHcOLECUQiEfj9fmaJikQi+OCDDzBmzBicd955bIDBn5vu3ciRI5mVWOT3CIiioiLcdtttSZXahoYG7Ny5E7t27cI999yT0mAsMzMTDz/8MPr164e+ffsyhVeN2267Dbt27cKyZcvafQ0dIRgM4rLLLuvQvl6vF2+//Tb+53/+J27d+PHjodPp8M9//lM1f/aFF17A888/D6DN27N9+3YAbRXW58+fj6effhoLFixAWlqaZujVXXfdBYPBgEceeUTk3AoAtCm1w4YNw/jx42GxWBAMBmGxWBCJRJhMiEQiaG1txYkTJ3DkyBGZgSoRFosFY8aMQY8ePVBeXs68kbzySIPdQYMGobKyEgcOHADQVsipubkZ6enpTNEmeak1sEyWP8hDRl4es9mM1tbWhJWRafC6a9cuVQNXfn4+TCYTxo4di6ysLNhsNnaNwWAQu3fvxt69exEOh9HS0sKU3HA4jGXLlmHChAmYMmUK8zbROXnFesyYMZAkCWvXrhWpQgKGXq9nSi0ZjCnHm4+8ICNLMBhEa2trUi8q8G0RKnoGaXxN6/i/tI4fS5NinOo8tsnCh/ntyJGjti6Rcgu09TtymGm1gQ8jputSKshKWlpaoNfrYbVaZW3jI0F0Oh3S0tJgMBjQ0tJy1npuz2rF1mazYcSIESynlkIF6EemB6eqqgq7du3CF198kVKHI4LBINavX4+NGzdixIgRGDBgAPLy8gDIra2RSIR5bImGhgYcOXIEmZmZrF1qOUNq//PflZZe+l/p7aSHWS3siQ+PaG1txY4dO/Dxxx/H7W8ymTBjxgx4PB6ZtQ1oe8F5PB7k5+cjFovB6/Vi//792LlzJ1paWtg5169fD4vFgrFjx6rmEQFtL6kRI0bAYDDgk08+YfsLzl1yc3OxaNEizfBjenZ27tyJNWvW4M4771S1qGpRV1eHm266CWazGX/84x8xZcoU9OvXT1XYVVRUyBTfxsZGHD58GCUlJe27qA5CA/ZkeL1evPPOO7j22mtly/v16wcA+OSTTxIK/IULF2LhwoUAgA0bNuCaa67B/v37AbQJ55tuugkOhwMLFiwAoD0wuP3222Gz2XDvvffKplcRnHvYbDaWUwuAGZoBuefl2LFj+Prrr7F+/fp2y+RPPvkEn376KcaOHYshQ4aguLiYDXJJZsViMVWZfPjwYWRlZcm2V3pReZJFWREGgwGVlZWyZfw8k2qynqKhWltbsWXLFrz//vuy/Slq6sorr0RmZibzxig9vWVlZZg+fTrq6uqwc+dOfPbZZ8zYF4vFsGbNGlitVkyePDmuyCP9NZlMGDduHIxGIz788EMhkwVMiaLiRJT/zSt3FJlHeeHtQZIk5tG02+0wmUyyKEd6X6h5dknxpNk5eIU3mac20bibUCql1FfVjqn0vJK3Vq0NvHEJAIu+UIs4UTOqNTc3s6l++OhM3lsciURgsVjY/T0blduzVrEly+2IESNYh+CrIFO+zv79+/Hf//43bn+73c7CmfiQJrKCer1etm0sFsPnn3+Ozz//HJdddhl69uwpK3EejUbhcDhkVcz279+Pjz76CEOGDEEkEokriU6odTK1XCHlvps2bZJ9nz59etxUP7S/0rqrVGodDgemTp2K4uJiBAIB+Hw+2cuLf3HQMe12OwYPHozc3FysWrWKhXkDwOrVq5Geno6BAwcyKz0PTbcwdOhQGI1GfPDBB7KpkgTnFunp6bj//vs1Q2lJcB4/fhwDBgyIW5+Tk6NZmj8YDMpyx0KhEO644w4AwOHDh5GXl8eEoxb/+c9/EI1GsXTp0vZcVkpEo1EcO3ZMtuydd96B3W5PuF9rayvefPNNfPe732XLdDodSktL8fXXX7e7HWPGjMHbb7+NCy64ANFoFJWVlZAkCVdddRVGjRqFHj16JNx/4cKFcDqduPXWW1FXV9fu8wu6P1arFRMmTMDYsWNhsVgQCARkhmagrT8eOHAA//znP+P2pwq/yuk7YrEYIpGITEbEYjGsW7cO69atww033ICysjJWW4M8Sg6HQxaCf/z4cWzatAkDBw5kUUiAemSTVvgxL1v5yCi9Xo9Dhw7Jrmf27NmyYyiV42g0Cp/Phx07dqgqtVdccQV69OjBco5JCeAjoXgDdkZGBmbMmIHevXvjr3/9K0KhEPOCr1ixApmZmRg4cCAL3eTbQqHZw4cPh16vx3vvvReXLyw4t6D+w0+PxXtX6RnUys1WGlAItfGsz+eDz+eD2+1myhm9CwAwxZaHrw7Oe23VQqS1HEfK/s47gnicTmect5Y/Pt0frfBjk8nErosU10Tw8/TylZmBNs+t2+1WNcwRsViMpRI2Nze3y3jYHTgrFVuj0YgpU6Zg8ODB0Ol0CIVCceFIer0emzZtkk2HA7QJX5PJhGuuuQYTJ05EcXExMjMzYTQaEQwG0djYiNWrV+MPf/gDU455gfrmm29ixowZGDt2LBPcZPHkk7uBNk/P7t270atXL5mClyjsiUfNWkx5rq+//jrbzmAwsBwaNSWU7snu3buxYsUK2TlsNhsuvvhiOBwO1NXVweFwxFmVErUvLy8PCxYswPbt22XK9n/+8x/k5eXJPF/KAYRer0ffvn2h0+mwbNmydnngBGcHdrsdTz31FK688krV9aTUfvbZZ5gyZYpsncvlgk6nw6pVq1QVXgD4+OOPMXfuXHYsPhetpKQE69atw8iRI+OUWzJ80cAwHA7D6/XKvDCdQWNjI3r37i07b0VFRUKPrSRJWLJkCfO2Am19qrCwkIVddoT+/fvj8OHDOHz4sEyRraioYBXQExkALr/8crjdblx22WXC43OOYTQaceGFF2LYsGGQJImF+vLhxwaDAV988QWWL18u29dkMrEonoqKCmRlZcHpdMJkMjGFbu/evXj//feZN5Yf7L300ku46KKLMHHiRDbAJS8PGa9pINnU1IQDBw6gf//+qK2tlYX18X1OywitNETzMwuoyWS/3x8nk4FvZenXX38dl/LgdDpx5513IiMjgxXDU1aOpWPwhWoikQjq6+vh8Xjwv//7v9i4caOshsY///lPLFq0iNXA4NtCxzCZTBg8eDBMJhPeeuutuEG14NyAIgxJqeWh8RvNq6xEp9OxcTY5jvi8Wt5xpOxnTU1NbLoq8gZTqLNS9pDBi/qwsm8myl3l28obiqg/Kz2uWnP18goxpQKo3Uu+0jvf37Tax1dvV6ts3tTUhIyMDOY0U+5L5zCbzXA6nfB6vWeVcnvWzdqr0+lw3nnnsXA7UuZ4K2okEsHWrVvjlFqz2Yzf/OY32LhxIx599FFceumlGDRoELKzs5GRkYGioiIMGjQIP/zhD3Hs2DFs2bIF999/f5w3aOXKldi0aVPc8vHjx6N///7s+4EDB/Daa68x4QaoV1RMtEy5PhKJYM2aNbLzjhkzBpmZmXGVHul+6fV6eL3eOE+KzWbDrFmzYLFYEA6HkZaWxqxgNH9tsvbSi2/QoEFxL8Cnn36aFRLQsizZ7XYMGDAAF110Uco5EIKzA6PRiBdeeAGXXnqp6npJagvz37x5c5xSazabcfDgQTQ2NmoqtQAwZcoUNDY2orGxEd98801cEaXx48dj586dcYLj6aefxp133sm+v/fee7jgggtSys1PFRoc8Pztb3/TNCwRLS0tsjw4nU6HkpISHDly5KTbpNfr4XK54u5Tbm5uSnNQn3/++Vi1alXSaxCcPeh0Opx//vno378/YrEYQqGQzGNCKTJbtmyJU2oNBgOuvvpqPPjgg7jyyisxZswYlJeXIzMzEw6HAy6XC0VFRbjgggvw2GOP4Z577sHcuXPjQuyXLVuGL774gj13NJAkAzhx7NgxLFu2DE1NTXG5arycUn5ooKncBmiToxs3bpS157zzzkNOTo5s/lq6V0RTUxOqq6tl+7lcLixatAg5OTloaGhgA3sAqu2JRqPMo0ttoWI/48ePj7tPjz32GAKBQMJCOw6HA4MHD8bFF1+cUkqE4OzCbDaz54hP6SNisRj8fr+qUkvF3TweD1wuF5xOJ4tmNBgMMJvN8Hg8zKGkVvuhsbFRs58p5VIkEmHhy3zeb0eg2VCUkQpOp5MZyoDUQpkJUuhpDur29CdSTnnjFU99fb1M4VZ6k+ndYDAYUiqa2Z04695KkydPxqBBg5gVQy2kZs+ePXjvvfdk++l0Onz99de44447kJ6ejvr6ejQ1NbGXPFlp/H4/GhoaUFtbC7PZjNtvvx1ffPFF3IP17rvvYt++fawDRqNRuFyuuOlFDhw4gPvvvx+RSEQWgqQlOJXLiGg0inA4jG3btsUVmBgwYAACgYCmAI1Go9i1a5fMo+pwODBjxgxkZmYySxVZ1ykMQi2fR03hpnMpc/0AoLq6WrM4B1nvdDodevfujenTp8dtIzh7eemll3DhhRfK8uB4JEnCwYMHMW7cOLaMXvZNTU1IT09v1/mys7NRX18f15eHDBmC6urqpEJq/fr1GDJkSKfkrEiShAMHDqCwsJAt0+l0uOKKK5J6a59++mn84Ac/YMtoHtrOIiMjA42NjarCNBWr74ABA/DWW291WnsEXZvzzz8fw4YNi6s2zHtXv/nmG7z55ptx+y5atAgDBgyAz+dDbW0tampqmGz2+/0IBoPw+XxoaGhAQ0MDMjMzMXHiRPzsZz+LO9Ybb7yBQ4cOyepDOJ3OuLD+I0eO4M9//jPzKCk9tUoZrJwSEGgbsFJBqLVr1+LDDz+UnWPQoEFoaWmJq5EBfPsO27lzp0whdrlcuPzyy2E2m3HixAmWa8gbmvlqsJT3R14xpWfYarWq3qeqqioWDqnWn8lZMGDAAMyaNStuveDsxWKxwGw2sym2aAxI/YTGcmrT19D4lxQ5SmujaudkgAkGgwgEArBYLEhLS0NWVlbcsZqbm1m0AD33fNogQeG/kiQxRxPvgU0FGv9KkqQaRmy1WmWpC/x+dB6+aBtB7aCxP71P1BxEyn142UtFu9TqZZAyn2jMQL9bsvSm7sRZp9iWlpbG5bfSQxKNRlFbW4t33nlHts+Pf/xjpmBVVlYiFouxiab5EB8KKbZarUhLS4PFYkFNTQ3y8/Nx+PDhuLb8+9//Zsel/SnHiKeyshI//vGP2QPOJ3rTQ6cUUgQJtHA4jHXr1uG5556THfviiy9GRkaGaigGQR4rHqPRiLy8PLS0tLDQrVSsXUrPM12P0WiE1WqNE4Q0xyV/zXxegtFoZHOkJfK8Cc4+evXqBZfLpbl+165dsjBdEpjRaFRTGU6Gw+FQ9boWFhbGTZ/1yCOP4KGHHoprU3FxcYfOzbNlyxZUVFSw73q9nlUlTkQ4HO5Ur7EW/PybBEWfJMNut8t+N8HZTXl5uSzfi5dzJJP/9a9/yfaZOHEifvOb36C8vBzBYJAVquGVTd7gazAYYDKZ4PP50NzcjIyMDDzyyCNxbfnrX/+Kqqoq2UB8+vTpcREf1dXV+M1vfgOz2cwUSD63lx8T8IZe2oaud/v27TIjjk6nw5VXXgmPx5Mwtaauri6umrvFYkGfPn3YoJ83hgPquYla0NyZaWlpcbULdu7cCQCaii3JZafTKWTyOQY/nZSap1CtSJTZbIbb7UZGRoYsr5uHFEBS7PR6PUKhEEKhEOx2O3Jzc+P2IVlDCmQ0GoXJZJLVsqH1fr+fzXWdSqgvtclgMMBisbBUJKXMczqdqmHQPGqFpYj2GMHVzsErx2qQQ0trf+DbXGR+qqDuzlml2N5yyy3IysqKs37Sw+Pz+fDVV1/J9tHpdPjRj36EQCAAm80Gh8PBrDzKcFsSyuFwGMFgEKFQCDabjVVfO3HiRFybtm/fLpsnz2w2Y/jw4Rg9erRsu6amJnz/+99HbW0t7HY760T0IqAPJdFTJzabzaitrcXSpUvx6quvxl1b//794ff7WYdWdmS9Xh9nTUpPT8e0adMQDAZl8+zxaFmV1KzPZKGPRCKsajTx2WefoaGhQfaiUSrF1PFcLhebG1NwdrNr1y6MHDlSc31tbW1cQRUAKZX1TwZ5lpR8+OGHsmrjOp0OixYtwrPPPivb7vjx4+32FvOsWrUKw4cPly3T6XQsvSIR27Ztw7Zt29j30aNHd6hYVEe4/fbbU54KpFevXnFFsQRnH4sWLUJubq5MjvJ1Jnw+H9avXx+33/z58xGJRJihmYoPkkxWQhFLQFseKHlzH3744bhtv/rqK/h8PibnqSgSzddKNDc3495770VzczPsdrvqXJh0PSS/SME9cuQI/vWvf+G1116L237gwIHw+/2qxjdSipubm2XvmpycHFx55ZXMQK81IE9mfFYaA6LRqMyABrQVd2xsbJQVv1Kej46RmZmJH//4xwnPKTg74KeL1KoArKbA0RSRXq+XPXf8c6r8nz+WTqdjfVXNc0tjQ0mSYDQa2ZzWyshISZJY3i6NEaivaX3oPUWeZb5gLEGhz1pGJtIZlN5cvV7PKhMnU66VHloetdlJeJRGhETvh1AodFLjlq7EWaPYzps3D06nU/WlT2G0lZWVsnnkTCYTduzYAa/XK1MkEz1ovPeUlGbemrt582ZZ/timTZvYvK6Ey+XCsGHD4pTbQCCA++67D//9739RU1MDq9XKlG2bzQaLxQKn08mK4hw4cAAvvfQSfv3rX8fNOWswGHD77bezHBwtb20sFsP+/ftlFRuNRiOb0oe3TPMoQ7ISdVDeYmQ0GjFp0iTZ+tra2jjFVu1YkiQhPT0dN998s+p5BGcHO3bsQM+ePRO+hHfv3i0bUJnN5rhq3R2FLLVk5SXuvvtufPPNN7JtDQYDrrjiCjz11FOy5Y2NjXC5XCnP2Qe05e1arVZceOGFsn2sVisLW0x2bUuWLMGSJUtk13Kq8uD0ej2750D7PEY6nQ75+flxOYSCs4cFCxYwz77Sa0BTg1RWVsqMzQaDAT/72c9gs9lY+CBF7dBfPgJK7UOyljyLDz74oKwPrF+/HpWVlaxdOp0OLpcLI0eOxOTJk2XXEAgE8PDDD2PFihWora2Fy+WC3W6H2+1Geno6ywOkEMsTJ05g6dKlePrpp+PmrDUajVi0aFHctIMEr3Tu379fVujNbDYjKysLfr9fVixHy4tDx0sW3kj5hxdddJFseU1NjcyLppUKFYlE4PF4cOuttyZ4EgTdnfT0dLhcrrjqw/zzFYlE4gybHo8HNpuN5dUr087UFFz+meP7iNVqRU5Ojuz4Xq+X1XHhnVgWi0XVA+n1elkovcVikRmkyDNLCi05sMiJpSQ3N5fpC1qyLxqNMiMbj5r3Vwk/9k6m4NK5Esl6rePQ70J5zmoGhO7GWVHBY8qUKSgvL4+rLMw/GIFAAMePH2cPn9VqxW9+8xvk5eWxJGt64Anlg5ooLp8SscvKyvDQQw/hF7/4BYLBICRJwvHjx5GTk8OENdBWrn/kyJHQ6XTYsGEDO04oFMLbb7+Nd999l7XlmmuuYWFYdXV1WLduHY4fP84Ei9K7ZLVacfPNN8Nms7F7ouVZJY8orXc6nejZs2fcPFntyUdQ+w1o/1gsFtdxmpqaklqt+Fzl7OxsnH/++XEVnAXdn9dffz3pPK11dXXYsmULe+5dLhcOHjzY4fBjLaxWK6qrq1FSUoKWlhZEIhHs27cPffv2ZdWPaVB8xRVXwGQy4aabbmL7e71eFBUVyd4p+/btY1bRSCSCG2+8keXEkxDlSU9Px759+1K+Nt6jNX78+Dhvcmei0+ni2nXw4EFkZ2fHFfHQ2j89PR3Lly+XTX0i6P5MnToVffv2ZTm1vGJLn0AggMOHD7N1JpMJV111FTIzM3H06FFWvEltQKc2wFNG++h0bbn2ubm5mDp1Kj7++GMm644fP47c3FyWd0fzsI8cORKRSARr165lxw2Hw1i1ahVWr17N3ktTp05FWloamxVh+/btqK2tleXc8thsNixatIgVyuKVc77NfNoULU9PT8ewYcPYzAQk12kf/n5oKQ1K6Lx6vR7BYBA9e/aUrSdvMbVHqczQsek6CwoKMGvWLLz77rua5xR0T6iwECli9Psrnz1lNIPH44Hdbkdzc7Msv5XQcprQOZRjQr/fz4pW8f2L35aqFkuSBJvNBpPJFJfbSjKWrsFsNrO2J4qG4LHZbGhtbWX7KvUN+qvlaKN1nQlvNOR/C74KstrvpnYMu92umifdXTgrFNtevXrJhAXf8eiHqqurk1mGjUYjzj//fLS0tLBpOxKV81cqh8qHgkKDvV4v5s2bh/vuu491oI0bN6KsrIwJagppstvtGDt2LDIzM2XVIPk5XwHg1VdfZQ8lFVRS6xRpaWmYNGkSSktLYTKZEAwGNUMz6VqUQpjyIbTuQyqoKbRELBZDWlqabJlWaXcgfu5A+gwfPlwotmchU6ZMkVlS1di4cSN+8YtfsO+kIJ0KlMe94447kJ2dLStkptPp4PF4cPXVV6NHjx6ydUoL9sCBA2Xvmbq6OtW81IqKCjz//PPo2bNnh6/N7XajT58+Hdq3o3z99dcYNGhQSoot0GYpV0ZwCLo//fv3ZzJV7b2u1+tRX1+PL774gi0zGAwYMGAAGzCGw+Gk8ksLen9YLBa0tLRg/PjxWLNmDZN1q1evRllZGbKzs9mcmLFYDDabDRMmTEB+fr5seh6lAfnDDz+Uzd1J1f2VuFwuTJs2DSUlJcwLpKwIzhtueYMzYbFY2LR4tF4tgoqOpTb+UduHZGk4HI6rZUDvrUSGbd5rrNfrMXr0aKHYnoVYrVZZXrxS6aToCz5Ul6LzgsEgi2hUewaB1MaYfDSG0+mUyVWaOoxPt6P+YzKZ4HA4VIs+0XlTrUmh0+lgs9lgs9lkBfCUx+QNccq+zG9Dx0z1HvDtUFNOySCmRDnlj9bYisYl4XAYVqu1Wyu23T4U+eKLL2YhB1qWCJo/ih5gm82Gq6++GoWFhWyuWUIZsqv1Ylcqufx2Ho9H1oZQKMRCJnirik7XVoyqd+/euO6662TVXXmoclxLSwvLr+Vxu90YM2YMLrroIvTu3RtWq1W13co2k1BTi/9XWn3ai5aHWI2vvvoKra2tCc+ntNrbbDZcd911HW6foOuxadOmuL6jRigUYoItOzs7btquU0l9fb2qIKSqguPHj8eXX34pGxTzHD9+HEePHmUfpVI7cOBAPPPMM1i+fDnGjh0rq4rcXmhwcTq57777UFVVlfL2Op0ODocDW7duPYWtEpxO5s2bB7vdHuc9JTkpSW25rT6fj/Ulk8mEYcOGyTwuSpSKn1qIrHJbXnHj3yvBYBAtLS1s0A18G5JntVrRp08f3HzzzZg6darqNQaDQfj9fgQCATZ45/F4PBg/fjwuueQS9O3bl+X88degJo/Jk8PLZJPJhLS0NASDQVZpORntURYkSYqLvNi0aVNKMpk/n9PplEWsCLo/6enpcdEBPLznnl9vtVpVo66UY2qtj/IcOp2OheCbzea4Z0+pdPPjRbPZjPT09A5X/TUajXC73cjMzGTOKb7YKd8O/q+WR9RoNCYsHKfcvj2o3T9SUBNFowLf5ivTOzhR4c6uTrf22I4ePRoVFRWs3DUPbwmhcCHCYrFg7NixrJqhmkVF+V1pAeW3U7OK3nPPPfj973/PLEUkJMg6y1tsDAYDcnJykJGRgR49euDEiROorKxk1Qm1KC4uRq9evZCdnY2srCzYbLa4zq12Pfy1qIUy0zaU6K92DC20OqLSoszj9/vjXoxqISv890gkgl69emHChAmysDFB9+Sxxx7DkCFDkuaD0rx0hMlkks1DeSp47733cMkll8RVKVXDarViyJAh6NmzJwt9XL58Of7whz8k7ENz587Fddddhx49eqCsrKxDXtpAIJA0b+dUo6wnkAo6nY4p9LfddlunTJckODNMmDABffr0QTAYhMViUS0yQzKZN+oYjUZUVFQwuZMoeipVby1tq9O15dNdeOGFeO+991gkFclkvmIz7a/T6ZhMLisrw/Hjx3H48OGkMrm0tBT9+/dHbm4usrOzmZGZBo1q4wj+vtC94fuQwWCA1Wplha60vLb89fL3KVmYciwWixs/kQE9kUGaVx6oiu2AAQMwefJkrF69OuF9EnR9yDNJio7W3MaUzsYvpxlFKLc2EcmiI5UYDAa4XC40NzdrOm74Y/FVnEkxjUQiql5cHrPZzK6DD3/m302J+qCWYssXp6T3ndp2qUDXrBUZQ9vw74JU5CsZEWw2W0ozHXQ1urVi269fP/agaEEWUD53zWAwoLCwkIUvpzKVjZZyq7YuFothzJgxMJvNrPMEAgHWMfjt+WMYDAbk5eUhJycHPXv2RN++fREKhZjyKUkSK1luMpngdrvhdrtZKXL+mrUEH52LPyd///hwBmVuVCooFVhegafvSg9x3759YbVaVQckyv/5ZdFoFMOHD8e6devaFcoh6Hpce+21mhON8wQCgbjpBDqjEnIiJkyYIAutbW5uZgN3NXQ6HdLS0nDeeedBkiT06NED48ePT3iO8vJy9OnT56RK7lNxnTPJbbfdhszMzA7tu2DBAtx+++2d3CLB6aR///6sEIuaHKIBH6XUEHq9HtnZ2XEe1M4iHA6jrKxM1j9aW1vjlE21KqN5eXkoLCxEnz59MGzYMFmFZpKhVEnV4/EgPT09TibTsbQiwHiUMpkUB7PZzMIuT1beJVJ6gbZ5drXeb4mOF4lEMGrUKHzyySdCJndzHA5HUuMGoO4lJGWSjwpQjuFSQev5JK+tsj8l8irTe4X6ktr4lh+b89WflVXdaZ/2GNkIchhR/Rut0OKOvv+U0ZZmsznpb6iGJElIS0sTiu3pZOTIkWx+1mSVwGKxmMzLQ4Ui6MFqT7iN1kPI5xDEYjG43W7ZevJK0nGUIRkAmFAnpdXlcslCLPgXhZpFm/+bqFPwD7jZbJaFK1IeEH99yTzVWudQU7bpHDx5eXmsDYleNLxVGwCryDhhwgSsW7dOeHq6ITqdDr/5zW+Qk5OT0ou8tbUVdXV1p6Fl2tTU1KC1tTXpwI/6ao8ePdCjR49T3i5lxcpIJAKfz3daJ16fNm1a3FQLqaDTteVJP/nkk7jrrrtOy1y8gs5lzJgxyMrKYhFU9D5WGjtp4KVUbJ1OZ1xhJf5vIrQMznTscDiMtLQ02TY+ny8uikopl0kmGwwGZkjmQ6BJAeWNcmoDXl6GqbWT354qQRPBYBB1dXXIz89HS0sLu7fJ5LCWUqC2nbLATlFREfNk0zG07i+/PhgMIj09HZMnT8Ynn3wiZHI3hWQGPz5O9vsTOt234bZa0wIlejbV+onS0aEV5swfnz8G3ydJ6VZGKSgjIdTG6GoOKSXKsSvfVjJS8YYrLQNge1CL1CCUjist1AyQALql17Zb5tjqdG3Fg5J5WvkfWxkepyZ4UxEAym20OqYyDyDRMXmLEnk0lRYi8tQqJ6dPtYqbsr3UacnSTPj9fpw4cUJVWW6P1UcrREOv18fNB0YDjmQeZrXl0WgUY8aMOWVTmghOLXq9vl1eOsrNO5PwfbMrs3fvXjz33HOn9ZwVFRUpF45S45ZbbjntecGCk0en02HUqFHsfzWFhh84Ko3NAFhaUCJZQMfnj5cKJOtSGS/wH/KeUngwyVt+HQ2USR6pzWmpdk3KgTt9+CmNgLYIkT179jBlOtm4ItF4hjeUEwaDIS4v3ul0xikHyoG+2liIjj9p0qQzHj0i6DgWi0X2rCfrj8rxFx8JqXyOgPjnp70eReX5tPbnn0n+/cM7iJTz8vLHUirKasdWnlvp8FLux/e/jowjtPbVUmx5p1F7zkfvtM6ebeJ00O20AZ1Ohz59+sDtdrPpebQ6idbDBiBuGgItklln+PPx5+Ln7gMgE6pqlmildYn/TgKNFF5+0EDXzxfR0GqrmrKq7LDBYBDV1dXs3iZTOLU6t9p56f89e/bI1vNJ6slefmrHdrlcGDp0qBCk3Qyj0YhbbrkF6enpKVsoychzJqFpBLo6Bw4cwGuvvXbKjh+LxbB48WJZv8zJyTnpe3Prrbd2S2F6rqLT6dCvXz9kZGTI8kB5UpETkUikQ+9wreOR7CJlUSmT6TlVym5+sEsDXv5//jqUhauUMlsrL1F5nETX4vf7cfToUfh8PhiNRhb5lYoxWEsRpf8px3jTpk2y/SlaTEspUV6Tcr3b7caoUaPO+Lta0H7o3ZuKM4PWKfttonFoonGl1jmV3lplOhs9q1rH0tIJlONupSLKL9My8iivmUdNsaX3Bq+7JFKg1c6hdW61ffn3XEcUaTXvdlen2ym2BoMBEydOZO78ZD8UhRLxXoRYLIampiaZVSnVHzwVQUJTGSiFKF/4QSkMEwkQtc6VrL1q7dSyGFOIFUETbStzgtrTKdQ6oE6ng8/nwzfffCPbNi0tTfXFpHY8/lhkNY9Go5gxY8ZJeYoEpx+z2YzHHnusXfs4HA429cWZIi0trcs+a/3790f//v3Z92g0ipaWllNyLkmScPfdd3f6cR977LG4KcEEXReDwYCpU6ey0Nxk3giSybzxgmQyX6SlvfJGS+ZIUpu3VllsRplnp5TJvMzVGrQq25CofXTcRNC53G43mz8UaDM4Hz9+HBaLRTafaKLBu9r9UPvf7/fjyy+/lLWD0gmUA/9kbSfDYzgcxuzZs7vse1KgjcPhUC2omsigoXyu+JQCrf2ToaXkUmqBsp/zbUqkgPLPsZpDKJEynmobeYWVIi2V69vjMErl/mkdjzfIJdpW6xx6vR42my1l50NXoFsptnq9Hvn5+fB4PAgGg3HeWrX/ySLJ55kFg0GsWbOGhT6lWkBKacmhv9QOOo7BYMCaNWtkOUQ0sXSy4yeyEKltm8zCk+g8tJ8yBzAQCODgwYOy86bSqdQsU7SOOvKBAwdk2+Tk5MimhlDuq/U//zcajcJms6G4uFhYiLsJJpMJU6ZMaXexpLS0NOTk5LDvwWDwlE/3s2rVKllf9ng8XdajePnll+Pyyy9n3+vr6/H+++93+nmi0ShWrlwpWzZp0qR2FZxJxOTJk0+qkJbg9KDX61FYWIjMzEz4/X6ZEqgcXNInGo3CaDTKjBfhcBhff/21bJYCtWl86HiJvtMy/jhGoxF79uyRpSTZ7XZZRWSlnOG/K724arKa/lcLbeT/V8pupZdYp9OhZ8+eqKioYPu1trZi586dsnnn1dqrNv7RUtiBNqPE5s2bZfcuNzeXyeRkhny1cwNtxnGbzYbS0lIhk7sRJpNJNr2PVl9TPvPKbVpaWpiRi++LyYw/iRRF+qvTteVy89tQRCStT6ScKvuGWh9Rbqs8hlb7ldOPUcVxpVzkFV/+2Gr3Qe2eKMfwfJErHqPR2K48d60xvNls7lZe226l2JrNZpx//vmqSek8yhe8wWCQDZJaWlrw+OOPyzpcMtoTKhCNRvGnP/1JlgtIZcPVjhmLxRCJRFi1xUgkIisYRTk3qSqx7bWMpaWlITMzk92jYDCIAwcO4Pjx43Fe8URWO1qvvP90jT6fD5999pls/2nTpmlagxK93JQdPRqNYu7cuR0qXCM4/bjdbrz55pvt3s9oNMq8AHV1dZg3b15nNi2OSy+9FA0NDSlvzw/glfl2pxqn04mSkhLk5+cDAPbv349FixZ1+jyxoVAIF154oWzZP//5z07zpr/++uvsGgRdF7PZjIsuukg1tUdL+SHjL29sDoVC+PTTT2WD0vZ4K1IZMK9evVqW10syWalkSpLE5HEwGEQoFEI4HGYymbySajJZy9is1T6tbZ1OJ7Kzs9k98vv92LZtG/bv38+qnNL+avdK697x3huqd/HOO+/Izj9z5kw4HA7Vdqkpz8rflpwF0WgUV1xxhYi+6CbodG3V/Kkva4031QwzSshjm2jsmAwtBVc5VRggf66VCqDSaATIUwUSzYXdkbby+2kVeaNlqaRDKs/DXxtvoFI7DqUUpILyPUZF8/hjdZdaNt3GlKbT6eB0OuHxeNDa2spe7qkoeyRELRYL87xIkoSamhrYbDaZ8qX0kqpZVNSgB9RsNuPIkSOyh8lqtcLhcMjm0yJl1ufzIRgMIhAIIBQKsY5gtVphs9lgsVhgNBrZdDi8VYraqHavEt1Hfj9qT2lpKerq6vDVV18BaKsY+cknn+CCCy6A2+1mgqo9HmL+vobDYezfv1+2Pi0tTTbtUrJjqV07fY9EInA6nXC73fB6vaIaYxfGaDSitLS0w949q9WKzMzMM1IdOScnJ85bG4vF0NLSgpqaGrYsEonA7/ezCuk8RUVFKReX6wiXXHIJTpw4gV/+8pcAgEOHDmHGjBnYsGFDp1RnjkajcZEXPXr0gNPp7FTBV1xcjKNHj4oKyV0UnU4Hl8uFjIwMNDc3w2KxyN7PiZQ7mptVKZPr6uqY4YoGa1peDeUx1YyukUgEJpMJdXV1svU2mw1Wq5UN3HS6tqKNVJyOZDKFPEajUaSlpclkMk1ppLxetQF5KoZxfjxjMBjQq1cvNDQ0YMOGDQAAr9eLt956CwsXLkR2drbM+8zLQuXglz+vUn5+8sknsjY4nU6UlpZqhpK2x7Aei8Xg8Xjg8XjQ3NwsZHIXhxQ/6n9Kj6Xyt+efLdqXf/YCgQBbpjbVVbJnSTnmI4OJshAsnZ9vK98e6tukFNOxyelFRiotA1qi/qqmeCvfA/xsJ7wso3Umk4nVtKHzJVJG+eulfchjrZz9he6b2rVoXZfSYEFRNGTw6A79uNsotmlpaZgzZw6bSgBA3ItcTZDSQ5CdnY2hQ4cyIREOh/HOO+/g1ltvRVVVFex2uyxcIpEAUnvwaF6qtLQ0LF++XNb5Ro8ezcInJUmC3+9HbW0t9u7dG1e0QYsLL7wQ5eXlbECc7OFPFepcLpcLeXl5rJMBbZ7bd999F3Pnzk0aFqgmyOnYAHD48GHZtZpMJlx22WVxnZo/ntZvq3Yu2nbBggV4+eWXZUqGoGtRXFwcN6BqDyNGjMCvf/1r3HnnnQDaBlA1NTXIzs7urCYyampqZM/b4sWLWfXXaDQKv9+PmpoavPnmm/jRj36U0jFXrFiBAQMGID09nQ2OO5Ps7Gz07NmTTWJP1zF48GDs37+/w/eJBvj79+/HgAED2HK3242dO3d2ej7dxx9/jOHDh8fl/wm6Bk6nE5dddhmbFzJVSCbn5uZi1KhR+PTTTwG09adNmzZhxowZTFGmiIdkBhOtiB9JkmAymbBx40bZgOy8886T9YPW1lacOHECO3fuTPl5mzNnDnr16sVkMhmulW1oD/zg3+12Iz8/XyaTfT4fnnvuOfzgBz+A1WpFKBSS1e/gp2bhwxRpfTQaZdt/9tlnWLduHTu32WzGNddcA4vFgkAgoBp6qKY0q7WdrxZ99dVX4/nnn0d1dXW77oXg9KHX6+FwOBAKhVhFZCVKw4bSUGWz2ViUoiRJaG5uRnZ2Nvx+f5xim2z8qjwXOZ0MBgN8Pp9sX7vdLsvNp/nc/X4/GhsbU7r+tLQ0pnzyY9fOGmPTsZW5wfQ/TY/Ep2KowSur/DtH6cHW6XSswK5aOLLa76i1jN6j0WgUGRkZqK+vjzMudDW6jWJLc7sq57lLZkWkF7zdbkdeXh7bJxgM4v/+7/8wc+ZMZGVlaT5MicKKlOc2Go3Yv38/fvWrX7EfngS42WxGJBJBTU0NNm3ahJ07d7br+t977z0AwIQJE9CvXz8WKtQeDyr/MlELaSgvL0c0GsWHH37I7kckEsEbb7yBSy65hBV54kNVEnV8vV6PQCCAffv2yfJ49Ho9pk+fjuLiYoTDYVkuhvLe8tYpaivfbp5gMAiXy8WUhc54KQk6F51OB5vNdlJzq2ZlZWHYsGFMUHi9XhQVFaG+vr7TQtElSYLP50NBQQHry2azGWVlZUhLS0MwGMThw4fx+OOP48knn2zXsc8//3wAwEsvvYTZs2fD7XZ3ev7KVVddBY/Hg7lz5zKPWEtLCwoLC9HQ0NDu+xSNRuHz+bBr1y6MHj2aLTebzfjPf/7DBgSdjdVq7TZW4nMNk8kEl8vF5oMnlJ4WtXU0kC4qKpJFMK1cuRIDBgxgHkk+xJAfZCXyStL2sVgMZrMZJ06cwNKlS9kzRLU6zGYzwuEwqqqq8Nlnn7VbJlMI7+TJkzFo0CDWp/gp+RJ5sKmdyv9pEKnT6VBRUYHzzz8f7733Hmt/KBTCI488gh/84AdMcSCvEN0vpZJNv5HZbEZTUxM+/fRTZuSne3LBBReguLgYkUgkLveYn2pImUOsdv/pb2trKzIzM1nEmZDJXROSyy0tLapKUKLICNpemWoXDofR0tKS0Oil5RFWOm8kqS0asrW1NW7OZd6zKElt+b3tnRKQCix6PB5m+KEoxUSKeCq6B98+g8EQ135SPs1ms6zWD39feK84H1kaCoVU20VjCmV/5I/Dn0P5P33nr5vPv+7qdIuA6fT0dMyaNStOKUv2kqQfJRqNQq/Xo6ioCEOHDmXrw+EwRowYwaYo4F/WfMw9fz56yZN1iDozWZZHjBgh+/HHjh2LXr16IRgMYunSpfj73//ebgHKs3btWvz1r3/Fxo0bmYVHK4RCidZ9o+sxmUyoqKjA1KlT4/b773//i0OHDrFCHFox/dThAoEAdu7ciSVLlsiUWp1Oh/POOw/9+vVDIBBgg26dTsfCuywWiyzkK5WXB///nDlzkJeXl/R+CE4/AwYMYEaak6F379546KGH2PdQKASn09kpOa30zqB8I+Kpp55Cr169EI1GcdNNN6F3796qSi3lpvAfNY/TDTfcgOzsbDzzzDOnZG7cyZMnY8mSJbJzh8Nhdl10rxKdlxSOjz76CC6XS6bUGgwGvPzyy5g8ebLmvILKT3tZt25d3PtIcObJzMzE3LlzNeVPMm8MzWpQVlYme6ZisRj++Mc/ytJe1ArUJDsH8G311D/84Q+ywfrkyZPRp08fhMNhvP766/jb3/6mKpP5gWkiI/Lq1auxePFirF27lslkmpov0T3Qug4aY9Cx+vTpg5kzZ8q2icVieOyxx7BmzRpEo1Hk5ubCZrPBbDYzmUmzQdjtdrjdbuh0OmzcuBGPPfaYTKnV6XSYMWMGBg8ezEKwqU0GgwEmk4mlU9FUZ4k86EqlRK/XY+7cuSgoKNDcR3DmIINHIBBgBo1k8GNJflorZZoOVSJXM4Qka5PSsaGm1JK3NhaLwev1oq6u7qTmuW9sbERNTQ0rTsW3vb3tVntv6PV6OJ3OuP1IHgNt3mMaM6gVreMVXLXfyuFwwGQysWug8/PjEOU7W03PUZPdlF7Q1QtJdQuPrclkQnp6OoLBIFMkk3lqCfpRyXo7aNAgWaiRJEno2bMnjh49yryRfGEIfjultTIcDqO1tZVZW9SKnfTr1w/Hjx/HBx98gOPHj6u20WAwwOPxyHIOSdnUCqn97LPP0NrainHjxsHlciW0LKl5apXb0bVarVb07dsXkiRh1apVsuNQyNjAgQORl5cHp9PJOgt1zNbWVhw4cCAunxZo69TnnXce+vfvz6xJVqsVLS0taG1tZZY2eklaLBY4nU72odArCr9Sa38oFEJubm6XrVp7rmOxWFBcXHzSx8nKysKFF16IRYsWsWWSJDGrYkfnNKZBt9qLe+LEiQiHwzj//PM1KzH36NEDS5cuxcCBA9nxYrEYtm7dinHjxsmqKxN33XUXqqqq8Mtf/rJTw3ltNhsuuOACfPDBB5gxY4ZsHV3f559/nnAO6GeeeQa333573HKTyYSXXnoJV155JYD4wXlNTQ1OnDjBKuVmZmaisLBQ1i9PhYdXcHowmUysErJaCC6h9Fjy/5NMHjJkCNavXy/b75e//CV+/vOfw+l0sqgeAEzO8fDHJdntdrtRV1eHX/ziF3FtGjhwIA4fPoy3334bR48eVW23w+HA5MmTkZ6ezvqkz+dDS0sL3n33XVWl9dNPP4XP58OkSZPgcrkSzmOrFQWmvCZJaqu3MXDgQMRisbgK58uWLcOyZcswbtw4FBUVoaSkBHa7nUVL+Xw+1NbWYsuWLdi+fXtcm8lTO2jQIDaOsVgsaG1tRWtrK3w+H3w+H7vvZrMZTqcTLpcLLpeLhZ9SipjSS6/TtYVJFhYWiirnXRQygEiSJJMDWgqusk+TIYee1UAgINu+rq4OTqeTRWkpqxHTcagtfGSGxWJhnlq1Ao5OpxMtLS0J66rodDpYLBZYrVa2DRV2VJPHANDU1MQcLHTNymlzkskvpY7CG4vcbjeamppk29P7orW1VabYki7AK5dav43ZbJZ5fvn9qaI6XQsZrdR0Kv434OnouOp00+UV24yMDIwZMwZms5lZcYHUB0VKd77H48FFF12EZcuWybYrKirCl19+idLSUmYVUlaGkyRJVh3RZrMhPT0du3btwsiRI+POffXVV0OSJCxbtixOQbVarcjIyIDD4ZB5JckTTA8khWTt378/Lgxg69atCAaDOO+88+B2u1WFPn8P6D4ks6YbDAYMGjQITqcT//3vf+O22b59u6qQTITRaMR5552HoUOHwmq1ssrLS5cuTTm8weVy4aqrrkJ+fr5MkVe+PIxGIyZOnIhQKIRjx461q52CU8fgwYPx+9//vtOO17dvX+zZswe9e/eWLTcajfD7/R0ybvh8PtUqnsePH0dmZiYmTpyIzz//XLZu9uzZePTRR9G3b9+4/Ui4DB06lOXBlJWV4fDhw7LtHnjgATQ0NGDx4sXtbnMizGYzpk6digMHDqgWjqJ84faQlpaG119/HRdccAFbdvDgQQwZMgRerzelY/Tq1Qt79uxJadsnn3wSd911Fz744IN2t1XQ+WRmZmLChAmwWCwIhUIdMlDwA1uPx4P58+fjjTfekG3z4IMP4p577kFWVhYzaPLvfN6TAciN2Hv37lWdI/uWW25BMBjEW2+9FSeTi4qKMHHiRPTo0YOF8pHXlyo5R6NRTJ48GQ0NDfjLX/4S50HavHkzgsEgZsyYwZRbalsySDYrQzLp3EOHDoXL5cKSJUvi9lXONpAKRqMRkydPxqhRo1iO37Zt2/Dmm2+ynN5keDweLFy4EPn5+Wwfpcc2FovBarViypQpCAQCmsYEwelHr9ezXHYy4CQbHyrDWHlFicbYytxWr9cLvV7PQtJp5g9AvZI4Kcw+nw9NTU2qc7F7PB6Ew2EEAgFVpdZkMsFms0Gv1yMYDDIjK70vjEYjTCYTYrEY/H5/3HUHg0HEYrGUpupMFVIWTSYTsrKyUFtbG7eNmkEMgGreM0HG41gsxt7Ler0e9fX1KUdK6fV6uFwuFj2p5jii97bdbmcGra5Il1dsrVYrcnNz2Q+VqqeWUIY0WCwW9O7dGz6fL87rMnLkSDz44IO49NJLkZGRwV72vJWDr1B88OBBvPjii7j33nvjznvFFVfA6XTi3//+d1wnd7lcyM7OZjk+pNgpHx7yIANAaWkpYrEYTpw4IbOI7d69G5FIBDNnzpQN5Dsa1sgLpfLyctxyyy3YuXMn1qxZ06HjAW3hInPnzkVJSQnMZjM+//xzvP/+++0OT2xubsZzzz0Hs9mMhQsXoqSkBM3NzczoQYOcSCSCvLw8MfVPFyMnJwdTpkzptOPpdDqUlJTggw8+kClZQJslt6qqql3Tz9TU1KiGyx09ehS5ubkYOHBgXMjiokWL8NBDDyX0WimXf/PNNwDacm1Xr17Nlj/55JOor6/Hq6++mnKbk0HnLi0thc/nw3//+19cffXVHT5eUVERvvrqK6SnpwMANmzYgEmTJsneVamwd+9emEwmOJ1O1NfXJ9y2V69e7HyCM4/NZkN+fj6CwSAbGCaTybyiowzRM5vN6NOnD84//3ysWLFCtt9jjz2GmTNnYsSIEUhPT2eKHg2M+QF1MBhEfX09tmzZEnccAFi4cCGMRiNee+21OO/PsGHDMHPmTOaFDoVCqkVveM/lokWL4PP58Oqrr+LIkSPsWDt27EA4HMacOXNgt9tTmk2AV2rVvLdk6O7duze+//3vY/fu3Xj33XcT3vNEOBwOzJ8/n1UzX7NmDd5+++12y+TGxkY88cQTMJvNuOOOO1BWVoaGhgZmvKa0pWAwiIKCAtUwTMGZg4oaqTkKUlVwlWHpVKxVaThqampCKBSC2WyWzfJBYft8kbNQKMSUUTXlyel0wuFwoKqqKk7hozlXqbgj8G0khxJSINPS0tj0Xvx1U2FTh8PRoUgwtXtIfZlmTKBw7Y6i1+vh8XgAgOkrSm9wKsRiMTQ2NjLjBP++UupeicY7XYEur9gajUbYbLaUqnslWs7PVRWLxTB48GBEo1FZddZoNIpf/vKX+PWvfw2dToef/OQnGDt2LDIzM2E0GhEKhdDQ0IDVq1ezeXD5CdOJ2bNno6KiAk899VScUpuVlYWsrCymgKnlpmldh8FgQG5uLqqrq2VV0Pbv34/3338fl19+Ofx+vyyMUq3DqFmGlVDns9lsGDVqFPr06YNvvvkGH3/8seY+SrKzszF9+nRkZGTA7XajpqYGL7/8ctL8o0RIUlvhr7/97W+YPHkyxowZw5bTtYbDYTidzg5PJyM4dXTmy5AGxeeddx5WrlwpC7eNRCIoKSlh51u+fDkmTZoUd4yPPvoIl1xyCQCoKmfbtm1DXl4eevfuHRde/9vf/haLFi2C0di+1yj1z+XLl+Paa6/Ff/7zH3b+JUuWoLm5OW5uyZOBTzOYP38+mpubsXLlSlx++eUp98OJEyfi7bffhslkgt1uRyAQQE5ODqLRaIettpFIBA0NDfB4PHj99dcxffp01eejKwvQcxEySJDiooWa95Ffxz97sVgMw4YNQygUkhl7YrEYPvjgA6xcuRI6XVt9BirgRuGTra2tTDYpc/6I+fPno3fv3vj9738fp9TOmDEDM2bMYCGPFKnFVyjl8+1IwQ2FQjAajZg/fz7efvtt7Nu3jx1z7969eOedd3DdddehpaUlYe6iUqlVC1+kc0ejUVitVgwbNozJ5Pa8K3JzczF79mx4PB5kZmaiuroav/vd705KJsdiMQQCAfz5z3/GjBkzMHHiRDZ+oPbTdHxCJnct6FnmvyvDUdX2UXtG+QhHo9GIgoKCuPQ7v98Pv9+P5uZmmEwm9jzw0RbkhdWCnqPKysq4sTf1M0qRoJQ3/tlWKuU0BjebzayAFi/TaBpOu92esgKaqK8DYIo80FZDKBKJsCk/U8VoNLLceXrvKSNIOoIkSWhsbGSFWP1+Pyt+y5+7M6f262y6tGKbm5uL4cOHw2g0JnTD86gNgnhLFK2PRCIYNWoUPB4Pli5dyralkCcAePjhh1k4Ev/w0Fx3asybNw+DBw/G5s2b40pw5+bmspDhVOZuVbsOg8GAnJwc1NXVsfAMSZLg9Xpx/Phx5ObmykK2tVC+tJQdUWm1stlsGD58OHr16oWmpiY0NzfD6/WylwZfqMLlcrE5/8gYcfToUbz++uuaHbeoqAh2u51tTzm7sViM5Qnx0ABo3bp1uPXWW1n+BF/NbsyYMfD7/cxDJjhzTJw4Effdd1+nKymk3E6aNAlHjx5FUVERW9fa2sr+v/TSS1XzV0OhkGqYE9A2/2tBQQE++uijuJCeP/3pT/if//mfkxqo2e12vPDCC/B4PHjxxRcBfKvsVVZWdnoBNJ1OB5PJBKPRiNmzZ7Mw/UOHDuHgwYMsp85utyM7OxulpaXIzs5m95iEaENDA/r27at53z755BP06tVLdd2qVatw7bXXypY1NTVhwYIFsFgsOHr0qKqy9Ic//AEmkwl///vfT/IuCE6G/Px8jB49GkajMalBQ9nXtfJKaSAcjUYxYcIEFBQU4LXXXmPbRaNRJv9Xr16NtWvXxg2sSdFU49prr8WQIUOwYcOGOLk9c+ZMjB07lg0seeO5Wr4oP4inaVHS0tJw8cUXY+XKlSxFh2TysWPHkJ2dHVftNJWUIOV3flkkEoHFYsHQoUNRUVHBCuc0NTUx5dtgMMBiscDhcMDlcjGFgLxOR44cwcsvv6x53yZNmoT8/Hx4PB44HA4W4lhdXY2dO3fGTVUYCoWwcuVKfPLJJ/jhD3/IflM6XywWw+TJkxEMBk+qgKagc6Dng0Ld2xsNCahXwo7FYqwejprnFgDzyqq9QxL1CxpXtra2xhliKEIvGo0yBVcZTcL3O+pTfD8nBZaiNgi+mBt/rfyx+OVa94q2pXbw95xyevl2keOMNxgo82KT6STAtxWZyaFG71Otey1JbdM18SHO/L2jWkQU1drV6NKKrcPhQFZWVtzkxWooHzS++JNaqXoKoSovL8e1116L3bt3Y9OmTbIfmh8YJ0Kv12PixIkoKytDjx490NLSgk8++USWmJ6Xl8emy6F9CDUvrVYIA9D2kFKIJQ0u6+rq8Mknn2D+/PmyqQa07g9PMisUvfSi0SjsdjubpoHCSPi8YACyl0kkEkFjYyP+85//xCn6QFuYIVVdVMuzoPPm5uaiublZFvJFRojnn38et9xyCwuPoP1ycnLgdrsTXpvg9JCfn9+hfM5UIIWtoKAAu3fvxooVK/D9739f9sJVKzyhhtlsxt///ncMGTKEFbm6/fbbZaE9zz33HK644opOCXX3eDx4+OGH4XA48Je//AVAW57ejTfeGFcHoLPQ6dqKaZDinJGRwYrT8PlSJED5Pnns2DGcd955qnNSbtq0CWlpaSgrK9MsgnXppZdi9+7dOHjwoKzSK0W29OvXD1u3bo0rNJOXlyf6chfA4XAgOzub5dYmGwyryW0+eorPk6Uc1qKiInznO9/B7t278cUXX8QZWVOJENDr9Zg6dSrKysrQv39/1NfX48MPP5QNVufMmYNhw4axZ5UvfqT08Civhz+PJElIT0/H5MmTAYApt9XV1fjggw9w1VVXqc5Pmcy4zC9Tnpf6pSRJbLBfUFAgk8nKATRBIYevvfaaqky+/vrrkZ+fD4fDETfVnk6nQ3Z2Nvr27Ytp06Zh3759ePPNN9m+JJMXL16MO++8UzafLQAhk7sQpNhSf9IyuCRzgPBVevnlNL91Xl4eAoGA6pyyqXpA09PTWUi7Wk4s5Qlr6QGJ+jB/3fReIoM1vS/Ik2y322VTVKaCmoEvWb/n0zR4pxyv05Djx2g0xs3tS9B7h49i0dIt6N3Bt0uSJNTX1yMzMzPOSEVpBkKxbSeUz0rWAUA9jJZevpQDqwxH4vNwlMLFaDQiPz8fmZmZKCkpQWVlJb744ouUQgIsFgtGjRqFrKws9OjRg1lDvvnmG5k3w+PxwG63xwn5RFYeNUWUtw5ZLBa4XC6WFxCNRtHc3Iz6+npkZ2e3u/PxaIWa8N9pqhClMgrI4+8bGxvxzjvvxBWVKS4uhtvtZkYGrXORlYrCRFwuF+rr63HixAm2TWNjI7Zt24axY8eysAkAMsuW4MxCQvRUQc9b7969kZWVhdGjR2PPnj24++67k+ZwAm1h80888QR69uyJfv36sQJSX331FY4dO8beG4sXL8bcuXPhcrk6re05OTm47rrrUFVVhddffx2BQACHDx9GY2Mjy505lVAlxWTs3bsXCxYsiAvJ/uyzz6DT6TB48OCkYdkOhwO9e/dGSUkJ1q9fD5/Ph2nTprH133zzDT766CMWGkpoTfkiOL1QQRZKDVIOhvkQPzJw8vMpKj0k/GCSllutVpSXlyMvLw+9evXCiRMnsG7dOs0KpjxWqxVjx45FdnY2ysrKYLPZEAqFsHPnTrS0tLB2jh49GgMGDGBeV6WcUBqe1WQ2vzwcDiMrKwuDBg1CY2Mjjh49ynLd6uvrkZubGzc9XyJjcyJ4RZWXv+FwWLacrkE5XUl9fT3eeOONuLDFSy65BIWFhSgsLGS5hvxAl/dqUZrSgAEDkJOTg6+//lqW1kW5zhMnTpSlR3X1EMZzCTWPpto2ieCdGYB8Tlng2xxVk8mEjIwMhEIhtLa2pvTM63Q6pKWlsSkgW1paWP/hx/F0LuXUY0oPKX9NWtEjtB9FPJhMJqb4U6Ql3/cTKcz8Mq3xtHK9MjpE6V3mt6H3r9fr1VRqaftk10tjdtJh+PWUq0zefXq3d+U82y6r2GZlZaGsrEyWtKz2MqeOGY1G4fV60dLSgt27d8s8LDqdDm63GxUVFSxMluZIpR/RbDajvLwchYWFKCoqgt/vZ3O6UYw9WVBsNhvsdjtsNhvy8vJYeB+1b926dbKOR5WPgXjBngitzk/3gtpCAt/r9WLt2rWYP38+y39SCmK149C5tLziynAL/jdQ24eEn8/nw4EDB1BXVyc7XllZGVwuV9xgQutFxJ/DZrMhJycHAGTK7fr165Gbm4uCggL2WxmNRvTs2RMnTpyQeXoFp5fRo0fjsssua9c+kiTh4MGD+NOf/oRdu3bJ1vXt2xf/8z//g4qKCjaFAE9GRgYyMjLQp08f5OXlMSNVS0sLmpqaEAwGYbFY4Ha7mQJLRiplcZM777xTlu8zbNiwdhWkSpVBgwZh5MiReP311wG0VRm+44478I9//KPTz9URGhoa8PHHH2PLli1smU6nw7JlyzBmzJh2Czir1YoxY8YgEolg6dKlLM8ZAH7+859j5MiRLAyauPLKK3Ho0CG8/fbbJ39BgnaTk5ODiooKZqVXvq9pkMuHAra0tKC5uRk7duyI89h4PB707dsXbrcbTqeTRVGRTLZYLOjRowcKCwtRUlLCQhd9Ph/8fj8L0bNYLEweWywWFBUVMZlMY4NPP/1UpqT17t0bTqdT1m4i1WeZH+DSIC83NxdFRUWs8m9zczM+/vhjXHPNNczLkWxgncpgmcYXyqk/lDKZ35/GSPv27YsLD73kkkswduxYNoetlkGY94SRsamwsBD5+fmw2+2yOco//fRT5Ofno7i4mO1nMBjQu3dvHD9+HAcPHtS4s4JTDe8EArQj+vhniBRK8pry+1HFYz7Plp5TPtLQarWyyAyKKuCPxStYtB9FAVDFX6VBRm2cq3z2E41vldB68paSYktjWqfTmfA+aR1Pa5nWOJp0Bf7DX7NOp2NTcfGozS2ezJCQyJsLtM0WQfeDbzPl3nY1r22XVWzdbjdycnKYJ1b5I9EnEong6NGj2Lt3L3w+H4LBIOrq6uKsuxaLBVVVVWxeLKvVitGjR7NqmySMHQ4HSkpKZJ1OaQWlWHX6zv/YgUAAdXV1svby8fA8agJObTs1yGLCezsjkQiqqqpUvbVqx0wmQJO1SevFQb9LVVUVtm3bJtunoKCAhTVoCXe15XxHNZlMLG+pqqoKQNvAe9WqVcybRi+4nJwcZGdnC8X2DNKnTx9MmDAhpW2/+uorPP300/D5fGhoaMD69evj8qu/+OILfP3118jIyGAepKeeeipugOpyuTB9+nT2PRQKIRAIsAgQq9Wa1FO5cePGOOvwqfA4UIg/0dLSgrVr13b6eTrKgQMH8OSTT7LvJpMJzz//PGbNmnVSxzUajbjooovw0ksv4YYbbgAAbNmyBbfffjuefPJJZsQCgBEjRmDQoEFCsT1DZGRkyAyHyuJP9H4Oh8M4cuQIdu3aBb/fj0AggOrq6riCMFarFZWVlbBarcwrM2nSJLjdbjb3IhUrKykpkRV/5JVpXskCvh30AW2yxO/3o7a2VibD3G43C9PTGni215MaiUTgcDhkURbhcBgnTpxAKBRSlcmJDM9aqBma6RjKKs78PqFQCCdOnMCXX37Jluv1ekybNg0DBgxg9zSVGh38+YC298GUKVPQ0tLC5ruvq6vDe++9h6uvvppFuMRiMeTl5SEnJ0cotmcQGscC6ooVX0AtEomwnFby4qs9e9SX6EPyjNZR3+XTAQHE9Wn+uVKO/SRJiktFoJoqqTqM+DYnWqdUDgGw2TcoYoXfNtm5tMbQyZRa5Tr+XadWZIuvf6D2O6n9z7/LqU38+aPRKFpaWtgc2dSGrppn22UVW5vNBofDwR4kNQW3uroau3btQl1dHU6cOJGwql8wGJR5+GhuK5fLhbFjx8ZNxKy0TKhVL+Y7Km2rtCY5nc648LxEHSoVKwv/sNOE6qTIS5LE5uLkBZRaJ03UHuX27VXA6+rq8NVXXzFvrU7XloROXphUBafyegmLxYKCggKm2ALA4cOHcfz4cabYRqNROBwOMe3PGYamt9KCvLN/+ctf8M033+Ddd99NmApQW1srm9OUipbp9Xo8+uijms9WqiG31Cbl8/3Tn/4UJSUlKe3fEUaOHIl58+bhrbfeOmXn6AhbtmzB7373O3z11VcA2pTw3/3ud7juuus65fh6vR7XXXcdU2wB4I033sAvfvELNu0a0CYTOjI3saBzsFqtbNoLfiBL6PV6VFZWYtu2baitrZWF8KuhnNOUwuDS0tIwbtw4Ngel8v1PBR15IxPJYr7IC+2rlMlDhgzRzPNM5ElVwg+26WMymVjkEFWElaS2ys1ut5sV1VHunwy1cYHWgFhte0mSUFtbi82bNzNDocFgwJAhQzB+/HhWgIYf0Kbq4QLalHqr1YpJkyYxxRZoizw5cuQIBgwYAACs2JbaXOGC0wevgKopV/QctLa2IhqNJk0DUFM4ifT0dObsoGPzU/soHUjKNtLxydjFoxbRqXYdWgqdWt/hv5PyxituSiVe2dZkqL1jUlWO6d6R91jt/aosfqfmQNN6ZyjvOQ9FuvHbUA59V6PLKrZkCQiHw6ysP/DtA/7ll1+ipqYGe/fu7dDxY7EYdu/ezY45fPhwZGRkMEWaPxeAuLnotF4KfB4P0GYZ5i3IiRTM9gg6Ur6V4cj0wHs8ng5bUZRCMdUOS/vFYjHU19fj8OHDsvbm5OQwq7XSSKF1PN56RFB7aI5jXrn96quvUFhYyCzEJpNJ5tUWnH6UkQU8sVgMv//973Ho0CE888wz7faSAG2e2McffxxAW67sD37wA1nYTEdRRl4sXLgQ+fn5J3XMRAwdOhRz5sxhiq0ktU1boCykdLrZs2cPC5EG2vrd3Xff3enn+clPfoLf//737J4//fTT+L//+z8UFhZ2+rkE7YdkMs1fC8i9MRs3bkRVVVWHK97GYjFs3boVAFhV+4yMDFk1UpKfND2NUg4r80nVZPLQoUORlpbGBohqqA1y1ZbTOUimGQwGZGVloaSkhCm2sVgMra2tyMzMZKG+iVAb5Gp5kBIdg29vNBpFXV0dDh06xLYxGo2YMGEC+021ro8/Hv2vlMsGgwF+vx/p6emYNGmSbN77L774AiUlJSyEU8jkM49y7Koc55HSlEpeuxbkTWxtbWUhyHykhVp7lCifR2V/VYu6SHRdav9rKZXUp00mk2wsnczho4bWeyOV7ZRtJI+x0ltLx1NWME7FkaY25le7L8FgUObt76p0ScXW5XKxcB7eGqrTtU3CvnfvXqxbty5uv5EjR6J3796aVv1IJIITJ07ETd7+xRdfIBqNYtiwYcjKyorzwqo9JGoPi16vj6sySB4iLWFF19ge+DYYDAaZR5gGw9ThEz2AiaxVam1MZPXhCQaDsuJZOp2OVW5s70shUShFLBZDcXExWltb2fm++eYb1NXVIS0tjW2bnp6OzMzMuFxfwamnZ8+e6Nu3r+q6cDiMF198ET/72c/i1l1++eVJCzQ1NDTEeTd/9rOfwel0YsGCBWy+6I7CG2ZOB+QRI2KxGOrq6mRTGJ1uaM5BwuFwxE3X0xnodDo89NBD2LdvH9566y1Eo1E8++yz+N73vidTbPv374/hw4dj8+bNnd4GgTYul4t5XihtB2iTeYFAALt27VKd45yqWZvNZlnYMPVLSt1Rzne5YcMG6HQ6DB06lE03wYfAaQ1Qlej1+rjZDVwul0y+a4X8JTM082MDvlCT1WqV5epTFBXJZP4atAzH/HghFYVWa/BO+ytlstFoZAW6GhsbYbVaZUZ9pYFA69gEjTXC4TBmz56Nffv2sd+Uour4Aprp6enIysqKSzMRnHqU6XR85KEktYWsq1XLtlgsLFoCiO93NOWWUhlubm5GLBaDy+WS5dZqjQX5MT+PTqdTddZQ7nqyZ1VNeU6kXGoZvXgnl1pf0zqeVt9R0w3UIjT4bdUqrAPf5hsr3yvKNiQznPFRsvy5yGvLe9wpX7srhSN3ScU2Pz8fBQUF7MehGxsMBrFnzx5Z9T2gLfcqLy8PCxcuxPnnn685IA4Gg9i2bRubj40PZ/zyyy8RCoUwZcoU9sNpPfRagpSEvHJZqpbW9ii4WoKMQkI6Q5FOZPVJpJQ2NzejsrKSfTcYDMjLy2uXdUt5fVovDIPBgNzcXFmlPXqRkoWwuLgYFRUVQrE9A0ydOlU2rQsRDAaxdOlS3HLLLbLls2bNgtFoxBNPPIGCgoKExz58+DAikQjC4bCsaMmdd94Jv9+P7373u8jIyOiwctvQ0NAhD3Jn0VkTrp8Me/bswerVq9n3zMxM/OlPfzpl5/vjH/+IZcuWsYGVz+eTVcWfOXMm9u/fLxTb00xRUREKCwvZoI4GNKFQCHv27IkzFmdkZMDtdmP48OEoKiqCzWZjVeppYC1JbcWljh49ii1btqChoUEWmrx+/Xr4/X5Mnz4dNpuNeXrUBoFKQzSh0+niBulUnb0jclBrPR2PZBKf8kAyOZGHWO1cSsU32b58W5SyvrGxUWY8sFqtmDhxokyhoe0TjXsSradj2Gw2jB49Gm+//TYLHW1sbERBQQH73UtKStCrVy+h2J4BaC5UNa9cMBiM6y9UiI1m9+CdJXx/Iy9iS0sLK7xKtLS0yDz1ypxarbFpMkcIrx+otSmRwSfZeFTLsNWeKEYtUvGiqp0b+NaAwENzRlO+sdbx2ts2Nf1Fef30PlXOfHIm6ZKKLRV14a2bsVgM+/fvj1Nqx4wZg9/+9reYNGlS0vw5i8WCkSNHYunSpaivr8ecOXOwfv16tn7Hjh2wWCwYO3Zs3BQFyToIfZR5BrxA0NqfX662vRpKgcQfgyaZVwv34K9FzRLE/58sfEKtg0uShOrqatmUIHq9Hna7PaUOliw8QynoJUmKy6E9cuQIevbsCYfDAUmSYLPZRE7PGSIrK0tWAAho89J8+OGHuOKKK2TLx44dizfeeCPl0NuSkhIsXboULS0tOP/882V9+Z577oHL5cK1117b4RzrM22B1Ol0ZzyndN26dXjllVdO2/lofmxi9erV6NmzJ5tzNy0trVOnWhKkBlUcpqlxdLq2Ggb79u3D+++/L9s2JycHY8eORXl5OdxuN9uW/vLT0lgsFgwZMgTDhw/H7t27sWzZMplyu2XLFqaEOZ1OJvP4Sqpq3hNSgnU6XZwHSU1BTOY11VLqeFnJD4SV0+RQOCOf5qR23mSDWlqezGOtHJRXV1fjm2++YespNai1tVV1yiPlOCSRUqtsg16vR+/evWXbHjx4EOXl5awStcPhEDL5DKHTfVt9mH5TUojUIg7T09Nhs9lY1AX/vPNhwKT8ZmVlob6+HtXV1bK+19DQAKfTyaID+PYkGnPSNnQOJcqaOJ0B3yZlv+IjIZVGrURtV+tLfB9TvkPUrofeZ7zRgH5PqibfHgOYmuecN1wCiFOW+VQU2q6z7ntn0SUnFKMiL/TjR6NR1NfXx1mF+/bti1WrVmHatGkpF4UB2n68zMxMrF69Oi5McvPmzThw4IBmZUBlB1IKVWU7yIqSqONpCSm1DxD/MCormpFRQCnstc6vXNceSzah1ikJZSXZRC+BVL3bdH6yjvNt+fLLL9HQ0MC+m0ymUzqHqkAb5QAmFoth3759mDNnjmy7vn37Ys2aNR3KJ01LS1Pty9/73vewYcMG1cqBqXAqpvVJhPK51+v1cdMPnUlMJhOKi4tP6znvvfdebN++/bSeUxAPyWSSNZFIBHV1dXEVqj0eDy677DKMGTMGdrsdoVAIkUiEFXWisEEqDmk0GtHU1ITa2loUFxdj4cKFcYXmNmzYwHJDaUCulJlKGcmvV8pkpaKrpRgn+ijPAXwrh5W5iTqdjimPvBxMxaukRE3Gqsl52kbLOO1wOGC1WmUD2GTnVSrwauehgbfH45G1acOGDaivr2eDZpqiSXD60Rq7Kj1uJpMJOTk5yMjIgNVqZcWb+A8dhxTeYDAIn88Hu92OwsLCuL7n9XoRCARkIclqxh2t51YttU4rbF5JqmNLtfdAom2SHbc9Y1raXu3/zpyNIVl7Ep03FAoxBZo3cHQluqRiS5W26KUbDAbj8t3y8/Px9ddfy/I22ovZbMaOHTviQh7fffddVFZWaipqai8GSWqr+qYUymqV4tQsq4mEq3Jf3hqtDEvQ6XRwOp2qecI8He1oyvYrocqUBE3Nk0jxVbu+ROv5YyQKjaK/iYoXCU4vzc3NcfnxBQUF+Prrr1Wtsami1ZenT5+OXbt2tTscB2ibW5Z/tmhgfqpobm5GdXU1+67X6xNWkz7dlJWV4emnnz7TzRCcASgcEQDzDvCzDABtXt2rr74aZWVlaG5uZrlXanKSvA5UHJJmQHA4HFi0aFGcQef111/H0aNHVb0bPLxslKS2EGBlwTfe6KncJ5kiq5S/wLdzupIBt7W1VXYOkskkixIZq9VkpFJxVEPpNeGPxyshQJuxcdiwYUxJSHV6Hx61e0+yOBaLqUbJ8Hl5ynBtwelD+TxRwVEevV6P4uJipKWlIRwOMy+lMs+dV3BI8aRtbDYbysvL4+S61+uF0WhUNfIo28n/1boW2j+ZY6Y9zzjvyVYakfg8VuU+ah9lG/i28sphsndbIi9uKBRSVXy1lPJkY2z+XiYrsNdexf100OUUW71eD7PZzB6ecDiM6upqWZih0+nEvn37Ou18x44dk809BwB79+5NaM1UE0yxWAzp6emyh6a5uTmuVLjaX7Vj03G1lFtJaivHzlvaeOuwUiDT8VJ5CJMps1qKslpHIGGeKqla1fiBhdox+EEI5XcJTh/8YBhoe4nv2rVLllebnp6OY8eOddg4xaPVlw8ePBgnuJOh0+lYXh+xdevWuEI0nckrr7xySqoNdxYWiwXl5eVnuhkwmUxnPET7XIJ/f8ZiMYTDYRw/fhwrV65k2xiNRlx55ZUoKSlBTU0NbDZb3HufV/74D3lzaYBmMpnw4x//OC7KZt++fUwpItQ8l7ysi0QiyMjIkLXj4MGDccbgRMqs2rGVkJyh8GyaGovWkccrkUxWXgu/Tm2eSbUxhJrRXGls1uv1SEtL0xygq93bZCgHucnGTWT0EDL59KN8ziVJiusP+fn5bLYN5bZqyiSvoAFtxpJIJAKLxYKePXvGPQ+pRlEli0zgc/6TKWx0jETL+WswGAyq4dla481UzqHV75Mp8Ymujfq2Mlc+VZLdM2XOLh2/q3lpebqcYtuzZ08UFhYyZTAYDOLYsWNsvcViwb/+9a+4QefJ0tDQIAuZ3LBhA/bu3SvLi0km5KjyG//ge73euHBkQks4KVE+rGovGcJgMMBiscRZd5Tt5S1v0WiUJf17vV60tLQgFAqxsDESgnQc3kJH7dISrnRflNeidY1q+3fEGsS/MKh68ujRo9t9HEHHue666zB79mz2vbq6Gh9++CH7brfbUV9f3+nnbWhokOVhzps3D59//nmHjsUr5ldffTW+/vrrk26fGmrPeKpRBvSMh8NhBIPBhJ+TEUbRaPSMF7MCgPnz5+Oxxx470804Z+jduzeKioqYYqaUyXq9HhMmTEDPnj1RVVUFu90eF2aolA+JFEmv1wuLxYLbb79d1gc++ugj7Nixg823ysMrTMqBY3p6ukwmr1u3DidOnGDTF2kNGhPJZuUAn5R2tWk4yDvJh27ybea9Q7yyT9VpfT4f/H4/CwE0mUxwuVyye8MPPqltaveX1odCITYuUQvl7Ig3ht9Oqz4BKdmxWAw9evTAhAkTUjq2oHOgysb876uMKvR4PEhLS0Nra2vcjBta8ONRvl/4fD4YjUaUlpbKni+fzyeLrFCipkDTWJUnFovBZDIxRTqV5zWZAkwRDmR8UduXf8fwbeH7Md+/+TBuaid/vlRIpLSmomgmckYp1ycaz1Ob+fet2WzuUqkFXa54FCWp0wPa0NCALVu2sPVGoxGzZs06Jef+29/+hoULFzKvTH19Pes4yhc1/9DSd7JGT58+HStXrmQPrM/nY5WWtR5OrYdVeQ7+oyyt7nK5MG3aNDbPlbJ6HX0PBAKoqqpCZWUltm7dKgt/VGI0GjF79mzk5ubC4/GwsBT+5ah2X/hroEGO1vXRflokW6fVDv7+WSyWLpWveC5A+TlA22+9bds23HvvvWx9Z+aMKGlqakJGRoYsJFAt+iEZS5YswYIFC5jVlh80diYk8IhevXphyZIlCfehtjQ3N2P9+vX47W9/i08//VRze7vdjtWrV2P48OEp9Tu1NjY2NrJCTmcKt9t9xttwLmG1WpmxlGQybygyGAyYMGECvF4vrFYr87oC8ucrWZERWmc0GhEKhVBYWMhkKfWNxsZG2TZq+/PfKeRx1qxZWL58OZPJR44cQWlpKRsU8/sojaxKI65au2mQV1VVhZqaGrbO7XbjggsuYOHb/DuPPOGSJMHr9aK6uhqVlZX48ssvZbMKKDEajZg3bx6ys7ORmZnJZDIVjVRrn7LGBRWLSqQEJHvPaY1hEnmd+G1MJpMoIHWaUUZRRCIRWTSTTqdDRkYGU1zUqmZrjeVof4L2jUajsFqtcLvdaGpqkh0rmQLFQ8ez2+2yNvPTB/FjPi0FNtFzzV9zJBKRvWMMBgMbQ6opidT36J1CFaaTKa52u50ZvsiopeYVp/OotZlfn0yxT2agSPVYynf7yaSSdTZdzmOrnGqHH5g6nU489dRTp+zcl19+uSzvo7q6mg1oldZgglc0SXj069dPJkiqq6vh9XpZiI7aMdTQ2o5CJBobG2VhyGazmU3JoJzXKxaLoaWlBTt27MBzzz2Hv//971i5cmVCpRZoe/EtXboUzz33HNasWQOv1wu32x1ndSKUD3gkEkF1dXXcwKAjXlgtgsGgquda2S6R03N6ycjIYJ7TSCQiC+nJzs4+rd6/lStX4siRI+3eb/bs2bJnady4cbKphTqL+++/Hz/4wQ/Yd7vdjsGDByfcZ9u2bSgvL0d6ejpmzZqVUKkF2gxso0aNgsFgwOLFi9vdB/fs2aM6dZPg7MZms8kqZDY1NbF1JpMJU6ZMQVpammwAF41G40JgeW+d0rtDUH0NknF9+vSR9b8TJ07A7/fLPCNq8F5USZIwaNAg2XHeeecd7Ny5kxk9SV4mGzjSd1pG57dYLAgGg9i0aZMsDNlsNqOgoIApkiT/aeBcWVmJDRs2YPHixXjhhRdYfY9ERCIRLFmyBE8++SQ+/vhjNDc3Iz09nVWbVg6G6X4SLS0t+OSTT5hnOZnHOhlq0WFqtUWUFXVNJlOHigUKOg49e2TcUIa4Z2dnx01VxffZ9p6Hf29QhXQiEAiw46pVOefhnxvlOI68woC8DkZ7jDL8uWm6TLX6NcqKzgRVGXc4HKitrUVtbS1aWlpS8sb6fD7U1taitbU1oQEt0bXQe47fTxm5oXatqRxbC9qf90Z3FbqcYmu1WpnVhJQxft0111xzys6t/KG//vprnDhxgimktE0iIRCLxZCZmRm3TUtLC3w+X5xym8oDzJ+ThG9tbS2zXgNtSsTEiRORlpYWF4ZkMBjQ0NCAZ599Fm+//XaH8wTXr1+P559/HuvWrWMdSfkiUhts0IsrlWtNxdqktM4pcyCmTp3KfgO6X1SJU3D6cLvdzCJfV1eHnTt3ytZ3ttczEQ8++CC++OKLdu+n1sbt27ejqqqqM5oFoG3e3QceeIB9Hzp0KJ555pmE98fj8WDYsGGsWmx7+d///V+YTCa88847cZ6vrsRbb72F8ePHn+lmnNPQQJJkMm+QMhgM6N27NwKBgMyzo8y500K5jdJbUVJSIpMnW7ZsYUWrlAWflPBhgDk5OXHbbN26lc2FzYdFJhvM8YZs+j8SieC9997D2rVr2baZmZmYOnUq0tPTZXKfPpWVlXjmmWdOSiavWbMGTz31FFatWsXGTbws1jIASFLbHMKpGHu1ojuU94pXYpRzgF944YXIysqSHUcotqcf/rml3HZ+HYWTqilIqY7ftDz5NNUT4ff7ZYqtcj8thUxNgQqHw7DZbGw+V76Pahm/qK284h6JRFjUCT+uNBgMsNvtsqnK+DaaTCbs378fx48f77CCFwqFUFdXh1gsBrvdztqtHPOq/Q5U/6Aj791EhgT6n4fmMubb19Xocoot/yBWVVXJrJ+0/nRCVqVEeSgEbw373ve+J4s5b25uRktLi6xjtFe5pbCqhoaGOEHocDhYkj4/AT1Nr/Lyyy8nHMCSR9NqtcJqtSYMK1i9ejX+/Oc/M8u98p6UlJRg+PDhsmVer7fdFuBUlkuSxAp9EdnZ2bLCGInCUgSnFnoGV69eLQtDPhPt6CjV1dXIzc1l33/+859j6dKlcdOGdIQdO3bIqr0CbQW1Ro0aFbetJEk4fPgwXC4XmpqaNHNqbr31Vhw7dgxVVVU4evQoXnzxRdVjxWIxXHbZZXC73ZoK8mWXXYYHH3ywYxfXAdLS0mRhZsXFxWLwe4ahwlGSJOHEiRPYsGEDW6fX65m3kK/DoDUo1QppVOuffr9ftbgQRegop/7R8sKQLLjzzjtlMvmrr77C5s2bUVdXJytmROGAau1UGnAp5HrTpk04ePCg7NxOpxP9+vWD0WhkszfQ4Hnfvn146aWXEsrk8vJyzJkzB3PnzsUll1yi+k6gNq5atQqPPvooC/Xk74kkSaioqMDYsWPZPpFIBEeOHGHXyodAphp+qLacPLGPPvqoTGnKzc2NC30mo7vg9MGPh5RRVABkv5Hab51obKbs2/y2Ws+5lnKk9ZzRcZUF4SKRCBobG1lIPj17qXhveeMUyRqlckpjez7smd4tVOA2Ub+hdwV9Eo2vm5ubUVlZqakg8+8dHmXqYXvHu2rKrRq8POD360oKbtcJiv7/8C87tdzMU62cfPjhh5g1axbzyNDglV78ynAl+s63KxQKISsrCxdeeCHef/99poQ2NDQgFArB7XYz6xJZzugcakKUCAQCqKyshN/vl21XXFyM6dOnw2azIRQKyawpBw4cwNKlS+NCg6igBZ8ry1u4aTBAwo4viEHtfe2113DZZZchNzdX9nBbrVbZHKCRSASHDh3CoEGD4q5L6yWqvKdqy2mQoHxGlAW86N52pRyAcwXeg6NVUORUsW/fPgwaNEhW6KYj2Gw2rF27FtOnT8ehQ4cQiUTw/e9/HwcOHMCdd94ZN8VQqlx66aX4+OOPZYOLiy++GC+88IKqh2Xfvn0YNWpU3HyDv/nNb3DFFVcgMzMTQFtkCxXXkyQJV111FZs3uKmpCRUVFWzfcDiMcDiMIUOGYM2aNayPEtnZ2bJKyEePHkVFRUWnVaVXoiy8IwxSZx4KZeVDSXko31VZjZ/g39mJ3unKv3TsWbNm4d1332X9hGQyeSkSQccLBALIycnBRRddhOXLl6O1tRWSJGH9+vVobGzEuHHjUFZWxuQhtYH3hPBtj0ajMJlMaGlpwWuvvYaDBw/KZGxJSQnOP/98FqJsNpvZuObgwYN4/fXX42TywIEDMXDgQPTo0YNFrlG+Ho2FZsyYgYaGBhw+fBjLly9n+9J9ePHFF3H11VejoKBAdj+tVivzmAJt4Y/Lly/HgAED0NraKgux7Gh/o3O1trbGvetdLhdbT8+RwWAQMvk0Q+9TrVxs8nh2FF655SMgqP9kZ2ejurpaNubl91O2U834RQaonJwc1NbWxqVAkOKlzGnXei/Rca1WK7xeb1y/NJlMcDgcsqhM2icQCKC5uTmu/eQokiQpLoefPOaUdqlWcA5oU3DdbjczPNHvxheqI+j9GwgE4t61qTrO1O4LbyTgr03t9+lKdDmPLf3wwJmxAJSWlqpWglM+LIms0vSD9+vXD+PGjWPhmPTSr6ysRFVVFXsIaeJ7/kGVpLZqdZFIhJUcP378uKpSO27cOOTm5iIUCrG26/V6HDp0CMuWLYuzllksFlgsFiZoqfPxlSzphWQ0GmE2m1UnVA+FQli6dCmOHTvGHn6yJilDnCgnmH9xdlSA8gOf7du3y9ZNmzZNJsD57U+3t1/Qxpl6+SmroZ4MZWVlePjhh1FWVgagbWC4ePFijB49Gj/60Y/afTwyejU3N7N+f+mll+K3v/2tzCgEtN2/xsZGTJ48WZZ+ALQZ4u6++25UVFQgMzMTmZmZcDgcsjBEi8WCzMxMZGRkoKysDAcOHMB7770nuzdNTU2YOXOmLJQSiE8tiMVicW3oDCRJQllZmWwQ8Oabb6JPnz6dfi5B+0hmXGiP540PD9QagPGKpSRJskElv52yXfwzz//lI6mGDh2KSZMmsSIwkUgEu3btwquvvoo333wTDQ0NsNvtLHyYogeUObiSJOHQoUN48cUXsW/fPlaxGGh7V5x33nnIy8tj8/RSe/fu3Yv//Oc/cTL5kksuwaWXXop+/foxJZNmKqCKyFTVPC8vD+PGjcMdd9yBCy64QHacYDCIJUuW4ODBg2wKJTLqKr08Pp8PW7Zsgd1uT2p0VP7+amGP4XAYLpcLjz76qOydP2vWLOTk5KR0XMGpJ5FHlu8zyeC3SxTKSuvJm6/sy2rjA7Xl/JibDCRkACIikQhaW1tZ2h8VcVKLFKGxN4X9UkQlj9FohNVqlaXe0buE6g0o20nbUw4z9T9SyHnjQiAQQCgUUk0JkCQJTU1N7H3Jn1/5vqVrVfvdkv2WauvJ8KB8L9A0e1rPTlehy5nLkoUWnWrU5mAllEot/79ymSS1JbmPHDkS0WgUmzZtYpadaDSKlpYWBAIBVrrf4XAwgUYPvU7XVi6dqjMrO11paSlGjx6N0tJSpoTyHtbly5fHhZpQODMpwMpQDbWXUSwWY9Ynm80mO6bP58Px48eRkZHBwjgMBgMKCwsxevRobNy4kZ3n6NGjsNlsTMC29/dV3l9eKSB69uzJjs2/BLuqZelspyvPddYeDAYDZs+ejXA4jN/+9rfYtWsXvF4vvF4v/va3v2HFihUYNGgQnnnmGTgcDtVjVFZW4vLLL4fX68WePXtkocwLFizAj370I/Tt2zdOaASDQUyaNAnHjx+XLV+xYgXGjx+f8pyu1B9KS0uRm5uLzZs3Y8yYMawdJ06cwPbt29G/f3+kp6ez/aZPn46nnnoKt912G4A2JZjv252FMhy6f//+XWoKgXOVZPmnWqk6WjIy0UCLzsErvsp3iNlsjvPsaslhJXa7HaNHj0Y0GsXGjRvR1NSESCSCSCSC7du34/Dhw8jKysLo0aNRUFCArKwsJpPJO3PixAmsWbMGPp8PTU1NMmNMeXk5JkyYgB49erBBKMlkn8+Hd955J25O7e985zsoLS2F1WqVXT9FTfG/A/BtBfWsrCw27c+7777L7lNrayuOHTuGrKwsFgJtNBpRWFiIcePG4bPPPgPQNmhduXIlCgsLkZOTg5aWlrhzqv0+at+j0SjS0tKwdevWOMNX37592e/Y3jntBaeGZL+BMnow0f5qnjt6jnlvrZqnOBKJyCIM+f0TtQ1o85Y6nU4YjUZZoSbeKWQwGFjxO+Vcznq9HoFAAMFgMK6QFvBtDjg5Y5Te37q6urh2KhV3rToAtB9dOxnAlJFtkiQxb6xOp2POJ5qGk69BREWvlPdPawym3JZ/X9GYX2mA48ca/G/MH68r0CUVW/p7JiwAyuRvelCVihKP8qGlDkwPx7Bhw+B0OrFhwwYW4kydLxwOIxQKobGxkYU98YOIaDSqWmGwT58+GDlyJAoKCmS5TUBbh1+yZImseiVdi8PhYHm+vBWL/6t2PdSpSCnlldtt27YxbxAp1zabDX369EFjYyP27NkDoM3De+DAAfTp04dVbk4mRJUDF7qvwWAQhw8flm0/efJkZGVlaXawrtTxzhWSTSnRnXA6nZgzZw4KCgrw61//Gp988gmAthSDhoYGHDhwAIcOHdL0XgWDQXz++edxoV533HEHbr/9dpSXl8d5VZqamnDxxRdjx44dsuXLli3DpEmTWD59e9DpdLDZbBgyZAhWrFiBOXPmsIJAjzzyCHr06CHzBKWnp+OCCy7A9773PTzzzDPMUDdt2jSsWrWq3edXEolEMGPGDNmy119/HcXFxaLPdgH497Aa/KAvkVKpRE2W8uuAtveH1+uVDc6oj/DhwWqKrvIaotEofD4frFYrRo4cCYfDgc8++0yWdlRTU4OGhgbU1NTIph6k64xEIggEAqivr49re//+/TF27FgUFxcz2cbL5H/84x9xMvmqq65i8pCuUVk1OpHnymAwYNiwYQCADz74gI0VvvzyS2RkZPy/9s47uq7qyv/f15t6syxLliW5944LzQZjiMEJEBgSkphUQhokLDIhkzJhZlKGH/xWSICEIaEMITRDHINNc8MFXLCNce+yZPWu1+vvD/324dzz7r3vPlnVnM9aWnrvlnPLu+fus8vZG1VVVewd4fF4MHXqVHR0dLCM0O3t7Xj55Zdx8803o7CwkJUmFGvVq8EPzt1uN44ePYo1a9Yotlm+fDmbIsEbSPhrkQwcqWRxb50NWvuJY0ox+RJNe9N6LtSUJt5rGYvF4Ha7YbVakxwdiUSClTPSal/M3E64XC6FQixGa3i93iRvZkZGhiIzOW1rxGNKY3+6Jv5cg8Eg8/jyhi9S2vmxOHnFKTs0r6ymOgdecXY4HKpKrZjQKpWhcrAYOr7j/w//AGVnZ6O0tHRAj/+zn/1MUWKItw6rWaXVvtP5k3DweDyYMmUKrrrqKlRUVCQdk4Slz+dTFGQPBoOqSu306dOZACWhRRa2eDzOLLY85Ckl67OW0KTzF4UrdTrqLPzgvbu7G7W1tfD5fAoLVWZmJsaNG6do2+/348yZM0meZLVjiso3/fl8PlRXVyvmJUyaNAmzZs1KCqXRUtYlAwO9WMeNG4eVK1cO6LFXrVqFlpaWPm0zJycHixcvxu9+9zvccMMNinXd3d3Ytm0btmzZovr3wQcfJCm1P/rRj3D33Xdj4sSJqp7XaDSKrVu3Kpa98MILbP7ehXLZZZfhV7/6FXJycgD0zEveunWrojSSyWRCSUkJbrrpJrYsHo9j06ZN+PznP39BhotAIIBbb70VW7ZsYcvuvfdeXHPNNTJp1BCC3r3Z2dkoLy9XLA+FQgpFTssArDawVDOiisv379+fVE+S2tN6p6s9kzRwA3rGFnPmzMG1116rmEMO9PS5lpYW1NTU4NSpUzh9+jROnz6N6upqnD9/XtVTQyHOlZWVisglPrpILDd26623Yvz48Yrr0CqFJMpiUtRpTDJhwgRMmzaNKf1dXV04f/48vF6vIjQ7Ozs7Kbz//PnzWLt2LTo7OxXzAlOND4BPxkf79u3D+vXrFeUDp0yZgvnz5yu87/y10G8iGTj4e095VnjomTISWcGj5Qyhz/ScikYqWscrTKkiPOg77UdzaTMyMlRDeskgRdPt6DtfGognIyMDbreb9QM1T6uo1JK3ld5NdN7isy/eHz6smd4XbrdbYeCmkGXeI01/WmMG8R2slx2af/dQpIiYu4Zq7Yrt8tc4lPrykPPY8oqMy+VCQUEBamtrAXwSztqfyu62bdsUIYI2m02h0OpZhXnEh9rpdKKqqgoulwu1tbU4c+YM82QaoaqqCiNGjEBmZiYqKiqQl5enmmwqHA4zTxJ/DTabTTUJhnjORix6JlPP3IRgMMi2P3PmDIqKipCRkcE8yFarFSNHjsScOXPw4YcfsjY6OjoQi8XQ3t6OwsJChSWIjiFag6imWFNTE0KhUFICnUsuuQSZmZm61ycZPMrKynDZZZfhn//854Adc+3atUkGlL7A4XBgwYIF+MlPfoLrrrsO77//Pv73f//X8P6rVq3CzJkz4XA4cM011yiSOfG0trYmzd997LHH8PnPf75Ps4nefvvtePjhh1kI4erVqzF79myUlZWxbZxOJ2bPno3//M//VGS3Xr16Ne666y6YTCY8/PDDhpXRxsZG/Pu//zvC4TBee+01xbqvf/3rLIRSMviIMrmoqIiFjScSPaXncnJyWCicniVfz1snyle73Y5AIIDm5mbFAJRPZJXqGHzbNGijQR5FFXk8HtTW1uLUqVNJkRF6jBs3DiNGjEBOTg7GjRuH/Px8RUIrOrdQKIQNGzYo9l24cCFmzpyJSCTClAk9ZU/0GPHbUnmQOXPm4Pjx48wYfvLkSRQWFiI7OxsOhwOJRE8IY2lpqSIkGeiR3+vXr4fb7caSJUuYTOZlsTg3OhKJoLa2Fnv27MH58+eTjOmXXnopMjMzk4zzRsYZkv6H+gMZjRKJnrBXqklt5P0r9kHxOeWV03g8nuQF5OeP0v5iO3qOI/44FJ5L89HVnEJaUN4Zakft/UXHVZveR/1eq3qK2jOvpkeYTD3Zme12u0K5pFBltTE/JagTz1PrWPzvw68nbzFvACRcLpfm/VRrb7AZUoptbm4uXC4Xu0H0oBI+nw+/+93v8Ic//KFfju/1ehU/zujRo3uVgEZN6CYSPVkAy8vLMWrUKIwZMwZjxoxBKBRCIBBgSSJIcJAySh2usrKSKYFizSrgk04eDAZx9OhRxflQaBF/LlodV88CzodB0ACBOkBnZyeam5sxevRoZGZmsrZcLhdmzpyJcDiMjz/+mLVH8xNjsRgcDgdycnJYm7y3lSb/U5hJW1tb0rlddtllKC4uTnrRAcqO7Ha7UVxcjIaGhlQ/oeQCmT59OkpLS9nvIHp6fD5fkpLUn9xyyy1s/nVfsWjRIixatAgLFy5kbZN1lQww0WgUmZmZyMrKYgXqP/vZz2LixIkpPa7d3d1JpXq+/e1v97nCV1hYiO9973t46KGH0NTUhCNHjuDw4cO46qqrkJWVxbYrKCjAd7/7XXR3d+N3v/sdW/7nP/8ZQE/mU4fDgW9/+9soLi5Oem9GIhEcPnwYq1evRltbG/70pz8lncsvf/lLVFVVpVTcS0pKcPnllycZ8SR9CyUjo3e/zWZDdnY2Wx+JRLBnzx5UVFQo5BJg3BsnykkywrpcLpw7d04huyoqKpCTk6OQsaJnk5cfvHeH/w98EgZZUVGBsrIyjB49GqWlpWxgTDKZsNvtLJmM3W7HhAkTUFxcrJiHx3tyaJDo9/tx+PBhxTVffvnlbFsa9Kt5vcRrFJVbfgwwcuRIjBs3DocPH0YoFEJbWxsaGhpQWVnJPErkEZozZw4CgYCinCIp9aT0V1ZWIisrS2FkokSWbW1tqKmpQWNjY1J9cqBnXv7IkSMVYZVqHj2Px4OSkpKk/AGSvkctGkLsex0dHSy0l4/u4+GfSa3nlbaj/maxWBSOEOCT/sQbT9TaEc+f2uDr1fLKLWXbJs8lH4HAh9jz41g+sRNtK2aB5w1VPLxSq6XEqim1Yrt0LJobTKWE+HXi7xePx5nXVku55UOS+ePxx6Vt1DzYpFCr7ce/j/jw8MFmSCm2vEWQ5nNS9kKgR2n761//igcffNBwwpR0eOyxxxQPx4QJE5Cbm9srC6OW1TUej8Nms6G8vBxlZWVMsfX5fGwgTCEG9EelAvhMa2rnE4/HVefV8h3E6HnrXS89xDQAoW3r6+vR0tKCrKwsRVhGRkYG5s+fj0QikZTFmBRVv9/POhCf2pzCtPlJ8kR5eTny8vKwePFidl6pvOiybt7AwGfdBno8fhTuCvT83r/5zW/6TbH905/+pOjLX/7yl1kSk75m5syZmDlzJoCePuj3+1lZrkgkguzsbOTm5rJ3iRFIGBMmkwnf/va3++P0AQDf//738dxzz7FQwk2bNmHevHlJWVdzcnLw85//HB0dHUyhJf77v/8bQI+A5Y0aRCQSwf79+/Hss88qlptMJtx8880YMWIEfv7znxvqo1arVYYqDwDkHSUZaLVaFcaOWCyGI0eOoLm5GSNGjEAwGEyZeEbNa8snWSKDqcViwY4dOxTK4tSpU1kNSz0PpzjA5I/DD8iAT5IaVVZWory8HKFQCMFgEN3d3fD7/ey83G43HA4HnE4ny/xPnhW1snMkw0SZPH78eBQXF6OtrS0pP4baoF7tfonKPCnps2bNwtmzZ9m7r66uDs3NzcjJyVHIZI/Hg8WLF8NsNmPv3r2K86M6xefPn0deXh4yMjLYmCwajcLr9aK5uZlF0vFUVVUhLy8PS5YsUQ31FJV3tQyvkv6FV9rE5VRiJi8vD6FQiPXFVAYkQm0ZKY5iCD/NYdV7V2gpt/wx+GX0vNGcVFLmxPnrBO9tTVWtQ88TqnU+avtpvbtoOZUqov+81xZIzj5MhijRsMYfX3znqZ2juC9VRKESaGpRlVr3ZbAZUopta2srfD4fe/nRnJCioiI24IpGo3jhhRdwxx139OmxW1pa8Itf/IIJhOzsbBQXF7NYd62wAT3U1lNHjkQiTNCQR4fmC9B2vCJLHU8vnCGRSKC1tVWxngZ/qV4ghOjNVTser6DzZQ6ojNGYMWOSXnwZGRm44oormGAUhaIo/PUwmUwYM2YMFi5ciNLSUkWnEy1//Ge1uceS/mH37t1JWW4LCwtx5ZVXYvPmzQB6BsUvv/wybrnllj4//j333MP68owZM1BaWqo6/6avobk+F+odpqLvfLv9FakCfDLIIDZs2IBFixYlKbZAz6D4kUceQVtbG4LBINauXatYTwquEaxWKz7/+c/jgQcewNixYw0r/ufOncNbb71l+DiS3tHU1MRyJwA9im5WVpYi8iUej+PDDz/E9ddfnzToMiIj1TwBdrsd58+fx65du9iAMzc3FyNHjmQDLbWoHPG4tJ3oEeUVSF6mAWDl7cgzTQN7GgSTwkbTY8TjUrvkAeLn+ZtMJixZsgQAkhLF8Z4rrUG01nKTqScxz8iRIxXvufr6etTX17N5xHwbWVlZuPrqqxEOh+H1enH27FlFuydOnEg6lhYmkwkVFRW44oorUFZWpvCW8econoPX602aeyzpH3iPJR9VYbPZFJ7B9vZ2ZGdna2b05dsjxO34yA2r1Qq/34+Ojg62D0Uk8s+CmgdYDTUlW+07vx0/fYHOj59zC6gnNxPvneiNpDE6Xw5IS+FTc7yoeW3JmCDuHw6HYTKZWPZ0sS2Xy4VgMKh6nuL5pNIFKHEe1SYXz1FNsdU67mAwpBRbHrqJWVlZmDlzJt5++20APT/u17/+dYwePRpLliwxPBBKxQsvvKD4USZNmoTi4mL2wKplAzNy/tTZRQsxdahQKISWlhaEw2HEYjE4nU4mvPnOIrbLQ21Ho9EkxY1SiRvJTtubeynuQ1YjtWs2mUxYsWIFGhoasHXrVgSDQTQ3NxtSuC0WC5vU73K5sGzZMlZrkND7XYaiVenTxtSpU/GrX/0KV1xxBYAez95tt92G/Pz8Pu3LGzduVHgK7rnnHtWkbX1JJBJBY2Mjjh07xpaZzWbMmTMHmZmZaV9bR0cHXn/9dcWy/vZsTJo0CadOnVKNjhCx2+148cUX0d7ejltuuQXhcBjvv/++IcFG+QZGjBgBl8uFv//9731x+pJ+hA9ly87Oxrx585hBIx6P4/3338fYsWMxYcIE5umh/UQjKT8IVlNsqe9u2LBB0Y+nTZvG6qGKHgQ11OQBhQySB5IguUVVCjo7O9ng3Gw2o7i4mHmBxLI1Wp4ak6lnvpyYvb+kpITVsNdTZMW21AbB4rW53W5kZ2ejtbWVGcnpukTIG3TTTTehoaEBb7/9NkKhEBoaGgzLZApVdrlcuPbaa5Gfn6/wPGkZmiWDB6+UWCwWeDweRYmm7u5udHR0IDs7myVmUmuD/ou/qVpURF1dneI75WLhQ2DVng2tZXy/UYvK4CMBqPRPIvFJwjVap5b1WA/RkMXPSzU6vubPV+3+qekMeuvoHtDUzWg0ikAgwK7XKBQVajKZWIQHP/+f14GGOkNWsSVsNhsKCgqQnZ3NvHrxeBxXXXUVPvzwQ8yaNeuCXpaJRAL79u3DD37wA/aDZWZmYuLEiSyLsJYVOpXSKXpJY7EYfD4f2tra0Nrayual8gkrTCYTFi1ahMzMTGRmZiInJwe5ubksHJm3MosvD6/Xq5jHCnwyt4FCnnqDWkei5RTGwSvXNPldTagFAgEUFhbi5ptvRnNzMzZu3Mi813yYNW1PlraMjAxMmjQJo0ePRk5ODrOc033WQrxHksHDarWioKAAkydPZnPO+qMvX3311ew3Hz9+PBYtWqQIg+4rzp8/z0qFdHV14e2338ZvfvMbtt5iseCZZ57BpEmT2LLp06cb6ot1dXX49a9/3efnrMf999+PEydOKBK96WEymZCXl4cNGzagvb0dN9xwA6vRGQ6HWTQHhaJRIr6SkhL84Ac/UPUGS4Y+JJPz8vLYVJJEIoFnn30W3/3udzFixAiFR0htAKem5FIJOKopy9dJzsrKwqRJkxRz/2h/LYOmmneE3488Iz6fD52dnWhvb0drayvq6uqwb98+RTtLly5FQUEBcnJyYLPZUFRUBLPZzOScWn6HRKIntJNvi66lra0NLpdLEf6ndw16g2Hxvk6ePJmVLQLAMsKSp5ug8UR3dzfy8vJw++23o7m5GevWrVPIZH5wTEoByeRp06ahvLwcubm5cDgcTIkQyx2J1yR6fSQDi1qEA7+spqYGVqsVHo8HoVCI9VFSBEVFlDd88V7ZWCyGjo4OhbHUYrEokrLySqraWFPNIML3CzI+8ZVByGkUDoeT6kZTciyax0qGLj6bMH8d/HMqGoh4Q1mqZ1n0cGt5UHlFW61dOh+1pFuknNI0QcobpHVu/H409REAM7yJDjEtPWCoMeQUW9ECk0gkWB3F119/XZHMYc6cOTh27BjGjh2bdoKnRKInA1xtbS3mzJmjWHfZZZdh9OjRiuQOhF54hNZnesCqq6uxa9eupJAf8by2b9+uWLZ8+XJUVFQgPz9fdwK42sNLAwHaRu0Fodch9R5atfZIOeUTS/Hb0PkkEgkUFRXhC1/4Aqsv6PV64fP5WKd1OBzweDzweDwsNIJq2GoV9tY7VylEB5/Jkydj3bp1WLx4sSK64EL6MtDz+54+fTqpLz/33HN97q1taGhgc4SffPJJze1isRi+9KUvKZbt3bsX2dnZGDVqVJ+U6+lLSkpKep27IDc3F9u2bWPf6+vrUVtbi2g0CofDgYKCAowYMWLIXbPEGOK7s7CwEDfeeCNeeOEF+Hw+tvzRRx/Fj370I2RkZCCRSCgGsEByJBPftslkQlZWFjZu3JiUKfvqq69mIa6iUqTmzVQ7d9FD7PP5cObMGWzbtg0nT57UvXYxq/Ett9yCsrIy5kHWQi0Zi9PpVHh5UslYwujgmRJMEhQ6zc+XpG3pNyIFNj8/H3fccQfi8TgCgQC6urrQ1dXFPEJOp1MROUWKPc1JppweIkNx8PtphX/m6Pmkeqj883XmzBmMHTs2yaHCK7FqkEJkMpnQ1NSkKJ8JgIU5i/1SPDf+fPm26T9ty+dl8fl8iveRGmJEUmZmJktay3twxXNQu2a9c9Valqq/8wo/5ccR75VWXVo6dzISUo4i3vnEt8WXGUokPplna7fbFbW1xXNUe98OpT4+JBVbgm6q2WzGiBEjcOWVV+Kdd95RWDknTJiAs2fPoqioCE6nM+XNJfd8a2srPv74Yyxbtkyx3ul0Yty4cezBMOqd1bIqxeNxVFdXY/369aivr0/jTnwCzSW76qqrMH36dGRlZaU8HyISiTDrjVqqcC1SCVzaRmsZPfxqVnrquPzv6PF42AuPt4CRwCUPEB8uoXee4u+RbliGpP8oLS3Fxo0bMW/ePHR1dbHl1JfLysoMK7dUNiocDifNa83Ly2Nh/X1BPB5HV1cXvvSlLyUNdI0ye/ZsAMDmzZtxySWXsIRpQwG+X10oI0eOxMiRI/ukLcngwntf+fd6fn4+brjhBqxevVrhyXj44YfZdCHeE0LwbZhMJqYMtbW1Ye3atfjggw8Ux3e5XBg3bhwSiYSiliJPqoE2P5YAekrhrFmzptc5F15++WUAwPXXX49p06YhJydH16vKEw6HVSOaCC1PDY/a4FJN5orb8h4mfh2fsJHulcPhQHFxMUpKSpJkLpVuCQaDzPOlF4nCH4M/F7VkN5L+g/8NSamhZ8bj8SQpfSdPnkRZWRncbjf7/chAwjsuxOfY7/ejpaUlSck0mXrK0/DvBLHfGHFA8Mnm3G43WlpaEAwGe3VPqEJHQUEBXC4Xy/MDQGEI0joPPlyb739a12FkbA3oG7JEBZ9fRudFDiTqn3z9b6Cn//HlxvjnQSzdpndeosFwKDDkFFtA28U9ceJEBINBbNmyRWFJGDNmDH7/+9/jtttuY+WBaI4qEYvF2I94/PhxzJ07N+m4VqsV3/nOd5Cbm6tq4RDPSfwsWsHC4TD279+PLVu2KAbwgHpxbBGxXtaGDRvQ2tqKBQsWoKCgQHF9Wh1ATEOude5aVqVUnVP8jciLqmbpEY/DD0bo9+EHIHw6djHRgNb5aC0jYSwZfCwWCyoqKrB27VosX75cIZDGjBnDaiITVBaAiEajbK5LXV0dxo0bl3QMl8uFkydPIjc3t0/OORaLobGxEZ/5zGfw0UcfJV1Pun35yiuvxBNPPIGbbrqpVyXF+gOv1ysHmhJN1N73FRUVWLZsGd566y2F4fAvf/kL5syZgzlz5mD06NFMHvODJTI2dnZ24vDhw/jHP/6RdEybzYZ//dd/RXZ2dlLJDrXzU4Pf1ufz4eTJk3j99ddVS8fxSp+I2nFff/11dHd3Y/78+WyKDD9AVztP0cicagCrNg5Ruz5SSnkPD10TL5O1PGBq4Zwkk2k9KbAmkykpo3M68MeQDDyicYmUmoyMjCTltqamBhkZGcjNzUVGRgYbj5GnnzdaBINBBAIBzfJN2dnZLHM6oFSKUhlyaHvC4XDA6/Wirq5ONfs2jY+1DD3is9fS0gKXy8WiTchYZ8TBw5+7EcVcD/EdKa7j+yzvXaZ9+AzQoiFJPF/R6K92H0VSKdtDgSGn2IodhScUCmH69Olwu91Yt26d4gbffffduPvuu9n3//iP/8Att9wCl8uFzs5OvPbaa/jlL3+pekw6zve+9z3k5+crrM9aVlDRQiWmFTeZTNixYwe2b9+uGLjTS2TVqlX4y1/+onsvKPSW74D79++H1+vFokWLMGbMGEXohNrgWE2IiqTqiHqhFHxWZOCTGH9RqRQt0nyCAdqf5uGJoRH8PGdRmdeyKonWcOmxHVrYbDZceuml2LNnD2bMmKH4bcTQ4WeeeQZf/OIX2fe1a9fipptuUm2X3httbW19VhIskUjg/fffx2233abw8FxoX/7Wt76FAwcO4Hvf+x7Gjx+v6oUaSGPMDTfckKS0GyFV3+Kza0qGHxT+K079II/b5MmT4XQ68dprrylkwYcffqiYrz137lxUVlbCbDYjEAjgzJkzOHDggOox6Vl54IEH4Ha72TnwHkU1Q63aMppPZ7FYsHPnTrz55puq4YojRozA5MmTkZOTw6K/aK5oJBLBkSNHcODAgSR5uGXLFjQ3N2Pp0qWoqKhQzEFUe+a9Xi9cLhfC4XCSzBbbVvsuyk1etpvNZmzbtk1RHYG8NVrGbdGjS/eZnxvPG6xJJtP+fGQbtafm1RHHIFrlSSQDg/h7kIHW5XKhublZsa3X61UovJmZmfB4PMxjSVPJ9MjPz2fhrbwyzZ8LfU6l5EYiEXZMtfHpuHHjcPXVVyM/Px9ZWVnMU0ylI48cOYJXXnkl6VhkgCYPNZ8xWc95lI4yq/fe4hPbUeJXrXuTyhjGG6tExOsWoziMymojHurBYEgqtoD6j08WokmTJiEzMxMvvPCCZjs///nP8fOf/9zQMb/4xS9i0qRJiEQiCAQCzBKp1cHEh1F8CKxWKzZv3oytW7cmZVF78MEHce+99xo6L9o3Pz9fYV0+efIke0FQGv9EIoGcnBxcc801LIM0AJbIQRQsWkKHR2t7+qzWYciiqxZ+Rtu3t7ezrK9anWHixImYPn06CgsL2WT/3gzyqX0pRAcHvZek2WzGlClTEIlEdD2Wq1atwqpVq1Iey2Qyob6+HoWFhX2qRH344Yf43Oc+l1RKqy/68h//+Ef4/X786Ec/wuTJk9l5T5gwAevWrcO1117Ltk1H4PQnYp/dv38/5s+fr9m/vv/97+O+++5DaWkpWzYUrkNiDDGMlx+EUc6ESZMmITc3V9fAs2fPHuzZs8fQMb/1rW+hvLycla8gwxCfXFBE75kym8344IMP8MYbbySFLFZWVmLq1KnIzs5m+RsoszMN1p1OJ6ZNm4YZM2bg5MmT2LVrl+J5P3z4MGKxGK688kpUVVUxJTAnJwfXX3+9IsN5XV0dxo4dqyuD0x3oA59UWxC3pVBvUSYDnxiKW1pa0N7enmSc4JkyZQrmzJmD4uJiuN1uNujWUmr1POi84VoycIjKC68kkdHCYrGgsLAwSbnlofBdI3g8HuTk5DBjCMl7tcziRs7fbDbD5/MlRUEBwIIFC3DVVVehuLgYoVAIoVAIfr8fiURPkjSTqSfkeuHChVi4cCFOnjyJJ598UlHzPhAIIBaLwePxsDmuNIb2eDwKoxj1Kx61iAjxs3hN4me6Tq33gpY3l99Or4Smy+Vixjv6S2d8LTqN+HMbCgw5xZbChdVq1QE9L+JQKIRRo0bhnnvuwenTp/HGG2+k7Y2zWCxYsGABxo8fj4KCAjQ3N8PtditSkKfzQ5HiZrfbsXPnTmzcuFHxwL/xxhu47rrr0jpHgurgzZw5k1m4z5w5wwYWFRUVCIVCsFqtKC4uVuxLL5ML8ZiodSB6CfLrysvL2eBVPFY4HEZTU1NSUhAtjh49iqNHjwLoSWqzfPlyFBUVqYZ9GLkuCtGSDBxerxeBQABut1t3O3qezp49i6lTpyZlMUyF2+3G6tWrsXz58gs5XU2WLl2qEOJ93Zf/+te/wuPx4N/+7d8wYsQIAD0D6fHjx7P9EokEdu7ciUsuuWRAlMJbb70V119/veq6RCKBs2fPoqqqylBbf/jDH1gN3mXLlmH16tUsqYVk6EPKnphVlzCbzQiHwygtLcWvfvUrnD59Gn/729/SVlosFguWLFmCqVOnIjMzE36/n9VX1qvLqBWFlEgk2ID0yJEjSXOBx4wZw4zkkUgEXV1dsFqtrAKByWSCy+ViRtFQKIRYLIZx48ZhwoQJOHXqFPbs2cPeV8eOHWP7U/JJm82GkpISxXmdPn2aTZ+gcYaRsYaetxbo+R2ampoU11hRUYGysjL2nT+e1+tFfX29YZl86NAhVsGhtLQUK1euZOMNrXmG4vmLoZGi4V/Sv5AnXg+qbEEJlXo7dzU3NxdOpxM2m439zhQFoRUBCSQ/J6LiR+MKngULFmDx4sUoLi5GPB5He3s7zGYznE4nXC4Xa5f6MhnMqqqq8OCDD+LDDz/EmjVrWNkjOl+3262o5SqW3PP5fL2uOKInx9VK+9nt9qTQYWrD7XYjkUhohoCLBAIBdg+tVivcbrdqVIcR6LcaSlP9hpxiS/VctRRL6hj0oE2ePBkVFRVobm5GbW0t9u7dqxsSkZGRgWXLlqG4uBj5+fnIyMhAIBBAVlYWE8RqgkbLCsMvM5vNqK2txZo1axSCeNu2bVi4cGGvB6S03549e7Bs2TJs2bIFAHDq1Ck4HA5kZmayEGoxYUsoFFJYxtQsLfxyPQ+1uEzcNisrCxkZGYp1kUgELS0tupbgVNTV1eGZZ55BdnY2br/9dmRkZBjqRKQwURiJFKIDS3d3N3w+X0rFFuj5rcaMGYP29nbEYjG8/vrr+PGPf6ybQXzs2LHYsGEDqzHZHwqfx+NRKNr91ZcfffRRAMAjjzzCtuOPEY/Hcdlll/XbM7x9+3bFe3PcuHFJIeGJRALV1dUYP358r/vyu+++i/z8fIwbN05R5kwydOFlslrGUPK+kNejqqoK999/PxobG3H69Gns3LlT17uTlZWFlStXorCwELm5uXC5XMxjSl7IdBKb8cqf2WxGfX09/vKXvygU7ZKSElRUVMDtdiMejyuSq4hGW34waTab4ff7EYvF4Ha7MXv2bBw4cIDl0Dh06BBsNhuuu+465ObmIhaLJcnkt99+GwsWLFDMy+9NOJ84TjGZTKipqVG8I7KyspCZmalQOiORCBoaGvDSSy/1uh/X1tbiT3/6E3Jzc/HVr36V1Tw1OjAmmcx7yiT9j6gsankLKblZLBaD0+lkn/1+v+7Yy2w2s1KVQI9jhRKM8SHIWtGOah5/koWRSAR2uz1pGsGiRYtw+eWXIy8vjz37LpcryQFDhi5KppRIJODz+WA2m1FZWYkbb7wRb7zxBpqamgD0vPfISwuoGwUSiZ6s4sFgkGUS5q/D6G+iFpJMyjdBUwLovcb33d4mwQN6DBldXV2wWCyKJHhaiL8P3Vup2OoQCATYw0kCR4S/8ZQpt7S0FKWlpZg7dy4LQQiHwyy0wul0wu12MwtMJBJBJBJBW1sbi2XnJ5vrPZR8WC2dJ53Tn/70J4VSu3fvXkyfPr1PksPYbDasW7cOt99+O0u0cfToUdhsNnz2s59lVtOrr74a7777LtuPPOB0jXohQkYxmUxJ6eFzcnJYiBLQo1SfOXMGmzdvvuCHnqxwzzzzDD772c+irKwsZQgr/xIPh8NJCbwk/UtjYyPa2tpQWFhoaHteoH7uc5/Dddddp/tMmkwmNhemr0kkEsjOzlYotf3Zl+PxOP70pz+hs7MTzzzzDACgqKgIL7zwAm677TYAPQJo//79mDFjRp9f8ze+8Q2cPn2afR8xYgTy8/PZ90AggPfeew8333zzBUU+0MD6yJEjqKqqwscff2zI8MHT3t6OmpqaXp+DJD0CgQBCoRBLqgIoZaSoYJH8pszYCxcuRDQaZTVOaf6Yw+GA3W5n/2k9lY0hOSuWCxIHvCL8QCsej+P//J//o1Bqy8rKcNlll8FutyMYDCoGimLYtVp99Xg8DovFguzsbGRlZbHnmeTLgQMHYLPZcNttt8Hv98Nut+O6667D+vXr2fl98MEHuO6669DS0gKHw6F7HaKXlq6d/icSPfOfOzs7sWPHDoWBKjc3F263mymQwWAQp06dwjvvvNMnMrm1tRVPPPEEbr31VpSXl6sa0rWUl1AopBsuKel7aCwoyg8tRZcfEzscjqS8FWpeVTJY0HPAh7mKx1GrhyueFynD8XgcDQ0NivWXXHIJVqxYwert0rWpheWbTCZFX+brvVosFkyePBk+nw+bN29mym0oFEIikWAGMLvdDrvdrjAeiXWbtcYsagqsuI7C82napYjYr0gp7QuowkROTk5aSjn9l4qtDidOnEgaVPGIlhASSvwkb7fbzTyH/EuWHna/3w+bzQan06mYN2Q0JIgQhYsYBgT0eHzUwgp6C4VLE/F4HN3d3Whra0NBQQFCoRAmTZqkUGxDoRDi8TgrCC8aC9SuWU+I0twjfpupU6eyxCCUCv748eN4//33VUPSKMRMzTJH38lAwdPd3Y1//OMfWLlyJcaMGaOr3PKWpZqaGkUiE0n/8/TTT6OqqgoTJkxIaz+TycSyLg4mopepv/tyJBJRhH25XC5cfvnlin2WLVuGurq6lFmY02Hy5Mk4ceIE688//vGPcf3117N+1dHRgX/+85+45557VJPunD9/PqUg/NOf/oQHHniAfadw5qlTp2LHjh1JUyj0+Oc//2k4f4Lkwjl69CiLcNILM6X/fFgqQcmbgE88vLQNlXLjM+6K002A1AZn2oYGtmazGS0tLUlRDlOmTEEoFILP52PzT/mBNz9AUwuJpIGxx+NBOBzGyJEjUVNTwwaYVLe+s7MTGRkZCIVCmDp1KlNsAWDTpk0YM2YMUwa1wry1rlE8H7vdjueff16hKM6YMQPjx4+HxWJhA/rjx49j8+bNqjJ55cqVGDVqFHJychQZkqPRKLxeL9ra2nDgwAEcPHhQsV9XVxdefPFF3HjjjZg4cSL8fr/me5I/93PnzmHXrl2GrlnSN5BhiRQxNXhlUjQSiYYl4BOlhryX1LbWeFqtf2tFEtJ6AMzozbNgwQJYLBaWG4f6r1Yb9J8vF8RXNZg8eTI+/vhjptjy10dtO51OxTslHA7D4XAkZR6n60rlSBLPiULB+WtwOByKUOF4PA6/369pZKayaGJeApq+SAZmUXmOx+Po6OhATk6O4px41H4rcewy2Ax+jQkBseyLHvxDQy9iUYkNh8PsBzSZTCzLH1lvaO4MWaXpuCR49dL/iwqZWOR927ZtGDNmTG9vhSa///3v8YUvfIF99/l8aGhoYBacvLw8XHHFFYp96B7QfAE965LeC4+UWvH3GTlyJBwOBwtZOXLkCHbt2pU0qPB4PMjKyoLVaoXD4YDD4WAvQ9GbbLfb4fF4kqyEXq8Xr7/+OpqamlQthnQN/IuDngPJwBEIBIbUy84oiUQiafA2UH25vr4eO3fuBNDzTOfl5eHpp59m61tbWzF16tSUGSiNMmPGDBw7dkwh4KZNm8bm5XV2dmL16tW477770N7ezrZxOBxsHjx55vT+7r77bhw9ehRPPPEEa4PmVV9xxRVpZZYMBoOGE5dILhwqr0VyQ23ASjKQFFiSnaTE0p/ae55XaPm2SJYAUOzLK8X8oJuXBeSNoTwNxLRp05CZmckGqOJgVGvcwV8PDRoDgQAzpFdWViIvL49t39HRgerqahYplZeXh6uuuoqtD4fD+Pvf/462tjZmcFYzGoj3mz9Huk6n04nHHnsM7e3tit+lpKSEJYhJJBI4dOgQtm3bppDJZrMZK1aswHe+8x1MmzYNLpcLwWCQGZXJSJGTk4OxY8di5cqVuPPOO7F48WLFeXZ3d2PNmjWoq6vTnavHL5cyeXCgcVwqIxH1K6NjcSrNSGi9K/h2RSMSf25iiKs4lrz22msxatQoFrUpGqW0lGpeb6AQaRojulwuLFq0SDENR1RSaR49j/h+5CNN1O6DqPSaTCaWjE3tnlG9e9JrgsFgUkUSAMyrzifhpXcnGSooMobaFa8lHo+js7NT8fuI7yCedB2CA8GQU2wBMI+fWsfTcuWL25BlgiZc82ERvBAmz63T6VQkjRCFpYi4PBqNYtu2bYpllZWVfepZIUpKSphFBegZ7B46dAihUAh2ux2hUAiXXHJJ0n78hHEAqqEOatCDG4lE4PP5kl50CxYsQGlpKbvWs2fPYu/evUkT/MVQNj7TsZrXlixpDoeDJQAgurq6sGbNmpTnLQ6QJJJUxONxRXkhYOD68r59+9h8WwAsjJHnxIkTWLJkCUtE1VsWLVqEgwcPKvrz73//e1x77bXMk/zWW2/hgQceUFiws7Ky8N5772HChAmYMGGCobClvLw8TJgwAbfccosic24ikcCJEyewaNGiC7oWSf9Cnh4e0ZPKG4L5Z4KXpaICSgNF+uP35wdS4iCX9xapDQZpfz5yCQCKi4uZ3OcHl3qDM3HcQF4eKnUSj8cxcuRIRT9uaWnBRx99hEQiwTzCCxcuVLTb1dWF5557DidPnmTtqhn1xfMjLypFnz355JMKIy8AXHrppRgzZgwLc6a5zvzUCrvdjltvvRVz5sxhCbQcDgebrkUGZxqg08A9NzcXl1xyCW644QbFeXZ2duKll15SZLwVo+vo2miALhkcxGdaRMt4JX4W+wU5i2hsx3tFeY8qv07st+I7gP4osRMxZcoUhaFJ69z5NnmFnhRFXiGORqMYN26cIoKITzZF41aHw5F0vyKRCEwmU9LcebV3I3//aJ3D4VCNpKDpVnRN4XBYdW660+lEJBJhij5/f3mvMP0WFLZN33lisRi6u7s1M60bkfmDyZBUbEOhEHtI1KxFWh1RbZloFaIfMR6Pw+fzoaWlBfX19WhsbER7ezu8Xi+rL2e321lnVHsR8Faf9vZ2RRjQyy+/jNzc3Au+F1p85zvfYZ6eaDSKzs5OdHR0sNh8t9uNz3zmM4p94vE4y+xI85zEl4c4cKD7F4lE2L48U6dOxYQJE+BwOBCPx3HixAns3r07KWSRXj5aFj3xRcQPXEymntBUUbFobm7Gq6++qnufyBI2HD2HFwNUsH04IXpsB7Ive73epFq5+fn5+Oc//6nYZ8+ePbjtttuwc+fOtBOwJBIJrFixAu+//77i3Xjvvffis5/9LJsG8vzzz+M//uM/cO7cObZNYWEhXn75ZcyfPz/t6wR65uHfdNNNCs9tItGT8fn666+Xg90hCuWsUAtNA/TDhNXkJ//HD7Li8TgCgQC6u7sRDAZZpBEpiC6XiylbvGcYSB7Q+v1+RZRBVVUVsrOzk+QQgCSFm/c0qyWMof8UFWaz2VBUVISsrCwAPRFSHR0dLClLPB6Hx+PB5z//eUVbDQ0NWLduHfbv34/Ozk5FKCfJab6yAfDJgLyurg6rV69GTU2N4rpnzpyJKVOmwOl0Ih6P4/Dhw9ixY4ciysHj8eALX/gCKioqFGWA6LiiV433WpGXeurUqbjxxhsV19PU1ITnnntO14NjsVhYHVLJ4KHVX40otHqoRRmQwsUbhUhp4ue9akVN0HYElZ3ip9aJHkVRoRWjMEXjGwCWk6eiokKR9E30LJvN5iRnC10nXx6IvyYtZxkZgWg+Lw+fCZmm+al5au12O+vHYmIpcXwvngetU1NuvV5vv+Qw6W+G3BxboGcwHAwGWap9IlWnohAAUXDSD0PCpqmpCUeOHGGx7Hz4MSm+VqsVU6ZMwahRo1ghajG8hldwxSQIy5cvTwqh7UumTp2KsWPHsu+RSATd3d2sM8bjcUyaNAnRaFRR15ZCLsgjSh2dHmox9EB88fBQrVmaLxsIBFBfX68YTPBKqdjh0rH68JYwPiTl9OnTaG5uRnFxsSKbNv03m82slplk4Glra0NLS4ui5ERfEQ6HcezYMTz00EMpt/3Xf/1XTJw4sVeWxoHuyyIWiwUrVqzAU089ha9+9ats+YYNG5BIJDBy5EjcdtttuPTSSxVeI554PI6Wlhb8+Mc/RiKRwLp16xTr77zzTnz1q1/FyJEjYTKZ0NHRgb179yoU/LKyMjz88MO45pprLuh6c3Jy8C//8i8IBAK4++672fJ169YhFAqxjJZqBAIB1Xm+kv6FZLLH42FGUSBZoRVlpNo2/LaxWAxdXV1obGzEgQMHmDeSvCNiOPOsWbNQVlbGylPwCpl4TDFcvbi4mBlgaRtxX9F4zQ+SgWT5SJ+j0SgyMjKQkZHB5tpSYpeioiKWC2LatGnw+/2K/ldXV4ft27fjyJEjGDt2LEpKSpCdnc3GHXQ/yFPT2tqKffv2wev1orq6WnGNVGuW9u3u7kZNTY0iuiMrKwvLli1DeXk5/H5/UiJMflyjpqDScrvdjilTpiAcDuONN95g60+cOIH6+nqUlpYmVbig3zQYDMp+PEjwzh6t/iOiJzdFr62eI4Fvh+al8t5e8Tj0PhENnuRMCQQCbH/RA5xqGiEfPcBfRyQSQWFhIQoKClBfX5+0Lynl5Kzhx5bkBKJ+RGH5aroJnS8ZpsVrpHEz7ctnbRfPh7bh+6/WfVd7Z/P78s8CTUUQFXvaT815OBQYkoptQ0MDGhoakJ+fr3jY9ToX/Ti0HS90wuEwGhsbcfToUfj9fnR0dBhKj93S0oLCwkJUVlaioqICmZmZ7MVMwp3+D7ZXiryxdN3xeE9G6RkzZqCzsxO7du1SrAPAzp2uQ62zaz20EydOxMyZM5Gdnc1ePtXV1UneJpvNxsKhjCgVet54fpI/r9xu27YNn//855OsVHTM8+fP48yZMymPLel73nvvPcydO1ehkF0ohw4dwtNPP41oNIqamhqsXr065T7BYBBlZWX4zGc+g0WLFiWFEg0lwuGwIoED0CO8Vq1ahebmZvzkJz9hfXLjxo0AgHPnzmHdunWsNIFIIpFAV1cXy7jM84Mf/ADf/OY3MW7cONa/Xn/9dWzYsIFtU1VVhZ/97GdJHqfekpWVha9//evo6upSJIK6//778eCDD2qGfW/atCnlFARJ31NfX4/6+noUFRUlKT8iqRRFGsw1NDTg8OHDCAQCaG9v1y3tRbS0tKCoqAiTJk1CRUUFS+imNngUFSe+BIgoj9SUcR5RBvIeTBqUi1FF0WgUPp9PMYg1mUyYPXs2uru7sW3bNnavmpqa0NTUhObmZuTn5yMzM1MxB5gGzKQs8xnMiWnTpmHWrFkKmXz27FlFBvGMjAzMmjUL48ePRzAYTDIG6xkh+PtC+9hsNsyePRutra344IMP2PabN2/GF7/4RU1DR21tbVJOEsnAQNUxyBOYSmnl4Z953iMai8VYf6M5+amIx+NMYaPoSD4JLN/HRKUvNzdXcS5Gr0P06vLXRVCJI9Ejq9YeGbx55ZYMXbwjhxRAUaGkd4cITcETQ5DF+8orvGrON7Vz1lJ8eScgf05+vx9utzsp8SydF+VFGkoMScW2o6MDbW1tSZYgLdReyrR9IBDAuXPncPDgwbRfpDU1NaipqUF9fT1qa2tRXl7Owpn48B2z2TzoPyx1EDG8wGazYd68eQB6hOe5c+cUDy0JTbXYfi0mTZqE2bNns7Ari8WCcDiM+vp6tLW1se1MJhNL+CFaCOkcjcD//haLBQ6HQ9HBjx07Br/fr+pVSyQSaGlpSUoTLxkYDh48iP379/dJW16vF/v378eTTz6pqqDp8eKLLwIADh8+jIULF2LhwoWKZC5EItH7gvR9RSgUQlNTU5L31WQy4b777kNrayvq6+vx8ssvM4Pa1q1bsXXr1rSPdffdd+Pee+9FSUkJE5DRaBTbt29X/G5lZWW44447entJqng8Htx9990KxfaRRx7Br3/9a03F9sMPP8R7773Xp+chSQ1FXvCDWa3oG7XlvNHU7/fj3Llz2L9/f1Jyp1ScPn0ap0+fRkNDA86cOYPKykqMHz+elePgxwFiiD5vzOIN4fxgkB8/GBl78PvwYYOAsoYntUkG58WLFyMajaK5uRlnzpxhMrm1tRWtra1p3ROgx1M7f/58lsfCZDKpyuScnBzMmjWLyU/eOM/fG7Xr0xqUm0wmLFq0SKHYksGCaqDy+ycSCTQ2NqKuri7t65RcODQPlp9nzqP1nQ9ppfcAeWh7ExUnPoM0zYDOj6YMUlZvHj5fi54yp3Y9etto9WVaxz/LdFxK0Eb9neitJ5NyyojvHpqiKZ4T//vw7zTx2tTgt+PfAfz9DgQC8Hg8rH3+OaBth9oUoiGp2AKfdD7eC8uj5VrnO1x9fT2qq6tx+vRp1bqHZrMZX/nKV5KWv/zyywprL1mrz549i0AggClTprDai1oWoMFAzVIej/eU+bniiitQW1uL7OxstLW1oaGhwZBVjaeiogIOhwMLFiyAx+Nh4VVkHecHEqTU8lYkI/dIy/rGd16ak8V38paWFpSXlzMhTcek+omSwYPm0lxIqZxdu3Zhx44d2LBhA15//fWk9Ub78rp167Bu3TpcddVVSCQSWLRoUVId1cEOW6d5hlr89re/xblz55CdnY3q6mq89957SYk1UnH77bfDZrPht7/9bVIdzdbWVkXW5fLyclx77bVpX4cRrFYrvvKVr+DZZ59lyzo7O9n0BsnQgWQy7yEQofe8aGwmOVFTU4OTJ0/i9OnTmh7a0aNHs+z9QI+h5fz584rB09mzZ3H27FmcOnUKPp8PkydPTjIEiYMtGjSLA2GtgZ9ahlVRxvJeGJofy++jFoqbSPTUxbz66qtRX1+P3NxctLa2ora2Nm2ZXFlZCafTicsuuwwZGRmKaUYdHR2K94jb7UZpaSkyMzPR3d2tKHNkBFGO8/ciMzMTVVVVOHXqFFvW3NyMyspKhEIhxTiO5iFKBg9eOeH7K4+asQf4xNNKnlnKnq1Gbm6uwhObSCRYxl0iHo+zetIZGRlsbMcrT+LYUSzRpXe+/DWL107bi/eAHDJa944fX8fjcbjdbnbOpOilqxOQgix6arXuQW/lI3/d/G9ORgT6ffnfiH5f8f03FPQeNYasYhsIBOD3+5GTk5MUe6+m1Ioe28bGRuzYsSPJS5uRkcFK4dhsNjz11FOqx29ubgbQ4yEgb19DQwO2bduGQCCAWbNmseQMAJImXg8Gagok3wlHjRqFkSNHor6+HgcOHEB3dzfC4TA6OzuTBvMWi4W9lCir9OWXX86sahTOQgOdpqYmRaFoyvJGHUS0CBuxounhcrkUwvHo0aMoLy9nx0okepIUdHV1ybk8g4zP50NHR4dmbepU7Nu3D7/+9a+TQlAvpC9v2LCBhcFeffXVirCjwe7LFoslSdkWGT16NB555BGcPn0aDz30EKqrqxEIBHDs2LGkaRYOhwPTpk1DVlYWswQ/8cQTmnNZt23bhuPHj7Pv8+bNw7/+67/2zcUJuFwu/M///I9CsX3ppZdw5513JoWC+f3+Qfemf5ohmZyXl8eSOwJK7wV95yGltrGxEdu2bcPhw4cV661WK4qLi+F2u2Gz2XDJJZcgKyuLGbb9fj/27t0Ln8+H7u5utLa2MiNqTU0N3n33XXR3d2PhwoUsioiUOx7KqSHOvVPzNvMylJ9Xq4bWclLoxblrJAutVitGjx6N4uJinD9/Hnv37kVXVxcikQja29uT5JbFYkFeXh4LebZYLFiyZAk8Hg9LGkneLavVisbGRkXuj8LCQkyZMgWBQIANYMVxE10P/5vyYwi1e0brrrrqKoVie+jQIVRUVLD94/E4bDYbOjs7ZbmuQYaMzaJxhtALWwU+yRQsGijMZjMr52i32zF69GhWfoaU4ZqaGoRCITbPmpQmmkqXmZkJm82WVJaKhy/NKT6LvJLKK7CAukJPy+m+8F5JHtFDzLdBSq3b7UYikWCJVrWyCgOfJI2itmhePCXM469ZrDnLhyCL12nUWyteF9+O3W5XyNpgMMjKeYrv/aGo3A6+NqZBV1cXmpubWSw9P0GaUFNoKUnK5s2bFRbh3NxcTJgwARUVFXj++ed1j80PkO+//3789a9/ZeUu2tra8MEHHyCRSOCqq65iQrI/k8sYgTykokWVf/jImltYWIirrrqKzdc5cuRI0mDY6XRi6tSp8Hg8yMzMZF4dCofgLTqJRALV1dWq5UfEjqWm1BpdBkD1OQCA3bt3Y+nSpYqXtNlsZvOWJIPHyZMnsXPnzqQs3UY4cuQI7r//frz11ltsWV/15d27d+OnP/0pHA4HS4hkMpnY4HiwcDgcGDFihKFtKysrWXmguro6/M///A/efPNNxTaFhYW47777MHbsWEWmRy1eeukl7Nq1K/0T7yN++MMf4vbbb09SbD/66KMkpUgycHR2dqKxsREFBQUAlB5LNW8JL3vq6urw5ptvKhQfm82G7OxsjBgxAldccQWKioqY18JsNjMPaCwWY0mXzpw5g927d+P48eNM8WttbcX7778Pu92OK664ghmmMjMzFecfDofh8XiSzpH3vtBytf9a0HpSnAmaNsMb5sX7Qp6qoqIiLF++HPF4Tw3JgwcPKrKRkydnxowZyMrKYnNwTaaekGM+yQu1ferUKUWZLqfTyYwSNptNMZ2KvxY1pZa/TjW5HI/HUVRUpFi2fft2XHPNNQqZbLFYWA4VyeBBCpcYbkuo/dZ8fxGVWqqnnJmZifHjx7PP5PigOb3xeBylpaUIBoNobW3F2bNn0dTUxJRYyi9BJadIKRSNVD6fT3OKm3gNasqt3n2hca7afFYx+oLgo1KoogqVPVLzaJPOQIlb6d2hpeNQnVyt8011XekitkXJfHkjlclkGpJhyMAQVmwbGhpw7NgxVFZWqj60apZGsnZs2LBBodRmZ2fjC1/4gqI+pFF+85vfwG6348UXX0R7ezuamprQ3d2N3bt3Iy8vDzNmzEAikUgahB0/fhwzZszoN+9PQ0ODYi4OeXn4ulyiZUosYm2321FUVISioiJNyxa9AMkiRfebD7Hi69HyiJYg8fdKB1HRVevEomc/kUjg9OnTigGCZODZunUrRo0albZiGwqFcPfdd+Odd95hy/q6Lx88eBD33HMP1q5di6qqKtX9Brov22y2XinXJSUl+OUvf4lf/vKXfXl6Q4bnn38e//jHPwb7ND611NXV4dChQ6oZvPW8tfF4XFWpraiowBVXXIFx48bBZOrJYuz1epm3lVeGyAM0Y8YMVFVV4c0338S+ffvg9/sRDofR3t6OLVu2ID8/H3PmzEEsFkvqQ5R4imQWPxhVky9aoXY0oKP/QI8sbW1tVXhIrVYrMjIyFLKSjk2fxXJFQI9ha+nSpYrzAD4pSUSDSdGzw4cLqtXDpUE0ebuNeKC1PHn0mb8utWQ7dH/4/U6ePJmUzVkysFAILSlVWmMz/vmjaACfz5ek1Obl5WHs2LEoLCyEw+Fg0RUUPUCOF77ySGlpKQoLC3Ho0CHU1NQw5Y2OkUgkWHSg6Mg4e/Ysq6EuGtZo3KrmcRWXicYgUvabmpoUMpmPANHKCA9A0S9pH7VpNfy58ONWsW3yIKsZoNSmSqRCyzglRpOoKauiM8tkMrGEdkONIT2JiawdohcS0I6nP3z4sEK4eDwefP3rX+/VQJj41a9+haNHj+JnP/sZW9bZ2Yl169bhzJkzcDgcyM7OVuwzd+7cfvUUPvDAA3jsscfYd6vVykoxiPeLf+h5oUr3l0o5BINB+P1+FvJHlmBSinmrGd+xtAo4i2EuWlYzPWVXTdnW2icUCrEMmTabDT6fb9CzVUt6SCQSab8A9+/frygd1V99+ciRI1iyZImmF2Gg+7IkGbWBimTgoRBEsXQboJ4B2WQy4eDBg0kK38SJE7FixQpMnDgRPp8PXV1dcDgczFPDD4Ip9DYej7O55CtWrMCXv/xlTJw4kbXb3t6OV155BTU1NbDZbElzbvft28fGE7xSy3/m0XrmxDBEGnzW19crPKQWi4XJZLoffLv0n+ac0nxFkskU+u31euH1ehEIBBTeH75MH7XHK79a/UX0Thv946+B35faVDP8kVKSSCTgdDrR3d0tpwYNIfhxtGio4P/E5YTZbEZRURGmTp2KkpISxONxdHV1seeBsh1TnWq+n1GpnmnTpmH+/PmKKKV4PM6UW6p7zLN+/Xo2d5s/d/HPyPXzzzb15SNHjiimMdI7gr9n/H3j74fNZoPb7YbT6VTkmeGNUmJpIkLNwaR1LeJ5pIuWJ1sMgyZ4p5laZvmhxJBWbAOBANra2pLqM4mdkT63trZi165dbDDscDhw3333GapzaQS73a4IOfZ6vXj++efR1NSEUaNGDdrcPApryM7OZlkYeQUWUJYnoO/UWcmCRqV56GXEv8z4DG9iO3oCVPyuJSTVEK3o/HI1DzEvRC0WC1pbWxXzfiWDR2tra1oZUL1eL+666y7s2bMHQP/35ZqaGkybNo19F8MYBwqr1Tro0xqGIuIcfsngEAgE0Nraqjp3VBwcm0w99ZC3bt3KpqmYzWbMnDkT11xzDfLy8tDd3c3kF9W/5OeT0bw8v9/PynDQ4KqqqgqTJ09WhFN2dnbi97//Pdra2pCfn58UatnS0sLqtwOfhGTyHhZeJvKDcX68wWdqpXJ/fOiiyWRiJTtoUC4qyqJSTcfivVrUBs2p5T1SWu3RZxHaj1ds1bYxKp/F46ptzycAtVgsaGxsTDvRnaR/oORP5AxQe2b454RqTpNhxWQyobS0FJMnT4bH44HP50MsFmNzMXlDDh9lEA6H2Xxr2mbEiBGKzPxAz/PX3d2tyKzNc+bMGRZST+fDj1PV+q6aUspHTFitVnR3dyflchD7lmgE4CEjPl2zWoRGKoWQH6+rGdiM9PV0HUZ8ZIjWs6DnWBpKDGnFtq6uDrt27VKtzyQ+pDabDS+//LJinuevf/3rPg3Lu/POO/HMM88oFNhoNIoTJ04gNzcXK1asUGxP4bt9DRVsJ4qLizF//nyWTU7Nmk6oPdD04qEMwtQpRauuuD+hZ0260DkAWvuoCWYx+96uXbtU6/1JBp53330XP/zhDw1vP2vWLOzbt499H4i+DPTM8bFarQoPEzBwffnaa6/VTIL1aeaee+7B//7v/w72aXzqqa2txfbt23WVI5LNbrcbzz77LBobG9m6yZMn44orrsCoUaNYzgcAbC4eGVX5wSZfc5PmpJISesUVV+DLX/6yQgbF43HU1tbC5XJh1apVinNrbGxMSg7De1D5ASnvlaABKQ1K+XPMzMxEQ0ODoqzOqFGjcNlllykUYKNKI78NyWV6T4jhh2pRTHqyX6xXr9aOVht6y+j3EKHstXR/P/jgA0VIumTwoPI0vCEKUHdIRKNRdHZ2KkJUS0pKMH78eOTk5Cjma9Nnsc/wf7FYjBmCSOGbMGEC5s+frzg+RTRYrdakqMhTp04lPbti1ALvHaVr4Y1HAFhfJgPbyZMnUV9fz45jt9uRlZWlq9SJDiS19VoGKS0uZLyhd45ay9QiNLS2tVgs6O7uHrIRkUNasQU+KXLOTxQXMZlMaG9vH5BJzLfeeivWr1/PvofDYbzyyivo7OzE+PHjFduWl5fj+PHjfTogTiQS+MIXvoA///nPbJnb7UZhYSHC4TCbtK4nRPUeXlE4phJ2/D69vR4jnlvxeGrH5AuO+/1+WVJgCNLfL/R0EPtyS0sLcnNz2Xf+GRvIviwmYfm0M1DPg8QYkUgE3d3dzNOjhpZMLisrg8fjSfL66skQPrMojQPi8ThL8DJ+/HjccMMNbPtgMIgnn3wSPp8PpaWliraOHDmCQ4cOsQE3DX55Y66oLJL3VJyOYzKZ4PF4EAgEcP78eUWmX4/Hg6KiImYoUzPwigNJtT/+WPx/Ldmudx/pOnlPkxHZq7cdbxhXK1VEMtliscDr9aZdzkjS/5Cyp+e1VRt75+TkwOFwwOv1Jq3XGjeKzxG9H8ihUlpaihkzZii2p/rZ4hzud955B9u2bWPLw+Ewe1Z5x4yWcYrvU+FwGG63Gz6fDx999JFCsaV9REOY2rg6FekonKn6p5oHWa0NI8fi29NzjA0Xhrxi6/f7UVtbyzKqqT0YDocD9fX1ijl8zz77bFoeogshkUigtrYWVVVV+OxnP6s4x4kTJ/ZphtGlS5filVdeYd/Ly8uxcOFCZGdnMwu42otETzAZUV5786BrhWqI2xhVjPmOrGbEoBAYs9mMmpoaWVJgiNHS0oJt27al3O7MmTOKAdBA9mWCnjE+lLG/+/LXvvY1/M///E+ftX+x8NFHHynmLkoGF7/fj5qaGkWtWRGn04m6ujqFTF6wYAGmTJmimG+nhprHSEtORKNRuFwujBs3TrE8kUigsbERo0ePxle/+lXFvrt370Z7ezsLO7ZarSxyQ8yySl6tQCCgiK6IRqNwOp0IhUJ47733UFdXx9qfNGkSrr76alaChz93o4Y9cfBsxIOaSo6SR1pMmHOh8J46ET4staamRk4nGGIkEqlzX6g9I+Xl5Rg5ciT77cX6zTxipKX43PEeVrPZjLy8vKTjUWJYsWTgyy+/jGPHjineJ3w9ad5DSp9Fj2kgEEBWVha6urrw7LPP4tixY4rj0vtKr79o9T2tMGgj+xohVf9Ve5fy+6p5bLXey7wCrFe7eCgw5BXbtrY27N69W3ebeDyOt99+W1GLNR2FKV2uuuoqxTklEgmcOXMGQE+olXjcRYsWKTxDvWXWrFnYvHmzYll+fj5KSkoQCoWY8q9l7dELNVATomr/+RcD/ZlMJkyePFlRSiQej7Nat30FbzETO99nPvMZRSbNnTt3KgYbksFn//79uPfee1Nut3jx4qRSFwPVl3nUjtmffdnlcg3a3F6ee+65B8uXLx+04+/YsUPhOb/vvvuwadOmQTsfiRIqr8PXfORJJHqS961ZswZer5ctHzFiBJtLS95SvWyh9F3Ni0rfaR2VsOP3o8oIajJ53bp1+Pjjj2Gz2WCz2ViIM5W1ozYoq2lGRgbz7ASDQdhsNrS1teHdd99NKnOXk5OD4uJixONx5tXmB9NGvbTiPVHbjh+s8/fJZOpJysN7rCORCLxer6asF9s2qvRS/Vyx+sDnPvc55vFOJBJ47733UFtba6hNycDAR0SSUiN6MykMmffKZmRksPnveoqQmuLEI/ZlymY+YcKEpPZojr3Io48+ih07djAFlLIxOxwORc4YSkJHxpZgMIhQKASn04nW1lY88cQTSc8wRWtoRYsOBIlET+I13sjOGwIu1Dgl9nl+3jGRlZWlcJrRPOmhypBXbIGebLd1dXVwuVyqdav0MgD2B2o/fDgcRiAQgNvtxr333qt4COPxOD73uc/hb3/7W6+POWHCBHz00UeKZTNmzMDixYvZ5Hq1iea9EZhaQo7/4+ffRqNRZGRkKEJF1EKT+sJCTNfID5iAnjlN5GFraWlJmvwvGRqEQqGUNQwH8oUp9uV4PK7oZ52dncjIyFCs74++/LOf/QwPP/zwkEjKMG7cOBQXF7Pvr732Gq699tp+OVZ3d3fS3Klp06Yxg5hYmF4yNAgGg6ipqUFWVpZCFtB/PjEMQfXQAbDfV8+bmcpLSXKf5r/zXttEIoGmpiY28P7FL34Bu92uaGv//v04cOAA2tvbWSZTu90Ol8sFm83GFNmuri60tLQgEomw90VbWxu2bt2aFBW0ePFiLFu2jCkIWoZmI3JXzYgsrlf7TspIZmamQibX1tZi06ZNiv6UjtxXgwa7FosFTz/9tGLd6NGjWUmZ1tZWVmZIMrSgMRyN18QQV5raxkMZfwEkKcOpjiU+W/xn6tPidBx6p4RCIRQVFSV5Hl955RW88cYb6OrqQnZ2NosmoT4UDofh9/vR0dGB9vZ2RKNRliz19OnTePzxx5OigpxOJ6t7LSp+/DnzxiQj1y3uz99rrTb4hHf8vlarVbN/6kW+pDpXsa/S+9xisWjW1B1KDAvFtqOjA++8847CIweA/bBkhSRefPFF3HLLLQN2frFYDG+++SZCoRCsVisKCwtx++23K6xL4XAYd955J/Lz8/GrX/3KcNujRo1Cfn4+Tp48qbjG6dOn45JLLmHZ6GjukZq1VUs51RK4evvw0PdYLAaXy8UGLfx6cZ5DugN3sfPTy08kOzubeQLeeOMNxRwJydDh0KFDadWzHei+HAwGWQ1JoMeLWl1drRC0fd2X//u//xv3339/0sB7oCElIScnBx6Phy2nsmD9hV4GymuuuQZbt27tt2NLekd7ezvWr1+vqANL73qLxcJKdRCzZs3CyJEjk+rGpiMP9AaPFotFYYCKxWJYu3Yt2ycvLw/f/e534Xa7Fe19/PHHePPNN3HgwAF4vV6EQiE2gHO5XMjKykJBQQFyc3PZvOH169dj06ZNiggxoCfUet68eaxUiZj91KgBWe26+f31lvMKApVO4rcPBoOs0gTJ0VSlR1Kdq8Viwfnz55PkclZWFpvT++qrr+L8+fOqv51kcInFYmzOPF83lfqp+ByPHj0aeXl5zDglKmc8Yhiy3nfCbDYnzaft7OxkHmKgZ7wnOrc2btyI3/3ud3jxxRfR3NzM2nG73cjKykJeXh4KCwtZXz579iz+67/+C08//XRSpm632w2PxwObzca82eJzb/TdpabQpoue8ppKqU4Fb9zXaoveFxaLBcFgcEh7awFgcOrTpEkikUAgEEBTUxNGjBgBr9fLMuBarVYWRkRkZWUlKVn9DdWgo3k306dPRyAQwBtvvMG8iz6fDz6fDw8//DDLfDpnzhysXr1a0Q6fhKq+vj7pgZ47dy4uueQSZGdnIxaLsRp/WoKOX2bEOsvvl2o58EnHmDhxIkKhEMtETPOT+EHyhUCDJzET2w033MDCRagGb29eHpL+h0oGGGUw+rKYETkvLw979uzB5ZdfzsIb+6ovP/roo/jSl76kGHAPJHy/phwGZrMZd955J9ra2vDCCy8AAD744ANcd911fRKGTTQ3N2Pu3LmKZXv37lUMajo7O4f0XJ5PKyST6+vrUVBQAL/fzwZHZrM56R3Me0Fpf37wrDUgFv+rnQcdUy3DOe9NrqysxKpVq/C3v/2NvYMoedTJkydx7tw5mEw92ZwrKytZyGIkEsHHH3/M+ohaNNCSJUswd+5cZGRkKEKQ1ZRRI8blVEqvnpzm78nUqVMRCoVw4sQJAD19buPGjVi5cmXS/vxvIf4magZmUoKi0WhSBMstt9zC7h/J5KE+GP40k0j0OIkoA7GeosSXgxQV4FTjLiMKmJrCqzZGHTFiBJqbmxUJqCKRCHbv3o2DBw/CYrEgNzcXixYtYlMMgsEg3njjDTbfXIz8A8DCl3lPLe+g0bpGreViP0pnXx673c7eR3ROoVCIjf9p7nw6UD/nDV1ipCXl76HjDId+PCwUW6BnILl+/Xp885vfZOEtFII0VG40dUiLxYJQKISZM2fC4/FgzZo1aG1tZdt1dXUxwdrc3IyZM2eydYlEAtXV1ZrHWLJkCWbNmsXqd4kCVE9RVROi/HHVlGFxHb+cXxePx5GZmZk0R5DmcDidTtjtdkWmYq2XhGjZou+xWAx+vz9pnwkTJrDQkldeeUVRdkEy9KipqcHSpUuxcePGwT4Vw5SVlWHdunW45ZZbcOjQIbb8QvryE088gVtuuQVZWVn9dt5qqPVv3msTiURQVVWFqqoqtk8wGMTmzZv7TLmtrq7GihUrkuY08fMhr7/++rRqH0sGlu7ubrz66qv4zne+AwCKLMmiMYI8H6kUVX6dOMDllS1xfyrhIcKH70WjUUyePBmrVq3CCy+8gObmZsU6OudAIACv16uQQ3plLW644QZMnz6d5bjgB5h6SqlIKmVX/K8my/nlajI5Ho+jvr4eb7zxBm688UYEAgE2YOY9c2r3nf8PgEXL/e1vf0tSECZMmMDuwQsvvJA0D1kytIjH4+js7ERmZqaidA+AJIORVj8Wx2v8f9FQIhq4+P3VjFR0jolETzQFZTHPy8tjocVEOBxmyllnZydaW1sVx9Cro+xyueByudg0gt56Qi/EsaK1r9VqZSU5CQqzppBkXkEV21G7//zY2mw2q2Ytt9vt8Pl88Hg8SSWfhirDRrGNx+Noa2tDZ2cnsxwA/ZtYJl2oZh15k+PxOCorK/HFL34R586dw65du5JCZP1+f9J8OzVmz56NyspKlJaWwm63M+sYn/EtlfJpRNHVUorV2uSh36C8vBw+nw8nT55k66LRKAKBgKLAPN+GEat8NBpFKBRKMmKsWLGCDV6CwSBaW1ulh2eIEw6HcfDgwcE+jbSZNGkSnnrqKXR1deF3v/sd3nnnHcV6o335b3/7G0aMGIHZs2cjJyenn85WHSPvAZOpp07nzTffjPPnz7O5c6Tcfu5zn8M//vGPXp/DkSNH8LWvfU1hIAB6ah2TpZy2G6p18iQ9MrmlpQVNTU3Izc1l81lpUMjDz3fjvTxaA14eo/Jdy8BNAz46fmVlJb761a+iqakJW7ZsYYkf+XaMPHeXX345Ro8ejdLSUhZVoubRMGJoVpOxevuI22rJVACorKyEz+dj2V5jsRhqa2uxdu1aXH311QrngJFkj2S87+zsxGuvvaYwEADATTfdxI4fDAbR3NwsZfIwgHKUhMNhRWgqny+GttMrvalmgDI6/5Z/N2i1zx8nHo8jIyMDwWBQNaFRLBbTVWQJj8ejmAqk1x+NXEe626Tah9aTEYqfGkTeZ4fDkZTQj38fqBkKeb1BbS411e8lo91w6cfDRrEFegbE69atw4033si8tvF4XJHJEAB+/etfw+Px4LLLLhuQ8zKZTJg+fTrsdjuCwSCzXNODVFxcjJycHBQWFqK+vh6tra04f/48ampqdNudPHkycnNzUVBQgIqKCmZJUhOKWkqqEaVWyxosfua30fqclZWFyspKhEIhxfWRt9XlcqmGrGgNaCi7svjSMplMmDNnDiZPnoxIJAKXy4V169bB5/Pp3lPJ0KCrqwtf+cpX8Oyzz+puN9B92Waz4ac//anm+nnz5gHoyQr59a9/He3t7Xj77bfx2muv6bb705/+FNOmTYPJZML1118Pt9s9oAY56m9qZUS03h1jx47Fl7/8ZbS3t2PNmjUAegaq69evx5e+9CU899xzaZ/Hvn37cN999+GDDz5gy8xmM/77v/8bS5cuZffkG9/4BhobG3t9vZKBIRQKYd26dfj617+uqG3rdDoVz/fRo0cxZcoUjB49GkBy2KuImkdHa44ayQl+0GU2mzFnzpykMh2kWI8cORL5+fnIzMxEY2MjWltbcfr06SQlV2TWrFkYMWIEsrOzMW7cOJZHgx8kGlVkU8nwVP1Ua3AsGguysrIwduxYBINBFkESi8Vw5swZbNy4EZdeeincbrfC0ywaG/j6n4lEAufOncP27dsVWY5NJhMuueQSTJ8+HaFQCA6HQ8rkYUQikUBXVxczLmopmfX19SguLmaZ67U8s2rhxFqOKFH2qEV8AJ/UWCXFm4ywHo8HbrebeXLD4bDCs6mGy+Vizha9Or7i+fHXYhQ9xVVtHK01NcNsNjPHnprnltapOZDUjsd7bEVo+kg0GoXdbkdXV9eQiY5NxbBSbGOxGE6dOsVemiaTiSVJ4B+ErVu3orq6esAGw2azGWVlZcxTy1ui6UFwOBwoLy/HqFGjEAgE0NzcjPPnzzNLE1nBKC25y+VCZWUlPB4PnE5n0gR2rZpcgH7YcTrKMH3n/2st4+9FQUEBxo8fj0gkosiASx3RZDIlzZsUrfiU+p1eVHyHorlDND+PkpWcOnVq2FiUPu2EQiGsXr06pWI70H3ZYrHgy1/+csrtLrnkElxyySXw+XyYNWsWrr76at3tb7jhBpSWlg5KdAnfp9WytGr1d7PZjBkzZuAb3/gGvF4vNmzYAKDHwPjCCy+wEOpHH3005XW9++67ePXVV3Hu3DnWDtAzYPnRj36EO+64Q7H9mjVr5IB4GBCPx3H69GmW9wJQL8vR0tICr9erUJx4RYmW8f/pMz+IVPNE0Hnw4bAmk4mF0osykr7b7XZUVVWhoqICfr8fEydORH19PQtLpvm3FOZstVpRVVXF5v3zCRtTGYB7q9iq7S+2z2/DXyNhsVhQWFiISZMmIRwOs6ixeDzOIqscDgfmzZsHt9vN5vtTm6RERCIRnDlzBqdPn0Z7ezvLNwD0yOTZs2djwYIFMJlMsNvtaG9vx/Hjx1MqGJKhQzAYZF5BLcXW5/Mxj6GoqOp5WwlRKeSPRfuLidmcTqfCG6ll7LJYLLBYLKyGNMk82tdqtTIDDh/uLCpsfLuprke8Nr3vRvbhl6kZBywWCxs/830rFoshEokgHo+zfAZ0r/h3LS3jxwMilB2e7iFN/RwuDCvFFuh5ALdv385CaGKxGDweD8rKygZVsaFETrwyy3cWeqDsdjucTicyMzNRVlamEKD8Q0hFpk0mExO0YvixnkLKk0qA0jb8tmqfxTbVlgM9g9WioiI2KODryWp1Dgp14K9NLeTFYrFg4sSJmDNnDjIzMxGJRODxeLBly5Zh1fEkPc/CAw88gF/84heK5StXrsQLL7ygmtihvzGbzYraj6nweDxMyR2K8AqtEY+S+NnpdGL+/Pn47ne/C6vVirfeegtAjxB9/PHHAQCFhaNkIfoAADMtSURBVIUKAbxixQrs3LlTMa9ux44dSaHbLpcL3/rWt/D9738f+fn5bPl//dd/JQ1sJEOXWCyGDRs24Nprr2XPjtPpxJgxY3Ds2DEmk7u7uxGJRJj3RS08TuuzOJjlQ5opWRUvZ0ymnkzIJDf5Oa/ic242m1lpnPLyciaPybhKobf0R9dM8kZLFtNncbmeHOa31dpHbFfcXlxGiibV1jWbzSxDcSKRYImlEokE3G43M0oUFRWhvb2dzbuLRCKora1Nym5ssVgwefJkLFiwABkZGSyCauvWrVImD0PC4TCLDgTAxq18+GswGGRZcoHeZfxVU1ABsLq5PC6XiyW2Eo/BK8S8Z5NXXPmxNaCcMsC/S6g9vevgFUOt9Xrf9RAVWv473w55bgHlmJretfSf319P/vNQ/V+ac0tzbNO5jsFmWCq2u3fvxsKFC9lEd5vNhvHjx6Ompob9oO+++y6mTp2qSObSV9TW1uLll19m300mE4qKihCJRJLK7oihPeSFNJlMrGC0eH30x08C5+cIGbGIpfrjtxX3E9sQt1PbT7wGm82GUaNGwW63w2KxJIVdi5PU6Xr1rs1ms2HChAmYN28eG7TYbDZ4vV7s27dPemuHGaTY/vSnP1UkpPjBD36At956iym2A9mXAQx4Fub+gO+3/HsjlXIr7k+GwyuvvBIZGRlwOp0sLJl44IEHFN+PHTuGTZs26YYSZ2dn45vf/CZ++MMfoqSkhC33+Xz4r//6Lzm3dhgRj8exY8cOXHbZZczYaDabMXnyZJw9e5a9l48dO4aSkhKmPPLhhCJaoXiiIkxttLe3K+btm0wmjBgxgslktXMmeLlBSqw4T40+iwPGdHNbiNvobWtE6dVbzv+nKKnRo0czmSwmbhPnvI8aNQotLS26pb7sdjtTanNzcxEKhZCRkYHOzk7s3btXyuRhSDAYhNPpRCKRYHljSLGkftPY2IicnBzk5uYqsoCng2i4or7s8/kUuWgo3FjNSMIbt9QcP/w6Og7fr3hlVw21a+qtUtsbBZc/nhjRSH3aZDIljafVQouNhBHb7XbVaVLpVLIYCgw7xRbo+dE/+ugjLFmyBKFQCNFoFCNHjlRYaJ555hlMnz69XwbDR48exW9/+1sAPYJ11KhRKCgoYBYlvfBgviMlEgmm6NI+ohWbH5Dy7fCfjSqxaucjtqP1nf8vflb7DvRYckeOHAm32w2LxQK/359UBJvQE4AOhwOFhYXIy8vD/PnzkZWVxSzPZrMZH3744bCJ/ZcoSSQSeOmll/CFL3yBLZs2bZpCuRyovmy323H99df3+TEGGnHQLU5bMKLY8lBSkcWLF2PkyJGwWCxoamrCtm3bVLenEkFq5OfnY+7cuRg/fjwefPDBpPV///vfh0XWRUkye/fuxbJlyxAKhRAMBtn0HOLYsWMsAaIYhgyoh/9peXD5wajf78epU6dw6tQptq68vBx5eXkIhUIsGkgLPZmrpXDy/8XPPFryOJW81lOQjSq2auditVpRWloKt9sNm80Gn8+nmC7Eo1d31uFwoKioCIWFhVi8eDGysrLYewIAdu3aJWXyMCYYDLJwe14xJJqamlBQUKCoJ2skDFlEVKAikQiam5sV0T52u50ZwtTeC+IxxfcIjRVpHT/+5rdT+8wfQ88r3VcKrR5aBiun08lkppbsTPX+s1qtLMSZnHMUrj0cjczDUrEFgM2bN2Pu3LlwOBwIBAIYOXIkCgsL4ff7mZJ08uRJnD59GpWVlX123MbGRkXmU5vNhssvvxwulwudnZ2qacoB5WATUJYGEkv28B5bPaFqtMOkEqB6Alc8png9etdKn3Nzc3HllVeipaUFH374Ias3Joab8DidTpaprqCgADNmzEBeXp4ivbnFYkFbWxu2b9/eZy8PycASj8dx++23Y/ny5cjLy2PCY86cOWhoaGBe24Hoy5mZmfjrX//aZ+0PBvx7JpVia0SpBaCwhI8dOxbPPfccDhw4gJ/85Cfw+/3o7u7GkSNHNPcfMWIEysrK4PF4MG3aNPz4xz9GWVlZ0nl3dnbi29/+tlRshyGJRAJvv/025s+fD6fTiWAwiOLiYowcORI+n4/J5NraWjQ2NqKsrEw3uyqPGCZIn2kAVltbiwMHDrDt7XY7li9fDqvVCr/fn5TVldpRUx7pM22jZQzi//NtaH3XU2T1FNRU2xs9FwAK43lhYSGWLVuGpqYm7Ny5k8nk9vb2pP0Il8uFjIwMOBwOFBQUYPbs2SgoKEA8/kk9TZvNxrJNS5k8fAkGg4o58zQ1jvcMtre3w+v1sug5o7+3Wl+m/tje3q4wqJhMJoUjg0+MpPZfPA5/TlpzhtW2VXsX8N/F7dTWpVpmNN+GeG3iPYtGo6z2O9UPJ3mtBW/Ms1qtLFEUr3PQdlKxHWC2b9+Oa6+9llllFy1ahPb2dlbH9PHHH0c4HMYvf/nLpIFUb2hpacHTTz+Nn/zkJwB6Bny5ubkYPXo0wuFwynAMfp0oMHmPbKr99RRdo3/iPmptaB0r1Xny0BzheDyOgoICXHfddejo6EBnZyf279+fZH2ifcrKylBZWYm8vDx4PB4WbsHPc4pGozh69KgUoBcBL730Eu688072DDzxxBO48sorsW/fPgD935dtNhumTJkCj8dzwW0PFmrGMTXFVi0cmW8DUApPspabzWaEQiHEYjHMnj0b77zzDqqrq3H06FH8/Oc/11RIr7/+enzlK1/B2LFjdcuJvPbaa7IvD3O2bNmCa6+9liVpWbZsGVpbW1lJmI8//hgOhwNZWVnIzs5mspvmwoq1VLW8QbRtU1MT9u/fj9OnT7Pl+fn5KCsrQygUUshkNSWSloufqb+oJW8Rt+fPrbeKq9i2UUVYS7FVuy4+bJMSVhYWFmLlypXo7OxEZ2cndu3apSmTx4wZgwkTJiA/P58NpEOhEEt4SZlaDx8+LPvxRUA0GmWRdhaLBS6Xi43lgJ7syJQzxul0IhKJsL4gekUBpTIlzpc3m83wer2oqalBa2sr28dqtSbN7xVRU/zUlEax72hNgdDrU2J7evun2l5NGVfbh29TTZmnXDxAT7UGyhEQDAYV58VDfZZ/59I7mPIKmM3mYZvrYlgrtu+//z6qqqowbtw4hEIhpgjxRYT/8pe/wOv14pFHHkFRUVGvj9XR0YFHH30U//7v/86WuVwuLF++HFlZWQgEArDZbCmFjvhw88KGOjk/sV0LtQ7YW6XWiMKrdu5GhBcvUMlqn52djby8PFRUVCiOR52MBkUAWAelOcl8h25oaMDWrVtTnoNk6POd73wHy5YtQ2VlJcxmM7KyslBaWoojR46wF3R/9uVRo0Zh48aNF3oZg4ao0KoptammNfCIygXv7TGbzeju7gYAjB49GhUVFbjuuuuS9tX6rnbu1dXV+NrXvnZhN0Ey6GzduhVjxozBvHnz0N3djTFjxqCgoADt7e3s/b9nzx6Ew2GsXLkSLpeLPVv0zhdL9NDzwyd+sdvtaG5uxpYtW7Br1y52fI/Hg5tuugkulwuBQEBR815PHqvJPlGp5peL/UivXS0Zy69Pta1eG+JncZnobeKT5ZCikpWVhdzcXFRVVSnGIZQRmo8so7r0JJP5ENG6urph/R6VfAJV7AB6lFyr1Zrkta2urkYkEsG0adNYyLDYlwHlOFAMI7Zareju7saJEycU874pqRufAE7sk3rhwWrw26UbKp/qGEZCsfVCqMVlagq6lmLOv5doHE36CB9+TduqHSeRSCjy+kQikWHprQUA7VnTw4TnnnsO4XCYKT833HADxowZo/ghX3zxRaxatUo39FWL7u5utLa24j//8z8VA2EKkZg4cSLzJKplK9aCH4jSPNtwOJwypENLqKl9T1ep1fvTm28kLqPlooeI7ls0GkUoFGJ/JFzpPoRCIQQCAYTDYUX8P39Ms9mM559/PuV9lgwfxo0bh87OTvY7//Of/8QNN9ygSLDWH33ZYrEgNzdX15s4lKG+R5ZaPqOr2jJ+Hb8snT8yQAUCAXi9XvbHly8z+h70+/3MyCUZ/vzv//4vOjo6WMb/W2+9FWPHjlXI5AMHDuCll15CLBZDRkYGAGV2T95zyz/fNBg9f/483nzzTezcuVOxT3Z2Nis1J5bIo7Z4tLw2dHw9o4x4flqfU8ljvW21pg/0tm1xmhPQ8/4juevz+Vg/jkajiEQiCIVC8Pv98Pl8CIfDiqoN/G9jNpvx1FNPad4vyfCjra2NRTElEglkZmYmJTytq6vDvn37EIvF4HA4WAQG7UP/6TkRn+v29nYcOnRIUT4K+CTzLylbat5eHq3nXy/HhLifHkZDh8V9tM5X691j9L2j5gEX14tlfvhxOP/+EvMCmUymYZcwimfYK7ZAjwU4IyMDoVAIBQUFuPrqqzFmzBjFj/3mm2/iuuuug9/vN2SFCAaD8Pv9+NKXvoSCggI89NBDbJ3JZEJJSQnuvPNOxWDYSAcRH0qyrpBFVM+yIi4XO6vePDqjwjZdQSqep9o6teuhayelVfwjr63aPgAUc6okFw9btmxRWIRfeukl3H777Yp+1pd92Ww2Y968edi7d2/fXsgAQX1WS5k1qujyA149ZVfs/2R4cjgcyMjIgMvlYllXUwnoRKLH+/P2228P4B2TDAS7d++G2+1GOBxGbm4uVq5cifHjxyueh+PHj+P3v/899u3bh7y8PGRlZcFutzMliw97tNlscLvdCAaDeOqpp/DQQw+xaQrAJ9NX7rvvPoVsJUQ5qqXgih6gVHKPb89IfxG3MyJj1bYV5X668po/b/pO8thmszHFlf5omSiTaexiMpmG7TtUok93dzccDgeTCW63O0m5pXnVtbW1sNlsCgWYV0zpebLb7QgGg9ixYwc2btyYlKjMarUiNzeXOaz0xsFaiqrRPia2SeeqJr/UFMgLxYhSrba92nWL/1PdN7XvJlNyluXhxrAORSbeeustlJWVYdSoUcz6v3TpUmzatIllSgR6Qpc9Hg9KSkqSUt2LzJs3T1E+gKe8vBy33347srKy4PV6FRYqwuiDmq6y2FuF1Gg7RhRUtWsQXz5qLyO1ZeT9oTa0SkDwA476+nq8++67hu6vZHhx4403oq6uDsXFxew3f/TRR5GRkYE//vGP7Pnpq7581VVXDVvFihfevEKqNsjml9G+akKREK3BvJDnB7d8e/F4XJFF00gIclNTE2666aa+vC2SIcDatWtRWlqK0tJSBINBjBo1Ctdeey1MJpMi0VhrayueffZZvPTSS7juuuswadIkZGVlwePxIBaLIRQKIRwOo66uDs8//7xi/h1PVVUVvvnNb8LhcMDn8ylq1wLa8iuVXNOSj+kqlkYjntJVTtMZEKvBh3RSqCcf9snLZH7gS//pc01NDd58880LOhfJ0IRC+t1uN3w+H6xWK3JycuD1ehVzMH0+H3bv3o19+/Zh8uTJKCwshNvthsvlUsinlpYW7N27V3P+pt1uZ6WjKOpCNDj1lVJJqHl/xXBnvf1SvUeMLBfH0UaOy++ntgxIDrnWapfeL2azGT6fT/PYw4GLQrEFgCeffBJ33XUXcnNz0dHRgTFjxmDFihXYtGkTPv74Y8W2dXV1mtmLUzFx4kTccsstyM7ORldXF7Mwp/Pwqi3X2qe3yqiRdXz4gd4+euertlyrc2q9JNSWi/uToA0EAkl1RyUXFyUlJTh+/DjGjh0Lk8kEl8uFRx55BMXFxfi3f/s3xbYX0pf/5V/+Rbc0zVCG+q+RcGJeqeWVUWpH/Kyl1Kr1Xd4rxkefUDt659/U1ITS0tILvheSocnjjz+Ou+66C6NGjUJnZydGjRqFm2++Ge+++y4++OADxbbBYBCvvfYaXnvttbSPM3XqVHzxi1+E2+1GIBBIUmqB1ElhjCqaRrbpjbzWUo7Vjscv00JNpvIDdX5fIwN4tbbpnRIKheS0oIuczs5OuFwuOJ1O5ozIzMwEgCQFNRqN9jqizu12Izc3l4W8A8leUvHZ11J601WC9foM315foeboMXqMVP1XK8xZ7/j03uzo6DB0DkOZiyIUmXj88cfh9Xrh8XgQDAZRVFSEm2++GatWrcLUqVMvqO2pU6fiu9/9LlatWsUsVw6HI+0J6Dxagiyd7XsjiNVCmC9UqdX6LLaltb/evgBY1rwnn3xS9x5JLg7Gjx+PPXv2KJbdf//9qK2txX/8x39cUNsPPPAAYrEY/v73v19QO4OJkfBjrT/+HaAWFml0ni2/PZ0T7xXW48SJEygpKenv2yQZZB5//HE2Ty8ajSI7Oxs33XQTvv/972POnDkX1PbcuXPxk5/8BN/85jfh8XhY+FxvB6BG5KleeKPRNgBo9iW14+m1o3UNF3of9NomIxdlzP3jH//Yq+NIhhcNDQ2IRCKIx+MsA3JmZiZycnLgdDovqG2Px4MRI0YgMzOTJYtUq5/bn6RSgFNNrTHShha97ataDiFxm1RG5ni8p4zmcJ5Xy3PReGyJffv2YfHixfB4PAiFQjCbzRg3bhzKy8sxf/58HD58OMlarMfChQsxc+ZMlJSUwGazsZh/q9WqmyBFTdFTE35a+12I4BS3NzrPQE+51bs+ESNhyeLyVJ7dUCiE6upqzWNKLj4OHTqEcePGIScnB8Anc9vvv/9+3HnnnVizZg2++c1vGm7vueeew4033giHwzGgArOv0Zo3a8Rbq/buEfsmH3LMe2t5TxgfughA8TkVXV1d2L17d6+FuWR4sX//fng8HuTk5LBSElVVVRgzZgyWLFmC3bt3Y8uWLYbbW7JkCebNm4cRI0bAYrGwUiB65fbUZDD9T1cpFbcVjyGuv5AEUEZl8oX2Ja1QTL5t/nsikUAwGMSZM2cu6LiS4UUoFILH41Eot2azmZX8iUajrPa8ETIyMuDxeBTJV6mearpojTP59SJDRQYZOTe9EGKjnmUxlwAvv/nkfcOdi06x3bFjB1wuF+bPnw+3241IJMIy9lVWVqKyshKLFi1CU1MTWltbEYlEFPM1ly5diuzsbIwYMQIFBQXIzMyEyWRiGXwp7NGo0pdKqU0lNC9UCPYmsYTWIED8zJNqTm264SB8W6FQCDU1NbK0z6eMu+66C4WFhVi+fDnrd+QpKCgowFe+8hXccsstSCQS6OjowP79+3HjjTey/devX4+5c+fCZrMB6Alz4mu+DTeoP6sptvz8WlHJ1XoP6MGHN6nVFiVFVmyTwtS0CAQCeO+999IySEiGN1u2bIHD4cCiRYuQkZHBMu0mEgmMGDECN954I5YuXYqWlhY0NDSgs7NTMe/9hhtuQHFxMUaOHIns7Gy43W7F/FutsDvxGU8l14wosunsZ0Tm9iYEWTwfI6gZm9Xujd46+k+D4LNnz8pcF58y/H4/Sw4IfJIQirDb7WxOLdBjhOUrGDgcDkWSULPZzJLEkWxJNd5MNfc03TGniJHxrh6pFGy1tkXHjlF4A9SFkEgkpGI7lInFYti8eTNsNhtmzJgBp9PJfvxIJIJEIoHs7GwUFBTAZDIhFoth/vz5SCR6Jk1nZGTAYrGw0jPBYJAN7PQswmqkq9QaVT5TbWu0LTGRjJbQTFeI8hi1oqm9jGgAfe7cOWzZsqVXVjzJ8CUYDOIrX/kKnnjiCdx8882KdSaTCXa7HXa7HYlEAllZWSguLkZtbS3bpqCgAHa7fdgqsjzUB3mlNVWGY1GpVZtyoIaal1ZUbHnllrZTew/x9z4UCuGtt97C1772tWFbH0+SPrFYDBs3boTT6cSsWbPgcDgAKEu/ORwOlJeXo6KiAmazGcuWLWPPDm1P5We6u7vZM8cnlzHSz/Vkcio5yn9Xk53p/qkptUZksvg/HfSip7TuFS+jqd+fPXsW77zzTlLSTMnFT2dnJzweD9xud5JcAHqeE+qXlE0b+CSJkV7OBq3xLqHlQFH7bqR/6CnS4v69HQP3FaISeyFKLd3/WCzGyqVeTFx0ii0AhMNhbNq0CQAwa9Ys5qWhtPRknaCBmcPhYA9IJBJhVmA+EUpf01tlVE/B1Wo7lVBN1Q59NgLv6VEb3KrdB3HyO2VXjUQiOH36NHbt2jXs049LekdbWxu+//3vo7u7G3fccYfqNvSSdjqdGDVq1MCe4AAgKrV6pXxSzZtN1af5QYfaoEXMmKr1bqH3J+0fiUTw2muv4d5770V7e/sA3TnJUCEUCuHtt99GLBbD3LlzmcGJSskAPc9jOBxmzxHNsaPpPyTDaVtCLcmMKIN4jMpbfhtxeyP768llUalNlTVZrY3eDmz1pgqpyW86rtVqRTQaxfHjx/H++++zEHDJp4tEIgGfz8dKcIlJCen5EY2jZPwEtA0pWs897aO2v1Y/SEfBFbczqtTqvV+0lothw+n0Yb6N3vR9eq/SZ3LeDbbS3tdclIot0BMysXXrVsTjccyfP19RUkYUkkSqOHe9Hz9dIaq2ndZ6o8LX6F+6QjTVtad7T/j11LZa+NPp06exZ88ezbTwkk8H9fX1+Pd//3cEAgHcddddg306Awr1n1T1aSmcS89bKyq2aqRSbOk7DVTE/1rtv/TSS/jFL36Burq6Pr5DkuGCz+fDli1bkEgksHjxYtUIKD7EUXzu9J5d/lk1IquMbjMQf2qJ2NRkr5a8NzrA1RujiLKYX8YbnE+ePImdO3cO+3IgkgsjkUigq6sL8XgcLpeLPcPphLjrta03lhafT/E4/LH0+vmFvCfSXc6fk96ydJTwdCJU6Fj8OyMcDiMQCFx0Si1wESu2QE+Skg8++ACJRAILFizQnPuVqhP05ofXUxi1lqmtV1M0tZTg3iq1RhTaVB1WrQNpreOPo/ZyMplMOH78OA4cOJBWIgLJxUt1dTUefvhhRCIR/OAHPxjs0xkQeKVWK1GUViiyqMymo9jySaMAKCy81BYfiiwu5wfoFosFTz31FB588EGcPn26n++YZKjT2dmJ7du3AwAuv/zyJIOJlnFZVHR5WdFb9OSe2rbidlqKZqp1WjJYK6JCbRyhtp3W/UgVvsm3pTbQpvt/5MgR7Nu3D93d3eo3VPKpIhaLwev1MuWW76dAcj9JFbmXarme8cVoe0ZIte+F6gl6Sntv0LoPem2GQiEEg0FDFQyGIxe1YgsA7e3t2LVrFwAw5Va07moJtN6ECOgt13qg0xGKen9G9kl1TH69+Dkd9MJG1LYBPglzPHnyJA4fPnxR1NOS9B0nT55kpSU+LcqtVqkdLe+tXmZkvXcdQX2Sf08CUGREpu3IQ8uHHlP7ZrMZsVgMTz31FB555BEcOXKkX++TZPjQ1taG999/HyaTCZdeeikSiZ4wV3pu+OeMl0Naiq+e58YIWvJPS25qbdNXcjyVYqum0PLnrua91goxFteJbVgsFkSjURw7dgwff/yxnEYgURCLxeD3+5FIJOB0Olm1EOCTTPmpxtHpKoRGwpDTPZYRZVN8Rxh57+iN/9M9d7W2jSq0vFyn5H0Xq1ILfAoUW6BHkO7atQtms1mRJRUw1qlShTelY+FJtxOnEpJqyy5EkGp9NoKe55Zfxl8jL1RjsZhUaiW6nDhxAn/4wx9gtVrxne98Z7BPp9+g/qelxBpVbHmlNpXHVi0EmUdMECWGHycSCZaBPhgM4m9/+xv+8Ic/4NChQ/1+vyTDi5aWFmzfvh0mkwnz5s1jeTD4eXhqA1lCK9InFWpyL9190pGlRqsS6E0PEv+nI5f1FFn++sQwRerbkUhEKrUSXUi5NZlMcLvdiEaj7BnipxYQWuNhPUVSRM0QY7Q/9wa+z6lFjujto7ad2J6RNnjUIiu07gEfeUVK7cWeiPVTodgCPcrt9u3bk5RbI/NAU3UYXiho0VtFVNz+QtoSB7labal9ToWWRVgrfERNqT1z5gwOHjx40RSJlvQPJ0+exIMPPgiXy4WvfvWrg306fQ6vJGoliVILQdYq8yMqtlqIiq3oPeO303q/mM1mhMNhvPTSS3j44Ydx/PjxfrtPkuFNa2srtmzZApPJhAULFsDpdLLnz4jMSTUQNjJQ1lqmpfwalZe9+eNlslqbWstSoSab9UI4ydMWiURw6tQpfPTRR4qSLRKJSDweRyAQgN1uV0TyXEjyVSMOJSMKptZ+esqgllLam2mLRt5LRo1yalEVesfm36eRSOSiDj/m+dQotkDP/J7NmzfD4XBg6tSpcLvdLANyOg9qqm20FFQj7RkVllrHMfoHQFO51VqWCqPhTuI28XgctbW1ck6txDBnz57Fz372M2RmZuLzn//8YJ9On8H3CbXQY7Xlav95pdaIYssrs1ohyGoKrRiGHAgEsH79evz2t7/F2bNn+/dmSYY9HR0d2LBhAxwOB2bPno3s7Gzm/eHnbOsN6PRQk2FqMllLkRXXq21/ITJZb15tqrFAOqjdR365eD9MJhPOnDkj59RKDBONRtHe3o6MjAw4HA7EYjFFdCSQ7FnU8zLqjcnTCXFWa0trbNub8b7ecqPta90Dve/8flr3gldqL/bwY55PlWILAF6vF2+88Qbi8Tjmzp2rSIxCqAnRVJYdIwor/1lPOIrt9laApiopILbDfxc/GyWVcisSjUZRX1+PPXv2yNqWkrSoq6vDt7/9bWRnZ2PZsmWDfTp9hto82lRzbNU8tlpzbNXg33likj1xLq2ozNK+3d3d2LBhA/7t3/4NjY2N/XuTJBcN3d3dWLNmDQDg0ksvTYocEOmrwacRma03INaSnVrz2lPJ/b6Sy3yf5FHz2KptSzJ5165dsiKBJC3i8Ti6u7sVIcixWEw1A7qIkbB5I/RGWe1N22qKs9bYV093uJD3XKo24/E4wuEwK6P2aeFTp9gCQDAYxNq1awEAM2bMgMPhSMuSorWNllDitzMqTEVBprYuXeHZW+Gqh5FkFGrXbzKZEAqF0NTUhJ07dyISiegeRyJRo7W1FTfeeCM2bNiAGTNmwOl0DvYp9RrqH3rZj/VK/hitY6tGKmWCthEzH9Pn9vZ2vPfee/jxj38swxYlaRMMBrF69WpEIhEsWLAAbrdbU/7oySRxkMnvo9WWnkKpt424Tk8eqym7WgndjMrm3qAXjpxI9NQRbmhowPbt22XteEmvSCQS6OjoQGFhIZNnorHUiNdWbVv6buQcxG2NjGW1jql3XuK5GVWsxXMzGonCK89aBiqKtAqHw5/KetOfSsUW6LFK/uMf/4DX68XcuXNZRjcarImkemDTUYxTKZda26rtq9WengA1otj2hQAV7wF/Dzs7O9HU1IR9+/Z9asIjJP2Dz+fDpZdeijfeeAPl5eUYP358WuGKQwFeqRVDi7Xm1+qVAUpHseWVWr05RPx8HV6xPXHiBHbs2IEHHnjgUylEJX1DNBrFa6+9hkAggIULF8LtdsNisSgMKCLigE6UW2oyW0vmam0rLlM7lhGl1ogCnI5s7i1qeS/i8Tg6OzvR2NiIDz/88KJPLiPpXxKJBJqampCZmQm73c6SkaXrgTWi8Klto2XgStWOuL1eG6mWGTmuqIAbUeC1FGL+czweZ+HHn0Y+tYot0PMgvPPOO3jnnXdw7733orCwELFYzJDVRa8TqB0nlVAyouzqKbK9EZapBCj/WcsLmwpxn3g8jmAwiPXr16fVjkSiRzQaxfLlywEAtbW1KCkpGTbKrah8pvLURqNR3WRS6SSP4qdaUHgx/53fjldmLRYLYrEY6urqsGTJkoG7WZKLmkQigfXr12P9+vW4//77MXLkSESjUYXROd2BKn1OV/aqrddq18if0RBltXm3asc3MggW1/P7Ul+PRqOKKDaJpK+g+dnFxcWKqSyAtodULaogVSRRKuUW0A4T1kLvfZFqWapjGNneyHhbVHKpPJfP59Pd72LHnHqTTwcPPfQQzp07x+YCpONFVHtI9R5sPSEqrhePka6imq6yq+XpTXe+kNo50/yLdevWGb63Ekm6lJaWoqWlBbFYzLAQG2yof6gptfxnPaU2VQbl3szLFd8BtH00GsXJkyelUivpN37zm9+gpqaGeW37QqE1Kr+Mftdqt7dG5lR5MXozf1frGNSfu7q62BxniaQ/aGhoYIlaCbX+3FtjtF5iJX4bI+8QrX6uN77VO26q89Jbl0pX4CGjwaddqQWkYqvgsccew/bt21nYBKH2UKnNTxHpreAR20wlePv6r7ehy1ptAD2e2nPnzuGdd97po19LItGmqKgIO3fuRCAQMCTMBgu+v2gljTKqtKopwOmUB1I7Nj8ApnMNBoN49dVXsXLlysG+fZKLnAcffBCbNm1ikVSE3oBTb5kRRBnc2++plEpxuV4oczpGZqPnGY/HUV1dLaOnJANCR0cHQqGQ5pQXo1mOe7M+lVKoto1aX0p1vumeQ2/eSSJ0HqFQSGYw//98qkOR1Vi3bh3WrVuHr33taxg/fjyi0ahi3u2FdK5UpBJQav/VlqVj1TUa9qSH2kR2no6ODmzdurXX90Ui6Q2LFy8GAOzfvx/Tp08H0HuLcH+iN082HU+smrIqvg8AZYiTOL+WN+jxc2oBIBaL4dixY7jjjjsG/B5JPr2sXbsWa9euxV133YVp06YhHA6zZIP8s6yFmoJn9E/cR60d/rt4TCPt6s3B1TqWUWhbfm68yWRCe3s7Nm3aZLgdiaQvaGtrAwDk5OTAYrGoKrlaUwHTCcvVwkg7/Llo9Wm9fcTvWiHReuesdp7iMn4+rfTSKpEeWw3++te/Yv369ejq6mK1uPQEHb9eXNYbIar1uTfCWEuh1VN8U12PeD/EdQDg9/tx8uRJqdRKBpWZM2fiueeeG5I1ktXCgPUUVyMhxr0JPVYLQeanY9TX1+PZZ5+VSq1k0Hj88cfx6quvorW1FVarVWGEoWdbxMhg1Kg8TbU9v17rs5YCa1Quqx0znevz+Xw4fPiwVGolg0pHRwdTxui556FyQURfGaSHgmE71XxhtW20lH85n1Yd6bHVYcuWLXjvvfdw+eWXY+HChcjMzEQ0GlU8XGpoKb5622kJqgtRYLWOoyU40zl3Ht4abDabEQwGUVtbi+PHjxtuQyLpT+644w6YTCY89thj+Na3vjXYpwMAqh7VVH9aiaT0FFa1gQOQ7K0VMyObzWa0tLTgzTffxF//+te03gkSSX/w7rvvYsOGDVi6dCmuuOIKZGVlIRKJsOdbHBBrYVTGpZK14vJU31MptUaVZv78tEp+8NsEg0HU1NTgyJEjhu6PRNLfBINBBINBuN1uuN1uNo4UpwEC2mG/6XhfjaJmzErnGGp99ELg9ycvdygUkuW4dJCKbQoSiQS2bt2K7du3Y9asWbjmmmvgcrnYQDLdCel6imMqQai2jZH9jApPtTaN3iOTyYRoNIqzZ8/i3LlzchAsGVLQwPd73/se7rnnHtx111146KGHBvWcEomErme1N8mgtBRb8Z3DK6/0nf4sFgu6u7vxyiuvYM2aNaxtiWQokEgksGnTJmzZsgVz587FihUr4PF4mJHHbDbryku+nb76E4+hJZO1jqs2h1Zrf7X7ISq39D0QCOD06dNSJkuGLH6/H36/Hy6XCx6PJ2k+PY+o6BpVblOhpYymOx7ujz7GTxP6tNalTRep2BqABoh79+7FwYMHMXr0aNx0003weDxIJBIIhUIKYQroW3BomRHFtS8ErZ5Sy8+7M6rYisp8PB7HsWPH0NzcnBTCKJEMJSKRCCKRCB577DE888wzuPzyy/Hqq68O+HkY8c6KiZ7UlFy1bVMptmIpn0Six0pusVgQCATw5z//GXv27JFWYcmQhZ7tPXv24MCBAxgzZgy++MUvIjMzE/F4HKFQCFarVXXgK8rmVHLUyHZG5K9WO1qJobS25+FDF/l1sVgMhw8fRlNTkzRMSYYFgUAAwWAQNpsNGRkZrC/YbDbV/BD9gdq4vb+VWq2kePzyUCg0rKo8DDZSsU2DWCyGQCCAU6dO4bHHHkN2djZuu+02hTAVE66kEpgivVFy1fYz8qclRPlja50j0FP/7siRI/D7/QiHw1J4SoYNFAa1fv16VFZWorS0FO+9996AHd9ouLHaMq2Mx2qKLd+n+f7Jh32ZTCZ0d3fjj3/8I+rq6tDV1SWtwpJhQTQaRTQaxfHjx/HQQw8hOzsbq1atQm5uLlsHqBtj0x2w9qUSLE5D0DI8q8lj8bz57SKRCA4ePMhkstq8Y4lkqJJIJBAOh9HR0QGz2Yzs7GyFB5ccSH2p4BoZ6/LbpMqGrKaYqh1DrR0xEWsoFErrXSXpQSq2vSAajaKzsxPd3d14+umnYbfbsXLlShQWFsJqtTKvEN8JU5GuBVhtP/pupD01IcrvL7ZFCnssFkM4HMaxY8cQjUYRCASkQisZtgSDQZw5cwbnz5/H7Nmz4XQ6sWPHjn49JvW9VB5YrXm14vapFFvgkwQd8XhPKTN6T7W2tuLJJ5+E3+9HQ0MDyzYrkQwnotEo2tvb0dXVhT//+c9wOBz47Gc/i1GjRsFqtSIajTLDs2jw0cKogdiI3L7Q9tTOiQa/sVgMkUgEhw4dQjQahd/vlzJZMqwhWdXR0QGgJ4sywT/7/eG9NfJe0KoAomeA0mpHVNLj8TiTw7If9w6p2F4A8XgcTU1NMJlM+Mc//gGn04l58+ahvLwcbrcbkUiEJZvSEqTpCsDerlcLSUwlQPnP4XAYfr8fNTU1iMVi8Hq90ookuWgIh8PYt28fzGYzrr76agDA//2//xdTp07tc+GpFzacTjiyuE5cxvd7mqOTSCTQ0dGB+vp6rF27FqFQCGfOnJECVHJREIvF0NDQAJPJhNWrV8PlcmHRokWoqqqC2+1GNBpFOBxmhiVAmfwwHVlrVJnVakfLQ6s3PYg/13A4DJ/Ph+rqasTjcXR1dUmZLLmooD7a1dUFAHA6nSwPBO9w6Y95tmrL+T7YF/Ale6hPa+kKEuNIxbYPSCQSqKurA9AzET47Oxt2ux1z5sxBfn4+rFYrS64kxsn3xrrLr0+1rdF5tbwVmN/O6/Wirq6OWZFkAWjJxUw8HseGDRsAAPfccw8KCwsBAL/97W9RVlZmOOuqXvuiR1X8rJdAyqgXNx5X1t4OhUKorq7Gxo0bEQwG4fV6cerUqQu7WRLJECWRSOD8+fMAemTyhx9+CLvdjkWLFiE3NxcOh4NFLfAyWc/Q2xvl1shfqnBk/hxisRg6OztRV1fHPLU06JdILlZ4DyYpsg6HA3a7XaHg6imEtO5CMinr7WtUGeXPk8bV4thccmFIxbaPaWhoQENDA4AegZqZmQmLxYKKigrk5+fD5XKxwbEozNRCpNIVqGoJY/Ta549DgtLv96OtrQ2JRE+ZAAoHkUg+TWzcuJF9NplMyM/Ph8lkwk033YR58+YhIyMj7TaNhBSnmmdLcwdFby2dZzweRzAYRFdXFxobG7F//35Eo1E0Nzfj8OHDfXZ/JJLhQF1dncLwnJGRAbvdjqqqKhQUFMDtdsNmszHZGI1G+0Umaxm1tGRyPB5HNBpFJBJBIBBAa2sr4vE4/H6/lMmSTyX8nPFEIsEUXqvVyhxIQHLdVx5xmdi3tbbrLWqJ3XhjmpwH3/dIxbYf4T0ijY2NyM/Ph9vthtVqRWZmJkaOHAmbzQartednoFBBtaROWlZdNc+PXhIKao8EOHlhfT4fU2yDwSA6OzsH9mZJJEOYF154gX0+deoUZsyYAbfbDQAYN24cli5ditzcXNhsNs02yHhESikpqPwf9UG15VpGq1gsBp/Px7yw58+fRygUQnd3N5qbm2XtSonk/3Ps2DH2ua6uDoWFhfB4PLBYLMjKysKoUaNgt9uTZDKgnO/WW0VWy1NLx4hEIgiHw+js7FTI5EAgIJVZiYSDTw4XjUZhNptZ+TqLxcJksZ4nV21sLKKmJItzY+kzP2YnSInl3yPSM9u/SMV2gKitrUVtbS37npubi9GjR8PtdsNut7N5A8XFxbBarar1JflQCv4z38n47/zAlwbL7e3trKNRkquOjg74fL6BvykSyTBk/fr1WL9+Pfs+depUHD58GPn5+bDb7QB6LMhLly5FZmYm3G43HA4H69M0WKYSO5TQieYN0TJeaFLym1AoBJ/PB5/Ph4MHDyIUCiEajcLr9aKzsxNHjhxBTU3NwN8UiWSYUV1djerqavY9NzcXFRUV8Hg8cDgcMJlMsFqtKCkpgcVigcViUXiE1Aa3BC+LRZlMHhuSv+SJBXrm+ofDYbS3t8Pr9Q7g3ZBIhi/UpwhRhgI9/dNms6WV1JXfV++zmrGKlsusxgOPVGwHifb2drS3tyuWmc1mTJ48GS6Xi80BEovN83+kEAcCgaSQYzGckQRmbW2ttBZJJH3IwYMHcfDgQcUyu92O73//+ygsLERubi4yMjIUdTXFPpqTkwOTyYTGxsYkzy313WAwCL/fj87OTnR2duLtt9+WZXkkkj5CSyZPmzYNLpcLTqcTdrsdZrNZM08FKcS8TBaTulH/pj5NCRklEknfICq6PGoeXLXSPLRdqvEyv43sx0MDqdgOIeLxeNIAWY/s7GyYzeYkYSyRSAaXcDiMhx56yPD2EydOhN1ux4EDB/rxrCQSSTrE43F89NFHhrfPycmBxWJBa2trP56VRCLpDcFg0PC2lAtHKqvDD6nYDmPkPFiJ5OLg6NGjg30KEonkApHzYCWSiwOp0A5fzIN9AhKJRCKRSCQSiUQikVwIUrGVSCQSiUQikUgkEsmwRiq2EolEIpFIJBKJRCIZ1kjFViKRSCQSiUQikUgkwxqp2EokEolEIpFIJBKJZFgjFVuJRCKRSCQSiUQikQxrpGIrkUgkEolEIpFIJJJhjVRsJRKJRCKRSCQSiUQyrJGKrUQikUgkEolEIpFIhjVSsZVIJBKJRCKRSCQSybBGKrYSiUQikUgkEolEIhnWSMVWIpFIJBKJRCKRSCTDGqnYSiQSiUQikUgkEolkWCMVW4lEIpFIJBKJRCKRDGukYiuRSCQSiUQikUgkkmGNVGwlEolEIpFIJBKJRDKskYqtRCKRSCQSiUQikUiGNVKxlUgkEolEIpFIJBLJsEYqthKJRCKRSCQSiUQiGdZIxVYikUgkEolEIpFIJMMaqdhKJBKJRCKRSCQSiWRYIxVbiUQikUgkEolEIpEMa6xGNopGowCAgoKCfj0ZiWQ4Q/2D+stQRPZliSQ1Q70vy34skaRmqPdjQPZlicQI6fRlQ4ptR0cHAODmm2/u/VlJJJ8SOjo6UFZWNtinoYrsyxKJcYZqX5b9WCIxzlDtx4DsyxJJOhjpy6ZEIpFI1ZDf78epU6eQk5MDq9WQLiyRfOqIRqPo6OhAVVUV3G73YJ+OKrIvSySpGep9WfZjiSQ1Q70fA7IvSyRGSKcvG1JsJRKJRCKRSCQSiUQiGarI5FESiUQikUgkEolEIhnWSMVWIpFIJBKJRCKRSCTDGqnYSiQSiUQikUgkEolkWCMVW4lEIpFIJBKJRCKRDGukYiuRSCQSiUQikUgkkmGNVGwlEolEIpFIJBKJRDKskYqtRCKRSCQSiUQikUiGNf8PCMnobrE+gz8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "importlib.reload(ps)\n", + "ps.plotCoefficientMaps()" + ] + }, + { + "cell_type": "markdown", + "id": "edd72a17", + "metadata": {}, + "source": [ + "### Temporal Signal Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "92b113c5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "importlib.reload(ps)\n", + "ps.plotTemporalEvolution()\n" + ] + }, + { + "cell_type": "markdown", + "id": "74857a61", + "metadata": {}, + "source": [ + "### T1 Map from Reconstructed Images\n", + "Using `bart mobafit` we obtain T1 parameter map via pixel-wise fitting. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "cb9b6bbe", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "bart: src/mobafit.c:303: main_mobafit: Assertion `bas_dims[TE_DIM] == enc_dims[TE_DIM]' failed.\n", + "\u001b[31mERROR: Reading input from -\n", + "\u001b[0m\u001b[31mERROR: Reading input from -\n", + "\u001b[0mbash: line 7: 711121 Aborted bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs -\n", + " 711122 | bart looklocker -t0 - -\n", + " 711123 | bart fmac roi_mask - t1map\n" + ] + }, + { + "ename": "CalledProcessError", + "evalue": "Command 'b'TR=0.006 # [s]\\nREP=700 # Repetitions\\n\\n### create vector with inversion times nREP*TR\\nbart index 5 $REP - | bart scale $TR - TI\\n\\nbart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map\\n'' returned non-zero exit status 134.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[35]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbash\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mTR=0.006 # [s]\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mREP=700 # Repetitions\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m### create vector with inversion times nREP*TR\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart index 5 $REP - | bart scale $TR - TI\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2565\u001b[39m, in \u001b[36mInteractiveShell.run_cell_magic\u001b[39m\u001b[34m(self, magic_name, line, cell)\u001b[39m\n\u001b[32m 2563\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m 2564\u001b[39m args = (magic_arg_s, cell)\n\u001b[32m-> \u001b[39m\u001b[32m2565\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2568\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2569\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2570\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:160\u001b[39m, in \u001b[36mScriptMagics._make_script_magic..named_script_magic\u001b[39m\u001b[34m(line, cell)\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 159\u001b[39m line = script\n\u001b[32m--> \u001b[39m\u001b[32m160\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshebang\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcell\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:343\u001b[39m, in \u001b[36mScriptMagics.shebang\u001b[39m\u001b[34m(self, line, cell)\u001b[39m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m args.raise_error \u001b[38;5;129;01mand\u001b[39;00m p.returncode != \u001b[32m0\u001b[39m:\n\u001b[32m 339\u001b[39m \u001b[38;5;66;03m# If we get here and p.returncode is still None, we must have\u001b[39;00m\n\u001b[32m 340\u001b[39m \u001b[38;5;66;03m# killed it but not yet seen its return code. We don't wait for it,\u001b[39;00m\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# in case it's stuck in uninterruptible sleep. -9 = SIGKILL\u001b[39;00m\n\u001b[32m 342\u001b[39m rc = p.returncode \u001b[38;5;129;01mor\u001b[39;00m -\u001b[32m9\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m343\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m CalledProcessError(rc, cell)\n", + "\u001b[31mCalledProcessError\u001b[39m: Command 'b'TR=0.006 # [s]\\nREP=700 # Repetitions\\n\\n### create vector with inversion times nREP*TR\\nbart index 5 $REP - | bart scale $TR - TI\\n\\nbart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map\\n'' returned non-zero exit status 134." + ] + } + ], + "source": [ + "%%bash\n", + "TR=0.006 # [s]\n", + "REP=700 # Repetitions\n", + "\n", + "### create vector with inversion times nREP*TR\n", + "bart index 5 $REP - | bart scale $TR - TI\n", + "\n", + "bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "79442445", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAW91JREFUeJztfXd4FcX6/2dPy0lPSAEMkEBCKBIBARERaSKgggpYUMQOiICAqD/FyxXlguWq6FVRsWBBRBQERMRIF1FAEQWBANKUkhBIL6ft7498Z5idnd2z5yRoDmc/z5Mnye603Z133jrvSLIsyzBhwsR5D8s/PQATJkz8PTCJ3YSJMIFJ7CZMhAlMYjdhIkxgErsJE2ECk9hNmAgTmMRuwkSYwCR2EybCBDYjhSoqKnDgwAEkJCTAZjNUxYQJE38DPB4PioqKkJmZiaioKN2yhij3wIEDWLx4cZ0MzoQJE3WPIUOGICcnR7eMIWJPSEgAAHz++ec4depUrQdmwoSJukFycjKGDh1KaVQPhoidiO6nTp3C8ePHazU4EyZM1D2MqNemgc6EiTCBSewmTIQJTGI3YSJMYBK7CRNhApPYTZgIE5jEbsJEmMAkdhMmwgQmsZswESYwid2EiTCBSewmTIQJTGI3YSJMYBK7CRNhApPYTZgIE5jEbsJEmMAkdhMmwgQmsZswESYwid2EiTCBSewmTIQJTGI3YSJMYBK7CRNhApPYTZgIE5jEbsJEmMAkdhMmwgQmsZswESYwid2EiTCBSexhiKioKMTHx//TwzDxN8Mk9jDE+PHjMW/evH96GCb+ZpjnL4c4VqxYgQ4dOkCSJACA1+uF1+uFz+cDAEiSBIvFQn/Lsgy73Q6LxYKDBw+q2pNlGQBoHXLN5/OhvLzc70mhJuovTGIPEfzvf/9DVlYWJEmiPwDQpk0bOJ1OAEpCJcRKCNXr9UKWZVpPkiTExcXROiKQsgQxMTFYtWoVfD4frSdJEtxuNwYPHlznz2yibmESez3EgAED0KlTJwCgBNq3b1+kpqYqyvHECNQQus/no5xdlmXaBuHsLMfWaoeHLMuwWCzo3Lmzoi4AeDwePPHEE/D5fHQhOnnyJObOnRvE05s4VzCJvR4gIiICl156Kf1/xIgR6N+/P4CzxM4SJEtoLOESLr5hwwa4XC5FXZvNhssuuww2m03F4XkQiYDvix0PWTiAmuOCJ06cqOjv0KFD2LdvH623a9cuFBQU1Oo9magdTGL/hxAfHw+r1QoASEtLw2effUbvEcLl9WaWQAnBeTwelJWVoaKiAl6vF0DNYlFRUaHqc+PGjYiPj6difkREBBISEhRts33pifiiBYddlFq0aIElS5bA5/PBarVi/PjxWLFiBa175syZwF+aiVrBJPZ/CLm5ucjKylIY0vTAEhfRmd1uNwDgmWeewZtvvum3zx49eij+j4+Px+7du+FwOFSiPT8mPcIXjZMt7/V6MXv2bMyePRs+nw8VFRVo3rw5fXYTfw9MYv8b0axZM6xbtw4ejweJiYkqjkog0qUJ15RlmVrbO3XqhMrKSlRVVQU1nuLiYrRu3RoA8MEHH6B79+6wWCy0v0AI3OhiZbFYEB8fj/3790OWZUyaNAnLli0LavwmAoNJ7H8DJk6ciL59+8LpdCIxMRFer1eh82qB55Jerxc//PADZs2aBVmWUVBQUGvuWFJSAgB47LHHcM899+C2226Dw+GgYzQCrQVLawHw+XyIj4+HJEl44oknMHr0aBw5cgT3339/8A9iwi9MYj9HsFgsmDx5MqxWK66++mq0a9cOgFgf5gmDJxJiePv222+xcOFC/PDDD6r+oqKi0KRJE5UxT4SCggIUFhYqru3evRuffvopZFnGiBEj4HA4qHVdNCZ/0CtPbBIAkJWVhaysLGRnZ+PRRx+FLMuYO3euqdOfA5jEXsdITU1FVlYW7HY7pkyZApvN5lf39UdIPp8P27dvx/z58/HVV18p7sXHx8NutyMhIQHZ2dnU6KfXZ2RkJCRJgs/nw+nTp+n1LVu2oKioCBkZGejdu7eumhEM8bNEzo+rQYMGmDJlCmRZxsGDB3H8+HHk5+cjLy8voH5MaMMk9jpCbGwsrFYrrr32WsyYMQMOh4OK6oH4s3n4fD4UFBRg4sSJ2LNnj+Ke3W5Hhw4dkJCQQK/p9Uf+b9asGZo1awa3243c3Fxq6AOAvLw83HXXXdi6dSuSk5NV9f0Rut4iw9dnx8rq9G+88QYkScKSJUvw0EMPQZZlFBcXa78kE4ZgEnsdYfXq1cjMzITVaoUkSXC5XNQVBgRP6B6PB507dxYa4a666irKyQF9jstzVaBmsbjmmmuwYsUKBcGXlZWhTZs22LlzJxo3bqxQO/QMdyI3oVYZfmzs38QOMXjwYAwePBhutxvp6emKMZoIHOZGmFogKysLv//+O/bu3YumTZvC5/PB7XbD5XJRH7kRHZoH62cXEVZERAQGDhxICV3EIXmIfOGk3lVXXYWkpCRVne7du2PdunV+jYD8MwYj4rPjY8N9JUmC3W7Hrl27cPjwYdxyyy0BtW3iLExiDxL9+/fHnDlzkJqaisTERMrRrVarwn3Fi7UiDisSdwHg1KlTuPHGG+Fyuei9Bg0a4JJLLoHD4QhovHpGQKvVipycHDRr1kxRp7i4mAbrsBJEbQibjIXU5Qmdv05+GjRogJiYGDz44IOYPHlywH2aMMX4gHHfffchLi4OHTp0QMeOHQFANVmNgJ/wBMRw5vP5UFZWhk2bNtF7KSkpaNq0KRo0aKDbrlYIrN61+Ph4NG3aFLIs4+jRo/T6kiVLEBkZib59+2p6Eow8qz8R34gdQJZlZGdn44YbbqDjePnllxXqkgltmMRuEJIkoXPnzpg0aRJSU1NpcAsROwHxxDcamMJP9lOnTmHbtm2Kaw0bNkSTJk0M7VQLRG8mhJOUlAS73Y6ysjLq+lq8eDHS0tLQs2dPw353vn8ji6CRIB7STtu2bdGmTRvIsowtW7bgp59+QmVlpeGxhStMMd4ALBYLkpKSsHTpUqSkpACASmTnIRLXtSAihh9++AGjR4+m/1utVqoqkPbZfnidPVgDWVxcHC677DLFfa/XC4/HoyqrhUANdIGAf6/Lly9Hu3btYLfba9VuOMAkdgNo06YN9uzZo9o3rodAjHN8ex6PR2V57t69OzIyMhTti/qpLTEBEC5ggbRbF2Pw1z4x4smyjK+++gojRow4p32eDzCJXQevvfYa8vLysHz5csiyTLmbHvxZxf0Z54jlW0RwRiUFo/WMbnp59913MXz4cKq21LZf0h/vGdAqJ/qf2DWI1+LJJ5/E7t27sXr1asPjCzeYxK6BuXPnom/fvmjQoAFNzhioDhrIdSKe+nw+vPvuu3jppZcU9/XsAnUxFr12q6qqUFRUBI/HA6vVGpR6oid9sITvbzHUUltiY2ORmpqK7OxsfPDBB6ZYL4BJ7BxsNhsmTJiAfv36ISUlRRH1xU9Y/odc5+FvceAnb15eHn7//feA26kLEE6ZmZmpki48Ho8i240RoxogJnSysJGceR6PBx6Ph/5PdvYR7s3/sONlrzmdTlx55ZV44IEHVBGA4Q7TGs8gKioK7du3x7///W/FJhAWeiKxlsjJu554EHcbH14rakuvv0Bi1v0Z0dq2bYujR49SHz8hzkAt8rwkQIj3559/VhEy2z/5TfTzDh06KPoW+fpJGxEREXj88cdx7NgxrFu3Dvn5+YbHfD7DJPb/g91uR05ODs2uYmQLqsgyzt5jJy2Z0Dw3ZMsZ6ZPvm79mxKdNoLdAiYiaTWJpJGSW1HG73ZCkmhDiiooKVFRUYODAgYa351osFuzatQtOpxNOpxN2u10YJMSP7bXXXsP06dMxd+5cVFdXG+rrfIYpxv8f7rnnHnz55ZfU4s6KkFrQsriz4Z5sObYe3w6p50+nN7oAifrRatcICIc1GsDCEp7L5UJVVRU++OADZGZmIicnJ6B9+D6fD23atEHz5s0xf/58uN1uhSohAvkG06ZNM5TFJxxgcnbUcICBAwdClmVUVVVpbi5hiY3olUDNxLLb7VTPJAE3sizD6XQq2hMlhSB9EIni79DN9SBJksrzQOIKRO9DpE6QH7fbjQEDBuD48eN1Evgyffp0PPvss0hLS8PXX38NSapJpsn2zf4tSRL69euHjRs3qtJyhRvCnthfeeUV9O7dm+ZQJ9lXgbMTh+jvhMBff/11/Pjjj4qJxevbrBh73333oUePHrBYLDQpBM9RWcPXXXfdhbi4OLzyyiuq8Qa7EBi1vAM1C9KWLVtUvn6r1erX/cbm1PN4PLjrrruQl5enmTrrwgsvRMOGDYX3Tpw4oTJUlpaW0p+RI0fizTffRExMjOL9s+OzWCxwOp3IzMzE/Pnzcffdd4etSB+2xG6323HvvffimmuuQVxcHICzYjTh2KxP1+Vy4d1334XX68XixYuF1nItREZGYufOnUhISMBtt90GAApuRPoiE7VNmzZo37694n4gLjd/ero/+Hw+lVGL5exafbEcPz8/HwsWLMCqVauE4yO57zIyMpCUlCS07EdGRioWzX379lGDYVVVFXJzczF37lzcfvvtNLJRa2wOhwP9+/fH6NGjsWDBgrBMax2WxB4VFYWcnBzMmDFDcbABu1uNID8/H0eOHEFZWRmefPLJoPzcy5Ytw7Jly9CoUSOaxaZdu3Y0Y4wRlJSUwOl0IiIiQnFdZKgKFlp1U1JS0LJlS6qza7ncSP2TJ09i7dq1eOqppxT3IyIiEBMTA0mq2WfgT9pISkqiW28tFgvKyspw4sQJypllWcbMmTPRrFkzXHHFFdRVKnoWMuZp06bhxIkTWLt2bdgRfNgZ6Gw2G9q3b48vvvhCYdXlJ57P50NJSQk+/vhjDBgwAMOGDVNZ0YkRSOuHx4kTJzB48GAMHDgQ27dvR0VFhcJCr2c93759O/766y/FGMk4jILXZ43ixhtvxOzZs4X32P7JeXALFy7EAw88oChnsVjQvHlzXHPNNRg4cGDAY/D5fOjduzeaN29O9wkQjBkzBp9++ikqKysV1/nxEbz22mu49dZbA94mHOoIO84+btw4TJ8+HV6vF9XV1YrINPJjtVpRVFSEMWPG4JtvvhG206hRI7Rs2RKA2i9M2tmwYYPmhB48eDBmzZqFESNGICoqSiFh8JOZh9FgFhZ64jdb5vTp0/juu+9U1414JlwuF0aNGoWVK1eq7l9++eXIyMigzxhMVlyv14suXbqgS5cuKC8vx+LFi+m9J598Etu2bcPbb7+NiIgIVfv82B9//HF07doVt956a8DjCFWEFbG/8cYb6N+/Pzwej+bkJxb56667TpjssEuXLoiIiBC603jufOmll1ILe0FBAfbv369oa9asWfj9998xa9YsxMTEKA5fvPLKK7Fy5UrKBQFgz549KCkpofvoRQhGzQDO+tV5ieSFF17A1VdfTQ2LbB+8P9/tdgtdc4MGDUJCQgIlcpGorSfV+HOzEXz77bcYMGAAVq1aRW0iIgmILKi9evXC+vXr0bNnT912zxeEjRj/+uuvo1evXoqTS3kXkizLKCkpwT333IO8vDyF1ZZElUVERKiCS0QhnECNUcjpdMLhcCA5OZlKAgQlJSXIzc3FI488gqqqKgURREZGolGjRoryHo8HJ0+exPbt2wOOZNMDeZY///wTu3btUtxLTU1VJLTUgs/nw8MPP4xffvlF0W7Pnj0RGxsrDCYSjUFrfDycTid69eqluFdVVYX8/Hy/MQlEUnE4HMjKysK8efNofMX5jLAhdhLrLgKZGAUFBXj33XexcuVKSuhRUVFo3Lgx0tLSkJKSohnlpkX4BBEREUhJScEFF1yguH7ixAl89dVXmDt3Lo00A2omeFxcHO6++26FSF9dXY1jx47hjz/+8BshR+CvjCRJOHbsGI4cOaLIJz98+HCkp6cLn5lv0+12q0JTJUlC06ZNqRXf33gDsT/YbDY0a9YMbdq0URktAf+7D4mk4HQ6cc011+iqTecLzntit1gsaNeunepj8oTp8/lw5MgRzJgxQ1EuPj4eWVlZaNGihSIJIg9/kW9AjbsvKyuLWqQJioqK8O9//5v6okkfiYmJ+M9//oOcnBzFhPZ4PPjtt99QUlJSJymZSktLsX//fpW77fHHH0fr1q0NbbclUW0EVqsViYmJiihDI75+I2oI+047d+6MyMhIxTh2796taxNgvS/kd5s2bRTtnI84r4ldkmoSFW7atIluUyXXWR86AFRWVqpOISG6HZnsRKcWgeVaIpGUnaCdOnVCVFSUqo2ioiLaBzGIRUREYNmyZWjbtq1qwVq/fr0inzpPWKIfdjwkVfWGDRtUzx4REUFz37NuSRGHJxGDLOLi4nDNNddoGgJFf5P2tCBSvwAoMvgUFBSgT58+qKys1NXz2XcsSRK++uorXHzxxec1hz+vib1Lly7YuXMnNcixBMeu7G63G++++64qTXGbNm2QlZVlSD/mjU5a/l6CSy65BI0bN6b/+3w+dOjQAbt27VIQjsViQWRkJJYvX4477rhD1c7GjRtx4MAB3XGJ9OPTp0/jyy+/xFdffaWKlIuJicG+ffuQmpoqrMujsrISmZmZOHnypOY4tMYUiOiuVXbAgAHIyspSXCNqmJH2iQdm2bJlGD9+vOHxhBrOW2v8Pffcg4kTJyrOLNPStUWbXoh4KBIHgw1c4Y16GRkZiIyMxB9//EHH4vF4VFtJScjnlClT0KpVKzz66KOKdvPy8mgbBJ06daKGNTKZ165dS2PetcTcDh06YN68eYiPj6c2BL3n5S30QM3Z7BdffLFi44y/d2bEGq8FUS5ALemKvc5+D3J/7NixyM7OxtixY3XHG4o4b4k9Li6OZoHVmixkIr/++utYsmSJ4h6xuvvTIbXa5sV60X273a4K7Hjqqacwbtw49O3bFwAUC1VycjL69+8PWZbx//7f/6N13G63ijuTc9fZsZSVlWk+z6RJk9C2bVskJyejSZMmAaXg4mG32zX1X71voXfPyDUWZI8DT/Raf5O5kJCQcN4mvTgvib1fv37o2LGj4kNrTUyfz4ctW7Zg9+7d9FqjRo1qdVyxv/IsZ+Hrb9y4Eddcc40wUYTVakWTJk1www03YNeuXXC5XMjNzVUczkjAn9Iqgt1ux9ChQ2Gz2TBkyBBkZ2fTPkXJO0QGNpH3gTyX6J0HQtR6HF3PVSfLMhYsWIChQ4cqCFdvTOS3xWJBkyZNcMstt+CTTz4Rth+qOO+IvWXLlnjooYdw8cUXA9CPHScGKnYCWCwWZGdn07o89ERNUTmWu4gmus1mQ2RkpGL7J9ldR1xW/N745ORkPP/88zQRxN69e6mRjBfnRSAx5zExMZg5cyYiIyOFe/D559K6x6sEhGjYc+j1Fjj2PYneoVY5SZKEiyIATJ06FV27dqWbbHhoifnEMj9r1ixs374d+/btCyrarz7ivCP2lStXIiEhQSi+i6zlWgYsIPhoNAKRKM/31aBBA1x00UX48ccfFfVEujDLTa1WK5KSkjBv3jxUVlbC5XKhqKgIXbt29Tuuu+++GxMmTIDFYqFWd3bRM+r+Ev1NYIRwte4bUY34uvx1u92u6x3RGiMpl5iYiO+++w6ZmZkoKSnRHXuo4LwjdqJr6rmKyG+ykvPQExEDQbCGPN5zoPV3RUUFLBYLoqKiEBMTg7i4OBw+fJgaHInRkXA/q9UKu90Ou91O3VXsARCBjI+VUrTcVcG+Rz3RnR+DqLwkSfjjjz/oFlmjY2AllfOFm7M4b4g9NjYWGzZsoIEcRsH6aFkEIsIHCzJh9ewDIg5KxkGs0GRySpKkitvn9WdC/OzRVXq2Db1n1tK/iXqkp5/XJUTxD2wSDQIjxlYe69atwz333IPt27fXwUj/WZw3fnaLxYKMjAyhC0ZLTySczcjKb3TC6hmujEK0AOipG2zfhJhJamY2RbOIY7HBJbUZL4vjx49j+/btARF5XUhSLPQiC424Acl40tPTz5u4+fOC2FNTUzFs2LCAJxcx8ASqo+pd0zPg6VmPtdoQEThP+FqSieiHL8OK+rwdQ2sxYX9EonpJSYli770RBMP9Sf9HjhxRRBKSe2y7omfSU/FYXHXVVcjJyQl4fPUN54UY37JlS8yaNQuA8W2TejBqINIjbN4ar+dqEhEhuS9ajLQmJXufqCd8H/4WrWDfWWZmJg4ePKjiqFruNC3vBE+keiBlduzYoQr3Ze8b4eSkHD8mWZYxceJEVFZW4rfffvM7pvqMkOfsFosFNptNMxmiiJD8idqsaC8ylhmFVhta5Xho6dJG2mNPWeHFdLYey/H8eSH4sqS80+nE+vXrVbsKRe9Zy+VFfge60IgWQ5vNZuj4J34x0HqnxB4S6nHzIU/skydPxsKFC4UfIhgO5fP5sGnTJlVEWiAwylGAmo0bW7ZsEbbhL7CHiN8iP7fNZqM/RvR/fuyBgPTD4syZM/j44481VR1evGb7DmQMCxYsQFFREf2/cePGyMvLQ2xsrKKcFiGz6ohev1OmTMGnn35qeFz1ESFP7FarFTabTbXFUgQRVyc7u7TKGYHIYm6krNbkYnPYsXHfhGO7XC4aIssa5VjwZ6iJUBtVhYfdbscXX3yhyM3u8XjwxRdfKBJziPoLxj1GjKuihS46OlpFwHqLm0jV4ecKkSBDGSE9+kmTJtFtlHqiJw92wlitVowePRrR0dH44osvhOVE9Vndju2fnzhaeim5zvfxyCOP4IorrlBEnrlcLng8HixZsoTmtSP1+fPP2HuDBw9G//79qXvOyPsQEbqeeM/WycjIQHR0tOJ+aWkptmzZggsvvNBvzLmevs4Tb2VlJbZt26Yg9vbt22PcuHH0wA6twz60+mX/FtlJsrOz8eyzz6o2IoUKQprY+/TpgwsvvBCAcYOOiLP26NEDO3fuVBB7QUEBkpOThVlQWGhNIiPW8pKSEpUVuX///nS7JtFHFy1aBJfLhSVLlmDjxo1+n5OgsrISxcXFimws7PPzG3386cy8bsu/T4vFgu7du+P48ePYsWMHvX748GHqvuIJXuub6KG0tBRHjhxRhAZ37NgRw4YNw3XXXadql+fYRtQF0QKempqKoUOHmsT+dyMjIwMOh4Nyt0DEbh6SJCE+Ph6NGzfG8ePHAQAHDhyAJElISUmh/ZCy/N/B9F1dXY2//vpLkbs8IyMDTqcTkiShtLQUBQUFkCQJDz30UFCnmJB89fHx8WjVqhVsNhsaN24Mp9Np6Lx3f8TPG9YsFgvuvfdexMXF4bnnnlO43/bu3QuXy4VOnTopuL8RoxwpU15eDrfbjT///BM///wzvZ+WloZ7770Xw4YNg9VqVWzi0TKwGlVVeKnGarWiefPmNFIxlBCyxL5hwwbExMSoLL2AvuuM/1+SJNjtdgwfPhyZmZkYPHgwvb9//35UVFSoEiMYcZn5w6+//qrY/GKxWLBhwwZER0fD6/Vi9erVuO+++zTr6xnv+ElYXFyM7t27AwAWLVqEyy+/XJgXzghh8+Dfhd1ux6233oqLLroIffv2VYzl4MGDOH36NK699lrFxhst9YD92+fzITc3VxWnbrVasWDBArRq1UoxVq1nEnF8re8pqhsbG4sffvgBrVq1UhgGQwEhS+zEpcTCiFWVB0vwokipY8eOoaSkhO6iY+vx0BPnybg8Hg82bdok5ArV1dWIiYnBv/71L7z99tuaY46Li8Ozzz5L22UnrcViwfjx4zUlgVtuuQVTpkzB5MmTVZtF9KBnFxGNo23btvj111+Rk5OjqFdcXIwFCxYAAK6//nrExMQo+mfHQQ7qWLZsGf2fhcViwcGDB+FwOBSGTBJBSPYEsGmy2SAico1IA1rPxSNUXXAhR+zx8fFYtWqVMD0xYJyrExCuAQCtW7fG8uXLMWjQIEWZ8vJy/PTTT+jUqVNAY+VFSZfLhR07dqgmVsOGDfHxxx/Ts+A2b96sCk4ZN24cTWNFMteInkuWZTz55JMAgFWrVmHdunWK+16vF3PnzsXBgwfxyiuvGPJHi/phVRgtgmjYsCG+/fZbDB8+XJHMkjx/bm6uX/eiyOIO1Lyz+fPn0wM2ZLkmy8+xY8dw4403CtvSkyK++eYbVSJQ9j6gfAerVq3C2LFj8dNPP+mOvz4h5IjdarUiOzs7IFeNPyss4brR0dHo0KEDZs2ahVmzZlGRUZZllJeXIy8vD82bN1dwRC0i4O+REFL+2OKOHTvi/vvvR2ZmJh5++GFs3rxZJR7edtttaNWqFdV1eRGXN3CRU1F79OiB9PR0uFwuyk0B4PTp01i3bh2mTp2KmTNn1plLiX/PFosFOTk5ePrpp1FWVobNmzfjs88+o/dLS0uD6qdDhw4YM2YM2rZtC4vFAo/Hg88//xzff/89ysrKsG/fvoDbfOSRR+BwOHDttdfiyiuvpEFaWvagzMxMYdLQ+oyQI3bAWBSbyM/qz+orSTV5xG+99Vb8+uuvWLNmjSKJ4okTJxAdHQ2Hw0HddomJiZpjyM/Pp/0UFxerDhK86KKLMGTIEFx11VVYvnw5PvroI4VP3OFwoGPHjujZsyc9l05kBdd6N+np6cjIyEB1dTX279+Pn3/+mUoM+fn5+Pjjj9G5c2fccMMNlOD59+JPdPd3z263Y8iQIfD5fGjWrBkVr4loHgh69+6N2NhYXHLJJbjhhhsAAEuXLkVVVRUWLlyIDRs2BNwmAQmYKSsrg9PpRPfu3SHLskLED0Q9rI8IKWJ3Op1IS0szVDYQdxgflOJ0OvHUU0/B5/Ph66+/VrjH2EyukZGRaNeunbBdWZaxZ88ezfE1atQIo0aNwvXXX4+TJ0+qspo6HA40bdoUY8aMUY3VKAGSRSEiIgKjRo3Ck08+iZMnT9IFpbKyEvfffz+uuuoqmmqb78sItBZRNhbAYrGgd+/e6NmzJ9xuN3bs2KFSVXgPAW9Ae/rpp9GiRQvKdY8cOYJRo0ZpRjtGRUUp9Gt+TrjdbpWk9cUXX+Cvv/7Cyy+/DLvdjubNm6ukQ6L6paamIj4+XuU+ra8IKWLv2rUrFi9eDJvN5ndrqhaxs0kdCOfnUzJ5vV4kJyfjv//9L9q0aUOPHuZ1x8rKSmzdujWgZyAT+pNPPkGbNm2EmVGBGq4/duxYyLJMY/79WY3ZSSnyn0+fPh3PP/889u7dq6hPiN+o31kPvDuOHyPJjrN161ZUV1fTxctisSA2NhY2mw1VVVU0OpA8t91upwY2r9eLv/76C5deeqnmWIGaM+bIMc786bokhdfy5ctV72vr1q247LLLAAC///47kpKShN/onXfewX//+1/VwSL1FSEXLivLsqHQWEAcA26z2eB0OhEZGUnFccLZ2SQQXq8XUVFRGDNmDA4cOBDw/mwRmjVrhgMHDuDAgQNo3749HA4Hli5diksuuURR7rbbbsOYMWMUhKDVt5a0wj47O9EnT56Mq6++WtFGu3btsHHjxqDiBQKtw2bMiY2NRVxcHOLj4xETEwOPx0Mz4DocDpoyixgRCaEvXbqUEiOPmJgYjB07Fg888AAaNmxI3x2x0LtcLrhcLvh8PmRkZGDcuHE06k6E9u3b44cfflA9J9HlQ8nXHlKcnUxgkdGN962KJj6JK2elAsIxRLq9JEl0ssXExGD16tXweDyYMWNGQPrhww8/jH79+sFutyMqKgp2ux0ejwdut5tyMYJx48ahVatWtQ4U4jk7+W232+m5d++//z4A5dFNRmwBtRkP247oVFg2tTb/DLIs47nnnsPHH3+sEt27dOmC7OxsSFLNJiB/rjReArnpppsgyzJ27NihONzS7XYrjtMmYbhkAante/k7ETLEPmDAAIwYMUJ1XeSfZfVasiEEAObNm4e9e/cqxHiLxYI77rgDrVu3ph+UiNZs9JXVasVFF10Er9eLBx54AAMHDlQdP8xHawE13oMrrriCnizD7jNfvHgxFi5cqHie1NRURYSZKLBDD0Z84bGxsartqG+99RYqKyvRv39/VT+BuDj1yugtKP5sLB6PBzabDSdOnMCxY8cU5Tp37oxWrVohKSlJ1x2od61BgwaQJAnt2rWDzWZThPu++eabKC8vR79+/ajBjtgC+vbti+LiYrz++uu676I+IGSIvVOnThgwYAAA/QlPCNnr9aKwsBCbN2+mXODDDz/E77//rqoTExNDM5EQ/fDKK69UBNmQD2y1WtG3b1/06tVLQexswAY72cjCIcp198MPP6hi3c8lp2BjCvixfP3112jbti2uuuoqTYs8Lz0FosNr3eOlMN4oR655PB5s3LgRR48eVbSRmZmJdu3aKc7yE0G0aIrsCo0aNYLNZkNJSQkOHjwIoObdEKnsiiuuUNTp0KEDqqurTWKvSxCdU0/MJDp3QUEBysrK8NNPP+GBBx7w2/arr76qurZs2TKkpaUhISEBiYmJCtGfJMvgD1IQufrYiC3eyMY/S2JiomqzSl2B7Y8saAkJCQqfPivF8M+mZXjj+9BbiLUImQe7kJB3d/ToUTz00EM4fPgwLRMTE4OBAwcGrfJoLWrJycno168f3nrrLXpv+fLlKCwsRLdu3eB0OkNKVycIGWInIAYr0XVigBk1ahS+//77WvVDYuTvvPNOzJgxA1FRUYpMrqRP0Ufng3VEk5vX9yRJwjPPPKMwFPELAq9valnnjaBFixZ48sknMXHiRFV/RgyRRkVxPRgdv8fjQY8ePRR6ekxMDO666y5an3/HIg+F6D4P8g5E39Xn86G6ulpxtFVtjbZ/J0LKGs9/BNZVVlhYiObNm6NVq1b44Ycf6qzPDz/8EFdffTUKCwtpllaW2FhLN6vzE/Fdi9BFLjejMdciL4MeRMZL1g2lV09vDHUFdlHk2xWd2mOkPb1xGhm70+nEAw88oDAYbtmyBZdcconwVOBQQEhw9v/973+48sor6aRlc5673W789NNPeOihh1BVVaWqa7FY0KpVK1UeNn5yybKMyspKHDlyRFHf6/Vi7969GDZsGD7++GO/h0WStliIOItevvraGOFEEBkxRf+zbZNxiPRqvfrBjE9vLCKCSk9PxxVXXKEar96YAhkHa7y94YYbsHr1apw6dYpydrfbTU8HBmpcl8uWLVPsmKyPCAliz8rKotZj8jFITHRubi7mz5+vOJgRAD0hRZJqDk4wMgFtNhuaNGkCWZZx/Phx+jGrq6vx22+/4T//+Q8effRRpKam0txugRipeOtyoHpfMEQUiBhLiFpE8Hy5uoRee4WFhXj++ecV7yoiIgINGjTQfH9GVRF/45EkCampqaqTdvmy0dHRNIlKfUZIifEsZFnG5s2b8emnn2LlypWKe1FRUWjQoAGSk5ORlJQk9Ieyuhm5b7PZkJycjJSUFCQkJCg2iPh8Pnz88cdYtmwZjh49qutW0hPxCEEFQ+zBgDcI+lswjFrZgx2LlhtP1Kcs12Tzee+994TbmUXWdPa3qD3R/3r2B17Vcbvd+Oabb+ByuVTPVd8REsTOG3JkuSaKbtasWaoNFTabDRdccAH1m5L6WlZwPokC2VLZtGlTxMXFqT72v/71L+Tm5uLMmTOa1lx/zyEaByA+JlmEuhKT9TijVh1ynzcc8p4IvXq1UQlIZJ1R4tLzIojcb/xYeVRUVOCOO+5AWVmZoWeuTwgZYvdHKATZ2dk0IQKpy9YTESg7CVmjWtOmTekechZTp07F008/jcrKSqGrTDT5+QVLK8UzOy7RddH/en1r3RO9Q73JqzepeanB6GJkhMD5trp3745evXoZsilojUfv3Rr1MogSadR3hITOzhOBz+dDhw4dFFtGLRYL2rZtq+unDmb1TUpKQmRkJPbv36+47nK5UFZWhoSEBFRXV/u1pPN9i+LdXS4XzUHH16tL8VqWZezduxezZ89WXSf2kNr2pcVJeWiJ9fziyJY3+h21yvlbLPmxaKkYbJRlKBB7vR/h8uXL0aZNG4WO7fF4UFlZSVdXp9OJ5s2bK/Kq6YF39ehNIEmSEBkZiczMTMX13NxcTJw4EUVFRbDZbJrcSI9z8IvYs88+S/fA600erfGzHNvfO5BlWaF36oFvn22DDRoiocnEDsKGKvPuSNGCptW33v//JNh3ERkZidzcXL+RfP8k6j1nb9++PU09BNToTLNmzVK42axWqypfeV2CnIGelpaGEydOwOv14syZM8jLy0NFRQUiIyN1jW28hZtcu/766+FyuWjihCNHjtBtn3p6rZZOrUfg/tSgkSNHok+fPpp1WWJnjYvHjx/H3Llz/fZ98803o127doYt5UYWLP656gKBeB7YZ7FYLOjYsWO9Pkii/o7s/8DqZbIso6KiQhHGGBERgejo6IA+eiATjv2YKSkpyM/Pp9yKGPSMtMM+D0GfPn1QXFysOFZo3759iI6ORlJSkqb1WqRza5Xl6/l8Ppw4cYLGfRMMHjwYl1xyiaZYDZyN+tuwYQNdbA8dOmQoLtxut+PYsWOIjo5G9+7daWARLynwHJ//TqdOnUJBQYFqIw8Po99YC/7sAex7qksV61wiZIidWM35rKmJiYlo1KiR5gQVWVxFHNGIhZjn3iT7KSFMf8/Bj03EvebPnw+gZiHgUy3rWcn1JjeZsBaLBaWlpVi3bh1yc3Pp/QYNGuimpSIiP0nRNXr0aBQWFuo+L4+XX34ZL7/8MrKysvDll1/C7XYrjJ9sv2zGGl6d2bFjByorK+mmKC0ES+j+FhtJkpCUlCQMiqrventIEDvZ3kh2jwXTRm3ua5X7448/0K1bNxw4cECVw56AlUpIGyIrPQ8iLosCOrS4iD9bgdfrxauvvoq8vDzFvU2bNmlmYwFqogh//vlnVdbdYLB//360bt0aAPDdd9+hRYsW9Nvyxkgt24U/1yApw793rfq8QVCPMcTFxWHnzp11dpDo34l6T+w+n48mW9ywYQNuu+02xX0j4uu5RnV1NRISEmgSCK3jo4Gzk4ncu/baa7F+/Xr07NmTllm4cCEOHjyI0aNHBx14w05osoFHK8MPOeKYvEcirpONJ3PnzsWsWbP89vnII48gISGBPlt1dTVNay1Cv379YLFYcOONN+LZZ58V6rvp6enIy8tD27ZtDaXPImAXDq17ov/5e3PnzkV5ebnfNkIB9Z7YPR4PNYC5XC5UVFQo7vN+8nONjIwMHD9+HGVlZfSa2+2G1WpV5E1jx8cuSPw9q9WKrKwsfP7557j55pvpqas7duzA7NmzMW7cOOH2WMC/a4kQbllZGV5++WXIsqxI/BAdHY1PPvkEcXFxinfIjnXatGlYsWKFKjHjoEGD0Lx5c0VfKSkpCo5nt9sxYcIE2tbOnTuxZs0aep+0uXz5cpw5cwZvvvkmnE4ntYOQhYqEPRMcOXIEK1aswDXXXKMYU13PAUmS4HK5VAuklnRZ3/X2ek/swNnEEEZioXmCqGtERkZqinA8IfvzV5NxO51OXHLJJZg6dSrmzJmD/Px8lJeXY/fu3fj8888hyzL69u1LuSYxtPFSAr/oSZKE/Px8rF69WpEVF6jJh3f33XejS5cuCo5KxutyufDKK69g1apVijPbgJrsLO3atUNycrLiFBYRx0xPT6d/k1N3JEnCihUraLnCwkJs2LABzzzzDB577DHNTUIEVVVVikMn2P70oOW/F4n4Xq8XW7duVRhg09PTcc8999D5qKeG1UeEDLED546Ajbqs9MpouYpEE4IvRzKujhs3DgcOHMDq1atx/PhxVFVV4auvvgJQY0Rr2LAhYmNj0axZM7/Pc/DgQVRVVeHIkSNYvXq14n56ejquvvpqVZpq8hxutxtr1qzBa6+9pjjIQZIkZGVloVevXtTVqafvsvWAmgMYL7jgAlgsFpp4k6gKZ86cwauvvorJkycjMjKSvjfC3bt3744ff/yRSgNerxdHjx5FkyZNFMEtet9LT1znrxNiZ9GkSROMGTNG+Nx6bdYX1G/z4f/BnyFL9D8rjvrjrrWF6CABo5OOjIEkoXzmmWcUZ6ARzJ8/Hy+++CIWLVqEwsJClJeXo7q6GhUVFSgrK0N5eTkqKipQWVmJiooKLFiwAC+++KLiBBYAiI2NxciRI/Hvf/9bsaedJfQ///wTI0aMUBC6xWJBfHw87rvvPkRGRirq8hNf7xsQrjh69Gg0bNhQdYZ6cXGxYuOSxWKBw+HAhx9+iLZt21KDZUVFBZYsWYKKigqFxGfke/LuPvaHXOPVlsjISMTGxiqe198iXt9Q7zk72coKwFDAgpbxRYsD8bq0nkUbUGeYAUANcnwddvKI2ucnmcPhgMvlwrRp09CpUyfce++9qv5///13PPLII37fgxbef/99XHbZZYqkmixBbt26Fddee62qXpMmTTB+/HhERETA7XZTA6QRz4DW9SlTpuDDDz+k56V5vV7k5OTg+++/p5liid0hKioKX375JR566CF8/PHHtI133nkHN998M00bbcSgqbUQk/qHDx9WbbAaN24cpkyZQjPXiuwy9R31nrOzH/Dyyy/Hpk2bFPeDcZvpWWP9Yf/+/cJjg1nOLpro/q4RVxuxjF999dWqQxlri02bNuGSSy6B3W6nk5bVj7XsIldccQXuv/9+miyktroqWWQ8Hg+GDh2K66+/XnGfcHti9/AnLS1evBi7d++u1bgkqcbF++OPP1LVieC9997DAw88oCB0f6pLfUS95+wEklST7onN/8XeOxcilEgXE0XMkbxxLIcMRNcXTWaHw4Hs7GwsX74cHo8HkydPVkW9+cOIESMwbNgwSjRZWVmUkPic7bIs49NPP1VFww0aNAgXXXSR4QQgRsCK6E6nExEREYr7o0ePxqOPPop+/fopgn2sVivGjx+Pxo0b44UXXqDl3W43tm7dit9//x2RkZEYNGiQ8MQg0TchzGTp0qVwu90oKSlRnLcH1ARuxcTEwGKxKKInQw31ltijoqJUOcBEH6u0tBR2ux0NGjSok35FYrhW30lJSbj77rtpHIBIR9Vqj+9TJG2wBwxOnDiRxuWTzSayXHOOGznogvRL3EU9evTApZdeKjyfnPTBEv3Ro0cVByQAQOPGjWk+diM+axHYBUX03GlpaejevTuV2n755RecPHlSpTKRBeu6665DaWmpImy6qKgIRUVFcDgc2Lx5M3w+H9q1a6eyfbAoKirC3r176bOLpJpJkyZRg6iRRXzChAmYN29ewAvz34F6S+x2ux2XXnqpIn7aYrGojukhAQ88sWtZSPUITq++LNcc28zWT0pKwvjx43V3vWn9ryWaiv63Wq2466674PV6qR+e6LLkiCTynkg8AumT6OZsRh7SLk/0/GRv0aLFOd1gRJCWlobLLrtMoaLl5eVh7969yMnJURF8mzZtMG7cOOzatQvff/+94r7L5aIJR2NiYlTuShYnTpzAjz/+qBpPfHw83bQzadIkKk0a4eadO3fGF198EdDz/12ot8ReXFyMoUOH4s8//0RkZCR90VFRUcKTM8mxPARabpFgRX5ZlhV72u12O6KjowPS2fQMgVr6piyfzZ4D1BBvREQE5dZVVVXUIk3CiUlee1Lf35HDRBfn38u9996L6OhoQ0Yvrffg7/2Q+3zswuuvv47CwkLMmTNHaFxNS0vDkiVL0K5dO1RXV6OyslK1ZZcN4DGKiIgIdO/eHe+99x68Xi+VmrSeh/975MiRAe8b+LtQ7w10PFHEx8fj559/pm4QADQARauuEe4ZyDgA4Prrr8eCBQsQHR2t0OP1RP9A3HKsKkD2ggM1nKuoqIgeg1RZWQmbzUYTbMbHx1Pd0u12w+PxGPb182XInnQji6M/v3UwILkL+PbYd7R7927s2bMHw4cPD7ofFhMmTMAbb7xBVSSeORjx1ddXhAyxkxdrtVoRFRWletFerxc7d+4U5pUXgeWmvI+Vn9zV1dWqY6PIcUBahwgG4iXg9Xp2LCQn/qlTp1BWVobc3FxcdNFF6NSpE7p06YKcnBy89dZbKCkpQX5+Pg4fPoyKigp4PB7K6fl3Ikln02+RheHOO+/EK6+8ohib0WCVukBycjL1/bPvgkgsIrDnrj399NPIy8vD2rVrA+q3QYMG2LFjB3bs2IHdu3fjwQcfRExMDOx2u98cBew4Q8FgV2/FeALRS3Q4HHjvvffwxBNPKDg6OXM7LS2N6llGreI8yEQvKipCQUGBgnuPHz8eQ4cORUREBFwuV1BpnERcnxCV1+tFdXU1jh07hoceeohyV0mScObMGcWRTUDNZo0VK1ZQ4rDZbJg+fTpat24Nu90Oh8Oh2JjDi8Q+nw+lpaXCvPsi1aO2hC9aPEiCEL4cIXYiofAg16KioujP0qVLAZyNieAXUPa30+lE48aNFQFC7LkERsYeKqj3xA4oJxnxc15xxRW48847sWjRImzbto2WLS8vx6lTp6i7xF+bWvD5fCgqKsKZM2dUm2/atGmD7OxsFdcMBFriYGVlJdasWYPt27fj9OnT+O677/y2dejQIRw6dEhx7e2330ZaWhoyMjIwdOhQquuzwT9aE1o0zrrkXIEsHixx6qlf5G+n04kePXooiJyXTkQLDd+faAy1jS/4pxESxE7AfnibzYZbb70VslwTYrlv3z5a7vTp05Dlmh1lfAJHI6ioqIDX68WpU6dUhN6+fXs0bNiQbgkllnijxKA14cgW1G3btuH999/Ht99+G9CYeXzyyScAgJycHDRu3Bhdu3aF0+lUuAgB/YQLpKw/z0ZdcHqtdvwZVLUMZloGUH6RI1ITaUeP8P09b30X5UOC2NkJSj6+1+tFdHQ0br/9djRr1gz33XefYt/xmTNnUF1djebNmysyvvCWb55QvV6vKpMsQUxMDN577z26tZNIGUa5u0iMJj/V1dU4evQoJk+erNqhVhv89ttvuOeee/Dtt9/SDTdGM6r4m9y1JXL2PZCjlfj7rIpklLuzf7M2GbYd1kNhxIAp6oOHSex1ANHHkCSJZnLp06cPvv/+e7Rv315RpqKiQhUkkpqaqkiHJMsyDh06pNj0IYLD4cCOHTuQnJysmCxGctCR8QJqkZEsXCUlJejZs6dmxteYmBi/2VE8Ho9inz1BcXExunTpgl9++QWJiYmIjo6mMe5Ex9dym/1dOHXqFJ599lnFNfa7+xOhWYLmF1/WIMkvuKF49HKwCBliZ38TkEASq9WKCy64ANu2bUOfPn1UsessCgoKVH5QvQ8+cuRITJs2DUBNEI3b7aYThw85FY1Ri9sQl5LH48GBAwcwaNAgFaFLUs0Z5HqTnOVQVqsVcXFx8Pl8qt1gANCrVy+888476Nq1K3Utked5//33MXv2bIVFvrbELuLE/LvyJ8LrpSEjhE3e5bfffotJkyYJx03a37JlCz1+m0gNfB/BGFvrO1cHQoTYtcCLaunp6Zg3bx6qqqqwePFi1fZO4Ky11R+ef/55JCYmolmzZtTfWl1drXBH8eIhPy4tEAtzeXk5NmzYgNmzZ+PMmTP0vt1upzYBfxxNtLgQ9yR5VmJlLyoqwvTp03HHHXdg2LBh1L1ktVqRkJCgipZjVR/RdX8wIuZrWbfHjBmDW265RfWNgbP+f+IyJHviRQs5jzvuuINu/unYsSMee+wx+g7YTS6BEG9d2S7ONUKK2EUclH3BFosFPXr0gM/ng8PhQMOGDWlk3TvvvCN0LbFISUnB0KFDIcsyBgwYgMTERLrq8zYDMh6W2EWcSotYqqursXr1aixatEiRJIHseiOidbB+bjJuEipLpIZff/0Vn3/+OaxWK2655RZK8KLz2jdu3IjOnTsr0lqzzxAoN9PjuPzztWrVCq1bt1ZcJ+9i7969+Prrr+Hz+bB27VrDqhQAhXfjzz//pMFZY8aMgcPhCGnXmj/Ue2LXmlA8UbGpghwOB3r37o0ePXrA4/HAarXi999/R1FRkcrPStqQJAktW7bE1KlTqYhLjFlEHObPeBeNiScCkVFOkiRs374dH374oSKLjMiApmf5FYnIPHFIkkTzuhGi+P7771FSUoIWLVqgR48edEFMS0tDmzZtaOzCN998g/T0dCQlJQnfebDg65eXl+P48eOaZdlTZw4dOoTly5fjueeeq9UYgJrtyk899RSAGi9Lx44dVQkqzifUe2KvqKhAdHS0wiorWu1ZomKJ3m63w+v1YsGCBfB4PHTSE5cLiSUnojPhiG63m7rdeAMPz+GMcDkyWcl4J0yYoHAXAqAReaS8XltaOq7W/9HR0Qpbxs6dO3H77bdj7969cDqdcLlcGD58OLKzs3HllVfScuSdERejliHPCGGIyni9XuzYsQOff/45vRYZGQmn06lICkISZ/73v//FokWLVO2wIcV6kGWZbiRiMXToUCxYsACXX3453YvBf2t/37i0tLRe6+71ntjbtm2LlStXokuXLgC0DTk8ePHabrdT3Zs/ppnotmRHGeGwRLdjdUWWaEV96oFICeXl5UKjoChIx+jzBgNZrkm/RKQJQggs3nvvPfTs2RPXXHONYndfXYxBkiQsXLiQZqohWLNmDbKysugYycI9cOBAVc57gv79+6Nz584AoGAMpA3g7Pd79913hZLE8OHD8fjjj2PixImKLD7seLVQVlaGjIwMYw/+D6HeEzsLveAOVkzmyxCCJWeUsWX4PGyEOxDiZzeDkPtkEWCNdfwYCXhXm4irEKs7+39dg/RRWVmpiKIjabrJc3To0AHbtm2jhAMAmzdvRn5+Pu677z5FTnwtA56/cRDMnj1blbkWUMZVkMX1wgsvxIkTJ1RtjR8/ngZPkbLs+Ng+ybcYMWIEPB4PDh48qNqO+vLLL2PXrl14++23NcclQn3m6AT1fiMMoObSPIyKkBaLBTabDQ6HA06nE06nk+4FZ8V0sgAQ8T4iIoKWZX3SvE9XZDnn//d4PBg9erSKs7ALTiDQW2h48GJueXk5br/9dhQUFNB3YLPZcMEFFyjKuVwuHDp0CPPmzaOcX8sT4Q8kUvDtt9/GsWPHFJKE1WrFhx9+iLS0NPo98vPzcdttt+HYsWMKQ1x0dDRuvvlmJCQkIDY2lnovWKlNBFmW4XQ6ER0djRYtWqhSYpWXl2Pjxo0YPXq0ymCp1aY/j0l9QUgQe7DwNyF5Yx3hJGQjSlVVleLH7XbTH5bbB3LGV3V1NdauXUvtAURlCBZGxUwC1i7h8XiQm5tLA3HI8zudTtx3331wOp20XmVlJXbt2oX169dTV5fRPtlgl7KyMqxfvx67du1StJOQkIAxY8agf//+iImJgc/nw+7duzF37lzk5uYqvmFSUhK6du1Kk1Ly70PLZcnPg+joaLRq1QrdunVTfMPTp0/j66+/xpw5c2hUn6itUODmLEJCjDfyUvkyIqs7+z/hyHxGUrfbjR07dtCjk0kGF16Et9lsiI2NRatWrRRGQlZk5K3zooMpWRH0XIAXPYl7ieWS/Ek2DocD06dPR15eHn7++WcaXej1erF8+XJccMEFiIyMRFxcHBITE4XJNnnDVmFhISoqKlBYWKg4IAKo2WbavXt3PPnkk/S9eb1e/PTTT3jppZcUZePj49G2bVv07NnTr+1EZEzlERERgf79++PYsWM4duwYXYAqKirwxBNP4KabbhKetxeKCAlir6qq0jzkUASW0PkPLrKql5eXU85dWlrq94RQgszMTCxduhQRERGIjY1ViPhknzi7mPiTMIwiEB+3P7UCOGu4Yg2WdrsdS5cuxa233opvvvlGIW6/+eabAIDLLrsMV199Nd03Lwo4It6RL7/8Er/99puqb4fDgeuuuw4vvvgi3cZKJCs+otBms6F3795o3769ypDIPhvv5hTp2uz/Pp8Pd955Jz744AMcPnxYsfgXFxcjPj5eN425z+fzG8NRHxASxD506FBMmzYNkyZNCiiWWfSBCdeQZRlVVVVwuVwYNWoUTdscCOEdOHAAOTk5AIANGzagefPmsFqtVFRmDWGkXSO5741Ai+CN+N95EPckoJR0vF4v3nrrLbz66qt45plnVPW+//57fP/997V5DLz44ou48cYbVSmaH374YSxcuFBRdtSoUXRvghHwxK8HWZZx++23Y82aNYrAmy5dumDZsmW47LLLNNvZunWr6ty5+oiQ09n9TVyticD7ym02G5xOJ66//nps2rQpaB2M1LvhhhvQuXNnTJ06FWfOnFGkHGbFymCOnNbqU4RgDJhsmCyrfhB7wqhRo7B9+/Zab7vlsWzZMlx77bWKKEUA1AvCQ3QMWF2rP6L2WPsMe5+VIEJBfw8Jzs4iGKsnS+g+nw979uzBrFmzIMsy9u3bp7nTLC4ujhrPWL27uLhYpXufOnUKALBy5Uq4XC7MnDmTZokhk4EE8ASCQF1b/sqLDFesSMyrPpJUk/cvLi4OKSkpmD9/PtxuN1566SXs2LEjoGcBgAsuuABPP/00rFYrOnTooEgxpuVxkSQJQ4YMESYj0ePewby7nJwcWK1WbNiwQXH9fEBIEbuWi8Mfl2N10R07dmDhwoWqUz+As6mRSL3o6GhqJ2CJncTek+vsttLjx49j5cqVyMrKwogRI1SHWuipISId0+hkFdkntNrkweqbfMwC6xKMiIjAwIED4XK5kJ+fjy5dukCSJLjdbsybN0/VrtVqxZ133qnQ3xs3boxrr71WU8qRZRmfffaZKqcAiZPnOay/hS1QpKSkoGnTpoprX331FaKjo9G5c2dVm3qnC9c3hAyxnzx5EocOHaIJ+1kCFoGf+D6fDwcPHsSnn36KuXPnKsoS4xI5bIKdTDwRybKM6OhoxSmmLpdLIR0UFhbi6aefRtu2bXH55ZfD4XDQNlh3k2jMRhGsOiOCy+Wi0o/I8EXak+WzQUEjR46k3ony8nJs3bpV1afD4cDMmTMVng82j73oGXw+H1566SX88ccfiuuiPH96vvS69Hu//fbbSEpKQqdOnVSifEFBgWqs9RUhQ+xvvvkm9uzZg88++0x3/7EWR5RlGY8++qgwl3hSUhI9JtjfhGKJn+VWrNsGqNHzbrrpJqxduxYtW7akce9axCTqU8u3y/fPg+fO7P8idxUhdLY+KcuCqEJ8YFFkZCTWrVunWny1yotOXdXqkx0j/5355zQqDfmTCrTeKdkKSyQeSZLw0UcfYebMmbr91ReEnIEOEG8t5fVMtiwAlJSUCLkqm4lWz2dLoDVBGjdurNghRtCnTx989NFHqKqqUgS0EBB3n1Fo+Y39+ZMJyFHPLAi3NRIcRCY92UfAehz4TUWirDxabforx5+cyj9nIJxcSx3UA1kkyfcj3pZAttf+0wgZzg6c5UB6Yhr7IckHqqqqwqBBgxS53SSp5lQRfx9dT1Q0Wm7WrFk4cOAAZsyYgcTERCHHNtqvFoyI9Vr3SXYb4OxmHH9qgJ7thF+E/cHos7KqW12K6UbGQhY5cp/EUYSKvg6EGGfftWsXJkyYAEBfJ2UnRVVVFUaNGoX9+/dTjmaz2ZCcnEzjqQl4PT1QSFLNxhL+3Lni4mLk5+ejrKwMMTExePbZZ5GamqrbFiu9GHHt+Fv8RCpKZGQkXnrpJSQmJioms5EJrCdNBfsMejBSN9j2ebFe9CzkWck7kmUZL774Is1RHwoIKWIvKCjAypUrAagnEgH/oaqqqvDll18qDGjE6i4iapHux/bBi5w8bDYboqOjVW6igwcPYtmyZbBYLBg4cKDqvpb7TwQtwmEJUCTyulwuBSGTc+D52Hx/Rk+tBbK28Ldw+JOIasvt/TEQ3nD7ww8/aG65rY8IKWLn4c8aL8uySk9nT4JlxVXe8MW3Jeqbn/SknsViUXH3X3/9Fa+88gqqqqoQHR2N9PR0RVYUduup3vOS8Rg1QhGQkE5yPTIyEi1atKDnrvNJNPnn1zIW+uuXrc8Ss+iH3NMDr6fX5SLjr4woqCeUEHLETghDT89lOT5vjIqJiUFycjItL+JS/CQScS9/xiKtgxJLSkqQmpqKOXPmoF+/for7ZWVlumfVGSFwERHKsqzKuJuTk4OFCxciPj6eegjqQg/2ZzfwJ9ZLkqQy7pG6gfYXDEQLm81mg81mU7j/RKfe1neEHLGfOXMG6enpqvzoogm+detWdOrUyVC7WtyLvReoFTctLU0RMef1enHmzBnYbDZFCioWpaWldMddbUEkG1FqbZvNRgmdSDq11av9wci7s1qtWL16NYYMGaK6fq7HB6hdgwCwaNEiTJw4kf5vsVjQunVrbNy48ZyOpa4RcsQOnE0lzLuLWDFUlmWhtVTEzUULhRErvJYYS354N5vVakVqaipKS0sRFRWFadOmYfr06ao2yF56kT1CzxDGw+VyobKyUnV95MiRmD17NuLi4hTn2osOQtRCMIufP7GfVYP4b/Tqq6/i9OnTQffjrzxRZTZv3qzKXsOOyefz+T3htb4iJIkdACZPnkyNI7yVlPzmA1ji4uJUJ4US6InoeuUDmVinTp3Cgw8+iPLycthsNjRq1AgDBw7Ev/71L1XbJOFlZWWlSj0RifdsmYqKClRUVMDlcqnGN2bMGIwYMQLp6emorKykhF7XXFNvMdDrhyySfL2ioiKFTcOfMS1YVFZWCk/VIaioqMC9996rOGosVBCyxL58+XKak4xNI01yoBPOzoKklgrEAKdVlp/MRgilvLwcixcvRnV1NdUB09PTceutt2Lw4MGqIBSSFYeE47pcLmEOO6/XS++z2XR47jN48GDcdNNNyMnJgc1mo1y9toRulMtrGeH4/q1WKy677DJ069ZNUW7Pnj0oLCz0u1hoXdeSWsjY8/LycPLkScW9YcOGoVGjRrSe1+vFp59+GpD3pL4gpIJqeBw+fBiFhYVo1KgRFeuJOAbon8Pmj+B5KUFE1LxRzijIkUuEi6Wnp2PGjBnYu3cvDh48qJpI7EmyopNpq6urdWPuLRYLMjIyMGPGDHoWuSzLdOHjg2gCFc313oPWu/OHESNGwG63Y/PmzfTa2rVr4fP50KFDB8TFxSlsKoGMXVTm9OnTWLt2rSqp5axZs9CgQQOaUuvw4cOGn6G+IWQ5OwBMmjQJH374IQClH1TP0mvExcNPokCt4nxfPNgz6iSpZnNM8+bN8fXXX6Nly5aU64vg9XpRXl6OsrIy+qNF6CSBZFJSEnJzc5GVlUXfDdE7/RF6IK6wYO5rgSwSvN1j/fr1dF+9VgYg3g7gz7bi8/nw1ltvqQidpM4m+vq2bdvQu3fvoJ6nPiCkiR04a6wTbY7xZ0TRIki9CWrUH6wHsiGGncwVFRVISUnB6tWrsWfPHrzwwgtBt08wduxYbN++HT/99BOSkpJQVlZGM+Sy55IHK8Lr1a9Nu+S7DBkyBOvXr1fd37VrF1599VXNb2D020iShKqqKsycOVMlTSUmJuLQoUNITEykEmJdJB75JxHyxD5nzhya9pcQPdHb+Zx1p06dQnFxsd829fQ+8ttIGR5paWnYuHEjoqKiFJ4CwmldLhdsNhsSEhJwww03YNOmTVixYgU2btyIli1b+h13QkIC1q5di5UrV2LDhg2YNGkSmjVrRrO1Em5O+jZicQ/2vmghDWSBJAtheno61q9fr3JTFhcXY86cOaqMQEb8+ECN1HP06FG8/fbbKqbQpUsXrFy5UqEuvfXWW7j//vsNj78+IqR1dqDG7378+HHF1kMtEZBMctZ6z4LUY3VMLX2Qdw2JOD7fvtVqRaNGjRTGMd5dSOrExsYiOzubTtrHH38cBQUFdKcZa5kn+8Tj4uLQunVrAKCqAGuw5KFnfPRXVlTPCLRiGbTKOp1OtGzZEs8//zxmzZqF/Px8ADUSXWFhIZYvXw5JknDRRRehefPmij74tolqtG7dOhQVFaG0tFRxei5QY8QcOXIkWrRoodh3f/r0ac3z6EIFIU/sAJCfn48lS5Zg6NChCkJu1KgRBg8ejGXLltGyRsVLkYuLXwwIeCOeXpsul0uRjFJvPGTLqNvtxsCBAxWn07D1yMJGtpeShY/o5Lx7TcsiHcizGIGRdkQeD/4922w23Hjjjdi3bx+++uorHDp0iJZlM9aSrcKEqDMzM3HmzBmaMoxc37FjB4qKilRj6dOnD26++Wb07t1bkR57zZo12LVrVwBPXj9xXhB7Xl4eHnroIRp1RbhZdnY2Zs6cqSB2shdbFL3GTjyeO4g4vshaz4LXAwkXJr95kZ+d5KS96upqaoG32WyqAwxZomaPrCJ9kGcO5Ay5QO0YWtCSfrTK8YY1AqvVioiICDzxxBOwWq345JNPUFBQoGjj119/xa+//qq4duONN2Lv3r2q6yKkp6dj6tSpaN++vUpSe+mllxRegVDFeUHsBCS3PDuxeYIrKyuDy+VC48aNhW3wnCZYY50sy4pzzCRJojviyFlkgNqizIvnZFHy+XyorKykSSPYVE9EjGePsRLp5HpqSW387KK2eYj61bN78O/WYrHA6XTiX//6Fy688EI88MADAPTdq6LTXnmQhXPNmjWIj4+n19lYjdq+m/qCkDfQERQXFyMtLQ1lZWUKvV2UkdQfautOEnkCBg8ejG+++QbR0dFwu92GOCVrTCNpnWNjY5GUlITU1FQkJycjMTERcXFxiIyMVCwMesapYJ7JHwKxgAdShn8Ou92Om266CX/99Rf++OOPWp3W0qtXLxw8eBCHDh2iRkxWuvJ6vWjTpg1+/PHHoPuoTzivOLvb7UZVVRU9X1uWZSQmJmLlypW4+eab6YYQt9uN48ePo3HjxgoDmV5ACH+dLc+X83g81JBEYLVa6cQ0MuHZPmRZVqV71todJ+KatbWM/9Ng1SXyP1FpyNlzsixj/fr1mDZtmm5bq1atQlRUFCwWC2JiYhS5B9l3R4K0QnF3mxbOK2IHgMceewxTpkyh53vbbDa0bdtWoaMTQ1lhYaEim6yW0YqHHqFUVVWhtLRUQZzDhg3DTTfdhIiICHg8nqD8tSLLssi4ZWSMRiSTc7UYBKO78/YRtnzLli3ptZiYGEWOAB4WiwUXXXQRnQv8Ism2X15ejqlTpwo3EoUqzjtiX7RoETIyMnDdddehbdu2kOWaU0kHDBiA3NxchWGnrKwMERERiIyMVFistcCv/rxeWV1djfLyckV4KwB069YNl19+OWw2m6YrTEuCEBmtWE4tMiTy4xO1b8QKLmrHCPQkIr0FSjS2QFycGRkZNNW4FrFrST4s8vPzsWrVKnz00Ue64ww1nDc6O4vnn3+eblN0u91wOBx47rnncMUVVyAuLk5RtrCwkG4n1TNe8ROVF9s9Hg+Ki4tVO6YaNWqExMREKsKLrPBGwJYlZ5yTo6O10kOT33qqCPu/nhqjZSkXtaulcweyaGiV5d2H/A95Xt5wyS/mokWD3Nu9ezcmTZpkeKyhgvOS2IGzBxIANR8xOjoaL774Iu6//37VRDp16hTOnDkDWVZvr9SbHOT+X3/9hb/++ksl8lksFixatAjXX3897Ha7YYIhYN1w7MS12WxwOBw09JVPBa1F4Hp9izguq97oSQmidkWLolYZo3W1xq4FYttgJSTRc7DvS2RcPV9w3hL7Cy+8gGuvvZbqyV6vF3FxcRg7dizef/99VfnS0lIcPnwYhw8fFnIIFpIkoby8HIcPH8aRI0eE/VutVuzcuRPt27cHUCNhGFEVjECLo/EIxhbBlw9k4RCpAKI+Avlbr77WfX5x9PcMBF6vFzNnzsTw4cP9lg1FnHc6O4HX68W2bdvQt29ffP3113R/t9PpRLdu3bBw4ULcfPPNqno+n89QWKTe6t+kSRO88847SEtLo2429ihkEerKIFZbq3tdla/L5wlmcQxk0SJ2lHHjxmHNmjWGTu0JRZy3xA7UZB355Zdf8PDDD+PJJ5+kbpaEhAR069YNM2fOhNvtxvz58xUpgfX2huth6NCh6NChA5KTk9GxY0e6s42A19WDJQg9Mbq2RGa0DSPl/BnqAoFRw16gIG1OnToV69evR2FhYcBthArOa2IHagj33XffxeOPP47o6GhFsM3dd98Nl8uF8vJy/PbbbygpKcGmTZsCal+SJPTv3x+SJGH48OHo1q0bPf7I7XZTXd2fUa42xMOOhS3nT/fVErm1xH7eGm50PIE8g147/DMZ6d9IfxaLBR9++KFuOqrzAec9sRMcPXoUUVFRcDqdkGWZxsfbbDY8+OCD8Pl82Lt3L26//XY6oSwWC8rLyxXbYhs2bKjQ4R0OB+bMmQObzQan00k3uRAdnQ+HDZbzalnGebD+Yi2dnR+HP44pcsmxbWgtHEYMeYEucIG8Pz3Jgv37+PHj561RjkXYEHvv3r2xYMECXHXVVfTYJ0IIJOKuXbt22LJlC6qqquDz+RAbG4sPPvgAjz32GG1nxYoVSEpKgs/noymhiTXc7XargmaM6ptaXChQC34gLrJAICJoLS5fGwObqDy7cPGEr/fO9N4l2SxUWFiICy+8MKAxhSrOW2u8CHfccQdmzJgBl8ulOH2U+KqtViuioqKQkpKChg0bwuFwYMSIEdi3bx/y8vKwf/9+ZGRkICkpCSkpKYiLi6OGN4/HQzeusFbyQFBXRi0e/ji7EfA6My9lBCIpBAstj4ORsvw47XY7Nm7cSL0l4YCw4exAzQ64jz76CH/99Rdee+01Gv/MT1QSDy1JNckTiGEPqOEIbIpmXrzVO188UNQV0dTlImI0PkCvbl1Y/PVUAT2ODtR8o9dffx3vvfee6sSg8xlhxdmBmsMh161bh+nTpwsNUfwPAU/cxP/+d3C0cwWj/md/0JJi6sv7YJ/TYrFgzpw5WLRoEQ4ePPgPj+zvRdgRO1AT+zx37lysXLlSuLITYmZFVX77IzuB9ET22hDUuVpI/Bn6RIuelpGORaD2BbZsIPaIYN+FJElYtWoV3n//fUWGm3BBWBI7ULNp5c4778S+ffsURy2JItP4JBJsZpi6suKeCx+yv/ZZg5pImqlN/1rWey2920j7tfFkeL1enDhxAnfddRf++OOPoNoJdYQtsRP06tUL69ev14yJJsY3sulEKyqLtxIHQzRGXGp8f0YJoC5sBrXh3Hr/G70XSH+8tHDixAlceOGF59WW1UAR9sQOAHfffTeeeuopYa42QE1oRhEIwQeyQBhx09UFjLrQApVK6sI1Z9RQKMsyVq1aha5duxpq93xGWFnjtVBdXY2FCxfi5MmTeO211xRx7FouJxECuedPb/bXphF/sxa0/Nb8/WDG4q8Nf/eMQq9tVrd//fXXMW/evLDm6AQmZ/8/ECs98cOzBjo9148WRw5EdK0L+FMPROMJ1Eftry9+AQp0rHX5jqxWK9544w189tlnYWd114JJ7AwKCgrwxhtvYNWqVaiqqgKgbbwSWeJ5w55WWV6n5InR33Ue/MLDi9h1tSBpGflYi72/+qI+Re/M37Oy/YvGtHbtWrzzzjthaXXXgknsHFwuF+644w7s2bOHErwR8G45fmL743SixUHruqg+Ow6tfrV84XywC+/iMmqE9Cea8+5K9hr/zvTegZYNhRhZCwsLceuttyoOkzBhErsm+vTpg1WrVilObmF/a10j/wdiwCJl9LieXj2+Xz0Xl1Z9owsTP1Z/v7XqighVz44hko5YkDiI48ePo1WrVmEVGWcUJrHrYOzYsWjevDn69+8PAKqMNQRaHC4QI5SeX9qo/huM0SsY3VrPBejv2f0tRFocWwSW8KdNm4aMjAx069ZN83nCHSax66Cqqgrl5eXYtWsXrrvuOtVhkFqcWIRgjE/n2qhXFwh0jIFKOSL7Bf+e77//fnz22WfCzL4mzsIkdgOorKzEjz/+iBkzZqCoqEioW7KoDcFrGaz8taVnPDuXMGKYq015HnzdZ555BmvXrlWd/WZCDdPPbhBerxezZ89GdnY2UlJScMEFFyA7O9tQXS2LuJ5ub8TYpfc/f8+o+4wfn15ZPUu/Hngfv14/Ij0+Pz8fu3fvhiRJmD179nmbM66uYRJ7gBg7diwA4JZbbsGsWbMQHx9PxXstI5NRf3YgXC/QwJRAA1+M9Gm0rqifQNph30l5eTlWrVqFyZMnG+rbxFmYYnyQ+OSTTzBw4EBIknqHHPs7UGi57kTlaotAXGXB9lkXdgdZPnua6hNPPGESepAwOXstkJeXh/T0dAA1R/6mp6cLA1rOBc5l24FCayx6tgujagQh9LZt28Ltdpthr7WASey1gM/noyfD3nfffXA6nejXrx8mTJhQq3aNcMO/m9CN6NWi8uz/vKqjVZ4Q+dq1azF79mzIsozTp0+HhHeiPsMk9jrC9u3bAdQcFllRUQGLxYIpU6YIOb3IMFcb3TnYdvSCWLTKBtK2lsdAL2JPkiS89dZbOH36NHbt2oXNmzcH1K8JbZjEXsf47bff8Ntvv8FqtaJr166wWq3Izs5Gw4YNaRk9Q5e/aDy+vFY9rbr+2hNF5PHGRiOLjVE3I0FFRQW2bdsGi8WCV1991dCpPCYCg0ns5wherxdDhw4FADz33HMYMmQIrFYrYmJiABjnwizx6BGuUfE6kOg+tqwRaURrrHpGy/Lycrjdbhw8eBBDhgzxOyYTwcO0xv8NeOSRR5CVlYXevXsDCC4ZhlFiDratQOoEEsLLX2fvWa1WTJkyBS1btsRVV10V8JhMBAaTs/+NOHLkCFq2bAkA+PLLL9G6dWtYrVbI8rk5JthfUEwwbQXSnlZ4q8vlQvv27eH1es3w1r8RJrH/jfD5fCgqKgIATJgwAdHR0ZAkCampqXjnnXeoL5kPmfUnegcTn66nexutr3VPtDC88MIL9Bw9WZbP6wMU6ytMYv+H8PPPP9O/4+Pj8fzzz9NtmldeeSU6dOhgmJsGG2+uZxgMph77d0FBAT744AM6tqVLl2LPnj0Bj9FE3cEk9nqA4uJizJgxg/5fUlICl8tF//f5fMjJyUF0dDQA/8YxPQRrLefrs/D5fNiyZYtCbTh06BCeeeYZv32Y+PtgEns9xGuvvYbXXntNcW358uX0AEKWqKKjoxUHSZLrbDm2vNEQXJEF3efz0WONyd5+WZZRXV2NQYMGmUEv9RwmsYcIBg0aJLz+7bff4uKLL1ZxXJHBT0st0LL08zH/5eXlyMzMDGr8Jv55mMQe4hg6dCg9rcYoxo8fjy5dumDkyJEB1TM5d2jDJPYQR3FxccB15s2bhy+++MK0iIcZTGIPQ5hZV8MTZgSdCRNhApPYTZgIE5jEbsJEmMAkdhMmwgQmsZswESYwid2EiTCBSewmTIQJTGI3YSJMYBK7CRNhApPYTZgIE5jEbsJEmMAkdhMmwgQmsZswESYwid2EiTCBSewmTIQJTGI3YSJMYBK7CRNhApPYTZgIE5jEbsJEmMAkdhMmwgQmsZswESYwid2EiTCBSewmTIQJTGI3YSJMYBK7CRNhAkMnwng8HgBAcnLyOR2MCRMmAgOhSUKjejBE7EVFRQBqDhE0YcJE/UNRURGaNm2qW0aSDRzNWVFRgQMHDiAhISHgE0NNmDBx7uDxeFBUVITMzExERUXpljVE7CZMmAh9mAY6EybCBCaxmzARJjCJ3YSJMIFJ7CZMhAlMYjdhIkxgErsJE2ECk9hNmAgT/H+iijGMi+EhewAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ps.plotT1Map()" + ] + }, + { + "cell_type": "markdown", + "id": "ce287e47", + "metadata": {}, + "source": [ + "## Reconstruction Pulseq Data\n", + "\n", + "Now, that we are familiar with subspace reconstruction, we apply this method on real-world data. In this case, we aim to reconstruct data obtained with Pulseq and a sequence prepared by `bart seq`.\n", + "\n", + "### Convert dat file to cfl\n", + "First, we need to convert Siemens `.dat` file to bart `.cfl/.hdr` file format using `bart twixread` and check input file dimensions." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "a591618d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "VD/VE Header. MeasID: 19 FileID: 67798 Scans: 1\n", + "Patient: xxxxxxxxxxxxx\n", + "Protocol: pulseq\n", + "VD/VE Header. MeasID: 19 FileID: 67798 Scans: 1\n", + "Patient: xxxxxxxxxxxxx\n", + "Protocol: pulseq\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "1 512 1131 18 1 1 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash \n", + "bart twixread -A -r 1 data/meas_MID00019 tmp_ksp\n", + "head -n2 tmp_ksp.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "ab8c08e4", + "metadata": {}, + "source": [ + "We notice `PHS2_DIM` should be `TE_DM` instead." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "d2b2a771", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash \n", + "bart transpose 2 5 tmp_ksp tmp_ksp\n", + "head -n2 tmp_ksp.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "e887aaff", + "metadata": {}, + "source": [ + "### Trajectory and Sequence Params\n", + "You should have all relevant information from initial use of `bart seq`, when preparing Pulseq sequence. In case that is lost, we rerun the following commands. " + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "c14782ff", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "loops: 3837483 \t dims: [ 1 377 1 1 1 1 3 3 377 1 3 1 1 1 1 1 ]\n", + "kernels: 1131 \t dims: [ 1 377 1 1 1 1 1 1 1 1 3 1 1 1 1 1 ]\n", + "Nr. of RF shapes: 2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "3 512 377 1 1 1 1 1 1 1 3 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash \n", + "\n", + "bart seq --IR_NON --raga -t 1131 -r 377 grad mom adc\n", + "bart vec 1 1 0 tmp_a\n", + "bart extract 0 2 5 adc - | bart fmac - tmp_a traj\n", + "bart scale 0.5 traj traj\n", + "head -n2 traj.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "5b5d1ff1", + "metadata": {}, + "source": [ + "For subspace reco, all spokes in dim 5:" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "07b9dded", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash \n", + "bart reshape $(bart bitmask 2 10) 1 1131 traj - | bart transpose 5 10 - traj\n", + "head -n2 traj.hdr" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "bb12ae41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "1 1 1 1 1 1131 100000 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "1131 100000 \n" + ] + } + ], + "source": [ + "%%bash\n", + "TR=0.00311 # [s] , BlockDurationRaster x DUR = 1e-05 x 311 = 0.00311\n", + "REP=1131 # Repetitions\n", + "nR1s=1000\n", + "nMss=100\n", + "### create vector with inversion times nREP*TR\n", + "bart index 5 $REP - | bart scale $TR - TI\n", + "bart signal -F -I -n $REP -r $TR -1 5e-3:5:$nR1s -3 1e-2:1:$nMss tmp_dict\n", + "# reshape the dictionary to have all the elements on the 6th dimension\n", + "bart reshape $(bart bitmask 6 7) $((nR1s * nMss)) 1 tmp_dict tmp_dict1\n", + "head -n2 tmp_dict1.hdr\n", + "# squeeze the dicc1 before SVD\n", + "bart squeeze tmp_dict1 subspace_dict\n", + "head -n2 subspace_dict.hdr\n", + "# perform SVD on dictionary\n", + "bart svd -e subspace_dict U S V" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "997f83b8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ps.plotSubspace()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "86725660", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "nCoe=4 # use 4 coefficients\n", + "\n", + "# create the temporal basis\n", + "bart extract 1 0 $nCoe U subbasis\n", + "# transpose the basis to have time on the 6th dimension and coefficients on the 5th dimension\n", + "bart transpose 1 6 subbasis - | bart transpose 0 5 - subbasis " + ] + }, + { + "cell_type": "markdown", + "id": "df31a4c0", + "metadata": {}, + "source": [ + "For consistency, check dimensions of subbasis, input data and trajectory:" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "dbc79fd8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Dimensions\n", + "1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash \n", + "\n", + "head -n2 subbasis.hdr\n", + "head -n2 data/ksp_MID00019.hdr\n", + "head -n2 traj.hdr\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "09aa77bc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Est. image size: 256 256 1\n", + "ksp : [ 1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [ 48 48 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: low-mem mode\n", + "NUFFT: Toeplitz mode\n", + "\n", + "Model created (non Cartesian, nufft-based):\n", + "kspace: [ 1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "images: [ 48 48 1 1 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "coils: [ 16 16 1 18 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "trajectory: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "pattern: [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "basis: [ 1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "mask: [ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "coilimg: [ 48 48 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "\n", + "NUFFT: Toeplitz mode\n", + "ksp : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [ 48 48 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: low-mem mode\n", + "Scaling: 531.556763\n", + "Step: 0, Res: 99.999995\n", + "\t cg: 1\n", + "Step: 1, Res: 99.999797\n", + "\t cg: 0\n", + "Step: 2, Res: 99.999512\n", + "\t cg: 0\n", + "Step: 3, Res: 99.995016\n", + "\t cg: 0\n", + "Step: 4, Res: 99.625178\n", + "\t cg: 1\n", + "Step: 5, Res: 84.841859\n", + "\t cg: 1\n", + "Step: 6, Res: 16.571952\n", + "\t cg: 7\n", + "Step: 7, Res: 13.540367\n", + "\t cg: 1\n", + "Step: 8, Res: 2.010430\n", + "\t cg: 17\n", + "Step: 9, Res: 2.518303\n", + "\t cg: 1\n", + "Step: 10, Res: 0.676207\n", + "\t cg: 26\n", + "Step: 11, Res: 0.881046\n", + "\t cg: 1\n", + "Step: 12, Res: 0.435268\n", + "\t cg: 47\n", + "Step: 13, Res: 0.365177\n", + "\t cg: 2\n", + "Step: 14, Res: 0.296283\n", + "\t cg: 100\n", + "Step: 15, Res: 0.244523\n", + "\t cg: 55\n", + "Total time: 5.99 s\n" + ] + } + ], + "source": [ + "%%bash\n", + "# bart traj -r -A --double-base -s1 -x512 -y 377 -t 3 - | bart reshape $(bart bitmask 2 10) 1 1131 - -| bart transpose 10 5 - traj\n", + "# head -n2 traj.hdr\n", + "\n", + "DEBUG_LEVEL=4 bart ncalib -N -i16 -t traj -B subbasis data/ksp_MID00019 sens_ncalib" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "7122e0f6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Basis: [256 256 1 18 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "Max: [256 256 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", "GPU reconstruction\n", - "[ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "[192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "ksp : [ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "cim : [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "bas : [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "[ 1 512 1 18 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "[256 256 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 512 1 18 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [256 256 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", "NUFFT: Toeplitz mode\n", - "psf_dims: [192 192 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "ksp : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "cim : [384 384 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", - "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", - "Scaling: 3231.860596 (max = 6739.995117/p90 = 3231.860596/median = 477.148560)\n", - "Inverse scaling of the data: 3231.860596\n", - "Maximum eigenvalue: 1.419121e+00\n", - "Maximum eigenvalue: 1.42e+00\n", + "psf_dims: [256 256 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [512 512 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "Scaling: 0.000651 (max = 0.000958/p90 = 0.000651/median = 0.000140)\n", + "Inverse scaling of the data: 0.000651\n", + "Maximum eigenvalue: 1.425364e+00\n", + "Maximum eigenvalue: 1.43e+00\n", "l1-wavelet regularization: 0.000500\n", "Regularization terms: 1, Supporting variables: 0\n", "FISTA\n", "lsqr: add GPU wrapper\n", "#It 000: 1.000000 \n", - "#It 001: 0.265382 \n", - "#It 002: 0.106763 \n", - "#It 003: 0.062998 \n", - "#It 004: 0.045892 \n", - "#It 005: 0.036046 \n", - "#It 006: 0.027813 \n", - "#It 007: 0.021099 \n", - "#It 008: 0.016300 \n", - "#It 009: 0.013111 \n", - "#It 010: 0.010909 \n", - "#It 011: 0.009308 \n", - "#It 012: 0.008172 \n", - "#It 013: 0.007376 \n", - "#It 014: 0.006745 \n", - "#It 015: 0.006140 \n", - "#It 016: 0.005512 \n", - "#It 017: 0.004872 \n", - "#It 018: 0.004250 \n", - "#It 019: 0.003675 \n", - "#It 020: 0.003172 \n", - "#It 021: 0.002766 \n", - "#It 022: 0.002470 \n", - "#It 023: 0.002274 \n", - "#It 024: 0.002150 \n", - "#It 025: 0.002062 \n", - "#It 026: 0.001982 \n", - "#It 027: 0.001893 \n", - "#It 028: 0.001790 \n", - "#It 029: 0.001673 \n", - "#It 030: 0.001547 \n", - "#It 031: 0.001420 \n", - "#It 032: 0.001299 \n", - "#It 033: 0.001192 \n", - "#It 034: 0.001100 \n", - "#It 035: 0.001028 \n", - "#It 036: 0.000972 \n", - "#It 037: 0.000929 \n", - "#It 038: 0.000893 \n", - "#It 039: 0.000861 \n", - "#It 040: 0.000829 \n", - "#It 041: 0.000797 \n", - "#It 042: 0.000764 \n", - "#It 043: 0.000731 \n", - "#It 044: 0.000699 \n", - "#It 045: 0.000670 \n", - "#It 046: 0.000642 \n", - "#It 047: 0.000618 \n", - "#It 048: 0.000596 \n", - "#It 049: 0.000575 \n", - "#It 050: 0.000555 \n", - "#It 051: 0.000537 \n", - "#It 052: 0.000521 \n", - "#It 053: 0.000505 \n", - "#It 054: 0.000491 \n", - "#It 055: 0.000477 \n", - "#It 056: 0.000466 \n", - "#It 057: 0.000456 \n", - "#It 058: 0.000446 \n", - "#It 059: 0.000437 \n", - "#It 060: 0.000428 \n", - "#It 061: 0.000419 \n", - "#It 062: 0.000409 \n", - "#It 063: 0.000399 \n", - "#It 064: 0.000389 \n", - "#It 065: 0.000378 \n", - "#It 066: 0.000368 \n", - "#It 067: 0.000358 \n", - "#It 068: 0.000349 \n", - "#It 069: 0.000340 \n", - "#It 070: 0.000332 \n", - "#It 071: 0.000325 \n", - "#It 072: 0.000319 \n", - "#It 073: 0.000315 \n", - "#It 074: 0.000309 \n", - "#It 075: 0.000305 \n", - "#It 076: 0.000300 \n", - "#It 077: 0.000297 \n", - "#It 078: 0.000292 \n", - "#It 079: 0.000288 \n", - "#It 080: 0.000285 \n", - "#It 081: 0.000281 \n", - "#It 082: 0.000278 \n", - "#It 083: 0.000275 \n", - "#It 084: 0.000272 \n", - "#It 085: 0.000269 \n", - "#It 086: 0.000266 \n", - "#It 087: 0.000263 \n", - "#It 088: 0.000261 \n", - "#It 089: 0.000259 \n", - "#It 090: 0.000257 \n", - "#It 091: 0.000257 \n", - "#It 092: 0.000256 \n", - "#It 093: 0.000256 \n", - "#It 094: 0.000256 \n", - "#It 095: 0.000256 \n", - "#It 096: 0.000257 \n", - "#It 097: 0.000257 \n", - "#It 098: 0.000258 \n", - "#It 099: 0.000259 \n", + "#It 001: 0.265007 \n", + "#It 002: 0.092365 \n", + "#It 003: 0.041775 \n", + "#It 004: 0.028820 \n", + "#It 005: 0.025867 \n", + "#It 006: 0.021312 \n", + "#It 007: 0.015648 \n", + "#It 008: 0.011378 \n", + "#It 009: 0.009323 \n", + "#It 010: 0.008263 \n", + "#It 011: 0.007150 \n", + "#It 012: 0.005946 \n", + "#It 013: 0.004954 \n", + "#It 014: 0.004296 \n", + "#It 015: 0.003848 \n", + "#It 016: 0.003462 \n", + "#It 017: 0.003098 \n", + "#It 018: 0.002778 \n", + "#It 019: 0.002524 \n", + "#It 020: 0.002326 \n", + "#It 021: 0.002165 \n", + "#It 022: 0.002022 \n", + "#It 023: 0.001887 \n", + "#It 024: 0.001757 \n", + "#It 025: 0.001631 \n", + "#It 026: 0.001511 \n", + "#It 027: 0.001402 \n", + "#It 028: 0.001303 \n", + "#It 029: 0.001216 \n", + "#It 030: 0.001138 \n", + "#It 031: 0.001065 \n", + "#It 032: 0.000999 \n", + "#It 033: 0.000938 \n", + "#It 034: 0.000884 \n", + "#It 035: 0.000839 \n", + "#It 036: 0.000800 \n", + "#It 037: 0.000768 \n", + "#It 038: 0.000741 \n", + "#It 039: 0.000717 \n", + "#It 040: 0.000695 \n", + "#It 041: 0.000673 \n", + "#It 042: 0.000652 \n", + "#It 043: 0.000632 \n", + "#It 044: 0.000612 \n", + "#It 045: 0.000594 \n", + "#It 046: 0.000576 \n", + "#It 047: 0.000560 \n", + "#It 048: 0.000545 \n", + "#It 049: 0.000531 \n", + "#It 050: 0.000519 \n", + "#It 051: 0.000508 \n", + "#It 052: 0.000499 \n", + "#It 053: 0.000491 \n", + "#It 054: 0.000484 \n", + "#It 055: 0.000478 \n", + "#It 056: 0.000473 \n", + "#It 057: 0.000469 \n", + "#It 058: 0.000466 \n", + "#It 059: 0.000463 \n", + "#It 060: 0.000460 \n", + "#It 061: 0.000457 \n", + "#It 062: 0.000454 \n", + "#It 063: 0.000452 \n", + "#It 064: 0.000450 \n", + "#It 065: 0.000448 \n", + "#It 066: 0.000446 \n", + "#It 067: 0.000445 \n", + "#It 068: 0.000443 \n", + "#It 069: 0.000443 \n", + "#It 070: 0.000441 \n", + "#It 071: 0.000440 \n", + "#It 072: 0.000439 \n", + "#It 073: 0.000438 \n", + "#It 074: 0.000438 \n", + "#It 075: 0.000438 \n", + "#It 076: 0.000437 \n", + "#It 077: 0.000437 \n", + "#It 078: 0.000437 \n", + "#It 079: 0.000437 \n", + "#It 080: 0.000437 \n", + "#It 081: 0.000437 \n", + "#It 082: 0.000437 \n", + "#It 083: 0.000437 \n", + "#It 084: 0.000436 \n", + "#It 085: 0.000436 \n", + "#It 086: 0.000436 \n", + "#It 087: 0.000435 \n", + "#It 088: 0.000435 \n", + "#It 089: 0.000434 \n", + "#It 090: 0.000434 \n", + "#It 091: 0.000434 \n", + "#It 092: 0.000433 \n", + "#It 093: 0.000433 \n", + "#It 094: 0.000432 \n", + "#It 095: 0.000432 \n", + "#It 096: 0.000431 \n", + "#It 097: 0.000431 \n", + "#It 098: 0.000430 \n", + "#It 099: 0.000430 \n", "\n", "\t\tFISTA iterations: 100\n", - "Total Time: 5.600155\n", + "Total Time: 19.267729\n", "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", "Freeing 8 bytes.\n", @@ -590,42 +1097,45 @@ "Freeing 8 bytes.\n", "Freeing 16 bytes.\n", "Freeing 16 bytes.\n", - "Freeing 2304 bytes.\n", - "Freeing 25088 bytes.\n", - "Freeing 25088 bytes.\n", - "Freeing 86528 bytes.\n", - "Freeing 86528 bytes.\n", - "Freeing 86528 bytes.\n", - "Freeing 320000 bytes.\n", - "Freeing 320000 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1233248 bytes.\n", - "Freeing 2359296 bytes.\n", - "Freeing 9437184 bytes.\n", + "Freeing 4096 bytes.\n", + "Freeing 12800 bytes.\n", + "Freeing 12800 bytes.\n", + "Freeing 12800 bytes.\n", + "Freeing 41472 bytes.\n", + "Freeing 41472 bytes.\n", + "Freeing 147968 bytes.\n", + "Freeing 147968 bytes.\n", + "Freeing 147968 bytes.\n", + "Freeing 557568 bytes.\n", + "Freeing 557568 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2170592 bytes.\n", "Freeing 9437184 bytes.\n", - "Freeing 18874368 bytes.\n", + "Freeing 33554432 bytes.\n", "Freeing 37748736 bytes.\n", "Freeing 37748736 bytes.\n", - "Freed 127326872 bytes.\n" + "Freeing 150994944 bytes.\n", + "Freeing 150994944 bytes.\n", + "Freed 441242904 bytes.\n" ] } ], "source": [ "%%bash\n", "\n", - "DIM=384 # Readouts\n", + "DIM=512 # Readouts\n", "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", "ITER=100\n", "REG=0.0005\n", "# # reconstruction with subspace constraint\n", - "bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n", + "bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj data/ksp_MID00019 sens_ncalib subspace_reco\n", "\n", "# resize the coefficient maps to the original size and multiply it with the roi_mask\n", "# bart resize -c 0 $BR 1 $BR subspace_reco - | bart fmac roi_mask - subspace_reco_masked\n", @@ -635,13 +1145,13 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "df606d77", + "execution_count": 67, + "id": "53cca807", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -655,16 +1165,28 @@ ] }, { - "cell_type": "markdown", - "id": "edd72a17", + "cell_type": "code", + "execution_count": null, + "id": "5a217ef7", "metadata": {}, + "outputs": [], "source": [ - "### Temporal Signal Evolution" + "%%bash\n", + "bart nlinv -d4 -g -i12 -t traj -B subbasis data/ksp_MID00019 img sens" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, + "id": "50a36a43", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "337338b7", "metadata": {}, "outputs": [], "source": [ @@ -674,13 +1196,13 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "92b113c5", + "execution_count": 70, + "id": "6e62143e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -690,44 +1212,44 @@ } ], "source": [ + "importlib.reload(ps)\n", "ps.plotTemporalEvolution()\n" ] }, - { - "cell_type": "markdown", - "id": "74857a61", - "metadata": {}, - "source": [ - "### T1 Map from Reconstructed Images\n", - "Using `bart mobafit` we obtain T1 parameter map via pixel-wise fitting. " - ] - }, { "cell_type": "code", - "execution_count": 20, - "id": "cb9b6bbe", + "execution_count": 74, + "id": "4d5e4eaa", "metadata": {}, "outputs": [], "source": [ "%%bash\n", - "TR=0.006 # [s]\n", - "REP=700 # Repetitions\n", + "TR=0.00311 # [s]\n", + "REP=1131 # Repetitions\n", "\n", "### create vector with inversion times nREP*TR\n", "bart index 5 $REP - | bart scale $TR - TI\n", "\n", - "bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" + "bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 -D15.3e-3 - t1map" ] }, { "cell_type": "code", - "execution_count": 21, - "id": "79442445", + "execution_count": 76, + "id": "a6cfbe43", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/vtelezki/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/matplotlib/colors.py:778: RuntimeWarning: overflow encountered in multiply\n", + " xa *= self.N\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -737,8 +1259,17 @@ } ], "source": [ + "importlib.reload(ps)\n", "ps.plotT1Map()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e50a1d54", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 39301476d0ceb6ec7a29f5ac1b3d9e2b713e90c6 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Fri, 29 Aug 2025 16:35:49 +0200 Subject: [PATCH 06/17] WIP pulseq reco --- src/plotSubspace.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/src/plotSubspace.py b/src/plotSubspace.py index 30a4d40..9d6696c 100644 --- a/src/plotSubspace.py +++ b/src/plotSubspace.py @@ -10,14 +10,11 @@ def plotCoefficientMaps(): fig, axs = plt.subplots(1,4, figsize=(12,4)) axs =axs.ravel() img = absImageFromCFL("subspace_reco") - mask = realImageFromCFL("roi_mask") for i, ax in enumerate(axs): ax.set_xticks([]) ax.set_yticks([]) - roi = np.ma.masked_where(mask==0, img[:,:,i]) ax.set_title("Coefficient # {}".format(i+1), fontdict={'fontsize':12}) - # ax.imshow(roi, cmap=ps.createNewMap("gray"), clim=(None, 1.2)) - ax.imshow(roi, cmap=createNewMap("gray"), clim=(None, 1.2)) + ax.imshow(img[:,:,i], cmap=createNewMap("gray"), clim=(None, 1.2)) plt.show() def plotTemporalEvolution(): @@ -25,13 +22,11 @@ def plotTemporalEvolution(): axs =axs.ravel() timesteps=[0,100, 200,600] img = absImageFromCFL("imgs") - mask = realImageFromCFL("roi_mask") for i, ax in zip(timesteps,axs): ax.set_xticks([]) ax.set_yticks([]) - roi = np.ma.masked_where(mask==0, img[:,:,i]) ax.set_title("t={}".format(i), fontdict={'fontsize':12}) - ax.imshow(roi, cmap=createNewMap("gray"), clim=(None, 0.125)) + ax.imshow(img[:,:,i], cmap=createNewMap("gray"), clim=(None, 0.125)) plt.tight_layout() plt.show() @@ -40,7 +35,7 @@ def plotT1Map(): axs.set_xticks([]) axs.set_yticks([]) img =absImageFromCFL("t1map") - axs.imshow(img, cmap=createNewMap("gray")) + axs.imshow(img, cmap=createNewMap("gray"),clim=(None,1.5)) plt.show() def createNewMap(mapName): From 6bdc90ddac1ebc381e5142a3d9e95de1bc72f84b Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 2 Sep 2025 10:54:40 +0200 Subject: [PATCH 07/17] Add pybash magic and mask for T1 phantom --- src/plotSubspace.py | 4 +- tutorial.ipynb | 570 +++++++++++++++++++++++++++++++------------- 2 files changed, 401 insertions(+), 173 deletions(-) diff --git a/src/plotSubspace.py b/src/plotSubspace.py index 9d6696c..ae29196 100644 --- a/src/plotSubspace.py +++ b/src/plotSubspace.py @@ -26,7 +26,9 @@ def plotTemporalEvolution(): ax.set_xticks([]) ax.set_yticks([]) ax.set_title("t={}".format(i), fontdict={'fontsize':12}) - ax.imshow(img[:,:,i], cmap=createNewMap("gray"), clim=(None, 0.125)) + ax.imshow(img[:,:,i], cmap=createNewMap("gray"), clim=(None, 0.125), + origin="upper") + plt.tight_layout() plt.show() diff --git a/tutorial.ipynb b/tutorial.ipynb index 6b81f7d..9f8bf76 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -50,6 +50,24 @@ "plt.style.use(['ggplot', 'src/customStyle.mplstyle'])" ] }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8496d154", + "metadata": {}, + "outputs": [], + "source": [ + "from IPython import get_ipython\n", + "from IPython.core.magic import register_cell_magic\n", + "\n", + "ipython = get_ipython()\n", + "\n", + "\n", + "@register_cell_magic\n", + "def pybash(line, cell):\n", + " ipython.run_cell_magic('bash', '', cell.format(**globals()))" + ] + }, { "cell_type": "markdown", "id": "638eb164", @@ -60,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "decdec9a", "metadata": {}, "outputs": [ @@ -71,7 +89,7 @@ "# BART used in this notebook:\n", "/home/vtelezki/Repos/Groups/AG_Uecker/barts/bart/bart\n", "# BART version: \n", - "v0.9.00-1128-g995d362\n" + "v0.9.00-1131-g7dd53c3\n" ] } ], @@ -94,9 +112,27 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "37a12f00", "metadata": {}, + "outputs": [], + "source": [ + "# Define Sequence Parameters\n", + "\n", + "TR=0.006 # [s]\n", + "DIM=384 # Readouts\n", + "SPOKES=1\n", + "REP=700 # Repetitions\n", + "NC=8 # Number of Coils\n", + "\n", + "BR=int(DIM/2) # Base resolution, as DIM includes two-fold oversampling" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f35fd58e", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -115,34 +151,26 @@ } ], "source": [ - "%%bash\n", - "# Define Sequence Parameters\n", - "TR=0.006 # [s]\n", - "DIM=384 # Readouts\n", - "SPOKES=1\n", - "REP=700 # Repetitions\n", - "NC=8 # Number of Coils\n", - "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", - "\n", + "%%pybash\n", "# create trajectory\n", - "bart traj -o 2 -x $BR -y $SPOKES -t $REP -r -G - | bart transpose 5 10 - traj\n", + "bart traj -o 2 -x {BR} -y {SPOKES} -t {REP} -r -G - | bart transpose 5 10 - traj\n", "# bart scale 0.5 tmp_traj traj \n", "\n", "echo dimensions of trajectory\n", "head -n2 traj.hdr\n", "\n", "# create geometry basis functions\n", - "bart phantom -s$NC -T -k -b -t traj tmp_basis_geom\n", + "bart phantom -s {NC} -T -k -b -t traj tmp_basis_geom\n", "#create phantom in plane mask \n", - "bart phantom -x $BR -T roi_mask\n", + "bart phantom -x {BR} -T roi_mask\n", "\n", "# check the dimensions\n", "echo dimensions of geometry basis functions\n", "head -n2 tmp_basis_geom.hdr\n", "\n", "# create signal tubes and background\n", - "bart signal -F -I -n$REP -r$TR -1 0.2:2.2:10 -2 0.045:0.045:1 tmp_basis_simu_tubes\n", - "bart signal -F -I -n$REP -r$TR -1 3:3:1 -2 1:1:1 tmp_basis_simu_water\n", + "bart signal -F -I -n {REP} -r {TR} -1 0.2:2.2:10 -2 0.045:0.045:1 tmp_basis_simu_tubes\n", + "bart signal -F -I -n {REP} -r {TR} -1 3:3:1 -2 1:1:1 tmp_basis_simu_water\n", "\n", "bart join 6 tmp_basis_simu_water tmp_basis_simu_tubes tmp_basis_simu\n", "# check the dimensions\n", @@ -152,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "f459b704", "metadata": {}, "outputs": [ @@ -197,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "2060b295", "metadata": {}, "outputs": [ @@ -227,9 +255,21 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "f46a35cc", "metadata": {}, + "outputs": [], + "source": [ + "## signal parameter\n", + "nR1s=1000\n", + "nMss=100 \n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "24f0719d", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -282,18 +322,12 @@ } ], "source": [ - "%%bash\n", - "## signal parameter\n", - "nR1s=1000\n", - "nMss=100 \n", - "REP=700\n", - "TR=0.006\n", - "\n", + "%%pybash\n", "bart signal -help\n", "\n", - "bart signal -F -I -n $REP -r $TR -1 5e-3:5:$nR1s -3 1e-2:1:$nMss tmp_dict\n", + "bart signal -F -I -n {REP} -r {TR} -1 5e-3:5:{nR1s} -3 1e-2:1:{nMss} tmp_dict\n", "# reshape the dictionary to have all the elements on the 6th dimension\n", - "bart reshape $(bart bitmask 6 7) $((nR1s * nMss)) 1 tmp_dict tmp_dict1\n", + "bart reshape $(bart bitmask 6 7) $(({nR1s} * {nMss})) 1 tmp_dict tmp_dict1\n", "head -n2 tmp_dict1.hdr\n", "# squeeze the dicc1 before SVD\n", "bart squeeze tmp_dict1 subspace_dict\n", @@ -312,13 +346,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "3f506260", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -344,9 +378,19 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "id": "e4af968a", "metadata": {}, + "outputs": [], + "source": [ + "nCoe=4 # use 4 coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5b410a4e", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -358,12 +402,9 @@ } ], "source": [ - "%%bash\n", - "\n", - "nCoe=4 # use 4 coefficients\n", - "\n", + "%%pybash\n", "# create the temporal basis\n", - "bart extract 1 0 $nCoe U subbasis\n", + "bart extract 1 0 {nCoe} U subbasis\n", "# transpose the basis to have time on the 6th dimension and coefficients on the 5th dimension\n", "bart transpose 1 6 subbasis - | bart transpose 0 5 - subbasis \n", "head -n2 subbasis.hdr" @@ -380,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "id": "0d735922", "metadata": {}, "outputs": [ @@ -431,7 +472,7 @@ "\t cg: 4\n", "Step: 7, Res: 2.849144\n", "\t cg: 9\n", - "Total time: 1.24 s\n" + "Total time: 1.43 s\n" ] } ], @@ -452,28 +493,192 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "id": "e4c42af8", "metadata": {}, + "outputs": [], + "source": [ + "ITER=100\n", + "REG=0.0005\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3c477980", + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "bart: src/pics.c:478: main_pics: Assertion `basis_dims[TE_DIM] == ksp_dims[TE_DIM]' failed.\n", - "bash: line 7: 710779 Aborted bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n" + "Basis: [192 192 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "Max: [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "GPU reconstruction\n", + "[ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "[192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: Toeplitz mode\n", + "psf_dims: [192 192 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [384 384 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "Scaling: 3231.903564 (max = 6739.982910/p90 = 3231.903564/median = 477.119476)\n", + "Inverse scaling of the data: 3231.903564\n", + "Maximum eigenvalue: 1.419106e+00\n", + "Maximum eigenvalue: 1.42e+00\n", + "l1-wavelet regularization: 0.000500\n", + "Regularization terms: 1, Supporting variables: 0\n", + "FISTA\n", + "lsqr: add GPU wrapper\n", + "#It 000: 1.000000 \n", + "#It 001: 0.265379 \n", + "#It 002: 0.106762 \n", + "#It 003: 0.062997 \n", + "#It 004: 0.045892 \n", + "#It 005: 0.036046 \n", + "#It 006: 0.027813 \n", + "#It 007: 0.021098 \n", + "#It 008: 0.016300 \n", + "#It 009: 0.013111 \n", + "#It 010: 0.010909 \n", + "#It 011: 0.009308 \n", + "#It 012: 0.008172 \n", + "#It 013: 0.007377 \n", + "#It 014: 0.006745 \n", + "#It 015: 0.006140 \n", + "#It 016: 0.005512 \n", + "#It 017: 0.004872 \n", + "#It 018: 0.004250 \n", + "#It 019: 0.003675 \n", + "#It 020: 0.003172 \n", + "#It 021: 0.002766 \n", + "#It 022: 0.002470 \n", + "#It 023: 0.002274 \n", + "#It 024: 0.002150 \n", + "#It 025: 0.002062 \n", + "#It 026: 0.001982 \n", + "#It 027: 0.001893 \n", + "#It 028: 0.001790 \n", + "#It 029: 0.001673 \n", + "#It 030: 0.001547 \n", + "#It 031: 0.001420 \n", + "#It 032: 0.001299 \n", + "#It 033: 0.001192 \n", + "#It 034: 0.001101 \n", + "#It 035: 0.001028 \n", + "#It 036: 0.000972 \n", + "#It 037: 0.000929 \n", + "#It 038: 0.000893 \n", + "#It 039: 0.000861 \n", + "#It 040: 0.000830 \n", + "#It 041: 0.000797 \n", + "#It 042: 0.000764 \n", + "#It 043: 0.000731 \n", + "#It 044: 0.000700 \n", + "#It 045: 0.000670 \n", + "#It 046: 0.000643 \n", + "#It 047: 0.000619 \n", + "#It 048: 0.000596 \n", + "#It 049: 0.000575 \n", + "#It 050: 0.000556 \n", + "#It 051: 0.000538 \n", + "#It 052: 0.000521 \n", + "#It 053: 0.000506 \n", + "#It 054: 0.000491 \n", + "#It 055: 0.000478 \n", + "#It 056: 0.000467 \n", + "#It 057: 0.000457 \n", + "#It 058: 0.000447 \n", + "#It 059: 0.000438 \n", + "#It 060: 0.000430 \n", + "#It 061: 0.000421 \n", + "#It 062: 0.000411 \n", + "#It 063: 0.000401 \n", + "#It 064: 0.000390 \n", + "#It 065: 0.000380 \n", + "#It 066: 0.000370 \n", + "#It 067: 0.000360 \n", + "#It 068: 0.000351 \n", + "#It 069: 0.000342 \n", + "#It 070: 0.000334 \n", + "#It 071: 0.000327 \n", + "#It 072: 0.000321 \n", + "#It 073: 0.000317 \n", + "#It 074: 0.000311 \n", + "#It 075: 0.000307 \n", + "#It 076: 0.000303 \n", + "#It 077: 0.000299 \n", + "#It 078: 0.000295 \n", + "#It 079: 0.000291 \n", + "#It 080: 0.000287 \n", + "#It 081: 0.000284 \n", + "#It 082: 0.000280 \n", + "#It 083: 0.000277 \n", + "#It 084: 0.000274 \n", + "#It 085: 0.000271 \n", + "#It 086: 0.000268 \n", + "#It 087: 0.000265 \n", + "#It 088: 0.000263 \n", + "#It 089: 0.000261 \n", + "#It 090: 0.000260 \n", + "#It 091: 0.000259 \n", + "#It 092: 0.000259 \n", + "#It 093: 0.000258 \n", + "#It 094: 0.000259 \n", + "#It 095: 0.000259 \n", + "#It 096: 0.000260 \n", + "#It 097: 0.000260 \n", + "#It 098: 0.000261 \n", + "#It 099: 0.000262 \n", + "\n", + "\t\tFISTA iterations: 100\n", + "Total Time: 6.222245\n", + "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", + "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", + "Freeing 8 bytes.\n", + "Freeing 8 bytes.\n", + "Freeing 8 bytes.\n", + "Freeing 16 bytes.\n", + "Freeing 16 bytes.\n", + "Freeing 2304 bytes.\n", + "Freeing 25088 bytes.\n", + "Freeing 25088 bytes.\n", + "Freeing 86528 bytes.\n", + "Freeing 86528 bytes.\n", + "Freeing 86528 bytes.\n", + "Freeing 320000 bytes.\n", + "Freeing 320000 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1179648 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1204352 bytes.\n", + "Freeing 1233248 bytes.\n", + "Freeing 2359296 bytes.\n", + "Freeing 9437184 bytes.\n", + "Freeing 9437184 bytes.\n", + "Freeing 18874368 bytes.\n", + "Freeing 37748736 bytes.\n", + "Freeing 37748736 bytes.\n", + "Freed 127326872 bytes.\n" ] } ], "source": [ - "%%bash\n", "\n", - "DIM=384 # Readouts\n", - "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", - "ITER=100\n", - "REG=0.0005\n", + "%%pybash\n", "# # reconstruction with subspace constraint\n", - "bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n", + "bart pics -g -e -d5 -i {ITER} -R W:$(bart bitmask 0 1):$(bart bitmask 6):{REG} -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n", "\n", "# multiply it with the roi_mask\n", "bart fmac roi_mask subspace_reco subspace_reco" @@ -481,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 16, "id": "df606d77", "metadata": {}, "outputs": [ @@ -511,7 +716,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -521,13 +726,13 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 18, "id": "92b113c5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -552,57 +757,28 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 19, "id": "cb9b6bbe", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "bart: src/mobafit.c:303: main_mobafit: Assertion `bas_dims[TE_DIM] == enc_dims[TE_DIM]' failed.\n", - "\u001b[31mERROR: Reading input from -\n", - "\u001b[0m\u001b[31mERROR: Reading input from -\n", - "\u001b[0mbash: line 7: 711121 Aborted bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs -\n", - " 711122 | bart looklocker -t0 - -\n", - " 711123 | bart fmac roi_mask - t1map\n" - ] - }, - { - "ename": "CalledProcessError", - "evalue": "Command 'b'TR=0.006 # [s]\\nREP=700 # Repetitions\\n\\n### create vector with inversion times nREP*TR\\nbart index 5 $REP - | bart scale $TR - TI\\n\\nbart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map\\n'' returned non-zero exit status 134.", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[35]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbash\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mTR=0.006 # [s]\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mREP=700 # Repetitions\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m### create vector with inversion times nREP*TR\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart index 5 $REP - | bart scale $TR - TI\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2565\u001b[39m, in \u001b[36mInteractiveShell.run_cell_magic\u001b[39m\u001b[34m(self, magic_name, line, cell)\u001b[39m\n\u001b[32m 2563\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m 2564\u001b[39m args = (magic_arg_s, cell)\n\u001b[32m-> \u001b[39m\u001b[32m2565\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2568\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2569\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2570\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:160\u001b[39m, in \u001b[36mScriptMagics._make_script_magic..named_script_magic\u001b[39m\u001b[34m(line, cell)\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 159\u001b[39m line = script\n\u001b[32m--> \u001b[39m\u001b[32m160\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshebang\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcell\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:343\u001b[39m, in \u001b[36mScriptMagics.shebang\u001b[39m\u001b[34m(self, line, cell)\u001b[39m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m args.raise_error \u001b[38;5;129;01mand\u001b[39;00m p.returncode != \u001b[32m0\u001b[39m:\n\u001b[32m 339\u001b[39m \u001b[38;5;66;03m# If we get here and p.returncode is still None, we must have\u001b[39;00m\n\u001b[32m 340\u001b[39m \u001b[38;5;66;03m# killed it but not yet seen its return code. We don't wait for it,\u001b[39;00m\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# in case it's stuck in uninterruptible sleep. -9 = SIGKILL\u001b[39;00m\n\u001b[32m 342\u001b[39m rc = p.returncode \u001b[38;5;129;01mor\u001b[39;00m -\u001b[32m9\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m343\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m CalledProcessError(rc, cell)\n", - "\u001b[31mCalledProcessError\u001b[39m: Command 'b'TR=0.006 # [s]\\nREP=700 # Repetitions\\n\\n### create vector with inversion times nREP*TR\\nbart index 5 $REP - | bart scale $TR - TI\\n\\nbart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map\\n'' returned non-zero exit status 134." - ] - } - ], + "outputs": [], "source": [ - "%%bash\n", - "TR=0.006 # [s]\n", - "REP=700 # Repetitions\n", + "%%pybash\n", "\n", "### create vector with inversion times nREP*TR\n", - "bart index 5 $REP - | bart scale $TR - TI\n", + "bart index 5 {REP} - | bart scale {TR} - TI\n", "\n", - "bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" + "bart mobafit -g -B subbasis -L --init 1:1:1 TI subspace_reco - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 20, "id": "79442445", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -630,7 +806,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 21, "id": "a591618d", "metadata": {}, "outputs": [ @@ -671,7 +847,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 22, "id": "d2b2a771", "metadata": {}, "outputs": [ @@ -701,7 +877,19 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 23, + "id": "cfa3809f", + "metadata": {}, + "outputs": [], + "source": [ + "FIBO=377 # fibonacci number satisfying Nyquist when using RAGA\n", + "FRAMES=3\n", + "REP=int(FIBO*FRAMES)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, "id": "c14782ff", "metadata": {}, "outputs": [ @@ -724,9 +912,9 @@ } ], "source": [ - "%%bash \n", + "%%pybash \n", "\n", - "bart seq --IR_NON --raga -t 1131 -r 377 grad mom adc\n", + "bart seq --IR_NON --raga -t {REP} -r {FIBO} grad mom adc\n", "bart vec 1 1 0 tmp_a\n", "bart extract 0 2 5 adc - | bart fmac - tmp_a traj\n", "bart scale 0.5 traj traj\n", @@ -743,7 +931,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 25, "id": "07b9dded", "metadata": {}, "outputs": [ @@ -757,16 +945,36 @@ } ], "source": [ - "%%bash \n", - "bart reshape $(bart bitmask 2 10) 1 1131 traj - | bart transpose 5 10 - traj\n", + "%%pybash \n", + "bart reshape $(bart bitmask 2 10) 1 {REP} traj - | bart transpose 5 10 - traj\n", "head -n2 traj.hdr" ] }, + { + "cell_type": "markdown", + "id": "5b4111b9", + "metadata": {}, + "source": [ + "### Parameter for Dictionary" + ] + }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 26, "id": "bb12ae41", "metadata": {}, + "outputs": [], + "source": [ + "TR=0.00311 # [s] , BlockDurationRaster x DUR = 1e-05 x 311 = 0.00311\n", + "nR1s=1000\n", + "nMss=100" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f00cf4a5", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -780,16 +988,12 @@ } ], "source": [ - "%%bash\n", - "TR=0.00311 # [s] , BlockDurationRaster x DUR = 1e-05 x 311 = 0.00311\n", - "REP=1131 # Repetitions\n", - "nR1s=1000\n", - "nMss=100\n", + "%%pybash\n", "### create vector with inversion times nREP*TR\n", - "bart index 5 $REP - | bart scale $TR - TI\n", - "bart signal -F -I -n $REP -r $TR -1 5e-3:5:$nR1s -3 1e-2:1:$nMss tmp_dict\n", + "bart index 5 {REP} - | bart scale {TR} - TI\n", + "bart signal -F -I -n {REP} -r {TR} -1 5e-3:5:{nR1s} -3 1e-2:1:{nMss} tmp_dict\n", "# reshape the dictionary to have all the elements on the 6th dimension\n", - "bart reshape $(bart bitmask 6 7) $((nR1s * nMss)) 1 tmp_dict tmp_dict1\n", + "bart reshape $(bart bitmask 6 7) $(({nR1s} * {nMss})) 1 tmp_dict tmp_dict1\n", "head -n2 tmp_dict1.hdr\n", "# squeeze the dicc1 before SVD\n", "bart squeeze tmp_dict1 subspace_dict\n", @@ -800,13 +1004,13 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 28, "id": "997f83b8", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -821,17 +1025,15 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 29, "id": "86725660", "metadata": {}, "outputs": [], "source": [ - "%%bash\n", - "\n", - "nCoe=4 # use 4 coefficients\n", + "%%pybash\n", "\n", "# create the temporal basis\n", - "bart extract 1 0 $nCoe U subbasis\n", + "bart extract 1 0 {nCoe} U subbasis\n", "# transpose the basis to have time on the 6th dimension and coefficients on the 5th dimension\n", "bart transpose 1 6 subbasis - | bart transpose 0 5 - subbasis " ] @@ -846,7 +1048,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 30, "id": "dbc79fd8", "metadata": {}, "outputs": [ @@ -873,7 +1075,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 31, "id": "09aa77bc", "metadata": {}, "outputs": [ @@ -940,23 +1142,32 @@ "\t cg: 100\n", "Step: 15, Res: 0.244523\n", "\t cg: 55\n", - "Total time: 5.99 s\n" + "Total time: 5.91 s\n" ] } ], "source": [ "%%bash\n", - "# bart traj -r -A --double-base -s1 -x512 -y 377 -t 3 - | bart reshape $(bart bitmask 2 10) 1 1131 - -| bart transpose 10 5 - traj\n", - "# head -n2 traj.hdr\n", "\n", "DEBUG_LEVEL=4 bart ncalib -N -i16 -t traj -B subbasis data/ksp_MID00019 sens_ncalib" ] }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 32, "id": "7122e0f6", "metadata": {}, + "outputs": [], + "source": [ + "ITER=100\n", + "REG=0.0005\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "3a3d91b5", + "metadata": {}, "outputs": [ { "name": "stderr", @@ -1089,7 +1300,7 @@ "#It 099: 0.000430 \n", "\n", "\t\tFISTA iterations: 100\n", - "Total Time: 19.267729\n", + "Total Time: 20.350636\n", "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", "Freeing 8 bytes.\n", @@ -1128,24 +1339,14 @@ } ], "source": [ - "%%bash\n", - "\n", - "DIM=512 # Readouts\n", - "BR=$((DIM/2)) # Base resolution, as DIM includes two-fold oversampling\n", - "ITER=100\n", - "REG=0.0005\n", + "%%pybash\n", "# # reconstruction with subspace constraint\n", - "bart pics -g -e -d5 -i $ITER -R W:$(bart bitmask 0 1):$(bart bitmask 6):$REG -B subbasis -t traj data/ksp_MID00019 sens_ncalib subspace_reco\n", - "\n", - "# resize the coefficient maps to the original size and multiply it with the roi_mask\n", - "# bart resize -c 0 $BR 1 $BR subspace_reco - | bart fmac roi_mask - subspace_reco_masked\n", - "# visualize subspace maps for 4 nCoe\n", - "# bart reshape $(bart bitmask 1 6) $((BR*nCoe)) 1 subspace_reco_masked subspace_maps" + "bart pics -g -e -d5 -i {ITER} -R W:$(bart bitmask 0 1):$(bart bitmask 6):{REG} -B subbasis -t traj data/ksp_MID00019 sens_ncalib subspace_reco" ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 34, "id": "53cca807", "metadata": {}, "outputs": [ @@ -1166,26 +1367,20 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "5a217ef7", + "execution_count": 35, + "id": "649fe1a6", "metadata": {}, "outputs": [], "source": [ "%%bash\n", - "bart nlinv -d4 -g -i12 -t traj -B subbasis data/ksp_MID00019 img sens" + "## coefficient map also suitable for mask \n", + "bart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\n", + "bart fmac mask subspace_reco subspace_reco" ] }, { "cell_type": "code", - "execution_count": null, - "id": "50a36a43", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 69, + "execution_count": 36, "id": "337338b7", "metadata": {}, "outputs": [], @@ -1196,13 +1391,13 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 37, "id": "6e62143e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1218,38 +1413,77 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 38, "id": "4d5e4eaa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Temp file for pipe: bart-aT5vlj\n", + "Step: 0, Res: 5748.667991\n", + "\t cg: 11\n", + "Step: 1, Res: 144.627954\n", + "\t cg: 10\n", + "Step: 2, Res: 274458.084239\n", + "\t cg: 50\n", + "Step: 3, Res: nan\n", + "\t cg: 50\n", + "Step: 4, Res: nan\n", + "\t cg: 50\n", + "Step: 5, Res: nan\n", + "\t cg: 50\n", + "Step: 6, Res: nan\n", + "\t cg: 50\n", + "Step: 7, Res: nan\n", + "\t cg: 50\n", + "Step: 8, Res: nan\n", + "\t cg: 50\n", + "Step: 9, Res: nan\n", + "\t cg: 50\n", + "Step: 10, Res: nan\n", + "\t cg: 50\n", + "Step: 11, Res: nan\n", + "\t cg: 50\n", + "Step: 12, Res: nan\n", + "\t cg: 50\n", + "Step: 13, Res: nan\n", + "\t cg: 50\n", + "Step: 14, Res: nan\n", + "\t cg: 50\n", + "Step: 15, Res: nan\n", + "\t cg: 50\n", + "Step: 16, Res: nan\n", + "\t cg: 50\n", + "Step: 17, Res: nan\n", + "\t cg: 50\n", + "Step: 18, Res: nan\n", + "\t cg: 50\n", + "Step: 19, Res: nan\n", + "\t cg: 50\n", + "Total Time: 2.49 s\n", + "Freed 3611607760 bytes.\n" + ] + } + ], "source": [ - "%%bash\n", - "TR=0.00311 # [s]\n", - "REP=1131 # Repetitions\n", - "\n", + "%%pybash\n", "### create vector with inversion times nREP*TR\n", - "bart index 5 $REP - | bart scale $TR - TI\n", + "bart index 5 {REP} - | bart scale {TR} - TI\n", "\n", - "bart mobafit -g -B subbasis -L --init 1:1:1 TI imgs - | bart looklocker -t0 -D15.3e-3 - t1map" + "DEBUG_LEVEL=4 bart mobafit -g -i20 --init 1:1:1 -B subbasis -L TI subspace_reco - | bart looklocker -t0 -D15.3e-3 - t1map" ] }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 39, "id": "a6cfbe43", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/vtelezki/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/matplotlib/colors.py:778: RuntimeWarning: overflow encountered in multiply\n", - " xa *= self.N\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1262,14 +1496,6 @@ "importlib.reload(ps)\n", "ps.plotT1Map()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e50a1d54", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 1587004a022930be6585c7e6fc7a874a4f635134 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 2 Sep 2025 10:57:25 +0200 Subject: [PATCH 08/17] Remove tracked pycache file --- src/__pycache__/plotSubspace.cpython-311.pyc | Bin 8444 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 src/__pycache__/plotSubspace.cpython-311.pyc diff --git a/src/__pycache__/plotSubspace.cpython-311.pyc b/src/__pycache__/plotSubspace.cpython-311.pyc deleted file mode 100644 index 72a6b2c7e11e527925daeeb442aac0c3c22b9da4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8444 zcmd5>U2GdycAgF~!S&n7Njub^dbRx-;)=oEB$Cm#T$+F;BcG`I3dMVCGqRk&^ zW@JkYwaXaZUBwU(x>XRi*ag@{k;S|uGr%zaju$({QLem5LgfpF zXLvTrTw~$vNHQtMH79HE$TdRST-V&Z^B!}}!xNw!?*i)O-9UZ32dJOtfCl(F-gl3^ z7UUy*5Y8dE4#7FhhoQBOXD66w{WiXOJj&|s*~QspMvj+@8F&5nYb&T5p=8EYZEL zv>3IVllR=BtC4fSJ~BTq(;S&{HkqBjgdUH~HCuASSS<51yD>ah0y(NJIl{A9VB6=! zdwE}iUH99cPG=gdeFnqi-14CcpAS?$Ew~=C?>Eb={MIHP;hnqfJB^YIau*)o#_ioE zKpr}_aUvq_%|llAOeLnJL{`v)()^?}8;c7!L?NEhIWd#Ck%~#TL|mL~-I~GTteo+`^M6gHOa|olJ|d#i(O^dXSbECm%X=5>LfufhH5FXr1ny zP0Bh4Z$u@Kbe9;rEhP1DY*HFY#ioVxVkULw{Fq)R3bCY(;}z2LDM5_Mg6@+9`No2r zh~JWo`l3;Hq-S+UDy9c;^a6k5&Ws=mx)*!P2{|d~?x~EJipjb=k&ja;svkBc1ThN`bI1-9%t5Lqa+BcI)34OO^At_{U zCHgK4vl*#xSj^1NN_|7aH?9itTY}iPv&2{W`|f1KTkxjY3ke}PaCG2UpCrcna5W~% z+t53^s5chIG0UHP+Hk%Ps-2ZvV=KWE&ov#dcs zbuF{Y1Dl-hv*7(;VN&IqG_FbEnrb;)p}G~}S*Z1CsI|1OH20fV*4o!%_}gIVuWe0O zKca??X`y4wPP{#EKcF;rJ!|ZJ+St1`w-I?Lsf~kLT;s+SZu}eQ z?7iQ~Gun8g%7^C{x{c4{c2-}*4VLe@bT%5Fe2M2jXR}qrw|6K zk!=Z)?VQG)Q|JN6rjdOr*{_lP3fW%;bYc%ImksF9oTEGV;sC7S%Ybg(X;+^A&2`+x zU1Ll5rkYaQ)8QdYD&%_Ta>xlJzaO($IsdwWfOdNRYi}Xictqu#%-Ji zRYu(<_k(|8C>AT$10Te_qD~dnp*m%%iJ=(IiegZ0knp)6`G(MYsnGX>?G}FseAE=i2L`vkL+?EhE=X{-8Gqv#czQZ>WXKQ8Bup%=1(ICkh3nY#NAed9own`^Y6smH5h{D>v~1C#o924wssfS{fk)I7yN=lRWCDEp z@u-X13Z0-Mt~=vXN!ru}c|phu)b&p!g)}Ulgu^%Fo*EuXjss6Z+W>3k53aoR z`QYk1#RavYTWjck)^PM`!%?+iKx-IK{ezl+P$7f=?^Z$_hSBe=g%hF_aReCRD3S|E z#(-GoPEi8MUtmLJ?#DlGUwxxEqt^OB~G1V$OEnhcSPSb3pDRR}}@U2kkor zv3^$$qxjG`^%xVSU$9J+g+LX8?`*i&j4E#!!S{q9_kYWwf7beA>ALQg64U8eGTS}@ zv1uIrt=1_BuUjV)sre*?y?pCgh}nT16Bn!e%s+qo)0@AS|90V|_#+s0G-P0bTa2ao zObUPi&WW_F2NKqpoxLKSg5Kf~kaCQkj7>sxPviAPTBjbT?vB9|rUl&z*dgL#>I6+? z)JuIxolS!?oaPtAi`e8brXf+=tP`A`;cs4rRtW_H46acOv&-SLaB3nCjW_}6KY$n* z^uuTVmZ$!f;`_zhYeR~^MfLY;{@(oA&EVnudt1S#BA|IYAbV+u{`k^)E%=5O?8y&r zc>^nl3b!@yVdzcVzr1+&V&RBN4r%0&LJsY4x>eGwk!FQ7BWLXHm=Zbu*c zD!HVQOA5KPwM0z zt{zH0-_a!xktjq=a*hpIac2_f@Ma@82EDax9F?0x|}W zRK42``(PPoWs!4kKDb-JN}-`{JlilUCerc5Y%JLt&p?EghD=>HA_~b~xK7JrVv+`1 z*_NSre11puFP#}`wd9wiDgekjd;2D~{~L;t1$5rZ^kgCV2Tz1-U~g;ByR9F;-8;C{ zVS9y$PEyn{{r7)|<##8ijY)iSG8>F72ok_gi~k#hq{E3&y*I-QXL#iAYqG+b$%j`$O7WGCot6Z0u_{9wQ% zfF`=HdAgcLnWOW=~PIk zsqlS|k36~j_*GQ+5si!}WMqrmSGcNj%^KI7ANo@;yz*gT?$eJ}KB7M3@>JpS%1xCV z$e-V;t6%jN+loUELaU+t2tIN6?(p(R;dXJdI9Hrp&6bX-B&w09LZX|I!Do@TpGMw( zeC$c**Ny+yqgL@ds;ml^Ch*ufz?Z?_6I5+2`DCORZPglS#nJl zh38~5TMky(VFikp+I=sz`_A3JLGZo`+yK;I5~f@LUH~pD-&eplIALb-nBDVXIcLrd zz5&Tqtr|cJriN-t&IMosT>G2AlK_A15&Vq;p2WL*c_a2vp#0q+G@cFZq-$DF$D~9x zK!{i1$s(Fygo>*aCBzSqH-S8YUkYgQ3nK0lz|mdQ{(~z)^}C|(RMW5Fji~O1n*TM{ zP9YgWg6nHheRoor7SeoK@yi;2Rg7aVjNdKZ0ooLsZxEp&c{vYd%3mpp|u* z3P$dZd~)I5g*^QkaTd(iEND}y`qzWV?iF#q{1c=#9?h}VaDaEOd#d5Ws@l-oY8}Cy zU$3#PRvQle{S~F-xm}(Pv)CyWf1z5`ZQ+3#$W-^DAJPKlRPI~w)JiJX5c^BOi?UP@ z4Ua2=42PJ+zCQu7jc^C@T1hMM*ffU(#ZMeW(hdafdL8Q>K&*KPo!Y0JFGM10{0w&a z1c;eVf-gbGmGFQX9?-%AMnY+e1ePZXk(Cb$F@+oe8>5i}P}w4Ng@(fWtNV*{rPB%l zv(}}NE~spg#zMTMML%9#3sxL(`=cMdBNnckChWT6WN2v@ypA_B|e+rkl z{Zyf!J6V?9WDY1h$0qZ-Vm~$+U!MLpnR;dCc-CoLi5*~x1@w(dD&CkM?}R$h)Zx)A>Zsxf>Y From a6f1f96262f921e2ff5766ada2c3f04617dd642e Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Wed, 3 Sep 2025 08:45:43 +0200 Subject: [PATCH 09/17] Add info pybash --- tutorial.ipynb | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/tutorial.ipynb b/tutorial.ipynb index 9f8bf76..d8d6828 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -12,7 +12,6 @@ "## Outline\n", "1. Bart Setup\n", "2. Simulation IR radial FLASH\n", - "4. Reconstruction Simulation PICS\n", "5. Prepare Subspace Reconstruction\n", " 1. Subspace basis generation\n", " 6. Subspace reconstruction\n", @@ -28,8 +27,18 @@ "\n", "**Institution**: University Medical Center Göttingen\n", "\n", - "Based on previous material written by [Daniel Mackner](mailto:daniel.mackner@tugraz.at), [Moritz Blumenthal](mailto:blumenthal@@tugraz.at) and [Jon Tamir](mailto:jtamir@utexas.edu)\n", - "\n" + "Based on previous material written by [Daniel Mackner](mailto:daniel.mackner@tugraz.at), [Moritz Blumenthal](mailto:blumenthal@@tugraz.at) and [Jon Tamir](mailto:jtamir@utexas.edu).\n", + "\n", + "In this interactive session, we recommend running BART calls in the terminal, and use this notebook as a reference. Nevertheless, we will provide some examples of how to run BART commands in this notebook to be self-contained.\n", + "\n", + "**💡CAVE:💡**\n", + "\n", + "- **`%%bash` Cells in Jupyter Notebooks:**\n", + " Magic commands like `%%bash` allow you to run bash commands directly within your notebook.\n", + " Simply prefix your cell with `%%bash`, and you can run any shell command, including calls to BART tools, just as you would in a terminal.\n", + "\n", + "- **`%%pybash` Cells in this Jupyter Notebook:**\n", + " Since it is cumbersome to redefine bash variables over and over, we use a custom magic command `%%pybash` instead. This custom magic command allows to access python variables inside the `bash` environment, making execution more convenient and consistent. The caveat here is that variables need to be enclosed by `{}` and not preceeded by `$`. Be careful, when copy-pasting code to your terminal. We use `%%bash` wherever possible for simple translation. " ] }, { @@ -41,10 +50,10 @@ "source": [ "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", - "import os\n", + "# import os\n", "import src.plotSubspace as ps\n", - "import numpy as np\n", - "import importlib\n", + "# import numpy as np\n", + "# import importlib\n", "\n", "mpl.rcParams.update(mpl.rcParamsDefault)\n", "plt.style.use(['ggplot', 'src/customStyle.mplstyle'])" @@ -152,7 +161,7 @@ ], "source": [ "%%pybash\n", - "# create trajectory\n", + "# create trajectory, account for oversampling factor 2\n", "bart traj -o 2 -x {BR} -y {SPOKES} -t {REP} -r -G - | bart transpose 5 10 - traj\n", "# bart scale 0.5 tmp_traj traj \n", "\n", From 13992697d3372eafccb1f8a78f90d3877d6d3c94 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Wed, 3 Sep 2025 08:48:14 +0200 Subject: [PATCH 10/17] update bart version --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index dd4ddee..ccb4634 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ Demonstrate subspace reconstruction for inversion recovery FLASH acquisition bot ## Requirements ``` -bart version v0.9.00-1128-g995d362 +bart version v0.9.00-1131-g7dd53c3 ``` Install python packages in virtual environment. From 2cfff1524bc8d293291322d4bcdc85354e6f48bd Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Thu, 4 Sep 2025 15:40:53 +0200 Subject: [PATCH 11/17] Prep for colab --- tutorial.ipynb | 910 +++++++++++++------------------------------------ 1 file changed, 239 insertions(+), 671 deletions(-) diff --git a/tutorial.ipynb b/tutorial.ipynb index d8d6828..b3e5c79 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -11,11 +11,6 @@ "\n", "## Outline\n", "1. Bart Setup\n", - "2. Simulation IR radial FLASH\n", - "5. Prepare Subspace Reconstruction\n", - " 1. Subspace basis generation\n", - " 6. Subspace reconstruction\n", - " 7. Postprocessing\n", "6. Reconstruction Pulseq Data\n", " 1. Prepare data\n", " 2. Subspace reconstruction\n", @@ -38,19 +33,33 @@ " Simply prefix your cell with `%%bash`, and you can run any shell command, including calls to BART tools, just as you would in a terminal.\n", "\n", "- **`%%pybash` Cells in this Jupyter Notebook:**\n", - " Since it is cumbersome to redefine bash variables over and over, we use a custom magic command `%%pybash` instead. This custom magic command allows to access python variables inside the `bash` environment, making execution more convenient and consistent. The caveat here is that variables need to be enclosed by `{}` and not preceeded by `$`. Be careful, when copy-pasting code to your terminal. We use `%%bash` wherever possible for simple translation. " + " Since it is cumbersome to redefine bash variables over and over, we use a custom magic command `%%pybash` instead. This custom magic command allows to access python variables inside the `bash` environment, making execution more convenient and consistent. The caveat here is that variables need to be enclosed by `{}` and not preceeded by `$`. Be careful, when copy-pasting code to your terminal. We use `%%bash` wherever possible for simple translation.\n", + "\n", + "\n", + "## Python Requirements " ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, + "id": "b0258fb8", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -r requirements.txt" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "90fab0a9", "metadata": {}, "outputs": [], "source": [ "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", - "# import os\n", + "import os\n", + "import sys\n", "import src.plotSubspace as ps\n", "# import numpy as np\n", "# import importlib\n", @@ -82,722 +91,142 @@ "id": "638eb164", "metadata": {}, "source": [ - "## Bart Setup Check\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "decdec9a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# BART used in this notebook:\n", - "/home/vtelezki/Repos/Groups/AG_Uecker/barts/bart/bart\n", - "# BART version: \n", - "v0.9.00-1131-g7dd53c3\n" - ] - } - ], - "source": [ - "%%bash\n", - "echo \"# BART used in this notebook:\"\n", - "which bart\n", - "echo \"# BART version: \"\n", - "bart version" - ] - }, - { - "cell_type": "markdown", - "id": "525c7c4b", - "metadata": {}, - "source": [ - "## Simulation: inversion-prepared radial FLASH \n", - "Using `bart phantom`, we will create a a numerical phantom with the inversion-prepared radial FLASH sequence with the following parameters. We use `bart signal` to simulate signal curves from individual vials and background and join them in one file" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "37a12f00", - "metadata": {}, - "outputs": [], - "source": [ - "# Define Sequence Parameters\n", - "\n", - "TR=0.006 # [s]\n", - "DIM=384 # Readouts\n", - "SPOKES=1\n", - "REP=700 # Repetitions\n", - "NC=8 # Number of Coils\n", + "## Bart Setup\n", + "### Google Colab\n", + "The cell will setup BART on Google Colab. For a detailed explanation, see **How to Run BART on Google Colaboratory** [here](https://github.com/mrirecon/bart-workshop/blob/master/ismrm2021/bart_on_colab/colab_gpu_tutorial.ipynb). You can skip this part if you want to run this notebook on your local machine.\n", "\n", - "BR=int(DIM/2) # Base resolution, as DIM includes two-fold oversampling" + "This tutorial do need a GPU, you can select one by going to **Edit → Notebook settings**: Choose **GPU** from **Hardware accelerator** drop-down menu." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "f35fd58e", + "execution_count": null, + "id": "fe98b350", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dimensions of trajectory\n", - "# Dimensions\n", - "3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 \n", - "dimensions of geometry basis functions\n", - "# Dimensions\n", - "1 384 1 8 1 700 11 1 1 1 1 1 1 1 1 1 \n", - "dimensions of signal basis functions\n", - "# Dimensions\n", - "1 1 1 1 1 700 11 1 1 1 1 1 1 1 1 1 \n" - ] - } - ], + "outputs": [], "source": [ - "%%pybash\n", - "# create trajectory, account for oversampling factor 2\n", - "bart traj -o 2 -x {BR} -y {SPOKES} -t {REP} -r -G - | bart transpose 5 10 - traj\n", - "# bart scale 0.5 tmp_traj traj \n", + "%%bash\n", "\n", - "echo dimensions of trajectory\n", - "head -n2 traj.hdr\n", + "# Use CUDA 10.1 when on Tesla K80\n", "\n", - "# create geometry basis functions\n", - "bart phantom -s {NC} -T -k -b -t traj tmp_basis_geom\n", - "#create phantom in plane mask \n", - "bart phantom -x {BR} -T roi_mask\n", + "# Estimate GPU Type\n", + "GPU_NAME=$(nvidia-smi --query-gpu=gpu_name --format=csv,noheader)\n", "\n", - "# check the dimensions\n", - "echo dimensions of geometry basis functions\n", - "head -n2 tmp_basis_geom.hdr\n", + "echo \"GPU Type:\"\n", + "echo $GPU_NAME\n", "\n", - "# create signal tubes and background\n", - "bart signal -F -I -n {REP} -r {TR} -1 0.2:2.2:10 -2 0.045:0.045:1 tmp_basis_simu_tubes\n", - "bart signal -F -I -n {REP} -r {TR} -1 3:3:1 -2 1:1:1 tmp_basis_simu_water\n", + "if [ \"Tesla K80\" = \"$GPU_NAME\" ];\n", + "then\n", + " echo \"GPU type Tesla K80 does not support CUDA 11. Set CUDA to version 10.1.\"\n", "\n", - "bart join 6 tmp_basis_simu_water tmp_basis_simu_tubes tmp_basis_simu\n", - "# check the dimensions\n", - "echo dimensions of signal basis functions\n", - "head -n2 tmp_basis_simu.hdr" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f459b704", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dimensions of simulated phantom\n", - "# Dimensions\n", - "1 384 1 8 1 700 1 1 1 1 1 1 1 1 1 1 \n" - ] - } - ], - "source": [ - "%%bash\n", - "# create simulated dataset\n", - "bart fmac -s $(bart bitmask 6) tmp_basis_geom tmp_basis_simu simu_ksp\n", - "\n", - "# add noise to the simulated dataset \n", - "bart noise -n1 simu_ksp simu_ksp \n", - "# check the dimensions\n", - "echo dimensions of simulated phantom \n", - "head -n2 simu_ksp.hdr\n", + " # Change default CUDA to version 10.1\n", + " cd /usr/local\n", + " rm cuda\n", + " ln -s cuda-10.1 cuda\n", + "else\n", + " echo \"Current GPU supports default CUDA-11.\"\n", + " echo \"No further actions are necessary.\"\n", + "fi\n", "\n", - "## remove tmp files\n", - "rm tmp_*" + "echo \"GPU Information:\"\n", + "nvidia-smi --query-gpu=gpu_name,driver_version,memory.total --format=csv\n", + "nvcc --version\n" ] }, { "cell_type": "markdown", - "id": "a68b191f", + "id": "468e5400", "metadata": {}, "source": [ - "## Subspace Reconstruction\n", - "Now, we aim to reconstruct the simulated phantom data. First, we create a signal dictionary, then we perform a SVD and finally create the temporal basis used in subspace reconstruction.\n", - "\n", - "The signal model according to Look-Locker in voxel $r$ at time $t$ is\n", - "$$ \n", - "M(t,r)~=~M_{ss}(r)~-~\\left[M_{ss}(r)~+~M_{0}(r)\\right]~e^{-tR_1^*(r)}.~\n", - "$$\n" + "Install BART" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "2060b295", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Type: complex float\n", - "Dimensions: 16\n", - "AoD:\t1\t384\t1\t8\t1\t700\t1\t1\t1\t1\t1\t1\t1\t1\t1\t1\n" - ] - } - ], - "source": [ - "%%bash \n", - "bart show -m simu_ksp" - ] - }, - { - "cell_type": "markdown", - "id": "69753496", - "metadata": {}, - "source": [ - "### Create Signal Dictionary\n", - "Using `bart signal` we create our signal dictionary with `nR1s` values for R1star and `nMss` values for steady-state magnetization. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f46a35cc", + "execution_count": null, + "id": "c32f68fb", "metadata": {}, "outputs": [], "source": [ - "## signal parameter\n", - "nR1s=1000\n", - "nMss=100 \n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "24f0719d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Usage: signal [-F] [-B] [-T] [-S] [-M] [-G] [-C] [-A] [--fat] [-I] [-s] [--short-TR-LL-approx] [-0 f:f:f] [-1 f:f:f] [-2 f:f:f] [-3 f:f:f] [-4 f:f:f] [-5 f:f:f] [-6 f:f:f] [-r f] [-e f] [-i f] [-f f] [-d f] [-t f] [-n d] [-b d] [--av-spokes d] [-m d] [--freq-samples d] [--pulsed] [-l f] [-a f] [--acquisition-only] \n", - "\n", - "Analytical simulation tool.\n", - "\n", - "-F FLASH\n", - "-B bSSFP\n", - "-T TSE\n", - "-S SE\n", - "-M MOLLI\n", - "-G MGRE\n", - "-C IR MGRE\n", - "-A ASL\n", - "--fat Simulate additional fat component.\n", - "-I inversion recovery\n", - "-s inversion recovery starting from steady state\n", - "--short-TR-LL-approx Short TR approximation for analytical LL model.\n", - "-0 min:max:N range of off-resonance frequency [Hz]\n", - "-1 min:max:N range of T1s [s]\n", - "-2 min:max:N range of T2s [s]\n", - "-3 min:max:N range of Mss\n", - "-4 min:max:N range of T1 values for fat [s]\n", - "-5 min:max:N range of FA values [°]\n", - "-6 min:max:N range of CBF values [ml/100g/min]\n", - "-r TR repetition time\n", - "-e TE echo time\n", - "-i TI inversion time\n", - "-f FA flip ange\n", - "-d FF fat fraction\n", - "-t T1 relax T1 relax period (second) for MOLLI\n", - "-n n number of measurements\n", - "-b heart beats number of heart beats for MOLLI\n", - "--av-spokes d Number of averaged consecutive spokes\n", - "-m multi echos number of multi gradient echos\n", - "--freq-samples d Samples in frequency-/z-domain for FSE model based on generating function formalism\n", - "--pulsed Pulsed Arterial Spin Labeling\n", - "-l lambda Blood-brain partition coefficient\n", - "-a Delta t Arterial transit time (ATT) in Buxton model\n", - "--acquisition-only only return the Buxton model signal during image acquisition\n", - "-h help\n", - "# Dimensions\n", - "1 1 1 1 1 700 100000 1 1 1 1 1 1 1 1 1 \n", - "# Dimensions\n", - "700 100000 \n" - ] - } - ], - "source": [ - "%%pybash\n", - "bart signal -help\n", + "%%bash\n", "\n", - "bart signal -F -I -n {REP} -r {TR} -1 5e-3:5:{nR1s} -3 1e-2:1:{nMss} tmp_dict\n", - "# reshape the dictionary to have all the elements on the 6th dimension\n", - "bart reshape $(bart bitmask 6 7) $(({nR1s} * {nMss})) 1 tmp_dict tmp_dict1\n", - "head -n2 tmp_dict1.hdr\n", - "# squeeze the dicc1 before SVD\n", - "bart squeeze tmp_dict1 subspace_dict\n", - "head -n2 subspace_dict.hdr\n", - "# perform SVD on dictionary\n", - "bart svd -e subspace_dict U S V" - ] - }, - { - "cell_type": "markdown", - "id": "2ea6095b", - "metadata": {}, - "source": [ - "### Visualize simulated dictionay and PCA coeffcients" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "3f506260", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "importlib.reload(ps)\n", - "ps.plotSubspace()" - ] - }, - { - "cell_type": "markdown", - "id": "796024a0", - "metadata": {}, - "source": [ + "# Install BARTs dependencies\n", + "apt-get install -y make gcc libfftw3-dev liblapacke-dev libpng-dev libopenblas-dev &> /dev/null\n", "\n", - "### Estimate Coil Sensitivities Using Subspace\n", - "We realized, that 4 PCA coefficients contribute to more than 99% of the observed signal. Hence, we can reduce our basis to only contain the first 4 eigenvectors. We create a subspace basis spanned by those 4 eigenvectors.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e4af968a", - "metadata": {}, - "outputs": [], - "source": [ - "nCoe=4 # use 4 coefficients" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "5b410a4e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# Dimensions\n", - "1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 \n" - ] - } - ], - "source": [ - "%%pybash\n", - "# create the temporal basis\n", - "bart extract 1 0 {nCoe} U subbasis\n", - "# transpose the basis to have time on the 6th dimension and coefficients on the 5th dimension\n", - "bart transpose 1 6 subbasis - | bart transpose 0 5 - subbasis \n", - "head -n2 subbasis.hdr" - ] - }, - { - "cell_type": "markdown", - "id": "afee5df8", - "metadata": {}, - "source": [ + "# Clone Bart\n", + "[ -d /content/bart ] && rm -r /content/bart\n", + "git clone https://github.com/mrirecon/bart/ bart &> /dev/null\n", "\n", - " Now, we estimate coil sensitivities using `bart ncalib` and reduced subspace basis in one go. " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "0d735922", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Est. image size: 192 192 1\n", - "ksp : [ 1 384 1 8 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "cim : [ 48 48 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "bas : [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "NUFFT: low-mem mode\n", - "NUFFT: Toeplitz mode\n", - "\n", - "Model created (non Cartesian, nufft-based):\n", - "kspace: [ 1 384 1 8 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "images: [ 48 48 1 1 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "coils: [ 16 16 1 8 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "trajectory: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "pattern: [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "basis: [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "mask: [ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "coilimg: [ 48 48 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "\n", - "NUFFT: Toeplitz mode\n", - "ksp : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "cim : [ 48 48 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", - "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", - "NUFFT: low-mem mode\n", - "Scaling: 0.000137\n", - "Step: 0, Res: 100.000000\n", - "\t cg: 2\n", - "Step: 1, Res: 99.987423\n", - "\t cg: 0\n", - "Step: 2, Res: 99.837287\n", - "\t cg: 0\n", - "Step: 3, Res: 96.891500\n", - "\t cg: 1\n", - "Step: 4, Res: 80.109092\n", - "\t cg: 2\n", - "Step: 5, Res: 60.550970\n", - "\t cg: 2\n", - "Step: 6, Res: 12.281537\n", - "\t cg: 4\n", - "Step: 7, Res: 2.849144\n", - "\t cg: 9\n", - "Total time: 1.43 s\n" - ] - } - ], - "source": [ - "%%bash\n", - "DEBUG_LEVEL=4 bart ncalib -N -i8 -t traj -B subbasis simu_ksp sens_ncalib" - ] - }, - { - "cell_type": "markdown", - "id": "1800164c", - "metadata": {}, - "source": [ - "### Perform reconstruction \n", + "cd bart\n", "\n", - "Using estimated coil sensitvities, we can now perform parrallel imaging reconstruction with `bart pics`." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "e4c42af8", - "metadata": {}, - "outputs": [], - "source": [ - "ITER=100\n", - "REG=0.0005\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "3c477980", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Basis: [192 192 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "Max: [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "GPU reconstruction\n", - "[ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "[192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "ksp : [ 1 384 1 8 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "cim : [192 192 1 8 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", - "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "bas : [ 1 1 1 1 1 700 4 1 1 1 1 1 1 1 1 1 ]\n", - "NUFFT: Toeplitz mode\n", - "psf_dims: [192 192 1 1 1 700 1 1 1 1 1 1 1 1 1 1 ]\n", - "ksp : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "cim : [384 384 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", - "traj: [ 3 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "wgh : [ 1 384 1 1 1 700 1 1 1 1 1 1 1 1 1 1 1 ]\n", - "bas : [ 1 1 1 1 1 700 16 1 1 1 1 1 1 1 1 1 1 ]\n", - "Scaling: 3231.903564 (max = 6739.982910/p90 = 3231.903564/median = 477.119476)\n", - "Inverse scaling of the data: 3231.903564\n", - "Maximum eigenvalue: 1.419106e+00\n", - "Maximum eigenvalue: 1.42e+00\n", - "l1-wavelet regularization: 0.000500\n", - "Regularization terms: 1, Supporting variables: 0\n", - "FISTA\n", - "lsqr: add GPU wrapper\n", - "#It 000: 1.000000 \n", - "#It 001: 0.265379 \n", - "#It 002: 0.106762 \n", - "#It 003: 0.062997 \n", - "#It 004: 0.045892 \n", - "#It 005: 0.036046 \n", - "#It 006: 0.027813 \n", - "#It 007: 0.021098 \n", - "#It 008: 0.016300 \n", - "#It 009: 0.013111 \n", - "#It 010: 0.010909 \n", - "#It 011: 0.009308 \n", - "#It 012: 0.008172 \n", - "#It 013: 0.007377 \n", - "#It 014: 0.006745 \n", - "#It 015: 0.006140 \n", - "#It 016: 0.005512 \n", - "#It 017: 0.004872 \n", - "#It 018: 0.004250 \n", - "#It 019: 0.003675 \n", - "#It 020: 0.003172 \n", - "#It 021: 0.002766 \n", - "#It 022: 0.002470 \n", - "#It 023: 0.002274 \n", - "#It 024: 0.002150 \n", - "#It 025: 0.002062 \n", - "#It 026: 0.001982 \n", - "#It 027: 0.001893 \n", - "#It 028: 0.001790 \n", - "#It 029: 0.001673 \n", - "#It 030: 0.001547 \n", - "#It 031: 0.001420 \n", - "#It 032: 0.001299 \n", - "#It 033: 0.001192 \n", - "#It 034: 0.001101 \n", - "#It 035: 0.001028 \n", - "#It 036: 0.000972 \n", - "#It 037: 0.000929 \n", - "#It 038: 0.000893 \n", - "#It 039: 0.000861 \n", - "#It 040: 0.000830 \n", - "#It 041: 0.000797 \n", - "#It 042: 0.000764 \n", - "#It 043: 0.000731 \n", - "#It 044: 0.000700 \n", - "#It 045: 0.000670 \n", - "#It 046: 0.000643 \n", - "#It 047: 0.000619 \n", - "#It 048: 0.000596 \n", - "#It 049: 0.000575 \n", - "#It 050: 0.000556 \n", - "#It 051: 0.000538 \n", - "#It 052: 0.000521 \n", - "#It 053: 0.000506 \n", - "#It 054: 0.000491 \n", - "#It 055: 0.000478 \n", - "#It 056: 0.000467 \n", - "#It 057: 0.000457 \n", - "#It 058: 0.000447 \n", - "#It 059: 0.000438 \n", - "#It 060: 0.000430 \n", - "#It 061: 0.000421 \n", - "#It 062: 0.000411 \n", - "#It 063: 0.000401 \n", - "#It 064: 0.000390 \n", - "#It 065: 0.000380 \n", - "#It 066: 0.000370 \n", - "#It 067: 0.000360 \n", - "#It 068: 0.000351 \n", - "#It 069: 0.000342 \n", - "#It 070: 0.000334 \n", - "#It 071: 0.000327 \n", - "#It 072: 0.000321 \n", - "#It 073: 0.000317 \n", - "#It 074: 0.000311 \n", - "#It 075: 0.000307 \n", - "#It 076: 0.000303 \n", - "#It 077: 0.000299 \n", - "#It 078: 0.000295 \n", - "#It 079: 0.000291 \n", - "#It 080: 0.000287 \n", - "#It 081: 0.000284 \n", - "#It 082: 0.000280 \n", - "#It 083: 0.000277 \n", - "#It 084: 0.000274 \n", - "#It 085: 0.000271 \n", - "#It 086: 0.000268 \n", - "#It 087: 0.000265 \n", - "#It 088: 0.000263 \n", - "#It 089: 0.000261 \n", - "#It 090: 0.000260 \n", - "#It 091: 0.000259 \n", - "#It 092: 0.000259 \n", - "#It 093: 0.000258 \n", - "#It 094: 0.000259 \n", - "#It 095: 0.000259 \n", - "#It 096: 0.000260 \n", - "#It 097: 0.000260 \n", - "#It 098: 0.000261 \n", - "#It 099: 0.000262 \n", - "\n", - "\t\tFISTA iterations: 100\n", - "Total Time: 6.222245\n", - "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", - "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", - "Freeing 8 bytes.\n", - "Freeing 8 bytes.\n", - "Freeing 8 bytes.\n", - "Freeing 16 bytes.\n", - "Freeing 16 bytes.\n", - "Freeing 2304 bytes.\n", - "Freeing 25088 bytes.\n", - "Freeing 25088 bytes.\n", - "Freeing 86528 bytes.\n", - "Freeing 86528 bytes.\n", - "Freeing 86528 bytes.\n", - "Freeing 320000 bytes.\n", - "Freeing 320000 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1179648 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1204352 bytes.\n", - "Freeing 1233248 bytes.\n", - "Freeing 2359296 bytes.\n", - "Freeing 9437184 bytes.\n", - "Freeing 9437184 bytes.\n", - "Freeing 18874368 bytes.\n", - "Freeing 37748736 bytes.\n", - "Freeing 37748736 bytes.\n", - "Freed 127326872 bytes.\n" - ] - } - ], - "source": [ + "# Define specifications \n", + "COMPILE_SPECS=\" PARALLEL=1\n", + " CUDA=1\n", + " CUDA_BASE=/usr/local/cuda\n", + " CUDA_LIB=lib64\n", + " OPENBLAS=1\n", + " BLAS_THREADSAFE=1\"\n", "\n", - "%%pybash\n", - "# # reconstruction with subspace constraint\n", - "bart pics -g -e -d5 -i {ITER} -R W:$(bart bitmask 0 1):$(bart bitmask 6):{REG} -B subbasis -t traj simu_ksp sens_ncalib subspace_reco\n", + "printf \"%s\\n\" $COMPILE_SPECS > Makefiles/Makefile.local\n", "\n", - "# multiply it with the roi_mask\n", - "bart fmac roi_mask subspace_reco subspace_reco" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "df606d77", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "importlib.reload(ps)\n", - "ps.plotCoefficientMaps()" + "make &> /dev/null\n" ] }, { "cell_type": "markdown", - "id": "edd72a17", + "id": "1b488cbf", "metadata": {}, "source": [ - "### Temporal Signal Evolution" + "Set environment variables: enables correct path to BART " ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, + "id": "b35dc3fa", "metadata": {}, "outputs": [], "source": [ - "%%bash \n", - "bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "92b113c5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ8AAAFTCAYAAACXn60ZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXd8HNW5//+Z7b2prLosy7bc5G7jjrExxQQCpoQWEi5cQgKpF0JIgxsgv4R2k5DKpQW4EDqEmACGGDDYYAds417kIlu9S9vb/P7Q9xxmZ2e2SCvX5/166SVpd+bMmdmdZ57zOc/zHEEURREEQRAEQRAEQRAEQRAEMQJojnUHCIIgCIIgCIIgCIIgiJMXEp8IgiAIgiAIgiAIgiCIEYPEJ4IgCIIgCIIgCIIgCGLEIPGJIAiCIAiCIAiCIAiCGDFIfCIIgiAIgiAIgiAIgiBGDBKfCIIgCIIgCIIgCIIgiBGDxCeCIAiCIAiCIAiCIAhixCDxiSAIgiAIgiAIgiAIghgxSHwiCIIgCIIgCIIgCIIgRgwSnwiCIAiCIAiCIAiCIIgRg8QnQpV169bhzjvvRG9vb97a/Pvf/44ZM2bAZDKhqqoKd9xxB2KxWN7aJwjixCXfNue5557D1VdfjbFjx0IQBCxZskR123A4jNtuuw1lZWUwm8047bTTsHr1atV+Lly4EBaLBSUlJfjOd74Dn8+Xlz4TBHH8kU/b1NXVhfvuuw+LFy9GUVERXC4X5s6di+eee05xe7JNBEGkYyTGawMDA/jhD3+ImpoaGI1GlJeX45JLLkEgEEjarre3FzfccAOKiopgtVpxxhln4LPPPlNsk8aABEDiE5GGdevW4b//+7/zZsz++c9/4sILL4TL5cJDDz2ECy+8EHfffTe+/e1v56V9giBObPJtc/70pz/htddeQ2VlJdxud9ptv/71r+PBBx/EVVddhd/+9rfQarVYsWIFPvzww6TtNm/ejGXLliEQCODBBx/E9ddfj4cffhiXXnppXvpMEMTxRz5t0/r16/GTn/wEHo8HP/3pT3HPPffAYrHg8ssvxx133JGyPdkmgiDSkW/fqa+vD4sWLcJjjz2GK664An/605/wne98B6FQCOFwmG+XSCRw3nnn4ZlnnsHNN9+Me++9F+3t7ViyZAn27t2b1CaNAQmOSBAq3HfffSIA8cCBA3lpb+LEieLUqVPFaDTKX/vJT34iCoIg7ty5My/HIAjixCXfNqexsVGMx+OiKIripEmTxNNPP11xu08++UQEIN533338tWAwKNbW1orz5s1L2vbcc88VS0tLxb6+Pv7a//7v/4oAxLfeeisv/SYI4vgin7Zp//794sGDB5NeSyQS4tKlS0Wj0Sj6fD7+OtkmgiAykW/f6Zvf/KbocrnE/fv3p93uueeeEwGIL7zwAn+tvb1ddLlc4hVXXJG0LY0BCQZFPhGK3Hnnnbj11lsBADU1NRAEAYIg4ODBg0Nqb8eOHdixYwduuOEG6HQ6/vq3vvUtiKKIF198MR/dJgjiBCXfNgcAKisrodFkfsy9+OKL0Gq1uOGGG/hrJpMJ1113HdavX4/Dhw8DAPr7+7F69WpcffXVcDgcfNtrrrkGNpsNzz///JD7ShDE8Um+bVNNTQ2qq6uTXhMEARdeeCHC4TD279/PXyfbRBBEOvJtn3p7e/H444/jhhtuQE1NDSKRSFK0k5QXX3wRXq8XK1eu5K8VFRXhsssuw2uvvcb3ozEgIUWXeRPiVGTlypXYs2cPnn32WfzP//wPCgsLAQwalb6+PkSj0YxtmEwm2Gw2AMCmTZsAALNmzUrapqysDBUVFfx9giBOTfJtc3Jh06ZNGDduXNKgDQDmzJkDYDCdpbKyElu3bkUsFkuxYwaDAdOmTSM7RhAnIUfLNrW2tgIAbx8g20QQRHrybZ8+/PBDhEIhjBkzBpdccgleffVVJBIJzJs3D3/4wx8wbdo0vt+mTZswY8aMlEm+OXPm4OGHH8aePXtQX19PY0AiCRKfCEWmTJmCGTNm4Nlnn8WFF16IUaNG8feWLFmC999/P2MbX/va1/DEE08AAFpaWgAApaWlKduVlpaiubk5L/0mCOLEJN82JxdaWlpUbRMAbp8y2bG1a9fmfGyCII5vjoZt6u7uxiOPPIJFixYl2ReyTQRBpCPf9onVarr99ttRW1uLJ598En19ffjv//5vLF26FNu3b+d2pqWlBYsXL05pT2qf6uvraQxIJEHiE5EzDzzwAHp6ejJuV1ZWxv8OBoMAAKPRmLKdyWRCf39//jpIEMRJxVBsTi4Eg0FV28Tel/5W25a9TxDEqUE+bFMikcBVV12F3t5ePPTQQ0nvkW0iCGKoDMU+sdUxBUHAu+++yyOipk+fzqOf7r77bgD5s080Bjy1IPGJyJmZM2fmvI/ZbAYAxbzhUCjE3ycIgpAzFJuTC2azWdU2sfelv8mOEQQB5Mc2ffvb38abb76JJ598ElOnTk16j2wTQRBDZTjjtfPPPz8pVXju3LmoqanBunXrkrYl+0TkColPRM50d3cjEolk3M5sNsPpdAJAUohmZWVl0nYtLS28fgFBEIScodicXCgtLUVTU1PK6yxUnM0KSu2Y0rZDjbwiCOLEZLi26b//+7/xxz/+Eb/61a/w1a9+NeV9sk0EQQyVodgnZiu8Xm/KdsXFxUmRVKWlpao2R9oWjQEJKbTaHaGKIAiKr69cuRKlpaUZf7773e/yfViBun//+99JbTU3N+PIkSNJBewIgjg1yafNyYVp06Zhz549KaHfn3zyCX8fACZPngydTpdixyKRCDZv3kx2jCBOUkbCNv3hD3/AnXfeie9973u47bbbFNsn20QQRCbyaZ9YtJSS6N3c3IyioiL+/7Rp0/DZZ58hkUgkbffJJ5/AYrFg3LhxfDuAxoDEIBT5RKhitVoBDC67KWUoOcSTJk3C+PHj8fDDD+Mb3/gGtFotAOBPf/oTBEHAJZdckr+OEwRxQpJPm5MLl1xyCe6//348/PDDuOWWWwAMhoc//vjjOO200/hMndPpxJlnnomnn34aP/vZz2C32wEATz31FHw+Hy699NIhHZ8giOObfNum5557Dt/5zndw1VVX4cEHH1Tdj2wTQRCZyKd9qqurw9SpU/Haa6+hs7OTr5739ttv4/Dhw/j2t7/Nt73kkkvw4osv4uWXX+bjuM7OTrzwwgs4//zzeY0nGgMSUgRRFMVj3Qni+GTjxo2YM2cOVqxYgcsvvxx6vR7nn38+N3K58o9//AMXXHABzjjjDFx++eXYtm0bfv/73+O6667Dww8/nOfeEwRxopFvm/PBBx/ggw8+AAA89NBDsFgsuO666wAAixcvTlql5bLLLsMrr7yC73//+xgzZgz++te/YsOGDXj33XeTtvvss88wf/58TJw4ETfccAOOHDmCBx54AIsXL8Zbb701jLMnCOJ4JZ+2acOGDVi0aBGcTid+/etfQ6/XJ70/f/58jB49mv9PtokgiHTk23das2YNli9fjjFjxuAb3/gG+vr68OCDD6K0tBSffvoprwUVj8excOFCbNu2DbfeeisKCwvxxz/+EY2Njdi4cSPq6up4mzQGJDgiQaThrrvuEsvLy0WNRiMCEA8cODCs9l555RVx2rRpotFoFCsqKsSf/vSnYiQSyU9nCYI44cmnzbnjjjtEAIo/d9xxR9K2wWBQvOWWW8SSkhLRaDSKs2fPFt98803FdteuXSvOnz9fNJlMYlFRkXjTTTeJ/f39Q+4nQRDHP/myTY8//riqXQIgPv7440nbk20iCCIT+R6vrV69Wpw7d65oMplEj8cjfvWrXxVbWlpStuvu7havu+46saCgQLRYLOLpp58ubty4UbFNGgMSoiiKFPlEEARBEARBEARBEARBjBhUcJwgCIIgCIIgCIIgCIIYMUh8IgiCIAiCIAiCIAiCIEYMEp8IgiAIgiAIgiAIgiCIEYPEJ4IgCIIgCIIgCIIgCGLEIPGJIAiCIAiCIAiCIAiCGDFIfCIIgiAIgiAIgiAIgiBGDBKfCIIgCIIgCIIgCIIgiBGDxCeCIAiCIAiCIAiCIAhixCDxiSAIgiAIgiAIgiAIghgxSHwiCIIgCIIgCIIgCIIgRgwSnwiCIAiCIAiCIAiCIIgRg8QngiAIgiAIgiAIgiAIYsQg8YkgCIIgCIIgCIIgCIIYMUh8IgiCIAiCIAiCIAiCIEYMEp8IgiAIgiAIgiAIgiCIEYPEJ4IgCIIgCIIgCIIgCGLEIPGJIAiCIAiCIAiCIAiCGDFIfCIIgiAIgiAIgiAIgiBGDBKfCIIgCIIgCIIgCIIgiBGDxCeCIAiCIAiCIAiCIAhixCDxiSAIgiAIgiAIgiAIghgxSHwiCIIgCIIgCIIgCIIgRgwSnwiCIAiCIAiCIAiCIIgRg8QngiAIgiAIgiAIgiAIYsQg8YkgCIIgCIIgCIIgCIIYMUh8IgiCIAiCIAiCIAiCIEYMXTYbBQIBNDQ0wOVyQafLaheCIAhVYrEYent7UVtbC4vFMqy2yD4RBJFP8mWfyDYRBJFPyDYRBHG8kq19ysriNDQ04OWXX85b5wiCIABg5cqVqK+vH1YbZJ8IghgJhmufyDYRBDESkG0iCOJ4JZN9ykp8crlcAICXXnoJnZ2deekYQRCnLoWFhbj44ou5bRkOZJ8Igsgn+bJPZJsIgsgnZJsIgjheydY+ZSU+sZDMzs5OtLS0DLtzBEEQAPIS7k32iSCIkWC49olsE0EQIwHZJoIgjlcy2ScqOE4QBEEQBEEQBEEQBEGMGCQ+EQRBEARBEARBEARBECMGiU8EQRAEQRAEQRAEQRDEiEHiE0EQBEEQBEEQBEEQBDFikPhEEARBEARBEARBEARBjBgkPhEEQRAEQRAEQRAEQRAjBolPBEEQBEEQBEEQBEEQxIhB4hNBEARBEARBEARBEAQxYpD4RBAEQRAEQRAEQRAEQYwYJD4RBEEQBEEQBEEQBEEQIwaJTwRBEARBEARBEARBEMSIQeITQRAEQRAEQRAEQRAEMWKQ+EQQBEEQBEEQBEEQBEGMGCQ+EQRBEARBEARBEARBECMGiU8EQRAEQRAEQRAEQRDEiEHiE0EQBEEQBEEQBEEQBDFikPhEEARBEARBEARBEARBjBgkPhEEQRAEQRAEQRAEQRAjBolPBEEQBEEQBEEQBEEQxIhB4hNBEARBEARBEARBEAQxYpD4RBAEQRAEQRAEQRAEQYwYJD4RBEEQBEEQBEEQBEEQIwaJTwRBEARBEARBEARBEMSIQeITQRAEQRAEQRAEQRAEMWKQ+EQQBEEQBEEQBEEQBEGMGCQ+EQRBEARBEARBEARBECMGiU8EQRAEQRAEQRAEQRDEiEHiE0EQBEEQBEEQBEEQBDFikPhEEARBEARBEARBEARBjBgkPhEEQRAEQRAEQRAEQRAjBolPRF7RarVYsGABysvLj3VXCIIgUrDZbNDr9ce6GwRBEElotVoIgnCsu0EQBJGE1Wolv4nIGyQ+EXnFZrNh1apVuPTSS491VwiCIJLQarUYN24cPB7Pse4KQRBEEjabDQaD4Vh3gyAIgqPRaDB69Gi4XK5j3RXiJEF3rDtAHF8YDAa8/vrrKCwsHNL+Wq0WNpsN//Vf/4WvfvWrQ+7Hz372M7zxxhtD3p8giJMPQRAwffp0WK1WGI1GmM1mGI1G6HQ6aLVaaDQaaDSalOiBRCLB9zeZTJg2bRqi0ShEUVQ9VjweRzweRywWQzgcRiQSQTQaRSAQQENDA7q6ukb0XAmCOLFwOBw8eklqi9hv9iOF2SZRFKHRaGC1WpPsknR79rooivzvRCKBRCIBURQRj8cRCAQQjUZH+lQJgjhBEAQBEydOhNlshsFggNFohMFggE6ng06nU/WbpHbGZDJh/PjxiMViEEUxxS6xH2aPEokEwuEwYrEYotEogsEgGhsb0dPTc1TPnTg+IfHpFMTpdOLcc89VfE+v12P27Nlwu93DOkZFRQUqKiqGvP+KFSvgcDgU39u/fz82bNgw5LYJgjh+0el0KCoqgl6v584Rc3Q0Gg2qqqpgNpuh1+u5A8UGfOxHo0kO6pWLTCaTSfF1KYlEIkmAYk5UOBwGABQUFPDt2LbRaBR+vx99fX15ux4EQRwfCIIAvV6vKCYJggCz2ZwiOLH3pH8zuyP9O50tYvtKt5GKT9KBHwA+QJSLVcyWEQRxcqHValFQUMD9IeY3MVtUUVHBJ+oMBgOfrJP6TlKktolhMpm4LVESn4BkexSNRrkPFQ6HIQgCPB5PkkjF/KZgMIiBgYGRv1DEcQGJTyc5Sjm6NTU1eOaZZ47r2gI33XQTbrrpJsX3nnjiCWzatCnl9Xg8zp0vgiCOf6QDMobFYsG0adPgdDphNpths9kUHSSpc8OimOLxOHeM5G1LB4vpBn3SYzDHzWQyJQ0oKysrAQw6WrFYDJFIBIFAAP39/WhsbMT27duT+ql0HIIgTiy0Wi0cDgcf4MlFbyD1fpcKQ/L3MolTmWwT65P0dSasy0WpWCyGYDAIn8+XxytCEMTRRskOWCwWTJw4ETabDSaTCRaLJSkinMHsARsvMXFIap+UhHU1+ybth3R7rVYLvV6f1BarBcxEcBZJ7vP50NzcjD179qS0TX7TyQmJTycxZrMZH3/8cUp9E53uxP7YL730Upx55pkpr99222145plnjkGPCILIFY1Gg9NOOw1utxsOhwMOh4M7KUajkQtJLOqIIQ3xNhgMMBgMSWHj0vcZ7HU2CJO+Lv1bOmCTHisej/P/5X1gopTT6YTT6UR5eTlmzZqFRCKBYDDIRak9e/agtbV1RK8pQRD5weVyqUYRKKW/AalRTdJ9lEQqJVsjbUcuoMsHYkoDQbmwxWyjTqeD0WiE0+lMijxg0ZqRSCSPV48giJFAo9Fg+vTpcDgcsFgssNlsPILJYDCkRB5JU3CZbWCpduy3Vqvl20h9KGk6r9QHkto5Zg/ltkkutiuJVTqdjvtNJSUlmDp1Ko+SCgaD6O/vx4EDB9DR0ZH/C0kcU05sFYJIora2FhdffDH/X6/Xo7a2Flarddhtd3d345FHHlFUobVaLW644QbVNLl8Y7VaFc9p5cqVSal+jY2N+Nvf/nZU+kQQRHosFgtKSkpgt9v5gK6qqgoWi4XXIGBIB15s1o7ZHq1Wy52ZSCTCazIdOXIkaX/pIKykpIQfg6XNyJ0mqfiUCbloJR0sajQaGI1GiKIInU7HZyFZP+LxOI9AIDGKII497J6VpvjKU+jUUIpCAJIjDEKhkGKUpyiKMBqNiql67H2lv5X+z9Qf9r/UrrI6U4IgIBaLJaXCsPRigiCOHWazGUVFRbBYLDzasry8PMmfUROnpfe/1N+JRqPcb2ppaVFMuxNFEUVFRfwY0tpQSlGd7HjZpA/L/wbAzy2RSECv18NkMsFsNkOr1aK4uJjbUb/fT2LUSQCJTycwFoslacA2a9Ys/PrXv85L26FQCMFgkP+/f/9+3H777YppbTqdDmeffXZKjSeNRsOjGY4GF198cZL49uGHH+LNN99M2qavr4/COAniKMAcFTa48Xg8mDRpEkpLS5MGetIZeIYoijxcXOoYJRIJ6HQ6nmo3MDAAn8+H7u5ufPTRR4r9EAQBU6dOhcvlgt1uh8vlSnKm2PFYX9g+auckReqEyaOm2GDSbDbDarXyWgexWAxdXV1obW1FT09PkgPHZhcJghhZpGKQwWCAzWZLEoKkEQBAapSRPJJJ2iazaSwlN12RXYfDwe2RdCApJR8+i9rEIYuYYP1mde3kCzKQ30QQI4/UZxIEAU6nE+PGjUNhYSGv1aTT6VKikqSR2OyHRTQxkZn5GH6/H36/Hz09Pfj3v/+t2pf6+no4HA7YbDbY7fakND6ldGI1lGwl65d0wQS2rdxvYnapp6cHHR0dfBwnj0wnThxIfDqB+eMf/4iVK1fy/6Whk8PloYcewi9+8Qv+v1TdlhOLxTBv3rwUw1JdXY3NmzcfszS/uXPnorGxkf8fiUQwZcoUNDc3H5P+EMSpxPjx41FRUQGv18tXgZIKTaFQKKlmirx2CZA84GGDuX379mH//v04cOBAVvWURFHE559/nuIAWa1WnHPOOXC5XDAajYqFeLNJc5Eir60AgAtl0m2Ki4vh9XoxdepU+P1+DAwMoL29HZ9++imlvxDECGO1WmEymZIiIZVSauWkE4YSiQRCoRACgUDSxF2mgVl/f79iFIDX6+U2MR+1LNUGfnJYKrPD4eAREpFIBP39/SRAEcQIU1tbi5KSEhQWFsJms/HxE7tfWSqdvMaSmu/BJrxaWlrQ2NiIw4cPp7VxUrZv354SsWmxWLB8+XJYrVZotVruN2XywdJtI+8767NUVGJ+U3FxMSZOnIiBgQH4/X709vZiy5YttMLnCQaJTycYF154IZYuXQoAmD9/Pux2e97a/uSTT/D0008DAP7973/nVJjS7/envNbY2Ijvfe97EAQB1dXV+K//+q+jFgUFDEZkSa9PPB7H3XffDZ/Ph0AggDvuuINCywkij5SXl6OkpAQWiwVerxc2mw0Gg4E7EwyW7y8vsqsUNi4IAnp7e9HR0YHDhw+jv78ffX19OTkbSoMsn8+HTz/9FEajEQ6HAxMnTlQVwLK1W2oDVqlzJa8LYzQaodVqYTKZoNfredTp9u3baQEFgsgTLE1Fq9XyyEtp5GM2s/dKrzFxJhgM8vp0uYo08u3j8Th6e3t5PRabzZaUWqP0t9L/mc5HqZ/S11iUA4t4YIWClfw9giCGhtfrRVFREcxmMxedWBSmXLhRSgGWRj1J0//7+/vR3d2N5uZm+Hw+DAwMDNtvCgQC2Lx5M/R6PWw2G+rq6lJKD2RLJsFKfq6sP6Io8hWPLRYLNBoNwuEwQqEQ9u7dS37TCQCJTycADocDhYWFAIDzzjsP119/fd7aDgQCaGlpAQB88MEH+P3vf5+3tgcGBvCHP/wBwGD45kUXXYTy8nK+GsvRRqvV4tprrwUwmH73f//3f/D7/YhGozh8+PAx6RNBnOjo9XruKFVWVmLMmDE8lUQQBJ7CASAp0ildlBMjFoshFAqhra0NjY2N2LVrV976HYvFsHfvXgCA2+1GSUkJnE4nL2AudWCGO+Ov5EQxh5GtpmexWOB0OhEKhTAwMIAjR44gGo0ikUggEAgM6/gEcSoiraPEaoiwSCelBQZyHTjF43EuPOVzFTlRFLnAo9free0TecFyOWqilNpr6Y7PbBMTn6TpzpFIhF87GugRRO6wBQAEQUBpaSmqq6tht9u5fZKm08knrwBlwZz9zwTx7u5uNDU1cT8nH8RiMTQ0NAAAnE4nSktL+cp60j5ki1Q0k6Jkq6TphXq9Hnq9HlarFTabDeFwmNfRZPXrpBGoxPEFiU8nAF//+tfxwAMPAFBWvYfD+vXrcfbZZwNQVrnzxdatW1FXV4cPPvgA8+fPH7HjZIvD4cCmTZsgiiIOHDiACRMmUN4wQQyB2tpazJo1Cy6Xiw/o2ACFRThJa4oA6pEGbFCo1WoRjUbR1NSEVatWjXi6R09PD1555RWcfvrpKCsr4ytCZYO8Lko2NVvkg0gWLSGKg0XKPR4PLrnkEl4v5vXXX6eUF4LIESbo6vV6/pq8QC4j16jscDiM9vb2/HQ0DdFoFC0tLSgqKkqKhkjX33QiVDZI95f6hUwoLy0t5cIbFf8liNwZNWoUpk6dylerA74QjZgfkG6STuoPSCf0EokE2tvb8e677464z9DX14d//OMfWLhwIbxeL6xWK59ozGR3MtWTUxPXpXX1mBgFDEa2ms1mnH/++QiFQujp6cG777475HMjRhYSn45T5s6di1tvvRUAMGbMmBGpm3TnnXfi3XffVRVd7HY7/vKXv8BoNGbdZiAQwA033KCoOMfjcfz4xz/GOeecgx/96EdD7nc+kBbjKysrwwsvvABRFLFnzx7cfvvtx7RvBHG8U1hYiEmTJsFms8Fms8FsNifNSrEZcyB9vTg5bDY9Eong008/RVNTk6oDJQgCnylkApdS2hyrFcVm7bu7u1WdnW3btqGzsxN1dXXweDx8BlIa/q5GNvWn1GYtpWHr0n5rtVq4XC6ce+65CIVC6O7uxubNm9P2gyBOZfR6PV9RU7qCkhJqs+5q2wKD92pfXx9CoZDqtjqdDqeddhpKS0vhdrt5RKW0LidLYQsGg+jr60NHRwdWr16tWHsOGBzomUwmWK3WpCiDdGK3XFxTO990IpXS4Jftr9frUVRUxCcc+vv7Va8JQZzqeDwejBs3DhaLhafWsTqYQHKKfq6RiqydrVu3orW1VdWm6fV6LFu2DFVVVSgsLITT6YTZbIZOp+PHZL5SIBDg0VMvv/yyYsqeKIrYsWMHOjs7UVtbC4fDkRI5nq7fQ0HuOwFfLPLAxnYulwtLlixBNBpFX18ftm3bNqRjESMDiU/HETabDZMmTQIALFmyJKmYeD4JBAL4/PPPsWrVqpSVDgRBwLRp02AwGOB0OnHhhRfCbDZn3bbP58Pjjz8Ov9+PcDicMlB6//33kUgkcMYZZ2Dq1KnHLAVPitVqxUUXXQQA2LZtG1599VUAQHd3d17DVQniREan08HlckGr1aKkpASjRo3iNdVY5I7UiRrKjLsoDi4D3NbWhkOHDqGzszNlGxaWrtVqYbfbYTAYeAi7VHyS1pGKRqPcoQqHw0lilJTOzk7E43HY7Xa+mqh0sDbcmcRshSn2m63ENWrUKASDQdhsNrS0tPCl0AcGBobVH4I4GZDWkGMz4NKVnpS2T/e/FPkMPUuzU1oYwOPx8Gir6dOno6KiAgUFBXxRA2nkOhOfAoEAent70dbWhsOHD8Pv9yMYDKK1tTWpbWlEhHRFrHRCU6bzyXT+aul7bB+WziiKg6uThkIh/hygSHKCGCw1wBZcKSoqQmVlJaxWK79PpGKu1H/Jpg6d9P1YLIbOzk40NTWhu7s7Zdvi4mLYbDZ4PB4sWLAANTU18Hq9cLlcquKT3+9HZ2cnDh8+jAMHDqC/vx+BQCBpIScA6OrqQjwe5ws5qK3aKe/zUMhUJwr4YgXTiooKRCIRWK1WtLa28mhNqll37CHx6Tiivr5edbnwfNLQ0IB58+YpvmcwGPCPf/wDpaWlAHIPRbfZbHjnnXcAAIcOHcKYMWNSnJC1a9di/vz52LVrF8aOHTuEMxg5Jk+ejPXr1wMAXnnlFVx88cXHuEcEcXzgdrv56nCslhMbgLFBlXzVkqEIUP39/fjHP/6h+n5hYSEsFguv4SIVvaQOm7RAp8lk4n1xuVzw+Xzw+XyKK1/29PRg/fr1MJlMKC4uhtPpVKz/lGnAmmv9GHm7Uic0FApBo9HA6/XikksuwcDAAA4cOIC1a9dmfQyCOFnR6XQoLCzkg550y38PddETVly8ra1N8X2NRoPly5djypQpGD9+PGw2Gy9AzqII5ClsWq0WVqsVTqcTY8aMwYIFC3htu9/85jcp58AiNwsKCrjoroTU/gxlsMf2zyZ1hkUbGAwGeL1exONxBINB9PT05HxcgjjZcDqdWLx4Mex2O4+kZn6TvP5lLhGYcnw+Hx97ydFqtVi5ciXmzp2LadOmJdkmJsbIJ720Wi3MZjNGjx6NCRMm4Nxzz0VDQwM2b96MH/3oRymRTb29vfj3v/8Nk8mEgoIC2Gy2pG2yjTDNRLoITnm6cCwWg0ajQUFBAc4991z4fD4cOXIEGzduHHY/iOFB4tMxpqKiAs899xw0Gg3sdvuIrwb3i1/8Ai+++KLieytWrMAdd9yBwsLCYfWD7VtaWoqPPvoIt99+O9asWZO0TSKRwKWXXoqrrrqKpxceL7D+L1myhAtRL7zwAh588MFj2S2COOqYzWbMnTsXLpcLFosFZrMZ4XA4ZQU3IHfHSSn64N///jcvZinHYrHA4/HwWUSNRpMSfaBkt+TCFJutNxqNsFgsaGlpUZwJ+/TTT1FTU4PJkyfz6E+1+k7Z1iyQk42dlTunkUgEOp0O1dXVKCwsRF9fHxobG7Fv376MbRHEyYJGo+ELG7CC2NlGC2Qb6QQkr7ipVvh//PjxOOusszBr1iyeStPf38/31Wg0vO6d/FiJRIKv1BSPx+F0OjFjxgzcddddePbZZ7F9+/aU/fr6+mCxWOBwOFT7PZyBXjb1pNjf8kgNQRBgNpthMBgQjUYRDAap8C9xSmE0GjF16lQ4HA5YLBZYrdak9DqlVTazWS1OyTZptVps3rwZBw8eVNxn2rRpuPTSS7F48WKYTCbEYjH09fUlCV+stIpSHaZIJIJQKIREIgGn04n58+fjsccew+9///uUzBkA2LJlC6qrqzFhwgTo9fq8RY3LzzubbaTXORaLwWAwoLKyEoWFhejt7UVzczMOHTqUt34R2UPi0zFAr9fjnHPOgU6nQ2lpKebOnZv3QuJq7N+/H1u3bk15fdmyZTjnnHMwZ86cvB3LaDTitNNOw7nnngtRFPHee+8lvb9lyxaUlJSgrq4O55xzjqJzdizxeDyYO3cugMEUvAMHDgAYTM2jdDziZEUQBBQUFMBkMsFut6OsrAw2m42vdpRLOkW2IdKiKPL6Akoh46xGAusHc5ri8XhKmp3UMZE7U9IZfY1GA4vFwlMH5QJUf38/2tra4HA4MG7cuJSZtmxm8tRm5tJdH7W0GKkTx6K5zGYzTCYTr7ni9/vh8/nS1qMhiBMZvV7PazmZTCaehgZkP8DJVaBiaShKNU/q6uowdepUTJ48mS9UwNJ6lVapkh5DnnrD0uoMBgPGjh2L6dOnA0CKABWLxRAOhxEMBrMqi5CuNlQ2g95c2gS+iOqS2i2WZkir4xEnI4IgwO12w2AwwGq1oqSkJKk+G7vPcynErfa+VPRlabu9vb0p206dOhVz587F7Nmz4Xa7uZ/AohXl0Y1K/pK0npTBYIDRaMSkSZOwYMECAEgRoAYGBtDR0QGHw4Hq6mrVsgXpatUNBem1lfuE0vdZWjYTxljdvUAgQH7TUYTEp6OMIAhwuVx45plnYLPZjtpxRXFwWWClB79Wq8VvfvMbTJ48eUSOfeutt2LJkiWYN29eysD1rbfewocffohDhw6hoKBgRI6fD1asWIEVK1YAAH70ox/hvvvuIyeKOCnR6XSYNGkSSktL4XK5oNfrEQ6HEQ6HecQRkN/VMROJBFpaWlQjC4qLi2G1WmEwGFIKm8tJF/0g7Tvbv6ioCFarVTHiqrW1lRfSZIWLlYqDpyPbFBilwam0mKZ0G+mAzmq1YuzYsaitrcW+ffvQ0NCAI0eOZNU3gjiREITBRQaMRiNfwU6adisfSEnvl2zeU0p9FUUR4XBYUXTXaDS45JJLUFdXh+LiYnR1dUGr1SbVilOq7SI9H/Zbo9FAr9fzem4ajQZf/vKXUV9fj9tvvz3F3rK057KysozCUrprkO78M7WZqS0WkWa1WvkAj6KgiJMRnU6HcePGoaioiNeijEajiMViWaXX5SK8sPsskUigo6ND8Z7SaDT4z//8T0ydOhWlpaVobW2FTqeDyWTiBcGlwlI626TVamE0GrkALwgCrrnmGsyZMwdf/epXU2xTW1sburq6UFFRkbQ4gtI55CNSVX5t011ndr4WiwWjRo1CdXU1GhsbcejQIcUyDMTIcHTCbQjODTfcgA0bNsBisRzV43Z0dKC+vh6vvPJK0uvz58/Hnj17MG7cuBE9fn19PXbv3o0ZM2aM6HGOBrfeeis++OCDEVmBkCCOJWPHjsX555+PCRMmwOVy8TQv5oBkk9aSDdJ24vE4/H4/1q1bl7J0uclkQlVVFWw2G7RaLS9srtSW9CfdcYEvBnuiOFgo12azYdy4cYoLIIiiiCNHjiAQCPBBZS7kWutAHhEmF6GkjiITxNjEQm1tLRYuXIizzjprxFO4CeJoYrFYuAjNvvfSaAKlNF7530riiloaGds+kUigu7s7JcW3uroat9xyC6ZOnQq73Y6uri4+o84WOJDeq8zmsELh0uOwezgSiSCRSCSJ5OXl5fjNb36DmpoaxevC9pEjHTymuz7pzj9Tm+nakmOxWOByuY7rSUaCGAqjRo3CGWecgdGjR8Nut3PBWm2CLB+w2mobNmxIWZhl7NixuP/++zF37lw4nU60t7dzQSwSifDoJ2abWKSi9Ec6ycaOxWwTizqvrq7GSy+9hLq6upT+iaKIjo4OhEKhpFU+cyWTH5PO7qttL/etRo0ahZkzZ2LhwoXkNx0laPR8FKirq8Py5csBAMuXL8eoUaOOeh9isRgOHDiAcDjMX7vwwguxbNkyjB49esSPbzKZUFtbi6uvvhqlpaVYtWoVfy8ajeJ///d/ceaZZ2LWrFkj3pfhUlBQgIkTJ+Kmm25CPB5HR0cHnnvuuWPdLYIYEhaLBYWFhTzFzul0Js2MKZEpnSzT9uw1jUaDcDjM66lIB1GsJpPNZlOsL6UWzp2pP2oRAEajEU6nE1qtNikFL5FI4ODBg9DpdLDZbGmjKNTOVa2PcqFJbdtsxCsmEFosFgiCgMmTJ8Pn88Hv96eIegRxIsBqJbHVLIc64ZNu9jxdhBQrWiuPeqqqqsL48eNRV1fHiwhnsplD6TMwGFHh9XoxZ84cWCyWpBQ8URxMV2YLMChFgOWbbK+lEiwqzGaz8RRupVUDCeJ4x2w2w+12w2q1wuv1wul0qkYapou6ZGRzz0rFIrbaLROFGGPGjMH06dMxZcoUaDQaXnSbRYwr9UPtOJn6odfrUVFRgaVLl8LhcCQV8k4kEmhsbIQgCHxhGKVrkekYQyVbG8gmIJnfVFdXB7/fj0AggK6urmH1gVCHxKcRxmKxYNGiRXjooYeOWR/C4bBiQd2bbroJZ5555lHty/e//32MGzcO77//Pl9hIRKJ4PbbbweAE0J8AgZX/vrNb34DYLB21RtvvIFAIEDLCxMnFFqtFh6PBxMnTkRlZSWPBmLRTunI1omQIt9Oo9HA5/Oho6Mj5T2r1Qq73Q6z2YxoNJritMkdNyXHSs0BlO/HnDePxwOdTodAIJDkRO7btw8ul4uvAjoUcSjdtchWwJK/L3foWA0sq9WK+fPno7W1FS0tLeju7k5xPgnieEev18NqtcJsNifNVgOp0Uzsb6X0r2zFEvl2auLIpEmTMH36dFRUVKCjo4MPsNQWY5D3U+01aYSjPKJr2bJl8Hg82L17N2KxGN/H7/fzdJpszjHd+9kMjNNd32wG2VqtFi6XC5FIBOFwmNt2gjhRYN/hsWPHorS0lEf2yFPs5JNLuabdqUVNazQaLo7I3589ezbmz5+PUaNGoa2tDYIgwGKxIBQKqdompeMr+WqAsm1auXIliouLsXnzZl4XTxRFNDQ0wGazobi4OGXCUG6TsrEBudhyJf9QbrPYNuxzs9lsmDVrFtrb29HW1obe3l4a040QlHY3wrz55ptcpDhW3HfffZg1a1ZS1NOxZPny5Thw4MAxiQAbCSZNmoRDhw7x4uQEcaKwePFiLFq0CKNHj04SYY5W6HE8HkdjYyM+/fTTFOfDYrHAYrGkRBNk67gNZUDDiqy73e4UJy0YDKK/v58v5348DZjk6Xks7L+oqAiTJ0/G+eefT+kuxAmF2+2G2+3mJQrU7vFM6V/pxKV0g0Fg8J5XKuRbX1+PCRMmoK+vj9efYnWahms7pQIbS3mJRCLweDwYP348VqxYAavVmrQPS9uTtiE/RzUypSeqifZq+6TbRorRaITdbkdxcTGv30UQJwKzZ8/GrFmzUFlZCQA8ii/d/Z9PnyqRSODIkSPYsmVLyn03Z84czJgxA11dXTCZTNDr9QiFQop9U4scV0PJNoVCIXg8HkyZMgVXXHEFX8CFEQ6HEQgE+EIxwyGblOBs3lfbltnawsJCTJgwAcuXL4fb7R5aZ4m0kPg0QtTW1uLee+9FXV1diqNwtGGDJobX68W9996LsWPHHpP+GAwGuN3uYeUBH0/odDq43W7cfPPN+I//+I9j3R2CyIjdbsfs2bNRXFwMs9nMZ9KZACWPLFKCbZMpdFq+nfTvSCSCSCSSNHDSaDSwWq18JSs2K8X2VWs3E5m2Z++xEGwl8amvr091v3THzUf/0m2vNjvKBucOhwOTJ08e8dp+BDFctFotnE4nTCYTrzPHkNcvSjd7nkmwliKNqpL+yIVvk8mEqVOnwuv18ohMJeRtSG0q+1++yp3Sfcz+Zyl9FosFdXV1KWINGzRJr81Q7HOmyLJM+2TzzJAiCAJ0Oh3sdvtRr4NKELlis9kwbdo0FBUVwWw2Z73oitK9qHYfKdkt+fus8LfUb7JYLJg/fz7Ky8u5bVLqn9wmZWublCYBmb+USCRgt9sxdepUGI3GpOOFQiHuN0knOIfiw2W6brn+yNsFkqOkbDYb6urqVOvtEUOH0u7yCMvNB4CZM2fi1ltvPcY9UqaoqAi33HLLcVdYra+vD83NzSgtLT3u+pYNl19+ObxeL9566y0Ag0ug9vT0HONeEcQggiDAYDBAq9WisLAQ9fX10Ol03JlREoPlAz81snEelLYJhUJJKSTA4EDLZrPBYDBAo9EgGo3yWbOhrLAnH0yx15QGrmw1O5bmI4UtaZxOvMrUBzXSpavkYgul58oGrMCg4F9bWwuz2YympiZex0Z+7QniWMHEXoPBALvdzsXTXEQkto1SxI7aPa8WxahUv8lkMmHKlClwu908PVdqk5TaURvk5IIgCIjFYjAYDKiurlYUn6LRaFJtFTXS2S+1tBW185Kns6i1o3SNpcIaE/tZkeZcB6QEMVIIggC9Xs9LFEyYMIHbJpbmzlCzMUMh3X5Kq2+azWbMnTsXBQUF0Ol0fMEDtfTkTMfJ5r4GwOtJmUwmjB07NsU2Mb+pvLxc0Z5nij5Nh9wGpbPnmZCeG/tcmb01m81oa2vjfhOl4g0fEp/yyJgxY7B582bVUGUiPffeey+eeeYZ7NmzJ0U9P1E4/fTTsX//fgDA448/jhtvvPEY94ggBjGbzTjttNP4zBgTHwRBOOpRiMxGdnV1IRAIJL3HIp/kYtNQnTg1Z0TJmWKvGY3GFBve2tqKgYEB1NfXD6kf2ZBp8KpUeyUdUicZAMrLy3H11Vdj//79OHToEPbs2ZOnnhPE0FGKdhqK0CwnkxCVzk9TihwwGo2YPHkyX9GOzfrL25X+Lz9urv1nbbK0Ho/HkxKVGQ6HEYvF4HQ6k2qy5EKugrc0+izdPmpRagx2TUwmE8rKyhAMBhEMBhXrlBLE0cZkMmHatGkoKSnh0U5s0ibb+kP5grXZ29uLUCiU9J7ZbMasWbP4inZ6vT5FfJL7DJkm0tLZL6k4z4qal5SUpCwK0d7eDp/Ph4kTJ6q2xc4tV/soty3D+Tyk27DfzG/yer248MIL0djYiKamJhw4cCCnfhKpkPiUJ2644QZccMEFQ1qKe6QIh8P49re/jY8++uhYdyUrpEb9RIWtzgMAZ555Jp544gl8+9vfxsDAwDHuGXEqU1VVhbKyMl4cUz5zIw85lpLLzFS6gZfScXbu3Inu7u6U7fR6fdKS5MOZBc82Iikbu81sFBPr8jWrqTbLKE8zyjaKS34c6f7xeBwlJSUwGo2w2Wz4/PPPT3i7S5y4mM1mGI1GLvhmujeyQWmApVbzQ+0e9vl8KcXGtVot3G43j0Ri4q60zWwGbrmchyiKScdhNedybUfpNaWBqdK1yVZgSne8bPdjPjRbjIIioIhjRXl5ObxeL7xeLxdzso0szCXaWa0N+f9sn71796ZkVeh0OhQXF0MQBESj0aTVN5lYLe1brhGlan2X2ga11UjZZEIux1SzN5kEM3nfMkV+qdk7+fuiKKK4uBhGoxFWqxU7d+6kCKhhQOLTMNHpdJg0aRLOPfdcnHfeece6O0nEYjG8/PLLx+1ykRMnTkQoFMKRI0eOdVdGhNraWpSXl+PJJ5/Ejh070Nraeqy7RJxiCMJgvZ+ysjJUVlbCarXyGX2pQ5JOYMoUfi3fVmlfNXGro6MjZQZP7sTIHSeldvKB/Jz0er1iiDUbdErT2tK1w8hWvJM6hulSVdTEqUyfJasdw5Y9b2pqQl9fX8rnQBAjjU6ng9FoTIp4SmeDlAQT+d/pyEWoDYfDKfc3i8pk9xGrSZeuvUyvZeqvHI1GA7fbjYGBgWFFB+US3aS0vZJNH64oJo3CFQSBR3TlIwqOILJFEAbr/Xi9XpSVlcFisaSksQGZJ6/S3SNqtkCtfenfnZ2dKQtIabVa2O12fr8w/0XpWEr+RbZiWTq7ptFoUFRUhN7e3qQJd6n4pGbjlcjFXir5Tmp+q9qKf0rbMhKJBMxmM7RaLfR6PY+EP14W8jrRoILjw6SgoADr16/Hl7/85WPdlRMKrVaLV199Fbfffvux7sqIYjQa8c477+A///M/j3VXiFMQg8GAZcuWYfz48XC73XxGbDhpdrkMMDI5ZGr7MPFJbdCRL+EpnQNYXFwMp9OZsj1bGjyfEa5yIUkURYRCIfh8PvT29qKzsxNtbW3o6OhAb28vfD4fgsFgkhCWaSZVOgsaiUT4IHb58uXHbPEJ4tRFo9GgoKAAVqtVdcZcjpoYku29ONztWH0iqRCWy2AqG5SiEuSDtnPOOQfTp09X3DddW+m2l08UyH8rCd0sdVtaAFk6EGU/2SBtV6PRwGg0orCwkAqRE0cdvV6PBQsWYMyYMXA6nRmf+dkKucPxGdh9pea7CcJgrUrgi3QxpUgtuT3J1n7Jo5ekf7P3BEHAJZdcgvnz56fsnylVcSiwCEmdTgedTgetVotYLMbTdnt7e9HV1YWuri74fL6kGqN6vZ7X8lI7X/k5s6j3goICLFq06KRZsf1YQJFPw+Daa6/F9ddfr1gfhMjM0b5m0WgUV155JTo6OnLed+XKlfjOd76T837sHK+99lpMnz4dl19+eUooP0GMBDU1NaitreVL3zLhCchPSoh832zCyLMdrA01jSNbhtOedICldO7ZDPbktQUikQj8fj82bdqESCSSdqZQOghkg7vi4mJUVVXB5XLxlEWl/VgfpP01GAyoq6tDQUEBPvjgA4oyIEYcs9nMo+8A5fRQOUoz2VIyRWdmY3OyjeBRi05Ui/DMpR9K28qPodVqU0Qd+UApm7bldkjtusXjcfT39yetVKV2LvI2DQYDzGZzSiHidH1i11cQBFitVhgMBsX0bILIN1VVVRg1ahRsNhsAJK1oqSZADTfKMVO0Uy4it1o0E7t35bZJzReUn6e8j0o2IB6Pw2AwKE4msJp1aj5oNucit3lMaNq6dWvOfpMgCCgsLER5eTmcTmdSNHs29pAt4uJ2u/HJJ5/k3Uc92SHxaQhoNBosWbIEZ555pqLCSxw/iKKIdevWob+/H7FYDGvWrBlSGqLD4eDRAXV1dRg9enRO+9fU1MDlcuGcc87BZ599dtKmGhLHByUlJSgvL+c1nuRFaNNF/GT6W21mXG07KVKn4GiLzyMdnQCkj/SSIhWduru7EQwGEQgE0NLSorp8ezrYjJzP54PdbofNZkuaFFG63tIQdIfDAYPBgPLycsUi8ASRLwwGQ1KNJymZ7lF5FE66QV86e5dtGnG6fqhFKCn1K12EUTbHkv8/3CgKIHPqsiiKiEQifOn1UCg0JBvK+huPx6HVahWFM7adEjqdDhqNBiaTifeHIEaCoqIieL1eFBUVpaQBp7tvlZ6tcjFbzS5l02Yu97qaXVISdtn7au1k87qSQJTNRGS256HUViQSQV9fH8LhMEKhENra2obsN2k0GgQCAVitVlgsFl6zV6k/8s/NZrNBr9ejtLQUPT09CAaDOffhVIXEpyFgMpnw7LPPori4+Fh3hVBB6qDcfPPN2Lx587Dae/311/H6668DAH71q1/h1ltvBZBbKK3b7cZrr72G66+/Ho899hgp5cSIoNVqsXjxYtjtduh0OgSDQe4QSGd11AZJ0npCUkdCOoiQh1yrtadENtEFuUYHZBv2ns3AL5v3ASguY5zJqWPvabVaRKNR9PX1cXF8OHR0dPCIzlGjRqG6uhpVVVXQ6XRpZzBZP1m9iKVLl+Kjjz7Cvn37htUfglBCEAS43e6UmfGhCEDyFLBM26YTi6V2IdMzPZ34Lv8/m7+V/pdHOkh/q0U3MXut9n4u11gUB9OLe3t7h70YQSQS4dHeZrOZ/6Q7tlwcZCmaPT09JIwTI4JWq8Xs2bNhtVp5+pbSs1JtgokJqlL/ib3HfuSRg+nIViRS2kdNMEtng9IdI120lPTcmG+oRLpSD5lEcIZGo0EsFkNvby8+/fRT+Hw+1f2yobu7m0dUVlZWorKyEuXl5RkzBNj1YGnYCxcuxMaNG2kVvBwg8SlHLrnkEtx9993weDzHuitEGm688UZ88MEHAICDBw/mte0HHngAjz/+OADg/vvvx5e+9KWc9r/rrrtw0UUX5bwfQWSiuroaM2fO5AUyY7EYH+gpOfVMQGHbRKNRhEIhhEIhRCIRxGIx7oQJwmAxWJPJBL1eD5PJxGel2cOazZIrpYRkG+UgimJSke9sBpaZ3lcayGXqSywWSyk2Lr1W6QZzcqdP6ozGYjGsW7cObW1tiMfjeZ8tO3LkCNra2rBp0yZMmTIFFRUVvEiyGuyaazQazJw5E6NGjcI777yT134RpzYmkwkOh4NHFDDSiT1yoZz9sKK6cjGdRdXIRXO1dtVeT1drjkUAMSFe+p58W7X3MqE06JTakr6+PtVi4+kiBpTal9PT08NTWPK9mlMoFEI4HEZ/fz8cDgePfkvXV+l7TqcTZrP5uF1EhzgxKSsrw8SJE2GxWLh9AdSjutn/TFCJx+Pcd2L1z6LRaNIkntls5lGfUoGK2TGpgCVFHrWkJgYnEgnuSwiCkLRdNlFMmfwDtUgu6ftarRbd3d2Kq3tLfUT5MyAd0uu0YcMGdHR0IB6P532BlJaWFnR2dmLr1q2YMGECSktLYTabFScGpIiiCJ1OhylTpqC8vBwffvhhXvt1skLiUw5ceuml+NKXvoS6urqc943H4/jb3/42pNVJ6uvrMW/evJz30+l0uOaaa7BmzZphR/7km0QigRdeeAEfffRRXtvt7e3FCy+8gPXr12P37t2q2xkMBlxxxRWqIZYAcODAAcUBmDTK4LXXXkMkEsFFF12U9axiaWkppk+fjv/8z//EG2+8gaampqz2I4h0VFdXo7KykhfJTie2SB/o0WgUfr8f7e3tXHBiqwyx1d6kThTL6WfFGm02G5xOJywWCx/4SSMIlKKCWB/UZrPj8XhS0fFc6gTIybSP2vvBYFCxPpuSsAak1quRCl7MGQyHw2hsbER7e3vGaCfpcaRRGdLjKg2SmWAYDAZx5MgRxGIxVFZWwmazQavVcpFJfg6sfavVCkEQMH78eBw+fHhYK2oRBDAoPDGxOhvY950NzJgYIp1ll4rnbB82qJP+ZoVo5ZEI6cRwURRhMBh4EW0GSz9jIpf0/ssUzZTpdaXtlCIMgMEJtfb29qzaYcgju5T6y2xeumgnQRBQXl7OP0/ptWWD8IGBAbS1tameExsoJxIJGI1Gxe+F0sCfrdBptVoRCoVoqXNi2LDyBNLFRZR8FenfzC+KRqPo6uridiIajfLnr3TSjvlNer2e3zMWiwV2ux0mk4lvw44tP6bclysoKEBvb2+S38TuX/lKvHI7Im1H/nc65H1Q+i2KInbv3o3m5uaU/dNFlKfrA7P/zc3NvHC4GhqNBqNHj+bpc9LI71gshkgkgp6eHjQ2Nqbsyz4zYFCIisfjXIBiYplSpCzDbDbD4/GgpqYGra2tlIKXARKfsoDlm9911105CU+iKPLleiORCG699Va0tLTkfPybbroJU6dOBfBFhf5sMBqNePDBB/GTn/zkuBOfRFHET3/607ymd0QiERw8eBDf+MY3VI0ZM/QulwsPPfQQL8asxGuvvZYkjrFZTymPPPIINm7ciHPOOQdGozHrVcTKysrw8MMP4/zzz0dHRwcVISeGhVarxfTp0+F0OlOibZScGWDQrsXjcfh8PnR2dmLjxo1D+h6WlpaitraWP6j1er1iSpr8b0EQUF1dDVEUU5woJj6pzbCNJOx4/f39iteDDbaUxCB5O+xHo9EgGAyiq6sLn3zySVb90Ol0vE3pTCGr4ZUuxJ1x8OBBdHR0QK/Xo6amBnq9XnFGlP1mDrDNZsOiRYvw1ltv8UEiQQwFQRBgt9uh1+sV7ZHSrDp7PR6PIxKJoLe3d0jCs9FohMVigdlsVhTD02G1WuH3+1PEJ7/fD4fDwe0nI9uIyqG8Lxfetm7ditbW1pTt0wlLSttK22bpLGowu6fX6zFlyhR4PB7YbDYYDAZunyKRCHw+Hw4dOoTu7u6UfkthQhdbfZVNWqj1Vxpd4Xa70dnZSeITMSy0Wi0mTJgAp9MJnU6XFK0kRW43otEoAoEAent7sXnz5iHVG/J6vRg1ahS8Xi8XYNXsidzXqKqqSvGb2KIArHi23G5lijzPxb4qieLMXn/yyScpNW2ZuMYWa8lG/GL9ZfWdPvvsM9X+MF/RaDRi4cKF8Hq9PEqS+VGBQAB9fX3YtWsXt53MLsntyOHDh9HV1QWtVovy8nLehpK/xyZxAcBisWDWrFn48MMP+difUIbEpyxYsmQJnn322SGl2p177rnYvn07RFEc8modjz32GJ5//nkAwJ133olvfetbQ2rnZOf222/HE088oWrM9Ho91q9fj7KyMj7Dn45zzjknKWXP5/NhxowZ6OvrS9pu+/btGDVqFF599dWcC9A/9dRT+Ne//oWLL744p/0IguH1erFw4ULYbLYUUUQuRLFZO7/fj5aWFmzbtg1+v587VEOhra0NnZ2d0Gg0qKioQHl5OWpraxVn3ADwQUY8HofH40mZIWeOApsllJ/HSMOiwdTsCHNEMjkW0oGgz+fDli1bcOjQobT7sFlRjUbDB+sA0g7M2KyrUpogAAQCAXz88ccIBAIoLS1FSUmJYt/ljpUgCFi8eDGampqwZs2atP0mCCUMBgPcbnfaSRl5ah2bofb5fIqDlVwIh8N88GIymZLqDalFQLH32L0oJRKJoKGhAZMmTYLBYEAkElFdsW84yM+XRX/G43H09vaqii5D6YMoiujv709bS0mj0eDKK69EcXFxkpAoF7rYcevq6rB06VKEQiF0dHTg8OHDePfdd1MiquLxOHp6engEiNFoVLWr8ugTj8eDcDhMKXjEkCgsLMTs2bO5PZCuBsyQ+03BYBCdnZ3YvXs3n5QZak20jo4OdHV1QaPR8OirqqqqpBRjOew1p9MJk8mU9F44HMaOHTswc+ZMmEwmhMNh7quMhG2S/maR3T09PXkVXEKhELZv3552gSaNRoMf/vCHqKiogNPp5Kv9Svso/RxnzJiBSy65BKFQCM3Nzdi7dy/+9re/pUw0BgIBfPbZZwgGgyguLkZxcXFWYrdOp8PcuXPR2tqK9evXD+PsT25IfMrAtddeizPPPDOn4uJPPvkkj+jZuXMnT9EaKsFgkIfwvfrqq1y1veyyyzB58uSc22tra8Mdd9yBr33ta6itrR1W3/LJmWeeiXPPPTfr6CGG3+/Hgw8+iDVr1igKfDfeeCNKS0t5SKbD4ciqXaPRmPS5O51O/PjHP8bf//73pIioWCyGjo4O/OUvf0FDQwO++tWvZt13l8uF6dOn484778Sf/vQnxVB1glBj9OjRKC0thc1mU5yNYjCHJhAIoLGxEb29vejv74fP5xuy6MRgqTEAeBRff38/ysrK4HK5YDabFR/aiURCcXWReDyOvr4+XviTnY9aDZdcB1pKyIUXluYjxe12w+v1pg0fVzpWLBbDzp070dnZqXit5SlC7G/p4Did08OiAdjglP1I+xGNRnkKns1m45Eg6aLSRFGE0WhEUVERpk+fjp07d+a9zgJx8mI2m/mMvpJAIR0YsO96MBhMElOHKjpJYW2zezoajfIZcTXhSRTFpHQyRiAQwEcffYSKigrY7Xa+ghvbLxvbkG2ElPze1Gq1iEQivFacFL1eD6PRqHo/q01IiKKIgYEBhMNhxT5MmDABbrcbTqcTJSUlsFgsSRMCatETLEJKEAQUFxfzZ8CePXtSUl5E8Ys6WqxttZQn6T5MoLfb7fD7/RRlQGRNZWUlvF4vLBYLf00tSpxNRh05coTXWvP7/cMuxC/1mzo7O7lIXlZWBofDwSPIle4xFmEuxefz4a233kJNTQ0cDgev98kic7KNiEz3utL7iUQCOp0Ofr8fzc3NKdfF5XKhsLBQ9T6WIp08jcVi2LNnD09rlDN79mwUFxfD4/Fweywt1aB0HCZAsbpbZWVlsFqtiEQi2LRpU0qpllgsxlPwWJRnupU6pX5TQUEBJk6ciIaGBoTDYdVreapC4pMKOp0OBQUFuP7667OOZonFYujs7MRjjz2G999/X3EbluebiVAolBJhAwCrV6/G6tWrAQAVFRUoLS2Fx+PJaQDW0dGBu+66C4sXLz4m4lMoFEJ3d3eKkVq2bBl+8IMf5NQWC/H+5S9/mTIw0uv18Hg8+Na3voX6+vph99toNOKHP/whwuEwFxf7+vr4cZ988kkcOXIEy5cvR2FhYdb1LWpqavDzn/8c77//PoLB4LBXviJOfgRBgMFgQG1tLbxeL189jTnlcieKzdB1d3dj9+7dqrPFTPiQFuyVD1rUQpWBwVS1/v5+HD58GAB4gXJ5f9jAhQ0CpSQSCQwMDCAajcJgMKSk58iRD/rUor/SwbZnQo/SsuIFBQWorq5OW4tBeo7A4Gyqz+fDrl27VKONmHDEliFP17Z0P+ngT1qDJhwOK342bW1tiMViKC4uRllZWUodA+l1kA7AHQ4Hpk2bhpaWFlVHkCCksAK7rKC0/LssTW1h37VYLIZAIKCa+svqzLEBlTw9htklVvhXjrQWGrNx6QYSSkuGB4NBbNy4EWeddRZKS0tT9svV5mT7OrProVAIBw8eTPGd9Ho9L46rZi/k/zMbrlRDhZWaqK+vR3V1NbxeL0KhEI9Kk143eZSB3BbabDZ4PB4UFRUhkUhwG8KKxgPgwqDRaExbh1OOTqeD3W5HOBxOG61KEMAXomh1dTWKior4qnbsPfm2zC719fVh//796OnpUWxXp9PxGkPSySTp95GlECvVAhoYGMDAwACampqg1Wqh0+mSJsnlPg5LdZXi9/vx3nvv4ZJLLkFlZWXKszwfQpPSa4lEAnq9HsFgELt3706x3y6XCxUVFWmFcSBZ/ItGowgGg9i3b1+K36TVamG1WjF//nzU1dWhsrISPp+P23Z2XdhnoHYNRFGE3W5HUVERSktLEY/H0drayqNlpcJgIpFAUVERCgsLU/xrJbuv0Whgt9sxceJEdHR0oKenZ9hi5ckGiU8qTJo0CevXr4fRaMx6n71792LmzJlpVc5vfvObuPvuuzO29corr+DKK69Mu83NN9+Mxx9/HOvWrcu6j8cDq1evxqWXXpqXOke/+93v8Itf/ELxms+dOxdvv/12Ts5MNvzoRz/CrbfeCgD42te+xlMiAeC9997D6NGjsWnTppwL0//zn//E//3f/+G6667La3+Jkw+73Y5FixbxlBYWYg2kOgs6nQ4dHR1obW3Fv//977QzxCy6x+PxcGeKzaizmbpAIID29va0Bf0BYMuWLThw4ABmz56N0tJS6PV6RCKRpMGj2gAQGBSW2eBFafUZOZlmyzPBzjEYDCrWU7FYLHC73RlXkWEDRUEQsHv3bmzZskXxmrMBOouwyHbmXuk8RfGLlamYA8wioKTtdnV14d1338X5558Pp9OpWN9CinQ1xDPOOAP79+/PumYVcWrCJu6y+V4zsTccDqsO7Bh1dXWYPXs2Jk2aBIfDAZvNBofDwb/n4XAYbW1t+PTTT/H000+nbau3txc+nw8ul4vPZisNTtQ4cOAAbDYbRo8ezQvyy9vIV4owGwCz4z755JMp4jIbsOYivvj9ftWJrrKyMnzlK1+B2+0GMLgCHqtpqSSQA1+IUHL7xAQurVaLM844A/PmzcPGjRvx+eefJ9nZaDSKzs5OeL3erCfu2DEKCgoQDAbT1qwiCJvNhnnz5sFut3PhSek+Zc/Fvr4+dHV1YdOmTWntWH19PRYuXIhp06bB7XbDbrfD5XJxgTccDqOpqQkfffQR/vSnP6Xt49atW3Hw4EFMmzYNXq+X+03ySTg1+7J79244HA6MGzeO2yY20SQVR1hb6UgXKSUV55iv85vf/CZFZLFYLHC5XDyFWq3f7D2NRoP9+/djx44ditd89OjR+N73voeioiKIooj29nYeCabX61VFcPmEBXs29ff3Q6fT4eKLL8aKFSvw9ttv46OPPkqK0Ozu7sbatWtx1llnwW63ZxWZyYTOefPmobGx8biru3ysIfFJgRtuuAHnnnsuL06dDY8//jhef/11RVV77ty5uP766wEAU6ZMScnVVWLevHl45JFH+P+hUAi33nprUvvRaBR79+7Fddddhx/96EcYN26cYlsrV65EQUEBbrvttiTD8MADD2Dz5s245ZZbsjrHfMFm5xkGgwG/+tWvcMYZZ+TcFltBSs73vvc9LF++PKtrnSvSou/ygTMbvP74xz/G+eefj69//etZtclCQRcvXoy//OUvuO2228iRIhSpqKhASUkJX52FpX4oRd+IooiOjg4cOHAALS0tig9zq9WK4uJiuFwu2Gw22Gy2pOWApY6LKIqwWCyw2WwoKCjgM3k+nw+HDx9OWf0pEAjwmncejwdWqzVlcFZaWopYLIYdO3YknUN/fz8SiQS3w+z42YRv5wpzegYGBlJqnwjC4OpOTJCTHk/pmrPffr9ftegkG8RJnUD5ualFUaRz4AAkRXUoHTuRSGDTpk2oqqpCXV0dX81QrX12fLPZzFfq3LZtG0VAESmwuj3yOkhKMME0EAiopnNWVlZi9uzZfEGDkpISuFwuXo9JepxEIgG3242ioiKMGzcOgUAAnZ2daGpqwurVqxXrDQ0MDPAaRtJZcun5AEhZOvzjjz/GwMAAKioqUlJ0APUUHvk1URvcye9Bs9mMhoYGHDp0KEV4Yku4S+/3TH5rusUKZs2ahdraWjidTn4sg8GQYqOUolnlSCMz2XZGoxGTJk3CoUOHFEX+/v5+mEwm2Gw2nnaUzj6xZ5TRaITdbofP56MIKCKF0tJSXrMMAH/uyb/H7DUWwd3e3q54r9TU1GDBggUYP348r3XpdruTVrRjJBIJOJ1OFBUVYcKECQgEAujo6MChQ4fw2muvJT1Lmd/EJvdcLpdi9LjX64Uoiti1a1fS9/2dd95Bb28vRo0apfgcl/8tJd09LBfW2cSU2WzGzp07sW/fviQbKwgCysrK4Ha7eTH1dLaCCUOBQEDVb1q2bBnq6+v5JKAoijCZTIrpiaxNJRsrtSFS22QymTBv3jzs3r07JT2YLfTAapoqiWlKdspsNsPr9WLixInYs2cPRUD9P0h8kqDT6TBmzBhccMEFOO+887LaJxaLYe/evXj99dfxyiuvpLw/evRoLF68OOdollGjRiXt4/P58NRTT2Hv3r1JdY26urrw+OOP44wzzoDJZEJVVVVKWzNnzkRpaSl+/OMfJ33x33zzTfT29mLFihUYPXr0iAg1cg4cOMBTchh6vR5XXnklCgsLs24nkUhg7969KcsNs1SklStXYtGiRXnpczoqKipQU1ODAwcOJL3+8ssvw+12Zy0+McaMGYOqqio888wz2LlzZ87LKRMnL9IHWVlZGYxGI48elD9kmXPAaoS0tLSgs7MzpU2LxQKPx4Py8nIUFRXxaCf5IEjqeLCw58LCQoRCIfh8PvT29vKlf6WOVDQaRUtLC08NltZYYHg8Hmg0GuzcuTPpHEKhEARBQDAYzKpGkRJyx0M+eyiNUmJOn3wCQRAElJSUwOFwQKvVpi32K+1HV1cXn3mUt8ciFZT6qPaaEmoDQWlkmZJj1tjYCJPJpDphoTTDqdVq+cD/0KFDPDWSIABwAUAqFgPKYimzJ+FwGKFQSDEKurS0FBMnTsTpp5+O+vp6WCwWXgeF/cTj8aT0OLvdjuLiYkyaNAk+nw/Nzc1oaGjAvn370NramiQiseOz6HYmLEv7yuoWycWn/fv3QxAEHDp0iEcnyM+PtZXp/k4XXcCuXTwex8GDBxUL72a7yq70c2B1taSwVJHx48ejpqYGOp2O22D5Kplq7SqdjzwFSaPRoKSkBF6vF+3t7SkRbywtUn4M1pZapIpOp4PZbObpgSRAEcDgd8NkMqG4uBglJSXQ6/WIRqO8iL8cJop3dnaivb1dsURBRUUFpk6dirPPPhuzZs1Ksk1M2I3FYtw2CcLgip8lJSWYPn06BgYGcOTIEezatQs7duxAU1NTUpmVWCyGtrY2uN1uPjEt76PL5YJWq8Xu3buTvus7d+6EIAhYunQpysrKFIVjpdXvpG2ne00uQMfjcezevRsNDQ0p1724uBhWqzVl9T2l47A2e3p6UiYA2QqXM2fOxMSJE2EwGBAIBCAIg+Un2OcpbYfZXiXbJLUn0glAjUaD6upqVFVV4ciRIynjr6amJhiNRr6gjly8VBLkWQplVVUVmpub4ff7yW8CiU9JeL1ebN68Oac0rc7OTsycOVMx4gkAXnrpJUydOnXYfbNarVi3bh1uvfVWPPjggynvX3PNNfjSl76E119/Pad2P/74Y0yePBlbtmzJS12kTFx99dWKaYIsVSRbIpEIlixZkjJzVlNTg61bt+bU1nC49957cfnll2PWrFl5a1Ov1+Nf//oXfv3rX+PHP/5x3tolTmz0ej1mzpyJ4uJiWCwWhMNhPmsjd86ZaNPd3Y2NGzeqznLPmTMHBQUFvCAsq7sivX+kD2/5crlMkCgoKEBxcTG2bduW4oQAgytCdnZ2wmw2c4eK9cloNMLlcin2LxgMYv/+/aitrYXJZFJMj1FzMuTOldIMFbtWbAXA3t7elEhKQRBQUVEBq9XKzz0dojhY1Hj9+vUpER3MWWKRFvJzUXLI1Jy0dDNu7LNhg2elwT0rcOpyuVL6IT8fYNAh1mq1KCgowPTp07F///4U0Z04NdFoNHA6nbwWiXRwoxapyFZHUuOOO+7AhAkTYLFY4PP54PP5kEgkeMQgu3elto3VamN1SKqqqjB27FjMnDkTDz/8MF566aWU4/T39/MCsfI+MqFYiYaGBvzsZz/DPffcg/Lycj54kd5LanY3nQ1htpedQzgcxq5du7B69Wo0NzcnbcsG1moil3xb9ltpVSq73Y6LLroIFRUVMBqN8Pv93BdWq4uTLdKBIbNHy5cvx+TJk/HHP/5RcXs2eM8G9lnp9Xo4HA4Eg8G0q/cRpw56vR5TpkxBUVERFyeVohwZ4XAYAwMDaVPtfve732Hy5MmwWCzo7e1FX18fFxqkNZ+kgovUNmm1WlRVVWHcuHGYO3cu7r//fjz11FMpx9m1axe6u7tTFgkRRRF6vV51xe4dO3bgP/7jP/D4449j1KhRSUIbO6d0i5ioTeyxNuLxOIxGI0KhELZt24ZXXnklaWVwtl9xcTFMJlOKcK0mcCUSCXz22WcpPpjL5cKNN96IMWPGwGw28+hIADwlMRtbofRMYteDfW5+vx+XX3455s2bh9tuuy2ljWg0ioGBAR7Fr+RrSmGF3wsLC1FfX49Dhw6lRFWdihydEfoJhNrMihJPPvkkLr/88pQb5Z577sGbb76JN998E7W1tUN+YMv7pdFocMMNN+Cpp55SdIg+/vhjnHPOOYqzYwUFBXj99ddx5plnprwniiJuvPFG3H///cPupxq7d+/G2Wefje3btye9/qUvfQmvvfYaHA5HztdJzdnK5TMcLoIgYOzYsXjzzTfzJt6xz/ponQNxYqDValFSUgKDwaA6awd8MbA7fPiwogNVXFyMsWPHYsGCBXC5XLyQLSvYygQt+X0kddZYgWwAvKYBi6Q57bTTFL+7PT09+Pjjj/kgUupI6XQ6LFy4UHVV0ebmZnR2diZFKrE+SX9L+8p+S89D7lSxQu1+vx9tbW0pIk1BQQHq6+uTVt6Tt8P+Z05ILBZLm/ohXZFFLVxc7TjZ2ASpoMZWhGIilJRAIMDFezaIl3/m0uOz71ssFkNFRQWvB0MQAJJqJ2X6ngaDQcUFVWbMmIErrrgCv/nNbzBq1CiIosjrBRkMBr56ntQGsHuP2S5Wp47VdBkYGIDFYsHFF1+Mn//854p2MxqNoqurK8lWSm1IQUGBYv1PURTx2GOP4Y033uDbsmgAqe2RimXsf+mP9HqxGlYGgwGdnZ3Ytm0bXnjhhZQIDIPBwP0mub1LJySrRTDpdDpUVVVBo9EgGo0mRZkNBSU/jA0wgS+iGVasWAGPx5O0HVv0QcluZ8JkMuVUM4o4udFoNHwBIPZMVJpsYd/N5uZmfP755ynfe1Y+5emnn8aoUaMQj8fR39/PV5o0mUxJKVzSCE3pZJDRaOSRhP39/bBYLLjmmmvwwAMPKNqm3t5ebNiwAX6/P0Xg1uv1mDt3LoqKilL2E0UR999/P5577jluZ6S2SWp/pGUA2P/st/QejsViiMfjMJvNaG9vx6effoo///nPKUEAHo8HEydO5DUtpRFHSj4N85sCgYDivW4wGFBXVwdBEBAKhWAwGLidVHvW5DIOZDaT+dVarRZFRUX42te+Bq/Xm7RtMBhEe3t7UmmDTMdh1724uDjr1dZPdkh8+n/U1tZiwYIFWX1ZRXFwadhdu3bh/fffTzFSM2fOxFlnnYWzzz47q5XtcqGurg7Lly/H0qVLUwZqnZ2dWL16teKMj9FoxPLly3HmmWdizpw5Ke+vW7cOq1evxpo1a/K2LCS7mbdu3Yp3330Xb7/9dorDWVlZiWXLlqWErWdqV0m1r6urw9y5c4fd71xxOBw4++yzUxyo5uZmvPfee0MurF5dXY1FixZlFVJPnNzYbDY+iyQf4Ekf6OzvQCCA3t7epBRdhtvt5mkPbGZbGtGjltag9hq7zwVBgMPhgNfrRVFRUcpgLRKJoKOjAz6fL+meYA5VWVkZvF6vYhQUqyvl9/uTnKehDE6kzmEkEkEgEIDf71dc4c5qtaK0tDQlwiwdak6U1OHLtc9DgX1HNBqN4rLyoVAIHR0dWUVzSdsUxcE6C6w4PYnkpzYs3S7b5xRbkU7puciKirNUFiDZNmUzKSMVYFgajCAIqKqq4m3LhVNWh1K6AptUUDaZTDwlWc6+ffuwfft27Ny5E6FQiA9g0tln+Q9DGlnQ09ODhoYG7Ny5EwcPHkzxy9h1z9Zes+Mr3e8ulwulpaWwWCxJQnS2qA3mM0VUGo1GHs0ghdlmpX3SweydXq/P+0IzxIkHKw/AaliqRdwA4MJGX1+fYkTm5MmTsXDhQsyfP59HvbBxiNJknRrSCCQmhrH6UQsWLEiJwGR+E0vXkk7aCYIAr9eLwsJCXgNUyrZt2/Dvf/8bmzdvRiAQ4FFX8nNXs1EMqb/FUhJ37NiBTZs2Yffu3SkR3mazGcXFxVlFI7HzYPX/5J9RcXExampqYLVa09omeb+VbGwmeyT1q00mE6ZOnQqbzZa0XTgc5hMV2fhN0ueAyWTitb9Odb+JxKf/xw033IDnnnsuKxFEFEVuDNQYyS+W1+vF22+/jSVLlqhuo3ZT3HbbbXjkkUcU+/f222/j3HPPRVdX17AHRmz/eDyOO+64AzfddNOw2pMSi8UUB4o/+MEP8MQTTxy1lLtM/POf/8SKFSuGXDj8iiuuwCuvvJLimBGnHmPGjMGCBQv4rLXSQE96P8jrm0gpKSlBaWkpf+AzhyQXIUf+UNdoNHzgxgrnK83Gsb4x507qtJnNZtTV1ammKfv9fhw6dIgXo1QaiGZyAqUiUjQaTVsPCxisieX1evksm9q1YGg0GkQiEXR3dysuEazX61UH6ZkiOTN9PkqfCdtPSXzq7+9HQ0MDgsGgYiSdUtQCIxqNorq6GmeeeSaJ46c4VqsVbrc74/eSwWryKDF37lzMmTMHoVAoafVGlhLMZt6lgwkpbEDHtgMG027Y/etwOPCb3/wGM2bMUDx+JBJJqRfE+m+1WhUHeMDgIO+BBx5Ac3Mz4vE4T4Vj/ZH2Sfq/9JxYX3U6HaLRKD755BO8/vrrWL16teIxWTRYugGVFNYfpcnF6dOnY9myZUkpLNKBtfxaqAlomV6XwkTB0tLSFKGICfjyBSykv9UQRRFmsxmFhYWn/ADvVKempoZPtit9f5jYwL4n7e3tquO6008/HYsWLYLf7+fPS4PBgFgshmg0yuuoyUUb6WRXPB5HJBLhNX+YbYrFYnC73Xj66acxb948xeN3dnby1Sml0U9arRa1tbWYNGmS4n4bN27ELbfcgsbGRsRiMS4wx+NxRKPRpP6z/9lrkUgkadEBVi9rzZo1ePLJJ/HCCy8oHtNkMsHj8agubCC/L1m0ZU9PT8r9ffrpp+Oyyy7jNZ7kdTeVxLJMNkjpPQabHBEEATU1NSm1kAcGBnDw4MGkiQal48vbBQZtXlVVFQUVgGo+wWKx4M0330RdXV3W+0QiEVx++eXYs2dP0uujR4/GSy+9hNra2nx3U5F7770XF110Ea644gr+WiKRwAUXXICrrroKP/vZzxT3GzNmDDZt2oRvfOMbKctms1z8G2+8Ed/+9reH3Lf7778fTz/9NERRxKFDh1Le12g0ePXVVzF9+vSc2/7HP/6Bn/3sZ4pRHceSRx55BG+99RZuvvnmvLXpdDqxbt063H333Xj++efz1i5xYqDVajF37lwUFxenLLmrBHtwbt++PcWJslgsmD17No/Qkxbrlc74ZEs6sUSr1WLy5Mnwer349NNPk97fs2cPotEo3G43j45iD2+LxYKSkhLMmTMHu3btSlkKXBRFHD58mK+4xwp9ypcZV0ofY85WIBDAwMAAj6JSSytZtmwZX1VFTfiROxmxWAxdXV3YtWtXygBbKSVG2sdcQsSzRTqrK3WUpe/7/X7odLqkFXWk+yrBvjdmsxlnn302tm7dSnUMTkFcLhcMBkNWUYHMxvh8vhQht6SkBD//+c9RU1OjWJ9EbUJJSXyWI49OSCQSuP7663Haaafhl7/8ZdK2LCVYOgnJ2mQRNR6PB/39/Sn3dywWw5///GeMGTMGEyZMwPjx4+F0OvnkkTziUdoftmrovn37sHHjRuzatQt+v191IFxQUMAHrrkQi8V4+o4Uu90Ot9uNaDSath5OOobyDAEGxcWZM2fC4XBgy5YtSe2pTTJkcyyWLunz+VRXUyROTjQaDaZPn46CggI+MZbu+yKKg+mo+/btS7nnKioq8D//8z8YPXo0vz+k4gW7r7P5PrLfbF8mVrGI6Gg0iu9+97tYtGhRSr2hhoYGxGKxpAwLdh+wmnUzZszA3r17UyYeY7EY7rrrLkyePBnTp0/HtGnT4Ha7eWaO3L+R+irhcBh+vx/bt2/H+++/j88++ww+ny/FN2MsXLiQr5SZrjSElEQigb6+vpQV8wDwSCGWbsfSqdWin+TXW2mbbOwUm7RbunQpPB4P1q5dm9QGWxhBr9fn7NMZDAYsWLAAe/bsQUtLS8a+nIyc0uJTXV0dFi1ahBkzZqgWblOCrbQmnS2fO3cuFi9ejKlTpx612Zbq6mokEglcffXVeOutt9DR0QFgsL6SUt0nhtlsxtSpU3HhhRfCZrPh3Xff5e+JoogdO3bgnXfeUazpsWTJElRUVCS9lkgk8Oqrryal+7377rv4/PPPFY9fUVGBM844A7Nnz0ZJSUlO5wwA3d3dSbWjjEYjLrroIowdOzbntvLJmDFjsHfv3ry2qdPpUF9fj3PPPRehUAh///vf89o+cfzCinMXFRXx5WSlSB0FYNDhYo6CfNU5m80Gj8fDnTGl0OV0D+V0D3UlQUYURb5UtnywFgqF+MBKPqvEZhNLSkrQ29sLnU6XIjIzAY5FL0kXK2DpP/KUQBYtxWqJBAIB1XRYFu3k8XhUBRm5I8lgApd8AQppbZdcaqjk81miFhEWDod5FIJa39T6IQgCCgsLUVxcDL/fr7gyEHHywVI52WAgG9hgS56uUFFRgYkTJ2L8+PEAwAtNZ7pP5Pdium2kxGIxlJaWIhaLYdKkSThw4AD3XaSrVSmlxzL7xNLd5KsWtbW18df7+/ths9m4jSsrK+OpI+xY0WgUTU1NCAaDCIfDaG1txd69e9HU1KR4PizVTrpgQbbXQJqKyBAEAUVFRbDZbDyqQW2luUzHkR9L+lq6qM1EIoGCggLFyURp7axMyM8TGBzksfowtMLUqYHJZILD4eDP70x2hN2vgUAAgUAgSfwYNWoUpk6dismTJyelyeUqzCodUylaJhaLobKyErFYDNOmTcPevXu5GBYOh3khfZaSLI3c0uv1KC4uRl9fH7RabUrGxZEjR3hkdm9vLxwOB7dN1dXVSbWImCB+8OBBvgLwkSNH8Pnnn6cUFmewVDuXywWj0ZiTn8N8OWlUJivF4HK5oNfruU+V7bVXsgfy/zNNvCYSCZSWlqbUtAIG/VBWBF7qT7P20rXLhHG2YnS6hTdOVk5p8Wn58uV46KGHctqHhU3Kb4Drr78e1113XT67lxU1NTV46qmnsGjRIi4+AV/UMGCzkkr86Ec/wpw5c7B27VpebJjx97//XVHoePnll1PSaWKxGL73ve/h8OHDqv1kxhEATjvtNDz55JM5nWc6HA4HHn30UcVl3E8Wvv71r2PBggX4xz/+MeQCoMSJhcfjQV1dHex2Ox+oyEN8pQ9S5lgopc0WFxejvLwcJpOJhwvLo4WA7GaF0j382XusYK3NZsOoUaOwZ88e+Hw+vl04HEZvby88Hk/Sg5o9xIuKiiCKIux2O3p7e1O+8+FwGOFwOKWGXEFBAXeoWLFPtqpWNk4ocwpY6LvcqVC7TuxvaQqNFJZuJxX+5AM0aTty5AM4JUdHaXv5b6X2WYpTuhli+flKv4Mmkwnl5eXQaDQkPp0i6PV6WCyWpOL56b6fbBsl32nWrFk4/fTTYbVa0d/fj0QikSRKywcLSseQkkmIiUQisNvtKCsrwwUXXICnnnoqaeKMDQKNRiP/nkvb1Gq1sFqt0Ol0ikXTW1tb0draig0bNiS9vmzZMlRVVXE/iNnAt99+W3W1ZDkGg4Gnsyjdk+nOXz7YBQYntyZMmJBkh7OdhJCjJjgp/S99PRaLwel0KhbijcfjSanSSp97usGkRqPh3yUSn04NnE4nampqYLfbueCtJAaw/6Wp8vLv9/z583HWWWfBYrFgYGCAp9Qqrf6oJNIq3S9q9wETYBwOByorK3H55Zfjz3/+c1IkFrMZUvGJ/dZoNHC73Rg9ejQsFgtfgU9KY2MjGhsb8a9//Svp9ZUrV2Ls2LH8XguFQujq6sILL7yQtryM9HwKCgpw2mmnIRqNpvW1lOy1Uv0kvV6PWbNmobi4WNUHy6ZfSsJTJv+JEY1GuUgkJxgMwmq1pqxqqNSu3BcDBic5y8rKoNVqSXwiMvPcc8/hlltuOe5SvuQ888wzWLNmDTZs2JBSCFvKggULsH//fixbtgy7d+/O2O7111+fEq0giiLa29vT7jdlyhSsWrUKAFL2JwgiFZvNhtLSUu48sVVD1AYdiUQCHR0d+PTTT1McbZvNBqfTyWeWpFEuIxGpyUQWjUaDioqKlNmyjo4O9Pf388EYc55Yv8LhMDweD+x2O7xeLz744IMk8UoNtYd4JuHJarWivr4eJSUlfIUWaeHhbGF1H+QwJ1fJUWHvp0MtlDvdzBpDKjwpRTWwAvBykSqd08ZeY7PGhYWFMBgM2Lhx47BnhYnjH3maZqbvpyAIiEQiigOimpoaTJw4EQMDA3zVpUgkkpJulc33Ph3MdppMJoTDYQiCgDPOOAOvv/56UqQ4W/mTRWUr2VudTgetVguz2YzOzk7VGlZSPvzww5Riv6IoZkwJ02q1cDgc/JjyOkjSa5zN+UvRaDRcsFca2GUzGZEN6dpgq2cpTR6yZcrVojKVzl3+WbGVPtXShIiTC4vFguLiYj6RkkmMFkUR3d3d2Lp1a8p9PG7cOEyfPp1HYet0OoTD4bTRnrncL/JoRKPRyIXw8847D88//3yS79TZ2YmBgQGUlZUBQFJqGxPWHQ4HXyhl3bp1WflNb7zxRspiColEIqMobrVaMXHiRF5CQRpNnst1YLWmpLDIJ7PZnLMvlg+bxcRAi8WSYpuY38RWG5UXcs/UJ9a2x+OBwWDA5s2bh93fE41TUnwSBAE33HADli9fnvO+gUAgKUfTYrHgm9/8JqZMmZLPLg4b1s9Mgy6j0YiysjLceOONaG1tRTwex5/+9CdVtTsX0c1ut+PKK6+E1WpFTU0NysrKRmSgezwTjUbxu9/9Dueccw4WLlw4rLbcbjduu+02vPDCC9i3b1+eekgcj9TU1MDr9WZMP5E+jFmBSLkD4Ha7YbPZYDAYFKNu0rUpJdt7Vz7jxJZgl8KiIKLRaMpKctLj6HQ6OBwOTJgwAf39/QgEAmhqalK9JrlEBWq1WhQWFsJms8Fut6O4uBhmsznjMt1qs2WCIKgWJk83CzcSKEVCKQ0+RVFEa2srXwFRLbpLrZ/S2WOz2YwJEybg8OHDqsXuiRMftvJbrt9f+fdPq9Wirq4OJSUlMJlMCAaDaSO1szlWuj5JX2d2wmq1Kg4asrEjLArVarXyVL1gMKh6/FxXEWYpjSy9USkNMJtIyWyOoyQu50q6SKxMUVksKlROOBzm4lGm/qm9zyZubDYbgsFgznWyiBOHiooKFBYWcpE2m+8zS8mUTtjpdDpMmjQJ5eXlMJvN8Pl8Kd/RfD3T5VF97LeSbWJ+kzQiUAkWnVlbWwu/349wOJzWb8qlJhoTrM1mM2w2GwoKCtKuJpgNSpFPgjBYU1I6kZktajZSKSJJaV/pNmxCRL5NR0cHnE4niouLFT8/pTblCMJgva5x48ahqakpY5TZycQpJz7p9Xq4XC786Ec/wqhRo4bdnt1ux913333Mo3kcDgdsNltWKrccQRDwve99D8Dgw37VqlVoa2vjinwwGFStj6LUlsvlgiAIKCsrw2233Qav13tSp8SlIxaL4Z577oHBYBi2+FRYWIhf/vKXaGxsRHt7O83knYQIwmCRw7q6OjidzqzCjNlDLRwOp0Q8aTQaeL1e2Gw26HQ6xYLlSg99JbJNuZDDZgzlq5QAg3nzer0eer0+pRaJdDZw0qRJ8Pv96OjoQE9PD0/fYal1uTg9bCbdaDSiqqoKXq8Xdrudz9zFYrGcVyJh559pdZdMTg97T+7Eqjk08u2VQr3Z32rXqaWlBeXl5Sn9zeRMyf/X6/WYPn06rzlGg7yTDzYoUkrZVSJdWoNer8fMmTPh9Xqh0+lSvp+ZhE95v5S2VfreSrfR6/VcTJP7OJkEE/Yeq20Xi8V4bbls+612HkzMZQKUPOJJTqYBT7pnBxN30qUYZ+qvfNtsniHyaCU18SlX31rpO6DRaOBwOBCPx7NOcSROHJjAOHr06JQi2pmetWyVXil6vR7z589HWVkZ902UJm/k7WUSSLMRPth7Op0OZrMZRqMxRbhmdfGU7hnWhkajQV1dHUKhEPr6+tDd3c39JuY75WKjmPhmMBhQXl4Oj8cDq9UKs9nMy7ZIzy8bkZzB/Dg5THRXsmXZiuXy651OJJe/L4qiqjDe3t6uWLM4nd/EkLbPhE6/35+0yuvJziknPp1zzjl45plnTjox5MUXX8SqVatw6aWXDqsdaepEPB5HQ0MD7rnnHrz88stZ7W+327Ft2zYejsgKshH545FHHsFHH32EM88881h3hcgzLpcL48aNg8fj4Sla2aRTCIKgKBKzOgAmkymrmSO1WaLh3sMTJ05ES0sLdu7cmfR6MBiEyWSC0WhMOVfpTL8oDq6EN3r0aFRXV8Pv92NgYABtbW04fPhw1rWGtFot5syZA6fTCYvFwheaYDOKajOb2czeq0U+SQdW2Q7k5NdcbdYs1yiIdMfPRUyQH4sNXJ1OJyZNmgSn06m64ARxYqLX62G1WmEwGACkr+MjHfhJRWIpOp2OrwjHnPyRigRkSO0Zuye/+tWvYuzYsXj66aeTtlVbaY0hv/f0ej28Xi8/10AggFAolFVKHmvD7XZzoV6+qla258X+z9RnBqtBleugLp8o2ZShtCH9LUen0/FJGIrMPLlwOBwYPXo03G43r12Y7Uq+LAJbil6vR319PVwuF6+PCSiLsrkKsErIfQ1mm775zW9i4sSJ+POf/5zUvnSlNbW2gC/SVgsLC3HWWWfxVTXb2trQ1NSUUpRcDa1WixkzZsDhcMBiscBkMvG6c/LVc5XI9BmoTdqxicJ82KZcIpLktjQbEUn6v/xvNZjfZLPZMG7cODgcjhQf+WTllBOf2APoZMNsNucl+orNbAKDN0ZNTQ2+8Y1vYNmyZVntbzAYeP0PYvAhdtddd2Hp0qV5a9NkMvHlm4mTC6PRyMN4c0khYw6XWrFraSRRNigNIIfy0Gf7sFWH5MeQFqeUChtKTgwTxIEvVrUzGo1wu908nUJphlKj0fAQda1Wi5KSEl4AXD77ly5cW+36SN9nUV7ybdlAloWQZzNDmg1qs3nybdK9V15enhRll81gV62f0WgUbrebljY/CWECi/R/6W/569L/lewZEytZ1FOujruUXOyT9Hsej8fhcDhSil2z94YiirD73GKx8FWfsr2f2Cp27JopRRGokc5eKW3DYNEQcjufzTVNZy8ztSPfRun5ZDKZhrwwhtLxdDqd4oCdOLExGAx8de5cVvLVaDSK9YYEQYDH44Fer0+ZFMsUUaU00aMWVaMmXIniYCF+l8sFl8uVchwWaSSvIalmA9ixpKm8rAYoE5Gk+zC7x0QwjUaDwsJC7jexfeQTc5lQ8+uUUtuAwchH9r60rpLScXOxB0pikdp3RM1+l5SUwGaz5Ty5p/RdSiQScDgcp5TfdEqJTxUVFSgtLT3W3ThhYFETZ511Fs4666xj3Z0TEp1Oh2uvvRbFxcV5bddkMmHMmDE4fPhwzrUkiOMTo9EIm80Gh8OR9MCTP7SUBneCICiKT4IgJM3aqUXQZHotF6FEaaCg5lww8Skbx0E6QGGrGJnNZhQUFHAhizlF0mLqbIZQ6kyx66u0ao3SeWQTicQGN0rnqTYbmq3jls0ALhNqA+mioiI+4aDWrrT/6Y4Zj8dhsVjgdDphtVoRDAZpdc6TACbgSoXVbCOCAGUHXqPR8LomuS5VLT1ONgJJuu+r2sQd63O2tUzkAzcmtsuFJDnS885FbMqFdJ8VG+DlYwl5NTJ9VmqRD2ySIVdRTK0PWq02aQBNnPgYDAZYLBYuBACZn+dsGzW/iaVpsu+JmngkJ52YkSnyRv4ee5YqTTQzv0kqPmWaLGPbGAwGmEwmLmrFYjFue6QTgGyyTgqL6pQeMxsBSG7/5OKRUmqbKIp8UlF+nHTCnZxsPgOlc2F/q0WzFxQU8AyqTN+PTPaKPYfsdjssFgtfkfpkJvsKXicBzz33HB566KFj3Q2CGDbTp0/Hrl27UF9ff6y7QuSJadOmYeLEiRkLXkuRPjjVZvBYMchj+TBLN7Ol5FwowZwhFsUUi8V4kfVoNMojM4xGI8xmM6+XwAYv8XgckUgE4XCY13mQ1k1I14dsnFlRFGEwGBQ/PyUHMRfSRS5l267SAJhdM+nAM9MgWE2slIp7TqcTy5cvV1w+nTjxsNlssNlsQ4o2AdQLytpstozpxenuyWz6k0nAYrZCDhOyh3LPsgFaPB7ng1vpa9If6fvpRKqRIJFIoLu7O2kCS3pdj0ZfBGFwaXelWkzS9MNcbF06tFotCgoKcnrOEscv48ePx5gxY3LKtpD6TazOoxQl25TtvZluoklOuu9yIpGA1WpVzNRhteWyFYyl9zSrTcd+pLZZul0ikUhaxEY6USgVi4ZyP8r30el0iovStLe3IxQKZZz4ywdq4mQgEOArEEoxGo1JNkRJuMoFjUYDl8uFRYsWnZTZWXJOKfFJrUAbcWLT19eHyy67DG+//fax7spRQzrQI04O7HY7zGZzxkg2+UNOOls1FNQelLk8QIc6Y59tTRXpa+x1Zs+lP/JZLvmgRWk79p70dzbnohSxoBb5JB1gqrUvnXHMJ0r9lGKz2VIKvqcjnTjFos6YI0UDvJMDNjhQsj2ZyCZ6aaj7y9tK156agKy2TzZ12uTtK9kV6Y+SzVKzR2q2IJOdUPuMlPaJxWLYsmULOjs7+b07VMFJKbpByT7IRW6tVou+vj7FBVTk12a4ohh7HrBIWOLEx2az8aLXuZJOVJKLwelE2UxRLkr3Rro+SfdR2laafpYr6ewQu9+UtlHyI6R+01AnJljUpXw8E41GsXbtWjQ3N/OIq1z8M7XtlD4Hdk7sGOx/vV6Prq6ulJqigiDAYrFAp9PlnJ6t1m9p3cxcF7w5ETklRq82mw3z5s3jqyAQJxeRSASrVq3CwYMHj2k/tm3bhh07dhzVY06ZMgV1dXVH9ZhEftFqtXC73TCbzfxhJiebB5vSAzzd4ErtPbljIX9Aq0XQyPspFX/UjqVU4DtdH5WcQfmDP5tBkBry85OfcyYnUs0JYc6T1LmR75NuoCZ/Xam/Sn3LxpGV1lXJJFSle036nkaj4fW46Ll74iIIAhee1MSYoQpIoigmRRcpiZrp7rWhCN7y+1MQBNWVlqTbZhKVco1qSNc3ud1Nd5x097/S+coRRRGdnZ3w+XyIxWKKg+t07au1qfa/2jOgo6MDHR0dKe9JB9mZBvi5wFKxT4VB3smKVquF0+mEyWRKWg1yqPedFGab0rUntT/pRJFM94Pa+8w2KfmDSsXUpfdoOnuR7ryVGEmRVknYYyQSCTQ3N6O/vz/JNintr/a//HW5X6e2D3tfq9WiqakJTU1NKduopQSnO768fXmfBGEwLdLlcp300U+nhPg0adIkfPTRR5g0adKx7goxwgxlJiBf3HzzzbjllluO2vEEQcCjjz6Ku++++6gdk8g/drsdCxYs4A8b9kDLRkCRztioLQnLnJdsIuWUHqRKwoh8H6W/GYKgvAocey+TcyMfLKYbgKWLLMpGUEnnaGb6PDJFJLBroCbqqQk/SoO/XAQ1hlpaJot8UquBko1DpeTwiqKI2bNnU2rwCYxWq02JYEsnlCp9V5jgqnRfsHpDam2qIb1fso2sUrtnWSqunHQDCqV7VG3fbH/kbWUabGV7X2ZjJ0KhEPx+v+LqUtl81pmOoTbYY39/9tln2LJlS9I+giCkPNNyHWzK/5YK/S6Xi9KCT2CsVitmzpzJ04GHEnkTj8dV/SZ5apvad01JmJYeI5toHaX2NRoNQqGQYhHqTFGZ2fSV+UtqP+lseibUfAN5X7KJnAoEAhgYGOATZNIFauTHyvQsUPNllfwrYPA6r1mzBmvXrk3pO5sslvqcuUZmKT3HEokEpk2bhgkTJmTc/0TmlBCfiJOLCy64AGvXroXH40l6PR6P81UgCOJEQavV8iLj6ZblVnpwSgc5BoMhZSUfURTR39/PQ9Iz3RtyoUdOLvszNBoNwuFwihMlCIMra8of4Lnev0p9zqWNXGet1GDOS1FREebMmZPyWUgjLNSinUYKVlRUCVZDK1vnOltYzQpWlJM48RCEL1a4kzrn6aIZlVCKyozH42htbUU4HE4pAK0mYiv9nan/UuSiik6nQ3d3N3p6elL2k94XQ7F76bZNFzmVrq1stksn1hsMBjidzpR9W1tbceDAARgMBl6HKheGMvBng/r29nZEIpG8Hieb60RlOE5stFot7HY7F5Fyhd3XJpMppV5UPB5HU1MTt03S+yFTamo6MSSdTyUVR0RxMOWrs7MzJeUL+CJaOZtU+XR9EATl9LrhRjvlaqtFUYTH48G0adNSUvUPHDiArVu3wmw2cx9ZaQJvKH2T78veY8+8I0eOqJbBYFGT8oi7XPsi3z6RSMBkMsFoNGbdzonISW95582bl9dl7uWEQiG8/PLLOHDgwIgdIxvWrFmDDz/88Jj24WhRVFSEWbNmpQzuPv3002NS96mnpwcvvPBCSth4TU0NLrroohE3IhUVFbj44otpkHcC4na7UVhYqDrIUZsxZkhFDKU0gkQigY6ODl60MVN7Ssi3zyYSQE5PTw/6+vpSXmfFrtVWvJO3qzRgkw8olQS6dIM9tm+mCCv5MZQiF0RRhNFoRFFRkWIK5HBqqmRC7RyZwyY/rtlsRklJSUq0QzbkIjrYbDZUVVVRissJhk6ng8FgUB1IZDtIYUKDfNtYLIZNmzahq6sr6fsn/y6q3WvZoLSf1A5qtVrs3bsXDQ0NKftme26ZoiKGO5jLpv1s29FoNCmfKQB0dnbiyJEjiEQiKbYwU5tK/6f7vKSfbyQSwY4dO+D3+5O2Ueun/HuRri+ZEITBlFKTyTTswTZxdHE6nfB4PElpmWrPdfn/0tcSiYTiIiHRaBQff/wxOjo6FGvdKR1jqMK8dHu5bdq+fTt27dqVsr10kRA1cUlu87Lxg0aCTNeCnbPRaITH40nxm1paWrBv376kKFnWrvw4Q+mbtB+CIHAxKRgMYsOGDRgYGEjax2QyoaioKMWfkV5rpfZznayxWCwoKys7af2mk158uuWWW/DLX/5yxG6yvr4+XHXVVfjXv/41Iu1ny89//nP8+te/PqZ9ONqwmUnGo48+iv/6r//iqzIcLQ4cOIDLLrsspd7T0qVL8X//939wOp0jevy5c+fib3/7G4qKikb0OET+qa2txfjx4/lqbbk6/Zkin+LxOBoaGjAwMJBWYFB7MA5XKGGCy+HDh9Hc3JzyvsFgSCs+MdgMHYtIUEvHUKvfkmkAKx9Uyx23dP2SO3s6nQ52u11RfJKm3mU7657NZ6DUR3YebNUaeTuFhYWYPn160ndGTQBV+p1t3wsKCrBo0SLF5eyJ4xeLxQKr1ap6P2UDGywoRZmEQiE899xz2L9/f5JtGopAni3y9jQaDd555x188MEHKduqLYagNMDNVRTLBekEAzue/PhqKNk5pUUAWlpasHv3bvT09PCBb7ain/R9qe1U2l4+cOzv78ebb76ZEnlmMBjgcDhUba98EKr03ckGvV4Pt9tNEVAnGNXV1aitrU2qy5TOh0n3npLfFAwG8eijj2LPnj1pxSe5eCH9OxvRPt39pdVqsWrVKsUJdan4pNYHKWqik5JYrMZQx9Dya6HkW7GyEWyFQSkHDx7E5s2b0dHRwf0raeqd0v2vdl2zsWlsgrCrqwtPPvkk2trakt73eDyYPHly1ouppLPXSuKh9DizZ88+aSOgyOISJyRGoxHr16/Hd7/73aTX9+/fj3Hjxik6kwRxvGG1WlUHeJmQP8SUnChGLBYb0mowctRmddL1MRAIqIbFs2Kh8oewTqfjPyxtz+fzobe3Fx0dHWhvb0d7ezv6+voQCAT4uRkMBl4IcqjkOrhTGuBpNBpMnToVZWVlKduHQiG+vHOmehKsvXSkczhjsZhqSovJZEJBQQEikUhSLSq1mdShOJ+sZobFYqHoghMMJvKmExEykc12kUgEwWAw5fWRiBJkg1R233V3d+ecYsbaURpExmIx/iNfwpxdz+EM4qS/5a+n20eKKIq8ULOU/v5+/PWvf0VjY2NKejBDXg9GqW21Z4RUDDcYDDh8+DB2796t2G8W+ZTNMYYKa5tW5DzxMJlMMJvNQ7p35aRLvwyFQggEAgCS7wW1Sa50ZDO5xmwTAHR1dan6bNJoZWm7bFKO2ZloNIpgMIiBgQH09vbyH7/fnxTlqNfrodfrebtK5MsWK02yste0Wi0mT56M0tLSpPc7Oztxzz33YO/evaq2idmWTP6U0vvs2sfjcVitVuzfvz+lBh3DaDTC5XLxaPJ8+zXsOSIIg2UpTla/6aS1ug6HA1//+tcxZsyYvLY7efJk3HTTTXjssccUHabjhfr6epxzzjlpZ5tfeuklHD58OOe2y8rKcNlllw2ne8NGEARUVVXB7XYnvR6LxXDo0CE8++yz6OjowKWXXjqi/fjnP/+Jd999N+X1a665BmeeeeaIHluKIAj4j//4D7z77rskvJ0A6HQ6VFRUwGw2Jz3Ask31UNqODfJLSkrQ3t6e5Bz5/X4MDAzA6XQiHo+nFNLMdFzpzJLU6VHal22r0WgQj8fh8/lSHDWr1YqCggLu7EhXgUskEggEAmhtbUUwGORpYyxqSDqok0ZBMaHKZDLB6/XyqCo5UudFabCULsogG9g+Ho9HsV4Dcy4AJDl70oFqtsdN97lJr5ecyspKFBUVKc7O5sOhUjqnsWPHorm5OWUmkTi+EASBi8KZyOW7otVqYTQaU2podHV1oaWlBRUVFfz7KhW92DHU7I2035nOCxi8/9mqoocOHUrpj1arTakBI42sSCQSvBgx65+SvZAOjtjf0nSyXKJc1UQkafty25Vue4PBkCJKJxIJDAwMYPv27QgGg3yBHnbOSpFgSlEXaq+xgbUgCOju7saBAwcUy1WweifsuSBvJ5toqFyxWCwIh8NZ154ijg1arRZlZWUwm815a1MQBotHFxcX8+gaRmdnJ5qbm5NskzzieqiTQ2r3iU6nQyQSQUNDQ0qdTIvFwtMN2T7Mz2J+EyuzAIBHPMvFMiZQSYUqVi5Ar9cr3stHC7fbje7u7qTXEokEenp68Mknn8Dn82HWrFlJ/iL7THKZHJWeIys8DwzWv1NbubysrAwFBQWKdlBuezOJ8JmeY+x5UV1djba2NkVf8kTmpBWfCgsL8cADD+R9VmPu3LmYMmUKnn/++STxKRQKwefzHXWlkg3u5JEF8+bNw7333puyfTAY5A/Yhx56CO+//37Ox5w3bx7OPvtsAIPhn8ey1pDRaITdbk/Jy3344Yexfft2nHXWWbDZbHnPm2WO2qOPPoqXXnqJv67T6WC1WvGTn/wE48aNy+sx06HVavHzn/8cDoeDxKcTAIPBgMmTJ/MCr9LVS9REEUC9WCJ73eFwoKamBl1dXUnORn9/P7q7u1FcXIxAIJB2oKL0YMx2tl1JpOrp6UmZoXQ6nRgzZgwPoWb7xeNxRCIR9PX14fPPP09xQrLB5XJh1qxZcLvdXIBSc6ayOa9MYpD8ffa30+mExWKBTqdLOX9mr9lAVCoCKrWl1jelvgDgqXZsKXspWq0WdXV1cLvdPOIp3eAu1z4o9UcURUyZMgU6nY7Ep+McQRB4+oM0SkhulzIJAawthk6ng9ls5jPujCNHjqChoQFjx47FwMAAF4fkoulwhCd5O6yI8Pbt21PqDen1+qRlrqXnm0gkEIlEMDAwMKSoC51OB4fDwQd4SiJUumusJI7LPxc1eyV9XxqFJd928+bN6OrqwpgxY7gIJ/88cxHHmW1j152lYe/evTtl8pPN9uv1etXPX8mGZ4q4Stc/AHzFNBKfjm8MBgPGjRsHo9GYIgQNB5vNhsrKypRIyMbGRuzevRvjxo1Df38/j9qTR2XKv3/pBIZ09yYTn/x+Pz777DP4fL6k7Zh/JxdbmN/U39+PXbt2KdbXzASzS+y30rXNdF9l8h/Stcf+ttlsMJvNKYtQAMB7772HpqYmTJ48mQdWKNmmTPYPQNLkazwe56vp7d69G59++in27t2btL9Wq0VtbS2cTmfGVPR0QpR0e+l20u+MdPvx48dDq9WS+EQoc+utt+LJJ5/E+vXrj6r4tHXrVixZsiTFSKnxgx/8AM8++ywAZL2PnA0bNqC6uhoAcOGFF+KJJ54YUjv54Lvf/S4uvvhi1NfXp8wSfPzxx6iursb777+PqVOn5vW4LS0tmDZtWoqRX7JkCV588cUk55Ug5Gg0GrhcLoTDYf7gk6ImgighfeiaTCYUFxenbNvS0gKfz4fS0lJemFzNKchH1ItWq0U4HEZ3dze2bNmS4kSwlC+2vSAIaGlpwY4dO9Da2sodgqHQ19eH9957D4IgwOv1YsqUKUmzVfIaDpnItG06QWvMmDHwer145513UhyWeDyOgYEB7mhlWj5ZitK2LFIgkUggHo8rrtLicrkwfvx4/j1gjraSE5hphk7J6VNzskRxsKAopbgc/wiCwB1xQP1zTedQKw1AWFRif39/0vdtzZo12L9/P2bOnMnF2pGq2chsU39/P/bs2YM//vGPKYKDRqPh6cvsPAKBAAKBAN92qBEBsViM1zdiE2fyVOl0g1j5b6V9skEURVgsFhgMBnR2dqa8f+TIEfz2t7/FV77yFZSXl/PIICZmy6Og1Aac0WgUWq2Wi22HDx/G/v378cEHH6SkFOl0OthsNj5hoCYyKTHUZxZrj0XNEsc3giDAbrcrRiENFeY3KS0SsmrVKuzcuRNz5szh90umdGC1e5S9piZKMLvZ39+PHTt24Ne//nXKM1xalJu109zcjIaGBnR2dg7Lb+rv7+fj18LCQtTV1cHj8WScfJOf33ARRRHV1dUoLCzE2rVrU54FDQ0N+MEPfoDvf//7qKmpgc1mQzAY5GlwTFRXs0/s84tGo9Dr9TAYDNBqtdi9eze2b9+OV199NeWZ4HA4MGbMGBQUFHBhPN25DjUKUy6gJRIJmM3mlEjck4GT0hO88MILcd55543Yw0Sv1+POO+/Eq6++itWrVwMYjCjat28fbr31Vtxwww2oq6sbkWNLeeqpp/D2228nCSCCIOCHP/whli1bxl+TpoZ98MEHQ1LFpcTjcd7G+vXrccsttwAATj/9dJx//vnDajtXTCYTysrK8Ktf/QrPPvssPvnkk5R+3n///Tj77LNx9dVXD+tYoVAI99xzD8+h7u7uTjKM3/zmN7Fs2bIRLzCejkWLFuHuu+/G3XffnSLGEccHRUVF8Hq9qgM1KZlmz+RRMxqNBmazGWVlZejq6uIRgaIoIhgMYseOHRg9ejQv5ip3KuSCgtpssvw9+Qw3ABw+fBhtbW0pzlBZWRm8Xi9sNhtCoRBaW1vR2tqKQCCA7u7uYdemEsUv0tp6enqwc+dOHlYvXT1Efg2VyMXxUoJFUYwbNw4tLS2KtpdFKElTCJmQxPqpFiUhPWcWlaE281dUVITi4mJ4vV4A4KmM8hB+6Wcv/Vylx2LvS/9npLtmhYWFmDRpEnbu3HlUF4UgskOv16ctcJqNQ60U9cT+F4TBlD5W8wwY/B62t7fj0UcfxUUXXYSqqirV46m1ne7+ZQsasO20Wi3WrFmDDRs2KA7uWM24aDSKSCSCSCSCaDSqWLR/KEiFGZ/PB41Gw4+rdG7DHcSo9YEJcVarFeFwOCniQxRFhMNhbNy4ES0tLRg9ejQ8Hk9KoWO1gTSroyOKIo8U27RpE7q7u9Hb25syuDMYDLxen/yZNtxrkW0UlMFggNVqTYmEI44PCgoKUFhYyP9XE3lyHfiz7Y1GI0pKStDT08P9pmg0ipaWFvz2t7/FVVddhZqampRjpxPp5f/LU9/ktkmn0+GNN97A2rVrU/x3r9eLoqIimM1mBINBtLe3o7OzE36/H319fXmpf8V8tb6+PjQ0NKCpqQkFBQXwer1cdMmHDVSDiTosg2T06NFoa2tLymxJJBIIBoN45513UFtbi0mTJqGkpCRp8Rol+yH1odh24XAYPT09eP/999HW1paUssjweDwoLCxEYWEh34/1U+o3sWOw30p+01B8fUEQ4PF4MGbMGOzfv/+k8ZtOSvFp6dKluP7660esfb1ej29961tobW3l4hMAdHd348EHH8T06dPhcrm4k59vYrEYmpub8dxzz2HVqlVJ7wnCYO2fcePGIZFIoLm5GW+88QZ+//vfp22zpKREtVgxO2ZLS0vK63v27MEDDzwAYFA5nzZtGsrLy4/qLJLFYsF3v/tdtLS0oLGxMaWfTz/9NPr7+7F48WIAg2GdLpcr48AfGDQILS0tiMVi8Pl8+N3vfof+/v6kbfR6PUpKSnDNNddg7ty5+T25HJk5cybGjBmD++67j8Sn4xSPx4Py8vKklVqyQTrwUhKF2EygXq9HaWkpd/oZ0WgU+/fv5+lorAi0mqiUa+oCaysejyMQCKC5uRmtra0p25eVlaGwsBA6nQ59fX04dOgQ9u/fn/bclWazpH1Um/Hz+/28rkg4HIbD4YDdbk8SVtIxXEeLObWjR4/mhZXlAy9WXFIqICrN2qkJgczZYql2Sn3Q6XQoLi5GSUkJXC6Xai0o1nYmR0nel0zfGfY3q1exZ8+ek8aJOpkwGAwwmUyKonQ6wSdTlJx0O1bnTjpYGhgYwGuvvYaJEyfCbrfD5XKlbSfXASbbNh6Po7u7Gx9++CHWrVuXsh2bZRYEAfF4HMFgMGNtT2nUovy+kKZ1yGHtA1/UoZIvvpApunCoA22GIAiwWCzcfsjvyZ07d6Knp4cPlFlKjNKAW/6dYYPEgYEBdHZ2Yt26dar2iQlPLOJObVJEvp/8/eFEXuj1elitVp6WThxfuN1ulJWVZZwwywa5aMRqH5WUlCAajSb5Tf39/Xj22WcxdepUOBwOuN3utKK42v2rJlJJ/abOzk6sXr0aa9asSemz1+vlKzP29fWhqakJjY2Nac+TCTJy+yT1GZRSTYPBII4cOQJg0G+y2WxJk+q53mfp7IR0G2n7er0elZWViEQiivXYNmzYgLa2Nl7v0+FwcFum1j7rhyiK8Pl86OvrQ0tLC954442UiQjmNxUWFqKoqAgOhyNpwQXpdmrfyXQTttLrkk54AgZLONTU1ODgwYMnjd90UopPx5qvf/3rWLp0qeISmfmgubkZ48ePzyguBINBzJ49G+3t7RnbfOONNzB58mTV9/fu3Yv6+vq0X/xHH30UL7/8MhoaGo5J9M8999yDq6++GlOmTEm56V9//XW88cYbAICbb74ZP//5zzM6uMCgg3jGGWfwwbHS7MKkSZOwYcOGvNeVIk5OLBYLnE4notGoahHXXB7uUqGXzeaMHj0aPp8Pzc3NKdt/9tlnKCwsxPz587ngnI2zrSaCsP6ylCq/34/Vq1erhn+PHj0aGo0GDQ0N+PDDD7Oqs1FcXAyr1ZpSaJRFJYRCIcVzldLQ0IDGxkYsXboULpcLZrOZD4aGG+GUCbfbjUmTJsHr9WL9+vUp77Mw8Gg0miRAsQEpGwwzh5HVamIrAabru8lkQl1dHSoqKmC32wF8Meuq0+n4aoGRSAQ+nw/RaJQLYqwPFosFVquVRyiwz5qJCNmIeaxeBhP+ieMPliIlL/QMZI6KzDYqikU+KfHrX/8a06dPx3333ce3j8fjKRNj6SKdpCJ1PB5HNBrl9UG6urpw5ZVXqh7farXygUlPT09WNqGiogJWqxVGozHJnrOoqWAwiEOHDqVtIxgMIhQKJS3CID9fJfE922uuNsBh97fNZoPRaOQpgVJaW1vR1tYGQRBQUVGB2tpabktYmiSLcopGo3xl0o6ODrz33ntczFG6llJBS1pbTDpQlQpj0igR1n9p/SrpvunEdbXrm24Clji2mEwm2Gw2/ryRMhQhWm6/4vE4Kioq0N/frzjR/uMf/xjz5s3Do48+yidvmGisNjEkhdkGqW2KRCJczG1ra8PZZ5+taptGjRoFjUaDw4cP45NPPsnKb5o+fToKCgrgcDiSoqoHBgYQCATQ19eHjz/+OG0bhw8fRmtrKxYuXMh9gGzsovQ+U5qIYtsovc7+d7vdGD9+PLxeLzZu3JhyjEOHDqGxsRGCMLigyZQpU1BbWwuPx5OSwhsOh/k5Nzc346WXXuKBBEq2wmg0YsyYMSgtLeWiltQnC4VCfGVTv9+fVGOTiZlsVUZpeh+zaWy140yw59/J5jedVOKTxWLBH//4R8yfP/+oHO+yyy5DRUUFbr755qQZnXg8ji1btuArX/kK7r33Xl4fKR889dRTeO655xAKhVIMwIwZM3DbbbehtLQUq1evxp///OeU1DBgcKUj5twBgzf56NGj0z54Kysr8eyzz0IURezatQt33nlnyjaJRAL9/f249tprcd111+G8884b3snmiFarRVVVFf72t7/h//v//j9s3ryZvyedaV21ahUOHjyYtKqDGolEAk1NTaohrTfddBPOO+88RYfxX//6F/7yl78M+Xy+/OUv48orr8x5P4vFgscffxyPPfYY/vGPfwz5+ER+0Wg0GDVqFJ85kzvLQPYpF+miTdh3kS1Xu23btpTw376+PmzcuBGTJk2CzWaDXq/nD075ttL6AmwQw/6XpmwFAgE0NTWhpaVFUXhyuVyoq6tDPB5Ha2srdu3apTgTrtVqeYSS0WiEwWDg6R7yhzVzhOLxOOx2O2KxGILBoKoQFYvFsHnzZtTW1qKsrCxpNdBM0TtDFadY/1jq36xZs7Bnz56UCErp9sxmS8O7pbNp2cwkAoNRZkVFRaisrITL5eLFz1k0QlNTU5IjrbREPBvgsUEm+yktLUVlZSUsFktKDSq17y0b4E2YMAFHjhw56YponsgwJ5mRzhYpzd5nQroPu+/kC4UkEgk0NDTgF7/4Ba699lq+spVS/bJ0YjjwRe0mjUYDv9+Pf/3rX/jggw9SCp4Dg1EvzH6wQYrSfcVmwtnAhi24olQzyGKxcKGYTTb4/X7VaAVRFHkNOJPJlHFSIlvBT+k6yfdnq/A5nU74/f4Uf4dd146ODgSDQezfvx86nY4/a6TPhXg8zq8jW61UCSZks5UVWRtMhJf7uGoClvw5KgiD0aZqKzams02CIPA0xOGmfxP5QaPRoLy8HE6nMylNLdeBeLYTTCUlJdBoNNi5c2fS9olEAjt37sT3v/99fPvb30ZlZSWPlFPqj9y3k6f+6nQ6GI1G+Hw+rFq1Cm+//baibXI6nRg3bhyi0Si6urqwf/9+xe8mi7BmE3UWiwUul4vbKen9zlY9jkQiKCkpQSgUQldXl6LAAwz6Tdu2bUN1dTVPccsUgZbt56PmYzE/yGg0wu12Y8qUKThw4EDKM4PZhaamJvj9fmzdupVPkDGxTTppF41GEQgEFFdhZhQXF6OgoAAlJSWw2Wx8dVS/34+enh60tramTAYqRURJSymwvni93hTfUw3ps8xgMKC2thatra3o7e3N6toez5xU4pPBYMDKlSv57O5IM3nyZJSWluKJJ57Anj17khzp9vZ2PP/887jwwguRSCR4rvBQicfj+Pzzz/HWW2+lpNoBQF1dHRYvXoxLL70U27dvx5o1a/Dyyy+nbDdq1CjMmTMHl112WU7G226347LLLgMAbNq0Ca+//jqAwZoq0pSZaDSKV155BTU1NaisrER9ff1RVWsdDgcuu+wyfPjhh9zx2LFjR1Lo/N69e1NWMsgVvV6P+vp6rFixAsuXL+ev9/X18bbXrFmD559/fsjHMJvNfMW8qqoqFBcXZ923iy66CB999BGJT8cR7MHDVocc7n2hNpMtdTC0Wi0aGxt5dAsjEomgubkZxcXFSCQSvAZUpn5JZ9Cls9KxWIwvma4k/FitVhQUFKCyspI/vJUiMtlgxOVyweFwwGQywWAw8GKScuFF+ttisfBZqL6+Pu4USGcI2Qwji1QoKytLakNJPFEKnc8Vtny81Wrl10AQBldXUppIUAvbVtpGCUEQ4HA4UFJSAq/Xy2fNQqEQ+vr60Nvbi9bWVsWlzrMlFovBYDDA4XDAarUmDZjTDYw1Gg3KysrQ19dH4tNxgiAIfJaY/Z9peyBz2oAc9p3V6XQwmUwIBoMpKzL29vbivffew6xZsxCLxXgavyAIqv2TR8sASBps7NmzBx9//LFiqp1Wq4XBYIDZbEYgEFBM8QAGB3cWiwWFhYVcGJcP6pSEa1EUYbVaeTpPb28vt5ny6PVwOMwHLJmKzGa67ko2RU2wZtdPGg3KhCQp2aQhZgMbeEsHxuyasOip4RyHpaDL6+gB6W0TE65YP4hjjyAMFsA2m81pbYzS9ztXsVYURdjtdmi1Whw+fJgXsmZ0d3fjn//8JxYsWIBYLMbr08mjmuT9lwq0giDw7zpbcXPt2rV47733Uva1WCzweDwoKytDR0cHr/Mkx263w+12o7a2lgsmVqs1SRCRCi3SupcFBQUIBoNoa2vD4cOHEY/HEQqFkkQeJjyz53xRUZHieaqJw+kiVdPBJj9ZHdO+vj4IgqAoTvt8viEvoiXtj81mQ1FREQoLC7lfHA6HMTAwgIGBAbS3t2dMd0xHPB6HwWCAzWbj/q18tWulfmk0Gni9Xv4MOdE5qcSnY4HH48FHH32E6667Do8//njK+1deeSWuvvpqPPXUU8M6js/nwxlnnKFaLPx///d/sXDhQiQSCaxcuVJVXLnjjjvwta99bVgD32nTpnGF/Pnnn8fll1+ess2DDz6Il19+GXv37j0mKxz99re/5X/PnDkTmzZtymv7xcXFWL9+fcqqOOvWrcOKFSvycoy//vWv+Otf/woA+MMf/oBvfetbeWmXODZoNBp4PB4YDAaeNpWJXGe3pf9bLBaYTCbMnDkTO3fuVAwl37x5MzweD2pqalBaWsoHVNLjMweGPQCZ48JqejARYceOHaqpdvX19fB6vTCZTNiwYUPK7BWjtLQURUVFMJlMfPZZKT1RTawBBoUutvplT0+PYsrL/v370draihUrVqguKyy9lkMVnRhS58JkMmHWrFkIBAI4dOgQ9u7dm5cBnRSj0YgFCxbA7XbDZDLxCM7m5mZs27YtL8dobGzkTti0adMwbtw4FBQUIBKJcLENSB6Es5+CgoKUFEri2JLpPlAi11luIDnFyel0wufzKUY23X///Zg0aRIuuOACLF68mEcbAV8IS8yOsuNLU9/Yvb9t2zb88Y9/VDwGMDhhxWxyf3+/qg2rrKzkA7toNJpSY03pGkjtBlvh9LTTTkMoFEJ7ezt2796dsg8TwIqKioblp8ntVjaRaoIg8KXEQ6EQfD7fkFfPUoNdB2lKcTgc5sfLB6FQiAt7TByXppMqwa6VwWCgepnHEYIg8DqV6fymfExyi6LI7dLkyZOxb98+dHR0pGz305/+FNOmTcMVV1yBs88+GxaLhftNUtFb6rewSDyNRoPu7m4cPHgQmzdvxj333KP6fZswYQJfFXjLli2qxfBnzpyJSZMmoaioCMFgkAvdSlGBLLpQaht0Oh2qqqpw7bXXoq+vD3v27ME777yTcpyDBw+ira0Ny5YtU8z2GO5noORrsf+NRiOmTp2aZDvz7TcZDAbMmjULTqeTT6a1tLTwSP180NTUhKamJgCDJVtqamrgdrv5M0Vup6WTvAUFBXzfEx0Sn4YJ+6L88Ic/xOLFi3HttdembPPWW29h0aJF/H+Hw4EXX3wxrfP93nvv4Wc/+xn/Px6PKz6Yx40bh0ceeQRTpkzB+vXrcdttt+Hw4cMp2xUUFOC5557D5MmT82IgGEuXLsW//vUvXH755SmRDC0tLViyZAnuvvtuLFmyZFjHHGofRVHEo48+Cp/Ph1gshq985SuKD5NsMJvNePHFF/msJzO+e/bswXXXXQcAijUT8sGDDz6ItWvX4umnn6baUicwrJhtIpHgM75KkTW5DuqUHthMNCotLYUgDK6YsX379pR9+/v7sXv3bhw4cIAPCseNG8e/49IBqSgOrprX29uLI0eO8AEgy3eXY7FYMGHCBFRWVsLv9+Ott97iYepSdDodxowZw1O4gsEgr0kkvS7ZpF2w7QwGAwoKCmCxWLB3796UVJJQKIT33nsP06dPh9fr5bPlSg7QcAQopc9Qo9HAYrFgzJgxKC4u5jVmGhoahrxqjVarxaxZs3jaTlFREWKxGNra2rBx40bViI58sHfvXrS3t2PixIkoKSmB2WxGLBZLslVSR8put5+UywefyDAhQGkZaTVhZbi+BFthTK/XK/o3Bw4cwFNPPYW///3v0Gq1MJvNuOqqq/jggNXiEMXBtPru7m7s2bMHq1ev5qlffr9f8Xuv1Wpht9v5d7W7u1vRhul0OkyePJmLVOFwOCkKi10L6W8gNe2G9ZMNSj0eD6ZOnYodO3akRNnE43F0dXXB4XDAaDTmbHvYZ6M2mMsmss1kMvF0bJYyOBwRnhVLZtFFoji4Eh6LUh2uwK+G3+9HOBzmNofVXQGUUxmVUiiJYwf7vrCUu3TRTZnIFC0MfLHiG8s0cDqd2LdvX8r2e/fuxZ/+9Cf87W9/47bpxhtvhNvthsViSSrkH4lE+ATd66+/ziN31GyT2WxGXV0dysrK4Pf7sXbtWkWhxWQy4YILLuAR9X19fVzUlX+H1XxLabosqy80evRorFy5Ev/85z9TjhsOh7Fu3TrU19dzHyNTVKFaxKUSar6WVIQqKyuD3W5HIBBAf38/Dhw4MGS/SaPRYNq0aTwKqaCggBd/37JlC6/dNxIcOHAAnZ2dGDduHI/ukwrk8qg1VnPrZOCkEZ9qa2sxa9asYzYwHzt2LIxGI770pS/h448/TgqN7OjoSBI8bDYbVq1alTbn86OPPsKHH36Y9pgzZszAokWLsHDhQgiCwFdxkVNXV4c5c+Zg0aJFef/iFhUVYdGiRVixYgU++eQT7Ny5k78XDofx0UcfKYaJHi0EQcD06dMBDKaJrFixYsj9MZvNfAaW8dlnn2Ht2rUZP6tx48Zh7NixGY/R1NSUVKuK0dDQgEAggFWrVkGj0cDtdmPBggVp25owYQKWLl2KNWvWjJhjR2SHyWSCw+FQFTekKIWKD3Wgx8Qkt9sNAOjs7ERPT0/Sw5St5MjQaDR8oMUcGdYXJj719/dnFHEdDgcKCgpQUVEBQRB4EVo5ZrMZdrudr0LHjiW/FvL/M32nWZ68TqeDy+WCz+dLmmFMJBLo7OyEz+eD2+3mYqASI3H/sLoPrKC3yWRCKBTikUPS+ktykZLVEJDWYmKr9bBBoyiK6OzsRFtbG9ra2tL2RT47Kv+OyvsghznRR44cQTQahdPp5DO2bH+p+KTRaGC321FQUECpd8cYqcibDulnCGSukZapLXZsVnuRRTlKne9AIIBAIMBXXjIYDBgzZgxPyZUO8JiA1NDQoPgMlaLT6ZJW9lNLs7JYLHyFK2mRfSW7lIuNZgNqNtjp7+9PEeWZoC8fcGeTPqbUNznp0pSYDWB2RaPRJK2QqWYP5PtL/2fpJew1ll6XaWDHFjtQqvvHBs3RaBTBYFBRwGT9ZvWn2Gcv7a/8HHQ6HfR6PaXeHWOMRiNsNluSDzIUsWkovpNOp4PT6YQgCDxVXfp98Pv98Pv9OHjwIO/rxIkT+WImbPECqfi0e/dufPLJJ2mPa7fb4fF4eM1Ov9+P7u7ulO08Hg9KSkpQWVnJv8/snmT3rprIKkUuQrHyACaTCTU1NWhtbU06fiKRQHd3N/x+P1wuV9L9mI/oM6X+ySNI5X4Ti/Zitly6mp+0HWnNSjbZotVqUVRUxCdbgcEgAvm4XQmn0wmn05lUY4rBImPZQi5KgQmsHEZLSwsikQgcDgc8Ho/qZI9Go4HVaoXL5TrhU+9OGvHp4osvxq9//etjdnytVouamhq8/vrrOOecc7B69WpVZ93n8+HSSy8d0nGkD/TbbruN12FSWiaXbX/NNdfgxz/+8ZCOlw06nQ6PP/44HnjgAfzwhz9M6QczAsd6Nkmn0+GJJ57IS1vsnO677z787W9/U92OnfPVV1+dFMmmxtNPP42vfe1r/BjS709LSwu+/OUvAwDmzZuHtWvXKq6WxrjuuuuwfPny/5+99w6Pozrbh+/tfaVdrbpkW5Z7xRU3sMGmBQKEkgYJKaQSEkIghfzSSCfh/ZLwppCQkARCSagvgRCqDQbce5OLXGRZVtdqe//+0PUczsycmZ1VsS2z93XpkjTlzJmZM895zv00NDY2DtoqUMTwoKysDOPHj5eU0lZLnJmP6JArEvK/5e0lk0k4nU6mEK1bt06zAmY2m8X+/ft135saGhsbMXbsWNTW1mLfvn04efKk8LjKykrU19dLqrZRyW258sBD5FVA23mFxWg0orGxEW1tbcJY/VAohGAwiMrKSpZ/hm9DjQCUL8bp2lqLc/5c/v27XC54vV7U1tYyS1soFGLV/PiFH+WDsdlscLlcLGG8yWSSJMHs6enBzp0781YBpGfEk1gGg0HiBcIn1VQLw0mlUti3bx/27duH8vJyYcEJfuFZU1MDs9mMNWvWFMnx0whKmq1FoPDbtYgXreNE75jCM2lM9/T0qIbHAQOy7B//+EfB9ygHVc60Wq0KUppHZWUlxo0bB5PJxPLO8RWL9EDLGwoYMA62tLRIcmcSyBthMCEuav3T65lA24xGI2w2m8QDSy6TaDufXJfeq6g/qVQK/f39mu+aUFtbywhHp9MpWWin02lEo1H09vbi+PHjQs9eOpbIAqvVqpk/M5vNwm63w2g0Fonx0wyfz4f6+npJJUSCmiFKTX7x+7S+HZJj6XQaDoeDGcc2b96sabhOJBJDKjBEoHy5ZWVlOHTokCoBMn36dCxatAhGo5ERLzabTUFYq0Fk0KLtpA9cfPHF2Lx5M958803F+eFwGP39/fD7/UwnUJtDhsMTk59jqFIc6U2ku1ExFdKbeGMGFTggo4PD4WDyip5XLpdDf3+/pr5K/QEGnE7mzZsHv9/PvFTpnpLJJPr7+1mI4FtvvcX28UilUjh48CAOHjyIsrIyrFy5UlHAha6ZyWRQVVUFk8mE9evXj2q96awhn84kPPDAA+jv70c4HMYNN9wgdNkcLL7+9a/jU5/6FAAwZhwYIDfWrFkjOdZut2P16tW6PG6GA5/61KewYsUKrFixQmKB+spXvoLHHnsMTzzxxIgw46cDFPcsCnEkXHfddfjxj38MABIvAC1ceeWVzHvsj3/8I+69917hcVu3bsXUqVPxxBNPYNasWQX2vohTDafTibKyMgmZoQdanj4iq7W8fVIqaAIuLS3F+eefj3A4zOLYhzO/RX19Perq6lBZWcms1aFQCE1NTQrvG4PBgGnTpsFqtbIwO9E96IHaQpffHggE4HQ6sX//fgmptX//fvT29qKyslKonGr1Q4t4yqcYyN9tKpViljiHw8ES0wPSZKHy5LkAWJUc+p9CCrVyIphMJuZNQIQVKXaie6MFJS3+UqmUKqnd09ODp556ChdffDF8Pp+kJDVdi5KpFnF6QeNANF7zEVHy4/hxLyKO1b4lOoevwhSJRDRz9BQKu93OQiuIaKVwMrn3jdFoxKxZs+DxeGA2mzVDcvNBazEMgHksut1u7Nq1S3LP4XAYyWRS13ciIv60FnpaJJRaf+m3xWKRVAsWeViQV5K87Ww2i+7ubs13O27cOMyfPx9ut5t5iImePXkUV1ZWYsKECViyZAm6urrQ1NSEPXv2CNtOJpM4efIkysrKFAnjCbT4LuL0wmazobS0VKjXDAYi0lhUxEBOEjscDsydOxfRaJRVnNNDnOpFdXU1qqqqWKU6s9mMcDiM5uZmBeFlMplwzTXXoLy8nPWdfvPVcUXQIsL5Z8OTyVOnTkUgEMBzzz0nme+bm5vR19eHpUuXKioiy5GP7NMDkU5GSdsJJpOJVZOWH8vfG6/v8KRYPB7HW2+9pakTz5w5E5deeilKS0uZ5xXfPoF0/nHjxmHOnDm46qqr0NraivXr1+Odd94Rtt3b24sXXngB559/PkpKShgRyPfb4XCgtLRU1zM7k1GUriOAuro6ZDIZxGIx3HjjjThx4gSy2SweeeQRYb6TfJg5cyYWL14MAFi5ciWrgMajpaVFYuGeOnUqVq5cyUqpnwr4fD5MnToVH/vYx7BmzRo2+at5HIxWrFu3DqtXr0ZTU5PCC6C+vh6XXXYZAGDZsmXCd6UFr9cLr9cLAFi1ahVLzLx27VqJMhWPx3HgwIFhnQCLGDlQeAnv7aLlZUDHEORKVz5vJy3PKD6EgRZ5iUQCHR0dg1rsuVwulJSUwOFwoLq6GhUVFSwBZzabRX9/P3OLJlgsFuZ9oLWgU7OgqUHNywgAc9N2u92S/iSTSUSjUcRiMckiR481TnRNPcqUHrKM9xTV8hqVK+UUaqeWo4UW0Xx5c/7aav2ncUb7iUwibyv+WpS8ubu7m5Wx5xVj8ng5W/IXjGboXazk286Pn8GQNAAU5bHJij/YeY7CUk0mEyMxyDOHiFZ5viEK9fF6vQWRcvmg9SytVis8Hg+8Xi+i0Sgjw/hnICe/tGS+mvziZZbeexB5eMqvp7ctCrUTeU86HA5UVVXB5XKhqqoKfr+f5fpRA401nhgnUtFsNqO3t5eFCPGgMEu+gIa83dPtqV/Eu8S43JNH5F2sNbblc5cW1L538rojL8hYLIZkMomurq5B6U0U0mu32xEIBODz+ZhulsvlEAqFFHqT2+1GRUUFK95SiN4k2s7vVzvH6XSioqIC1dXV6O7uZmvYZDKJWCyGeDwuyWWqdR1+n9zzSq9MyqcTyt9zvr7QT09PDzo7OxGNRhXP1ePxYNy4cSgtLWXFecg7Um2uk8smOp6eV3t7O06ePCkJn8tmswiHw+jr62M6slxvorXEaMdZQT45HI5hfRmJRELVokslYvPBZDLB7Xbje9/7Hmvz9ddfF1acyodLL70U99xzj3AflcWUC7/zzjsP9913X8HXGiocDgd+9rOf4Zvf/KaELMlms4hGo6ziw2jG008/LXwfNpsN8+bNGxbXW2DgvV966aUAgNtuuw3Nzc0KRj4ejyORSKiOSZo0I5HIsFetKUIfaKFPSotWqCQdr0ZA0T41l2l+MhUpaDSR2Ww2VFdXw+fzsZwCwWBQ4gGgR7ExGAbKIE+YMAHl5eWMdAqFQiwXR1dXlyJ3hsPhYJY7/p54xaFQC1q+/QbDQC4PyjPE9ymTyaCvrw+BQABmsxmZTEaVnJE/Gy2iT36sVt/k+QJ4UketLVpI8++9ra1NNfyEFBe5NU303NWuScfTwj6ZTLKQJDna2trYM49EIsyjgDyhKFywGBZ8epFvUVKot6Z8PIus6nSsnDylUAir1cryZhBJJO9bvvuwWq1s0Sgf89S2vF2Xy4WamhoWZiZKcjwYyBfHcm8hm82GQCCAzs5OhSdWJpMRkiH53stQCHL5sfI+55sfRASAWkU7ymM5d+5c1NbWwmg0Ip1OI5lMsrEkIhDo/fB9crlcmDJlCiZNmoSmpibs3r2b5XvikUwmmTzkw4bkfR7KOy9i8ODnGJof8s21Wm3xcok/Xh4yBoi/cwo/tdvt8Pl8LPclhXkRtMYLf12qMkweeCaTiXkwp1Ip9Pb2KubFsrIyzJo1C263mxHTw5FzSY3QyeUGEvC73W5MnDiRreMIZGSinHh65olCdCetc0XH0jPJ9w54vYnQ1tYmrBJvMplQWVmJiy++GBMnTmTviQwifFvyOY/S4ZBs8nq9OPfcc7FgwQJs3LgRa9euZboyj46ODphMJpSUlEiuw5NPo11vGvXkk8Viwbp169DY2Dhsbd5666146qmnhPtuvPFG/OpXvyq4TavVig0bNgyKIddKTL5r1y6sXLkSwWCw4HZHCnxJZMKOHTswduxYvPDCC1i4cOFp6tnI4vHHH8eKFStGpO0f/ehH+OhHP4rFixdLxtD73/9+fOADH8CDDz4oPK+mpgaHDh3CzTffjGeffXZE+laEOgwGA6sApkWmiJRemtTI8h+PxxEKhXDo0CHVXBSBQABjx45l1aAozIQmRZqsaFK0WCwoLS1FaWkpamtrWYJESgRLCz9y/7VYLMyDwOFwwGazSYg1irMnpTEUCmHdunWKyZXc6WkypYS2IwX++VI54v7+frYtFAph9erVuOSSS+D3+1Wt/Xx7ehcleo8VucTLF49a7WSzWTQ3NwuTkwJg44BfsOm5hpoiSEoVeatQYlUeBw4cQDgchsvlQiAQkORXoPDCRYsWYd++fae1MMV7FRTWRFZVkRzif4v2Ae/muFCr3gSAyQxSnOUJcek33y4t+PiQWJJdfM4h3sJMf1Ob/N98v9PpNILBoGK822w2lJWV5Q1hGQ7I26+srEQkEpHoc+l0Gt3d3QgEArBaraqLNzmJx28faehZcPIeXXIsX74c9fX1CAQCbHHLJwbXQ3TRe6fk87lcDjNmzEAgEEBLSwtee+01yblUAZm8a+TtmkwmVqiimHj81GPy5MnMQFUI+S33bKSEz1pzo9/vR11dHfNEIo87nmSVz5mUb5Eq5ZKexucbomPNZjMrBEJtk95E7fIGr1gshm3btil0Iq/Xi/Hjx7NzhtM7T8sz02AwYNKkSejs7ERrayvbF4lE8M4772DFihXw+XzIZDK6DYTDKZdERjn+WmrnkC50/Phx1QTeH/zgBzFlyhTU1tYiFAqx98nnwFObvwwGAwtPJtkUj8eRy+WwbNky1NTUoKmpCY888ojkHpqbmxGJRFhUAa9DGo1G2O12zJs3DwcOHFAd02c6Rj35BAwIDpfLVfB5xOL+6le/kuTGeOutt1QXd6tXr8a3v/1txfZrrrkG8+bNU72WwWAYkfwWpJicKVBT1qifo5mpTSQS+MUvfoE33nhDsr26uhq33HILzjnnHJSUlIzItd1uNyZMmIAf/vCHeOihh7Bv3z4AQDAYxLp16/Cd73wHt99+O6tqRjCZTAgEArq89YoYGXg8HjZRib4PkcdJLjcQfx6NRtHa2spIoEQigd7eXtUwlN7eXuRyOdjtdlYRxGw2o7q6GqWlpZIwBj7mHQBbFJK3AC3ueO8YvvqRPERGfl9ERom+eTpftBgpdLEnstqJQPdBCp58H3lBqLnti0gZLXd2PYSR1n3oaYNfkKdSKRw/flxCqhFI0TUYDMz7bihQ88wjrzHaTx5le/bswcKFC5khhV9Q+Hy+YvjdacJgy8rTwo6KBGh5EhFoAZ9IJCRWZ5vNJskflA88Ma9F2GotcuTeozz4UB+9i14170Ct40QyiMJ69PZXi3BSIw5FfdOSUWr3km9hxz9/ms/ki2m73Y5JkyaxcDt+wV7I4lSNIEin0/B4PKivr8e0adNw7NgxiedVKpVCOBxGSUmJ8DvgvUSLOHUgcoe8H7W+JX6c0+I+kUjg5MmTSKfTLIec3LObB5HQvN5kMBhQUVGBkpIS2Gw2RXguXZPmVtItKBxORIzLPZVFY5zIU5HeRCSW6DvR+qb1kNHytngDXC6XY17t8mvQM9aT5HyoUHtmWp5SWn2iZ93W1qbwyHS73Zg3bx4aGxtRWlqKeDwuqboon+fyeWvJCcNkMomysjJMnjwZixcvxt69e1lFvGw2i2AwiP379+Occ85h6zf+/j0ez6gOvzsryKdCkcvl0NnZiUQigb6+PvziF78QKuwibN++Hdu3b1dsLysrYwnAy8rKTutiv7y8fMRIEL3wer0oLy/PW6pytCASieDEiROKsVJaWooZM2bgrrvuGnHB6/f7cdddd2H9+vWMfAKAffv24ac//Sk+/elPK8inIk4/+PxHvOIBiF2NyYIWCoXQ1dWFvXv36vYKotLkcpAiQx5RfEgZPzmSpUbuSiwPbVArZcsvONTKl5OyJieBCvl+tI4VKSgiyxhVh+PBV7uTX0ekwKkt+HjFbTCWvkKONRgMrDoeKdzy/TzJkK9PerwY+OP4Niikjt8WDodx4MABzJgxAxaLRVKyHgBL6lzEqQfvgaT3+yOvo1QqxXIS6gFVbpODFnBa4SNy4kVONNEx/G/RddTaI9DCk2RDIYSYFrGk1gf5b/n1ecj7XMg7448fCrmfj8gSXYP3QJHLipKSEsycOZORP4lEghGR/P3qIb/kRhKDwYBEIsE8gKdNm4be3l7JIjOTySASicDj8ShCZgAIDRVFnBrYbDY2n6jNV/y7IeIpGo2ir69PUVhEC7FYTFicg75JklGiMUdyggxqvPclfxxvyFPTmwBlEm3+eZAnO+lVhZK0+aD2nHO5HKt4abVahWHBpN8WqucUqm/k2y7vvxZ5Tt9/V1eX5JlbrVYEAgEsX74cFRUVMJlMCIfDLEcpr+OI9Hm1uYbXq2OxGJxOJ5xOJ5YuXYqOjg5GPgEDuvzhw4cxdepUidc6TwaO5hQ270mNL5PJYPny5Th8+DByuZwqG14IvvGNb+Cuu+4CADz33HO46KKLhtzmYGA0GvHaa69h8uTJp+X6hO985zu44YYbMH369LMi19Df/vY33H777QqPk1//+tf40Ic+dJp6VcRoAJFPeuLzY7EYurq6sGXLFuaeOxzKxd69exlhef7556O2thYOh4PJPiIoCLRgoL/loAlXTiTwEzIlpJRjzJgx8Hg8Eg8cLUViOEHX8/v9MJlMikII5DJfCBkiWnCdygWLyWRCS0sLNm7cqFC2+UU9vU/KzTBUaHlXiEB5DAKBgCRHVElJyai24I1miL4/EYnKh1UGg8FhndP7+/uZQYeSTMuhtsAQET56rPwiyzUATJo0iYUDD4aoKRQiQo1CjZqbmxXH5nI5xaJW/q6oLTlG4l7k40V0jXg8LkwLMW3aNDQ0NKCiogLxeBzpdJp5uhRKrMmvzZdXpzL0jY2N2LZtm/Bcyi0ll42D9QwsYuhwOp265iqTyYR4PI7e3l7s2LGD5UUdjjlu//79LA/QggULUFlZKQl9JVKKB8lGNb1AbqSTfzuUlF+OVatWoa6uDul0WtWAOVyQk1pEmEyYMAFmsxlr166V7CcPd3lYsJ7r8BB99/mIfC1yKd+1W1tbsXPnTsVcsHTpUsyaNQv19fWIRCJIpVJwOp1Mh+I9d/NdRy4/aHzYbDZGyM+ePRuvvvqq4txcLofu7m4YjUZWCfZsMdqN3p4PAnfffTeam5tZjOdwVgrj2ep77rkHW7ZswTe+8Y1ha78QWK3W067MU2zz2YJMJiMcL6fjPr/yla9g5syZ+PGPf8y2ZbNZ3HHHHbjmmmvw0Y9+9JT2pwht0ERFMf2A2GK8a9cu9PX1sfxOw1lmnF+o7d27Fz09PZg0aRJcLhfLt0QKTT4iSM/ijioOiYh9smjK3bpF5M1gFiHy80XbyH1dDlKi+Hh+tbb0EGby49T6I29fDfwzIxBhJhovcmVXr2Kndl3Rdv46uVyOefnxXm+5XI5Zoskr91Qs7ovQhvybp23y/aFQiIVXjKQxifLruN1uRc6VoYwVOUkiCqEBBnQnvQq9msyifXr7JT9HTTaJDBF6CW81kkrUT7Vj9dyDvB21awADXuN+v5/pVYV6ceTrG//OaY6bNWsWSktLsWnTJsmx4XAYuVzulFWGLiI/5HqTiCA3GAzYt28fQqEQEokECwMeLvDf3KFDhxAMBtHY2Ai73Z53vOqZ3+TzMiXaF601XC6XJH2DHoj6qCan5NtFhgibzQaPx6O4Ds0NvJf8YJDvvtQMoXrb4ceQWiELYCB6qLKykhlPeR1Z1KaWriyfv/jnScRUKpXCihUrUFlZif/85z+SNg4ePIh0Oq2QTfkKF53pGNXkU0lJCRoaGvIqC9FoFIcOHcITTzyBnTt3Co+prKxEeXl5Qddvb28XhpW98sor6O/vx/ve9z5MmDABDoejoHaLOPNhNpsxefLk0xLeeOGFF8Lv9+PZZ5/FoUOHEIvFkMvl8OSTT6Kurk5IPtXX16OxsRGHDh065f19r4Li/+WEE7/wIQ+jSCSCY8eOqRYOsFqtsFqtLGeT2sRDFv1UKoVYLCZUYtrb2xGPx1FSUoK6ujpFJSjRYlRkoZL/zU+uBoNBNeyOT1DNPxu+Df7a8usWMuGKzqdJX0TQ80rUUBfZvIKstYDWs+gSWVHpXLXqrDzxlG9hrKaEirZpKa/0Tkm549HR0cG8nuRztt1uh9PpFIaMFjEy4MNIRIsN2p7JZBCLxVTzNbpcLjidTrhcLvZti8IBKFyPrxIlB1mC5Xmg9BDh+fbzbal5PvGeLoMhXeTfab7Fqfy8XC4nTIANSHP0iQh7vh0RBkOIDQXyuY7f7nK54PF44HK5kEwmNSuL6oXIi4R/H5lMBvX19bBYLNi9ezcSiQQbA8lkUtVrgy/8UcTIw2QySXJTqpEnJEtOnDihmjaFkoKTbKJwfx4kC6i9YDAobK+rqwvJZBI+nw+BQEAzT51eUlgOIp/Uwu7kFeW0jEIi2ZmPiNLqNxmWRMQ46U2FfMNaek8+OabVbz0g/USu4xkMBpSWlsLn88Hr9SIej0vCgEWynd8n+k3H8Neg80mPT6VSmDx5Mmw2G9auXYtIJMLkTVdXF0vmzo9dg8HAQjHlVdBHA0Y1+XTZZZfhkUceyXvcjh07sHjxYs1jvvrVr+LrX/96Qdf/3ve+hx/+8IfCfRs2bMDs2bOxdetWzJ49u6B2izjzUVlZic2bN5+2RLmzZ8/Gjh07sHDhQoUVT4Rf/OIX+MhHPoL58+efgt4VAQA+nw+TJk2S5AzgS69Sydauri6sXbtWs60xY8Zg4sSJmDBhArxeLxwOByO1aSGSyw2EEEejURw7dgzbtm3Drl27hO0Fg0G8+eabWLhwIWpqalBdXY1IJKLLWieH2gKP8sLIwSe+LjQEbKQtPWQNIyVwKNeUP5ehWGRFfaBFUTAYFJI2fJJKfsE6GOjxMpD/L1qwESlKpD21O2XKFHi9XrzzzjuD6l8RhcFiscDlcgmJZh56CprMnz8fy5cvx7Jly1BZWQmv18sq9ADvekHSwm7jxo148skn8e9//1vYXiqVYgo3eXFrjd3BLD7UyCcquqCXaCjUS0gL9C4od4zoWlreRHoWooU+w6GSQLQo5WGz2XDeeeehqqpqWHMqaS1W+TC8srIyzJ49Gzt37kQkEpEcJ18s5nI5Fv6lVg2riOGF1+vN61SQy+XQ19eXd75YtGgRVq5ciQsuuADV1dUoKSlRGIzT6TTLE7V+/Xo89thjePrpp4Xt9ff345133sGcOXNQUVEBv98vSV1AfRssyOgl15sMBgNLhk4VGofTw4uuwf8tb1+LfOL1puHuSyH7eGjJNINhwJtXnhbC6XTi+uuvR0NDg6Iiq14UMg+QXMpms3A6naipqcGFF16INWvWSOQNRd643W4JoT9+/Hg4nU7VcOIzGaOafALyD8Tvf//7eP7554X7rr76atxyyy0AgAkTJhQ8Cd500004//zzAQD33nsvXnzxRcn+XC6Hz33uc7j66qvxzW9+s6C2izgzkMlk8IlPfAIbNmxQ7BvMQn24UOhi9nT1870Mk8kEp9MJQKqQ8Dl49u3bh7a2NuH5FRUVaGhoQGNjIwKBAEpLSyVeSolEQqEwmM1meL1eTJkyBfX19Vi+fDmOHj2K7du3o6WlRXGNffv2oa+vD+l0GmVlZcxaTe3xv3nkG39qVkt5G6cDWpY5rYW41kJdz7eodb1CrYC8ostXSeH3m81mFo6nRvIN1RtCrnDzhJPValWEQVCRD5/PJyFiHQ5HMeTlFILIcLX3T8q5WmqCyZMnY9GiRTj//PMxZswYVFZWshBeOlcuP8iqvGLFCsyYMQOf//znsW3bNjz11FPYsmWL4hqhUAg2mw1ut1vhraBloc/n+aMldwrxVOK3DYa8yedtWCiG4oUxGPJOT1sURsnDaDSyvFZU+TBfm/x+kcdBPvDvyWw2o76+Hk1NTRLyiTyG5QZFkbdMESMHk8kEh8Ohmnctm81i//796OjoEJ4/bdo0LFu2DBdeeCHGjh2LyspKJkNyuRx6e3sl7dLfPp8Py5cvx5QpU/DZz34We/bsweOPPy7U/Q8ePIj+/n6MHz9eYUjR4/FTKETE6GAwVCOYVruD6ddw9KcQmcZvozBKHiaTCfX19TCbzUgkEmzMDMbIUAgJRaSjxWLB1KlTsX79esn+ZDKJ/v5+uN1upqOThzCtMUYbRj35pIZoNIp33nkHr776qtAzZMmSJVi5ciVWrVo16Gs0NjaisbERALBt2zb09fVh3bp1kmPWr18Pt9uNhQsXYunSpWdVHqT3AnK5HN5++21F8s8zFS0tLVi9ejWWLl162vN+vddhMpkkiqzcK4jCdkWhdpWVlRg3bhwmTZqEhoYGOBwOloyVkg7KK6YA73rD2O12eDweVFZWwm63MyVbTkD19/fDZDLB5XLB6/Uqxox8AamXfCFlRGvy5cNbRC7fI6Ek5UO+PqhZN9X6K3peauEhevokaqu/v1+Y2H2wlthCw3n4/Tx5KQ+lAQbm5c7OTjQ0NLDzyKJalFenDvJvU/4tU742kefilClTsGDBAqxYsQKLFy+G2+2GzWaTlNzmZRN585BHj8fjQSAQwMSJE+H3+9Hd3Q2DwYDNmzdLrkOJdePxOFwul7Cvovvir6uHeOFB4zEfeS7/tvR4HGmRJTx5q3Xd4cBg5AGgTWKp3Zcop4rBYIDD4WBzGOWIy9devvcn8vASyXNK3itKFJ1IJBTk0+k0Mr4XQSHxIpIxk8mgp6cHXV1dQr1p+vTpzNvpvPPOg9vthtVqZbnqSD4B744XXjY5nU6UlZVh4sSJqKmpQWdnJwwGg4IMCIVCTG/iyXE1+aPHeKNnfIva0voWRd/6UMh3NQ9UMjrICeLhgl7jXiEeoaFQSBGuZjQa4fF4mJ5ttVolScbz9bFQgorvO1ULpJBOHrFYDN3d3aipqZFcz2KxnLbom6HirCWf2tracMkllwjzdphMJjz00EMYP378sF3vjjvuwPve9z7MmDFD8QG8+uqrePPNN9Hc3IyampriRHYW4Ex9h0899RReeeUVHD16FKWlpae7O+9pEAnE/w8MjJ1kMom33npLVTlYuXIls9rF43FWAYXiz8mzhY7nf1PJYdo2btw4VFVVobW1Fb/+9a8V1+zt7UUwGERNTQ28Xq+imoseiI7Tyv0CQBG/Lm8nnwKlRyHJ5zUkh9zVWn6dfBb/oShJon7rXbSqXacQt/FCFSatPgMQvvuuri709/dLwn/JG2G0KlGjEQaDskoTIZvNqobaGY1GfO1rX8O8efPQ2NiI7u5uxGIxRKNR2Gw2mEwmljeJFiTyBVkkEmEK/Zw5czB16lTs2rUL559/vmKsplIpBINBOJ1OhfKfj1xSG8taHgqFLpq0Flyivuklt7WKB2jJAi3yrRDPonxEk9p2/nwtOUmLOvJuKaR/eu9HtI+uJ/KmI7JVnlCZxnIRpwaUK1NOyJLeJCeCCEajEd/85jexcOFCTJgwAT09PYhGo0w20RzD603890Z6E1VinTlzJqZNm4Y9e/bgnHPOUXyrfX196O/vR3V1NcspJTI26SEv+f1qehMZHfN5CvJyRe3bzdcPuf7Df9uiNTV9I/x5eoxf+fZp6V9a8oAnyeRtaOlfJJuSySQzfuSDiCQV9UnrXPIYNxgGPPDk77+7uxv9/f2YPn265B5HM/n0npOoK1euxLZt21BXVzfsbY8fPx7bt2/HkiVLFPtSqRRWrlyJX//618N+3SJOLb761a/i5ZdfLlrqi9AELfBosialIRgMor29XTgBjhkzBjfddBMmTZoEp9OJYDDIwqYoeTmvBGQyGYnHAU12tAgk92Gj0YiamhrccccdGDdunOK62WwWb7zxBg4ePDgoRVt+L9lsliWRlkO+6KBnpafdfNvlELVLOV1Elfjsdruk0p28Da1+FkLy6NnGX09tsal1XVKi9b7PQhdy8v2FeAjIF9fFBd7pBb07sviKMHfuXPz5z3/GihUr4Pf7cfLkSZjNZthsNjgcDnZ+Op1GMplEPB5nP4lEgin0FI7sdrsRCoWQyWQwYcIEvPPOOzj33HOF1+7s7GQ56YYDags86qPaQkqEQhaZ+dqg/FiicEcixvO1IfpftAhSI774xZka8S+6llxWic6trKzElClTBvWc9JKLes63Wq2a5NhQr1XE4EH6i3wOjkQiqnm3Fi5ciMceewwXXXQRAoEATp48CYvFAofDwSrTUS4lIssjkQii0ShisRiSySQrluF0OuHxeFjF4cbGRtV1XTabxVtvvYXm5mbdhh6tY7LZLEsiLUckEkEikYDZbFYNScyHocgnk8mERCIhLBTB5+Yr5PvRK1dFx+e7hlwmiYgpHuPGjcPChQslMnYwxgg1aMlUfuzY7XbdupDaPDYacFZqe+vXr8dTTz2lUHDf97734aqrrsKMGTNGhC202+2YOXMmPvCBD+Diiy+W7MvlcmhqasLJkyeH/bpnIjZs2IAnnnhi2N0vzwQMRYEq4r0Dg8GgmESy2Sz6+vqEcqC+vh4TJkzAmDFjJB5Oam3Tbz0TKzCQTLempgazZs3C5MmTFftDoRBCoRAikYiE5NIzzkULGzWrDFVnowlXfp+ihYx8X74feV/k7VPFLdEzIuVO6/74tvN5H4msgDxxVKhrvPz6atfMdw+DUV7zEV75+sZv53+LvpUiRhYiC3AqlRJWzpk3bx7OO+88zJs3Dzabjb0vNZKW/tdaiPDn2mw2TJ06FVdccQUuvPBCxfWpApQo1LgQ8FZ80Xgj2TSUuV2vXOKP5RGNRhU53NSO1fONaRHbhRDhWtB7jt1uZ3lL+HPz9UN0jNY95jNmaJUp58fnUAjFIgYHNb0pGAwK8zwtXLgQK1aswIIFCxjRxOfqUbuGiJjg3z2NEZvNhunTp+Pqq69WrOuAgbxmRAwVqivJx1cup+4FTNfgn42W3qQlf9XuP99xPT09aGlpUTxXqiSopcsUIr+0UIgOwh+f77pOpxM+n29I/StEN5LLGUIhZNJolk+jNuxOK0fEww8/jP/93/9l/xsMA6503/ve97Bw4cIR79sdd9yBefPmYc2aNax0MIGPKx+pQUPuw6fTM+eRRx4penmdYTAajbDZbIoxWcTwgxQok8mEVCrFJqVUKoX29nYcO3ZMcrzRaMT8+fPR2NgIn8+Hvr4+VnJYVHZXjaARkRykrFB+jQsvvBD19fU4ePCgwsshEomgs7MTpaWlbME3mMoqRD6JLHjkBu92uyUKvsi9Wo38yre4UFtY0b7+/n60t7cr9pG3GN+OqH3536J+5JPv8mvodSnnoRaeQ27cWous4YTIrV3P8+GfQbGk+amDnBCld5FIJBSVE00mEz7ykY9g8eLFqKurQ3t7OywWC9xuN2KxGGuLD7Pj/+evSdcjmUYhvrncQP6fW2+9Feeccw7Wrl3L5CaBvKpoYZZPJml9g2qedrFYjCVO5/vM34N87KpdV+37Fsk5/n8140S+hYbW/eY7jz9G9M60oNdAASjzIOYjCPL1VQ+GQu4P9vgiBgdeb+KfeTqdRkdHhyJnpclkwk033YRly5bllU28fFKbF0k25XI5SehfNpvFHXfcgfnz52P16tUK2ZRIJBAMBlFeXs6O13OvcpCXu4h86u3thd/vlxjtRG2JZJNcxqidR/vV5FtLS4uwgjKRT/JiNfLr6YFcD9J7vJ75QKtPVquVkZeFkjry68t1V736oNbYVLuuSH8eDRi1psbnnnsOv/rVr3QdO2fOHBw+fBjnnHPOiPaJx5IlS3D48GFMnTpVsv33v/89zjnnHGFp7OFANpvFBRdcgG9/+9sj0n4RoxczZszA4cOHsWDBgtPdlbMeEydOxJgxY9hkTBNKe3u74tv3er1YsWIFpkyZAp/Ph97eXlitVphMJiSTyUFZN9Qm/1QqBYPBgLFjx+LLX/4yAoGA5LzW1lZs3LgR0WiUkRd6riGCmoGgo6MD/f39LNGsGoEynOAXOVptU6l1PX2g90LVkPiwmFwuh2QyiUQiwUKPqPIcMKA0k2cY5cjh+6nXkp+vf9TmYM4r9JxCrseHiJLi5HQ6sWzZMni93oKvX4R+OBwOSeETegepVEpBRldVVeHWW29lhPWJEydY6floNCoZ93KlnQglOWhxKSe1c7kcTCYTFixYgFdeeUWRkzMWi6Gnp0dSaloLWuOYlHw5Wlpa0NHRgUwmIyRj8rXL75fL7Xwkuto74Pdr9UXP33rAv0c95xbSvlZYp16cjoWW0WiE3+9n+YKKGBmMHTsWVVVVCg/Frq4uhUdmdXU1br/9dlxyySUYO3YsWltb4XK5YLFYJLKJl08EvtIqrxdQugLSTeTjbMGCBdiwYQMmTpwo2X78+HFs2LBBMscXCuqL1WoVFqbatGkTDhw4ICF4httbmDda8jAYDCwflgiiipD5vlH+ect1p3Q6jVQqJfF2paTwpFeazWaJoasQbygRKIWFHuOZ/P60PKv0kt969Se5bu90OrFgwYJRVy141EpSKj3OIx6P47777lNUt7NYLKiqqjql1gubzYaqqip8/vOfxyuvvIL/+7//AzDgWdDR0TFsk2dVVRXuuusuPPTQQ8wqoFYJ4nSiuroan/zkJ1FbWzvoNnK5HP74xz+iq6tL1/FjxozBxz72sUFf72yDxWJBdXX1qE1QN5pACzx+Ms9mszhx4gTC4bDkWJvNhoaGBvZeeMuWSLnIt8gQLZp4ywtZ16qrq1n+J/qmKBdSPB5ni0w1S1Q+i7XBMOCyXltbi87OTpZjiUpa85bJQqzf/LXVFmMi6x5dKxaLKZQoq9WK6upqFlKUz1LFL8ySySSSySRisRg6OzuZVVSuvMqtrna7nVUjpAW52oJddP9qfdTap4XhWGgOZl6j501VqIoLvJGFyOsnl8sJvwu3241Fixax6mR8ZTJ5+IecsFD7n/6Ww2AwMM+myZMnY9GiRTAajThw4ADrIyXdHaouR9+h3BM4k8mwb5n32sxHHA3VC5L2i94BydHB5uKjZ0Z5bdT6zPeRPJREHmBDef7UHz3ElpYnQT6Pgnx91LtQ5QlyuTdOEcMPm82m0E+z2Sza29tZxV6Cx+PBsmXLhLJJLo/yySXRbwKR4tlsFlarFePHj8fixYthNBqxb98+1sdEIoFUKqVIvi2H2hjix7jVakVlZSV6enpYxdFUKoVoNIpgMMhy7KmNc9E9iPbp8RoiGdDV1aXIRWexWFBeXs5kJc3j/P2o3WcqlWL57eg+RUSS3LBhs9lQXl7O5BORXrxBKx9Ex5Bnrdr+fPejF6J5Q65X6xk7/BpBVEDhTMeo1fJEC7NYLIa7775bsrjzeDwoKSk51d0DMNDHW2+9FT6fj5FPhMEuEOSora3Fj3/8Y7zxxhsSl9R4PI7u7m74fL5Tmksjm82it7dXYaWora3Fj370o4LuN51OSxIM5nI5/M///A/279+v6/wlS5bgsssuAzCwuKQqJkN95tFoFD09PfD5fEVlpAghyKOFn0TS6TROnDghWVxQgsu6ujqm4PDnDVeyaJI3RqMRmUyGlZQdP348ksmkhNDN5XIsNI7KFGstGkUEC8k2u92OsWPHor+/X5LgO5VKIRQKsW9SRGrpIZ5Ex4ombrp3g8GAcDisSDZus9kwYcIEOBwO4bPj/yeQstLf349IJIKenh7s379fmCxYBK/XC4NhoLqJ3W5n1y5EmclHPomUmqEsHAs5dzAeVw6Ho5j7aYSh5tYfj8cl78xqtcLv92POnDkABr5Zu93OFli8h6CIYFILu+P/l3/DqVQKZrMZ5eXlOO+88xCPxxn5RBjKOOavR9VIqWADgWQTfY/y4ghq7fL9U9uXr18i2WQ0GoXV/vKB5BNZ9CORiG6vDLPZDLfbrahcmA/53gslox8uDFaWFeqdQuRTESML8mgB3n23mUwGJ0+elHyjVqsVZWVlWLBgAQyGgSp4DodDIZvk4A1A/Db+N/83L5tID3K73bjggguQSCQY+USgisRms1miN8nbpb/l+gv1z2q1oq6uDpFIhJFPwMDa4+TJk5gwYQJ7NlqkCH8Pas8j33Yi0jo6OhQEoNVqxdixYyVGO3k7cn2N5FIkEkEsFkMwGMShQ4d0ywWPx8P0VyoQI79WPojuWy3foQhaHmJ6ztXqayGyidoarHHidGLUkk96cf/99+Pqq68+o0gCYn2pusJI4JFHHsELL7yAffv2oaysbESuIUIoFMKMGTN0eydpYe/evVi0aJFkWywW033+unXrMHbsWADANddcg/vvv5/F9A4FP/3pT/Hoo49i165dRS+iIoSg0r6ZTAZmsxnJZBLhcFgx4UybNg0TJ06E1+tli4NCZIIeDx36TX+Tu3I2m8XUqVMRj8exY8cOdg55aNntdrhcLok1qNDJ3Wq1YsyYMThw4ICkSkpvby9CoRDmzZvHrjkYok2rT7zyRbmrDAYDDh06pOr5pJUrib+n7u5unDx5Ehs3bpRYqgpRHPr7+7F+/XoYDAaUlJSgvr4eDQ0NrEIPeYapPRe5BZcHTzSqKUqFQq/c1HMc/3z550djs4iRAz17uTekHBdddBHOP/98lJWVoaenB5lMhhVCUANPDPEeLloLPH4ckBKdSCRwwQUXoLe3F08++aTkGtFoFA6HA1ardVAhLjw55nQ6EYvFJAvb7u5uBINBnHfeeZLCD8PlrS5qi7xBm5qaJItN6qfa4k6EVCqFZDKJ/v7+QfeZN/xRpVWn08nCa9See75v98SJEwiFQpg7d+6gyOnhAHmpDNf7LGL4QGHvZCDLZDJCQuCyyy7DhRdeiLKyMnR3dyOdTku+VZG84d83X4GY924jyM8noyDh0ksvRTAYxGOPPca2ZbNZtLW1oa6uDna7fUjhpVQc5vDhw5Ltzc3NaG1txa233iohXeT3N5ygd/DKK68o3oXFYkFFRYVEb5KDf67BYBDd3d3YuXOnRC8ppO+hUAhbtmwBMGDAq62tZc/carWqhgby/RHJkgMHDqC7uxsXXXTRiOWd1PLUpN+U8qIQjGQO6ZHCWU8+URngMwnRaBS33347brrpJlxwwQUjco10Oo1oNHpKJ9iXX34ZjzzyCJsMCJ/97GdxySWX6Gqjr68P3/72t5FOp9Hd3T2k3FjZbJad//bbb+PWW2+F2WzGJZdcgmuuuWbQ7ZL765mICy+8EDfeeOMZN+bfa+ATMJrNZvY9yuHz+RAIBFSt67yVJN/konWMSAlLpVLweDxwuVySY7PZLFpaWlBWVga/3y9sR80bSL4PgKo3SyaTQW9vLzweDxwOB5LJpKaVXc2jScvrgBQbq9WKYDCIrq4uhVJYWVmJ6upqVuVOTRlNp9OIx+PYuHEjK9ecT9HJB1IywuEwWlpaEAwGEQgEUFFRAZ/PxyyFIjd+NSVKhMFYPweDfFY9n8+HmpoahQWajs9HbhQxdPBkCpHQooXS2LFj0djYyL5LfpEgWtyJrqN1ffkxPIGbyWRQXl6uSK2Qyw2EB5KyzX//+TwmRVAjdrPZLLq7u1FSUgKXy1XQYkBNHvH9k3sE9PT0KLxiAbD8L2rfP9/fTCaDSCSCTCYjIZ2HClp8ZjIZWK1WSVn1QpHL5VjJe5H80vsO9cyLormACA3RAo8KZKjd16kq3vBeBnna0ZxHIbDydzJ+/HhMnDhRIpt4HYofF6J3Jp/btYgnao9+ZzIZeL1eRY6dbDaL1tZW+Hw+id6Uz/tJDhqXIm9Hclw4ePAg6urq4Pf7JXoTr7+oPQM9ugDJerPZjObmZuzatUtB2JaXl7PwN96zXt4e6U1NTU0s/+VQ877RM4pEImhtbUUwGITf70cgEEBJSQl7Dmrhj2qyJ51OM8/1fHqtFvTIL/44Gu+ZTAbBYFDxfEpKSljqIPmcYjAYYLFYip5Ppws9PT04dOjQqKiUk0gk8Le//Q0LFy4cNvKpvr4etbW1aG1tZduy2SwOHjwIg8Ewot5P9DFs374df/3rXxX7L7roIl1kT2dnJ/bt24c//elPCuufHAaDAQ0NDYr8IMlkEkeOHFEc39zcjObmZgADz2X69OkAwBZ5+a4TDoeFZV5PF2KxGI4dO6awRMycOROf/OQnT1OviiCIlCiRJdrtdsPj8Ugmm0JCSvIpMmrHkrImTz5M+7q7uxGLxVRJMdHErDZZm81muFwuOBwOiediLjdQ2clisYw4WZrL5Vi+PTkCgQAqKyslldbkz5UWLL29vdi3b58uRUSeI4QUNNEclUwm0dPTg56eHmY0oEVePk84u93O8k0UAvnCXfR3Pojuj7aLErZ6PB7U19dLlOKi59Ophfw9UxiE/F1VVFSgqqpKUvSg0BA0PQSpnDyiRYDH44HT6VQcT17jQxknPMFMyW7l+ZB6enqY14/8voYK/lmn02kEg0FhhTtR8mHRQpJyVcnDYtQgt5TTNyiSIfQ++PBEPg+LFvgFMd9ePB5XJdXUIFpM6yWvSM7QAo9y8/Hg37VIBo62xd1oBP8tUsEV3mOaUFlZiZqaGiH5JB8bavOZnm0iY1s2mxXmpiKZwevkhcypctLIYrHA5XIhHA5L2szlcjhy5AgcDgdLKZOP0C8U1EYymURbW5uwwp3P50N5eTn7pkRtZLNZxGIx9PX14fDhw7r643K5FPeg5gGXSqXQ19eHvr4+tp+KufBh4SLinvL98XKAPI/sdrukIIbcWCB/TkMBtW0ymRCPx9HS0qIIQfR4PKipqVFtYzTmyRx9PVbBAw88gG9961ujgnwaCTz88MP497//jauuuopti8fjWLJkCX70ox/hrrvuGtHra1Vp0Yv/+Z//wc9//nNdAspqteLNN99EZWWlZHtTUxNmzJih2cYDDzyAv/zlLwCAX//61/jSl76keqzRaMRLL72E++67D7fddpu+GzkF2Lp1K84777z37Hg/0yH3Lujs7BRO4JTrR5QfYLj7QyAlmkIC1SYusqDrCQPUUuSy2SyWLl2KlpYWrF69WnJMR0cHCxMhZZJc6PVYwbWURZrQrVYrjhw5olqEgcgnkds4vcOOjg40NTUJiW01kGIGDDxzynfS09OjeV5HRwc6OjqwefNmzJs3D5MmTRIeR2NrxowZOHbsGCPXCXJLsBxqSlQh41CkVJPSKcp95XA4mFWYJxv46xbJp5EFnxDXYDAwYlyO0tJS+Hw+JJNJSaiuXuIBUI4P/h2LiAT6XqjqkFbIqfzvwZKmpaWliMfj6O3tlfT7+PHjTB7V1dWxBe5gF3RyLz+6v5aWFkluSx7kaSTvMw8infSmJDAYDJg0aRKT+2QciUajChkiulYymUQwGERJSYmEHBR5XHi9XuYlSshms+jo6EBlZSVcLpfuuW+wckE+Vnp7e/HMM88ojjMajcyLo4jTAzn51NPTg7179yqO8/v9KCsrE8omID+xpKVbiGSbXH/SGovyCr7yb0INctmYy+WwcOFCtLa24u2335a0v3XrVsRiMcTjccyZM4etv0TzvR5PJ/48eo4WiwXr16+X5BLm4ff7UV5eLiH95GRNV1cXmpubVduQw2g04rzzzmMksNFoRDQaRV9fH9atW6d5bldXF0v3MmvWLDQ0NCjulX8W06ZNw/HjxyU6XSaTwbFjxzBmzBh4vd5TppfT+Ojo6MCvf/1rxTuz2WwoLS1leq18TOmdj88knDXkk5pF+UzAihUr8NRTT+Hmm2/Ou/AYLIxGI84991w8++yz+MIXvoATJ04AGHguf//737Fv3z488MADw56j6M0332SEkVxxqaiowB//+EcsXLhQs41YLIZPfepTLH+KHD/4wQ8we/ZsySLYaDSirKxMsTAeM2aMJLl7LpfDbbfdJlyYAcAf/vAHbNu2Dffff79wkU0ftVwJ7u7uxgc+8AF8/etfx/LlyzXvb6Rwpo73IqQVpbQmf7vdzvIDkFIjt+AB+gkYPdY1+k1/V1ZW4vzzz8e6deskFhcK5SAiSMu7KR+ostuCBQuwY8cOCTERDodZTia32y2pEqh2n2rXpz7S4rq/vx8nTpxANBpVWLqtVitmz56NiooKlp+Lh9FoRDweRzAYxPbt21XJK6fTKcmJQs9KlF8ul8vB6/WyZ5tMJtHb26savnfw4EH09vZKZCiFc5JFkMIW5ddJJBKw2WwwmUwsEetwghQg3ouEFFe1a5nNZladSPQ+i0l9Rx56yRoiximJLr1f3qNP7XyR/CqERCZMnjwZX/ziF/G3v/1N4tUjIi4HSxoQQe31ehEOhyXzal9fH/P8KikpYVWm5NeW94u/L9pGct1kMiGdTqO3txdHjx5FNBpVWLoNBgM8Hg977qJ3RR5roVBI1euxrKyMFd3h+05Je/m2MpkMKioqGEkeiUSEVngCJUOWF/Th+0nh5zySySQ2bdqEJUuWwOPxIJlMwmKxSJ5RIUSiHtDYpRLuasdohenwv4sYGRD5lG/R73A44HQ6EY1GJWOH95zVIqCG4z1OmzYNt99+O+6//36FbBJ5UOu9Li9fzGYz/H4/Zs6ciaamJsm32NLSgkgkAqPRiNraWpSUlEj0On5elkOuB9KxREi3tLRg/fr16O3tVaSLsFqtmDZtGlt/yd8V6U2hUAh79uwReq4BwLhx4xAIBFBVVYWSkhL27ZWXl0tkBoXpNjY2IpFIsGJaO3bsUPX0PHz4MILBIM455xyhjpjNZuFyuSQVTYEBh40XX3wRV111FUpLS5FIJJiXKOnoQ5VNfH94vYkq/4nkD81R/PultkhujTbZdNaQT2cy6urqJOUoRwqVlZW44oor8Nhjj2Hjxo04ePAggAFvoK6uLrz55puwWq1wOp2YO3fukD+gbdu24bXXXsPzzz+v2D9+/HjMnTsXV1xxheaC4sSJE9i1axeef/55hZByuVyYM2cOLr30UsydO1eXa6Hb7cYVV1wh6eczzzyDmpoa5HI5bNy4USLAd+/ejZ6eHqxduxbTp09HIBDQc/uIx+N44YUXcOONN+o6fjixZ88ebN++XbF9wYIFGD9+/CnvTxFKyCd9tYURJXBVq1qiprwM50TjcrlQX1+PjRs3SraLCH15H9UUG/lxRqMRLpcLY8aMwbFjx9DX18cIKLLa9fb2IpvNwul0spAMPdfj99HxmUyGuXt3d3crjrXb7SgtLUV9fb1kUcYjk8kgFAqhra0NnZ2dCnLKYDCwpOz0myef1N6dzWZjiz1SpqgMunxhFAwGkUwm0dnZCa/XqyDmcrmBJM2kgPNQ89KQvx+RtVTeZxHUrKtqhiCv1wuXyyUk+vRcr4jhAf+daJFC5BUZj8dViaR8xLcWia5Hlvn9fpxzzjl45JFHdN7d4ECkaDweZyW/ATDPJ8oV53a72Xeez7sCEOekS6VSCIfD6OnpQWdnp6INo9HIQsDUSNxc7t38JMlkUvHtUjWo8vJyeL1eRj7JyRW5fKUCE1QgIxqNMuJennsnnU6z0G0KM5ffr2hRlM1m0dnZif7+fsTjccV5csv+YGSC6B6NRiM6OzuFodcikqyQuaeI4YFctuSTTVrzrGiOU7uW6Nr5UFZWhvnz5+PBBx9UkE9yrxTRtfOR5dSGw+FAbW0t2traJFWDI5EIEokEDh48iFQqhYqKCkYI0b3w35Tom+DJDzJYdXV14ejRo4oqo8CA3kQhYCK9yWAwsEp2HR0drFAFD6pm2tDQgMrKSgX5pPZcKL9VLBZDaWkp+vr6WGX1YDAoOY8I+e7ubng8HoXTRTabFaY0IM8nSjshl5ciryOtdyffJn9WtM1oNKK1tRXHjh1TtEXh51qFHkZjSHCRfDrLYDQa8cgjj+D+++/H5z//eba9u7sbq1atAgDMmDEDO3bs0BTMauA/oM985jPYvHmz8Lhbb701b5gaEUO33HKLcH9jYyPeeOONIU36BoMBf/7znwEMKJKNjY04fvy45Ji2tjasWLECTz75ZMGJyNUWmiOJb33rWxLvLmCAxPjnP/+JcePGnbJ+FKGOQsaDSAESKV56FCita8uvQwsDvpoSD959fDD3w/eNJvvKykpMnjwZx44dk7g7Z7NZtLe3o729HTabDZMmTWKLGgKvmIiIPVoApdNphMNhHDhwQDUUpa6uDg0NDQgEAizun5RZai8YDOLo0aPYuXOnsA2r1Yr6+nqmwJBlXf4s+Gcgcqeurq5mC9Lu7m6FghGLxfDqq69i+fLlqKurQzqdloQ+mUwmzdBJAEKLvhbpRNAzR5ASRXIwkUgISctZs2axpJlqC83RaMEbzdCzuM9HMBXanug4+UKNxoHJZILT6Ry2MaFGlhuNRua9SElxCZRIuLW1FQ6HA7Nnz4bX65V891qFCmhc53I5JJNJ9PX1Ye/evapFS6gfWh6nRAaFw2FhGw6HA3PmzEFJSQnLnUOySUSo8B4QJpOJ9SEQCLB8l/v371fIN0rM7vP5Cq4k3N7eDofDgQkTJjDyXTR+RASeXH6o3Rfwbjl6h8OB9evXCxfVXq9XmMNHz0KziOGD6L3qOb4QnUmtHTXSS04k0XdvNpuFsomML2rEFr8t3/xKelNFRQUaGxtx4sQJSQhbOp3Gtm3bsG3bNvh8Plx33XUIBAJMnyPZJNLjSMZaLBZWnKm1tRUvvviiaoROdXU1xo4dy8Kx5R7VBoMB4XAYx48fR1NTk7CNkpISXHPNNSgvL4fZbGYEt9pzkMsmp9OJkpISjB07Ft3d3Thw4ADWrl2rCPOPx+NYu3Ytzj33XNTU1Cg8tESEM6GlpQVerxezZs1CPB5ncwT1R+19qb1PNdlE48TlcuG5555jVfx4TJs2jaVwUMtJOhrlU5F8OktxzTXXYMaMGbj88ssV4SIHDx7E/PnzAQALFy7E73//e93tfvWrX8Wbb74JANi3b59iv9vtxvPPP4/JkydrtpPJZHDttdcKPzYAuPvuu3Httdfq7pcemM1mvPDCC/jTn/6E++67r6BzP/ShD+Gcc87B5ZdfLvHQ+va3v41///vf+Mc//jEqBUARI4PBTAhqZMBgFSoR5FYc+tFTHWmoJDBZ/SdNmsTyhTQ1NSksY8lkkhVKcDgcLDcIKQuiflJp8K6uLlbJSJSg0mg0YubMmaivr0dZWRlisRgjb2hip+exYcMGSR4YHoFAAB6PR7VCnnzRIldg5W7vZrMZPp8PZrMZoVBIuKjs6emBw+FAIBBgCaLpmjU1NVi6dCnWr18vWSBSkmDeM0ptwTYYiBRotXFSVVUFt9vNwrhEitpotOCNdmiNgXzvVOs8tQWdljwTKe0i2VTIwpQfZ2oLB/oOXS4XLBYLzGaz8BuMx+PYuXMn8+Ssqalh58i9DylJdyqVQiQSQXt7O6tGJ5JNAJh3I30faouY/v5+1fCxKVOmsH5R3j5+0cy3I3oO9JtkjMPhQH19PcxmMzMQyJFKpViiXzkoeW9fX5/kus3Nzejv70dZWRnzJqPwa1E/1QiBfCAZffjwYdUwHavVyjwLRIaNIgF1akByQssDRnTOYK4hkkeFtCUyNlEbWrmnRMfn25fJZNDQ0MDSEjQ3NysMPP39/Xj66adhMplQVlaG2bNnw+/3s6IyPHlCeTbj8Tg6OzuxZ88edHd3q+b/MxqNmDp1Kqqrq+H3+5FIJGA0GiXfDMnq7du3q+awu+CCCzB16lSWryuZTDLvf/5bE/3mQeFpHo8Hc+bMgd1ux/79+4XEcjAYhMPhgM/nU5A3VVVVsNvt2Lx5s0QP3bp1Kzo6OlBdXQ2v1wuz2cxknLxvWrq+mvyi50XE386dO4XP3WAwIBAIwOl0suT6/HX540abfCqST2cpyN36uuuuw9tvvy1J2hePxxnpk0wm8fjjj+tu980331QljCZNmoTFixdj/vz5wio1hNbWVrz55ptYv369osKL3W7H5ZdfjhUrVmDatGm6+6UHtPBcuXIlWlpa8O9//1syebz11lvwer3MQ4xHRUUFPB4Prr32WrzzzjuM1SfvjX/+85+44IILUFFRMax95hEKhfCf//yH5fMi1NXVYdmyZZrPvIhTDzVLmhx6lKzBTCx6JiSyjonyevC5ewq5fj6yzGq1wufzob6+HqFQCL29vZKFXi6XYx5L6XQaVqsV8XhcoaTwx2cyGYTDYfT39wsTXQMDISV+vx+1tbXwer2wWCxIJBKK/kWjUbS1tSkq19C9UPgYH0attkgUKQn0m1dc6MfpdLKQPLnXVk9PDywWi6SMMynpDocD5eXl8Pv9LJyF388njucJo+GGiCiw2+1MCTabzYrKaoNV/osYOvJ5venJwZOPoJKPcTUvAH7hSaAqk6J+Fqpw5/NkIes2hbylUilJhTc6hggMylUUiUSEhRvo3HQ6zUKA1UgnIm5sNpukUqoclMifKv7xMBqNqKqqQiAQgNvthsFgYN+jnuek9YxNJhP8fj8LyZOT8uQBISKfKJG3xWJhoXoAWJL3Q4cOYfz48XC73Zo5VbQ8oNRgNBqRSqVYMnU5+UR9E4V4F3H6kI+Akif1Fp2vd1s+2aQGCi8TeflqeamI+iQiPOXbLRYLSkpKUFNTw3Qd3nsyk8mwhNuxWAwulwslJSWw2WwKz/ZUKsVyDPX09OD48eNC8gMA8zSqrKyE2+0Whn8ZDAbEYjG0t7dLUioQzGYzJk+ejLFjxyIQCEhIlEKJXf75kOGwrq4OiUQCsVgMra2tkmOoojLlxKL+5nIDKQt8Ph9KS0sRDodZv8PhME6ePInt27dj1qxZkrBA0RhRMxRo3RdfBVuUU5T6RuS9KO3DaJZXZw35REqDWuLW0wm1UsYjDZvNhgceeADf/e538dOf/lT4bHbt2oUPf/jDQ76W2WzGVVddhXvuuSfvsZs2bcJHPvIRxXaj0YiKigr84x//UJQXHk5cddVVOP/889HY2Cixxv3P//wP3nrrLaxcuVIoNOx2O/7yl7/gG9/4Bn7xi1+w7UeOHMGHP/xhvPLKK1i+fPmIlL3MZDI4fvw4PvKRj0gEv8lkwpIlS/Doo48O+zWLGBr0TKq8EsWHHhH0WMVEf+vxZuATnIsWeCRTta7L91vrWvw1E4kEHA4HJk2aBJvNhr179+LgwYPCPlOp36HCYDCguroaM2bMQGVlJfNKoPvjr93d3Y21a9cK2zGbzaivr2fnyCvK5VvMy70xgHfLkafTaWahNJvNOHHihOS41tZWxGIxjB8/niVWpcWl2WyG2+1GY2Mjjhw5onhmVD2MErrSXKBX6dNyJ6dFey6XE5KYPp+PWSepD2qeLKPRgjfaQM8+X44N+kb4Maslc+i3/B1qHSf/m/pF/8fjcXR1dQkXmmr9zkd+57NSm81mRqJoVZFLJBK6qzjlg81mkxRbEMlUg8GAVCql6o1ps9kwf/58JtP5hZLoWcm9YOXX4t97NptFSUkJCzXaunWrZDFEobZkAJO/c6PRyHJq8QvTSCSCt99+Gw6HA3V1dfB4PEilUuwckaFBTiBqeV6azWb09fWhtbUVmzZtUjwDWpTqMbIU5dLIg5dNWiDyhCcERHqTGsktP24wiMfjaG9vF5LAcoJGTYaKICKiyFvJ4XCgoaEBFosFBw8exLFjx4Tfdn9/vyKH52BgMBhQXl6OSZMmoby8nCX/5udwktd9fX3CaxoMA2Fl119/PTOs8cYwPmxZft/yv6k9nrxKJBIoLy+H1WpFSUkJ/u///k/iFXry5EnEYjHU1dUxvYnXW8izs7W1VZKDLxgM4qmnnoLb7cbEiRNRWloq0ZtEZLi8n3Kyih8HFouFVQN86aWXFOeXlpZi5syZbC7Syv83GmXTWePj/slPfhJvvvnmGen98cwzz2Dq1KnCRIenArfffjvefvvtYa90RzCbzXjjjTfwrW99a0jt3HnnnSPaTx4lJSXYvn07brrppoLPVfvQP/rRj+LTn/70ULsmxPe+9z2sXLlSMdE9/fTT+N///d8RuWYRgwdNbjShBAIBTJ06VTGBxGIxxGIxVtVIL7SOVVu4qKG1tRUvvfSSwirPL8IG2xdR36jNeDyOmpoaLFq0CJdddtmIhVwZDAZceumlWLhwIXP35kvG86A8BiIEAgE0NDRIrPeia2lZUdUW+2SBz2QyMJvNKCkpQSAQEFZjOXjwoCQ8hcirVCqFMWPGKKpPEcjVns4diuVMvkggF345Jk+ejClTpqCyspIpnnKMRsXpbAHlFHG73Yp9oVAIoVCIGYL0LpzyEUx6Fvg0vnbv3o1f/vKXihA4ESmhBr2LGnnfnE4nfD4fysrKVNseDgQCAZSWluY1uNGiTYQJEybgvPPOA5A/FIQgX4TLF1K8rCIrvdVqRSAQwIQJExRyJpvNKpKS8+3Z7XZVw9xbb72FNWvWoKOjgy3eyWMzk8kIPS2oXfpNC1g632g0Yu/evVi7di1LFcHD5XLB7XafEn2zCH2Qe6b4/X5MnDhRoRuQbCKDBi+bRONePifzXt2D9fDeuXMnfvKTnygKJWlVe1VDvnnYYHi3El0qlUJ1dTXmzp2LFStWjKjetHz5csyZMweBQIDJHpHxSEtvWrJkCT75yU8yBwx6PvJcVLSd/5v/lvnnyhNWZNB0Op1obGzE4sWLUV1dLelDKpVCa2urhPQC3vWar6urg9frFfb/ySefxOOPP45jx44xD9VcLseMM6QPqs1J8r5SovNNmzbhySefxGOPPaY4d/z48ZgwYQLKy8slbfHvZrTjrPF8Ki0txbhx487InBHRaHTYLGSDQWlpKSZPnoyvfvWrrHLL3/72t0G3V1tbK/GWMhqNmDJlCnw+X95zH330Ubz00kuSbRaLBZ/5zGdw8cUXo7a2dtD9KgRGoxH19fUKpbutrQ333nsvbrjhBoUAow/+vPPOQ19fHx544AGJUtTR0YENGzbgl7/8JQBg5syZuOSSSwbdxw0bNuCNN94AALz++utCD5CqqiomoIo480Bjxmq1wuVyKfZHo1GEw2F4PB42uQ+FhFJTvER/m0wmpFIpxONxoXVfbsHjyQot4kJP//l2HA4HysrKMGfOHMTjcUQiEUky8kJBCyS3281ysfj9fonruZoH0tGjRxVhrcC7FUeIIKJzeSuanvvOR/jw+yk/Ek/qpFIpnDx5ErW1tcKFnMlkQnl5OeLxuPAZEgHEW4tFBJla3+T9pPAftZxhVIFHrZ0iTj3kBKiah2NPTw+6urpQUVHBcmzIvQu0PJzyeR/IyQ7ei4G82GOxmCIcQQ0iK7Soj2rWaFE7RAp7vV62UFFLFK63j5RfyGAwsBLavCVf1CdgwFAhD2cxGAyorKxEWVkZC9lVuy6Bf/fy7SK5KIfRaERZWRmCwaDk3VCePTKkyL096FkSScWDyqfv3bsXHo8Hfr8f1dXVkrbUFmBynT8ajaK7uxsdHR1ob29HZ2enkBinUMAizizwhKLFYhHqTd3d3ejs7ERFRQWr9siTCiJZJJJV+bZpgYoHiKAmUwr1ulI7xmAYqLTr8/kwbdo0VgVuKOtM0pMcDgfLe6eHFDcajTh+/LgihYrBYMCkSZNQX18v8RrSuje9MkgO/h2PHTsW7e3tkvVSKpVCe3s7AoGAYq4j2USGSfkzjEQiaG1tZcUKqqurMX78eM1wXZ7k5BEOh3HixAkcPXoUx44dQ0tLizAPXVlZGUpLS/MaSEYzRh35ZDKZWHJCHmazWfiRRCIRhEIheDyeU9XFvDAYDMLqGiMJr9eLn/3sZwCAPXv24Nlnnx201XvmzJmMYCkU9913H9555x3JNqvVirvvvnvELYwiOBwOeDweZr04duwY7rzzTixbtkxBPhGuuOIKzJkzB0899RSCwaCE8d+3bx/uvPNOAMDHPvYxnHvuuQAGQvbkXgwiJJNJptw+//zzuPvuu4XHmUwmFn9dKKhctFryzSKGBvkCjRQjUUU5KhdbV1fHFvCicAMt5FsEAu9O6mS1ogVePB4XhkpRDhOKNR9O5Ylf/JEHktvtxrJlyxAMBpniwCuh/N9q16A2PR4Pxo8fj5qaGjidTtjtdvZs+ecrb8tkMuHgwYOKhLoGgwE+n4+VFhadn4/AyeftIb/HTCYDl8uFUCgkUW6IfIpEIpJS7PwCjRJ7nzhxQlI2nkDeBHy5ajWoLYbJE0LN2knjq7y8HKWlpayaoOg58CFCcstoESMPkgtyJZoqK/EVf+RkNP3Ws7gT/Q8oZRMwEEIWiUSEpAF/LTVj41AUdPl3bbFY4PP5kMlk2CJPz7mifpjNZjgcDlitVsX3pybjqI1oNKqQ1QaDAePGjUNpaSn7ZuT9L1TP479F+Tb62+fzwel0Sr5TCoGhsuCia1NOKxpPPEKhEKssOn78eHg8Hng8HolXsFwe8WOPvD97enqwb98+7N69W/UeiQTkCx/o9ewrYmQg/5az2SxMJhObd3kcP34cx44dw9y5c9lYslgsqkYQ+Xjh/85HOom2q3khkpcOYTAGOjUZyY/9TCYDo9EIp9OJefPmIRqNoqenB+3t7YrvVuTtKSLn3G43xowZg0AgAIfDAbvdzs6XV4qTE/SHDx9m+ab4ZzFv3jxUV1dLchbJ+1CofBIR6aSTZbNZ1NXVoampSZKGh8incePGwWazwWq1Kq5bUVEBt9uNkydPKtLk9Pb2MkeAc845B2VlZfD5fJJCBSIjJD1bmjva29uxYcMGoScmHW82m1FWVsYM0vK5VQ2jLW/dqCOf5s6di7/97W9oaGjQdfznPvc5/PWvf8Urr7xyxkwcpaWl2LVrFwKBwGm5/uTJk4fkWTASOY1OF37wgx/ghhtuwNy5cwta7FRXV+PgwYP49Kc/jSeffFJ4zGOPPYZnn30WAHDXXXfhG9/4Rt52n376aXz2s58FANXEyQAwb948vPTSS8JwiXx44okn8Pzzz+NDH/pQwecWoQ3KXcETy6QYiQjwjRs3or29HdOnTwcgVY4GM4moKQhy4sVoNMJms6GpqQmtra2SNsxmM5YsWYKamppTNplR3imn04kJEyZg/PjxLL9ALBZDb28vYrEY4vG4ZIFFioTVamXeSeTWTPesJw8g78Ujh8EwkLPAYDCw6ix63ORFSp/ateW/SWHxeDwwGo2KkO1QKASHw4HS0lIJGUAKe0lJCVatWoVt27YJPbmAd3P6AO+GCshlO+8ZRQq3nudZVlaGiy66CHa7XZEXK988PH78eFgsFhw+fDjvdYrQD8pvIV8cibzfgAEv5QMHDuDyyy9nY0xORgP5Q+1E5BQPGvfUNo3DjRs3Ys+ePZJjiQgmD5p8kI83nljRow+SDKE+WiwWiVHKYDBIvP/kJDdfzpwPI+G/BxHZpFd2GAwGVoY7kUgUbIwSPQf5Ylytj9XV1bBarYqqxxQmJ6pgRYurQCCgWRziyJEjaGlpgcEw4MnQ0NAAr9cLu90u8VYi77je3l6cPHkSBw4cYItlNZBnLMnLfOQDv4+IEC0CsojCYbfbUVtbKyEFyEAi8nz6+9//jqamJlx99dVMDhDZoEUu0Q8v8wYTLbNhwwYFuWk2mzF//nxUVFQovCvp+vzvoYLIllQqBYvFgqqqKlxzzTUszCuTybDiI/F4nMmpbDbLdCaLxQKv18u8nfhqbrx8lXtm8lDLZ2w0GtHY2Aij0YhYLJbX0DUUUF/pvU6bNg0ejwevvvqq5DjSMamgBJ1D8srj8WD58uXYuXOnsKonAOzYsQN79+5l16E8oi6XS6L3p1Iplri8ubkZmzdvzquP+nw+rFixIu+zEo2hMWPGwGw2n9Yoq0Iw6liElpYW3Hvvvfjud7+LMWPG5D0+FoudNg+PXC6HX/7yl4oPwGA49Z5PPGhxciZg6dKl+MhHPiKcYE4FHA4HqwzD41e/+hUuvvhifOpTnxKeZzQaUVJSgk9/+tMYN24c7r33XsUxlBQRGMj7pSdx8r59+1SrTgQCAXzrW9+C0WhEdXX1oN/hn//8Z8WYLGJ4kEql0NXVhVQqxb5v8u6xWq2KcUZVzU6ePImysjKmQIkWEXqVF63jeMUrl8th+/btOHjwoOIYfoGn1g5BywNIL6hfRCzxMfJ2ux3l5eVMcSJlhzwx6IeUJ72EGb8IzWazwso1FC6Z75nqVar09gt41/Ir8phsaWlBJpOB3+9nCy25x53L5WJVpPbv3695Td5yJ+oL9V1rwU/J2EtLS1FaWioZ74WMi66uLvT09Og+vgh9yOUGEsI7HA7FPtH7SaVSCAaDOHDgACoqKmC1Wlm5Z/pm9CzceIJDTkbxizR5kt5nnnlGmPifkvKLLOhqRIrafr0QETL0m89JQsSI2sKXP1f+txZEHh1utxtlZWWSKpb0W8v7qRAiWA253EAOJ5FBhbzVtELaKILBbDYL9XM+H0x7ezvi8bikEiB/XDqdZuHaIi9e4N0wJQonGux98zpdEcOHdDqN7u5ujB07VrIuIrkgB4W8NTU1MdmUSCQU3h/5CG+5DNKLf/7znwrvFS29qRCCk++fVt/pHJ7Mpr/pOZBBTl4dkLzaiejncynpfQ40B8RiMYVeUFZWhrFjxypkk+he80H+LPLJzEwmA7fbzQhmuTdvNptlFYP5eYjGgcPhwLhx4+B2u3Ho0CFF+1RxFACOHj2KSCQCl8slIe/ouGQyiUgkolnp1Gw2o6amBl6vF16vV1IEpxBZ3dvbqxoGeiZi1JFPJ0+exJ///Gd88YtfVJBPRqMRY8eOxbFjxyRJ4BKJBI4ePYrq6uoRraImwsMPP4wdO3aw/z0eD2pra4eN/R7tmDVrFm655ZbT3Q0FHn/8cSSTSVXyiXDZZZdhzJgxePLJJ5HLDZSIFyWWX7duHdatWzfo/vj9fkyfPh1f+cpXBhVqx+Nf//qXajWvIoaGdDqN3t5eRXluWpg4HA5Eo1HJ/mQyiaNHj6KkpEQSBiCy0A/WesYfTwu3SCSCAwcOSDxjiOygSVDPAnMwCpWIsKFt5EFAigGVPieSiVf++TbI4i4KC9K6Pv0dDocVFnPyqFI7j8dQrXrytnkvEDk6OjpYGKd8cU+wWCyora2Fy+VCa2srs4aqLdDyeQxowWq1wu12Y+zYsaiurobD4RBW+5FfT7S9r69Pd56fIvSDvPvUQJ5H/DiORqPYsmULVq5cCYfDwbxreIWdUKhM4sc6P34zmQyCwSDWrFkj8S6ghZa8QqWe71HNCyFf39SO5b9Vko/0XOTEE0/ayj2p1K4hl5si8snpdKK6ulp1npA/n0KhdR4lqhcRmURQqt0P/W+z2WAymVjYlOi5AAOVu9QMcnpAcwjl7BN5ruZb3NHxqVTqjKyoPdqRTqfR19cn9Kokj81YLCaZnyKRCDZu3IiLL74YTqcTsVhMMifybej53vMRVQBYzrdXX30Vu3btYtvJk9ztdjO9STQn856X/L585IzatywnT/h2SVbyZJRc1gLvekDzBIweWU7XjUajCvLJ5/Nh8uTJ7BhRJUIt6JVZ8ndNstbhcAgTiHd3d6tyANSOyWRCVVUVnE4n2tramN4kmju7u7vR3d2tq68iUE6zuro6lJeXKzzF5dB6dsFgUJH8/kzGmZedewjwer3Ytm0bPv7xj0u2b9u2DRMmTMC2bdtOT8c4fPzjH8d///tf4aRdxOjEtGnTcODAARw8eBB//vOfR+QaP/jBD/DKK6+ckQn1i9AGWYgAYNmyZairq5Ps7+npwVNPPYW2tjak02mF5Y9+y/9WUya0kE6nYbPZEI/H8frrryuqSJWXl2P69OkoLS2VKFEjTZaT0kBKnNfrRWlpKUpKSlgFU8qHxlcXkRNWg7FiEhnX19enWFhQJTC1hdFIQP5Otb55XunjFVBSmAwGA/x+Pz7wgQ9gxYoVmDp16oj0ecaMGbj44osxadIkOBwOVdKU+infVsTph9/vV3jZHTlyBF/5ylfQ1NTEZAegXlFNXqWIfvgQNDqffmg7Vf3s6enBgw8+iN7eXknbJBdECzU1gmg4ZBf/TfHENuXxczgc7IcWe+SRQ2QFT1QVMofzC0S5/LHb7cyCL5JNavPCYDyv5CCPLy3vJrW2+XdvNptZ0RS1alNDhdvtZmNbLZ9iURadeaB3YjQace655ypysDY3N+Pmm2/G7t27kUql8lblFMkmnpTRg/b2djz66KMK2RQIBDB58mTNMcbfk/yahZAt/A/JJTQClXoAAK/eSURBVLpni8UCu90Op9MJj8cDl8sFp9PJiF6STaRLRSIRFqpIxQ/0GhPpPvv7+xVGK4/Hg7Fjx45ITj4t0DMhg6UaRDKQ+kR6ZElJCS699FIsW7YMU6ZMGZH+Tpo0CcuWLcPYsWNhs9nyVlE+mzDqPJ+0QBYO0UvKZDL41re+hcsuu4wlhB5J7Ny5E9///vdx9OhRyXaHwwG/33/GDKQdO3YIk1pfc801+OhHPzps1zl48CC++c1voqmpadjaHC5UVlbi8ccfxy9+8QusX7++4PNp3AHA/Pnz8a9//QsA8Oqrr+IPf/hDwe2ZTCb87Gc/Q1VVFROgc+bMOatybb1XILfAUQU20XH//e9/MWXKFCxfvlyS1Fq0eFBzyRURVPzxNpsNnZ2dOHz4MDZs2KCo3OT1elFbW6tZeU+vcqK1j38u/KKUEvrG43EkEgn09/fj6NGjikS65eXlqKysZMl7LRYLbDabZGEjenZyqyO1G4/HsX//foVrNJE/qVRKkgh7JOW3fMwYjUZ4PB7EYjEJOUYLXD0gV/SxY8eipKQE4XAYnZ2dg84PUF9fz9zEHQ4HfD4fbDab0DqoZtU9VWReEfqglvspm83i5z//OVauXIlbbrlFkV8DUCbEVfM+oEUO/c1/Tw6HA8eOHcOGDRvw4IMPKkIvieyRK+iFeF+Jxp7WOBSRv2QFp0qhfLuUT4VCxEgf5Z+PPAdaPmQyGYTDYcV9k1ckkcxqi14tL6uhyjGz2Yza2lp0d3erhpVo9QV493nYbDYWRpwvsbsW7HY7e/Z8afN8/TpTdPL3MtTGJhG7cmSzWfzwhz/ExRdfjNtvv13iMc1/k/QN0naRZxJ9Q2rj4MSJE9iwYQPuv/9+hbeL2+1GZWUlm49Fbeu9b639chnL32Mmk0EkEkEsFkMoFJIUbaFz/X4/AoEAI6SIbCL5xOfM0iLQaF8ikcDBgwcV3yrJaj6npCgUUUsOD0U/MBgGCgrMmDEDR48elXhOkrEy3zOn52G321FVVcW877q7u1XzaOZDTU0NPB4P3G43bDYbSkpKJM/pvYSzcjU7duxYzJw5k1XOILz++uvI5XJYsWIFZs6cqav62GDQ1NSEN998E0899RTbZjAYMGvWLMZwnmokk0ns2LFD8UFv2LBBmDDb6/Vi4sSJiu0TJ05EaWlpwdfv7e1VTcx9uuF2u3HttdfiH//4x5DbqqqqwnXXXQdgwGti06ZNBbdhsVhw5ZVXspCZIkYv5N8bJdDkKywSDh8+DIPBgMbGRtTW1grDA7Qs/Grg9ycSCRw7dgyHDh1S5CBzu90oKSlhSazVyBu1a+jZBigXi+RREAwGGekUDocRjUYRDAaFcffkAUXJI8kDQZRwXK7kiPqSTqeFeYb4Z8cvqgdjtdRCvjAQm82mSM5LVs98i0l6DhaLhYURhkIhmEwmRKNRCVknCu8hpZwUc5PJhJqaGvh8PuaZxlthRVZd/rkVSafTD9F7ICMKXyWIsG7dOhiNRixbtoxZ+OULukKvz39XFL6xfft2rFu3TqG7mc1mlq9HRP4WQnoXci6dwz+PdDrNKj2K8hURcZ/NZhkBkslkJLlZ1PrGb+O/FzVSl9qm//WQKIV8f/I25edS7ktKbKx2HRFBKCcsKUyIFob8M6fj1OZD/rfNZoPFYmFJ3vXeZxFnLkwmE/PmketNa9euhdFoxAUXXIApU6Yw2UTQ0kP0zEskm3bs2IF169Zh69atkv0ulwterxcej0c4/+mZn/n+aEE+3tPpNPM8SqfTCIfDLMfQsWPHFOeT3kS5oMjL3ul0Ssg9NZJevj2TySi8wIB3iXE+R+BIELxaXowUPnfy5EnFOWqpGfi/6TjKT+dyuRCNRpneRMfw3mdyQzDvWWc0GlFZWYmSkhJWPIEg74+e+x5uHfRU46wkn772ta/hAx/4ACZPnqxwB1y9ejUWL16MpqYmNDY2jsj1v/zlL+Oll16SbLNYLHj++edRU1MzItfMh66uLixbtkyzghqPBx98EA8++KBi+3PPPYcrrrhiuLt3VuLKK6/ElVdeebq7UcRpAq9Y85alhoYG+P1+vP7664pzmpub8dvf/hbf+MY34Pf7YTQaWQJy3norJ0Tk2+WTkcViQSqVQlNTE/7973/j+PHjkv0GgwFz5sxBXV0dPB4PwuEwIxz4RYJe6CGjaEIOhULo7OzEf//7X90VJ9vb24XVSBYsWIAxY8agsrISqVRKQqzwfRBZEtXug0qDyz095IvnoSBfG1arVbGQIrKIPOnyeXCQkpTNZuH1elFSUsLmyGQyyVzxk8kkmzdpQUjEntVqZfm36PrkFSZaXMv7UMSZi1wuB5fLBbvdLsxb+Pbbb+Pyyy/H22+/jXHjxsFgGAiVI89DQOoNRX/L840QwUnfut1uRyKRwIYNG/DjH/8YmzdvVly7pKREUUF0MONJzznyviYSCdXKRyIkEgmhnuX3+9kiT+7JORjQAo+8FYb7+9Lbnkg20fla8lUug0lOU44fSk3BE+Py0Go+hEprYV+UPaMbmUwGDQ0NqKiowOrVqxX733jjDaxYsQI7duxAQ0MDDAYDotEo8+4BlAU5RBBtj8fjLJJlw4YNiuNnzZqFiooK5hmjhnzX1EM88eM+Eomgu7sbr7/+um69qbOzE52dnYrt8+bNQ21tLfx+PwvxJfmn1V+1PpPnE8lBvlreUL9FuVwRkdz02+FwCL0eiVTKdx3Sf+n5ulwuNDQ0YNy4cazSIFXcJL2JrxzscDhYoQOeDKdz6Rry6xYCuY47WnBWkk8GgwG1tbV44403cNddd2HNmjWS/ZlMBh/84Adx44034qtf/eqwXffw4cO48cYbFSU45X07VYjH47jmmmvQ19eHVCqlmmi2ENx55534yU9+AoPBgD//+c8jFgt7NqCo8BQBKK0aFosFJSUlmDdvHg4dOqSoUJHL5fDQQw9hxowZOPfcc+Hz+dh2+aKF/pYv+vh8K/F4HIcOHcKxY8fwxhtvqHr41NTUSKw7fPuFKGv5tpFSE4vFsGbNGsRiMVYGeKjYu3cvDh06BKvVirlz5yIQCKCkpATRaJRZ12nS1/t9FhomUwi0lDG9Sqmetvg2yVuCHzs2m43l1BG1x489XqGksUbH5OvTcHtmFDH8MBqN8Pv9CIVCCo+bbDaLz3zmM7j88svxsY99jBnTiMDk5RD/jfELJyKrTCYT0uk0Nm3ahM2bN+P3v/+9Ik0BgRJFDzYZK0HP2KKx3t3dLfQEHCz6+/sRDodhMBgk1SDlnkvyb0TvolQP8nmA6jlWz7VFhD9tlxP4eu+PryYokisi7ypRv+T7RsIjo4jBQWvMESk5f/58HDx4UKE3ZTIZ3HDDDbj66qvx6U9/GhUVFeybkssmgnyOtVgskmO2bt2KTZs24b777sPhw4cVfTIYDCgrK2ME+nDnOJLrd0SGv/POO4jH4yz/5VCxb98+NDc3w2KxYObMmfD5fHA6nZJKuvKQvHzyYTjn8cF6TYveOe/RxG8DxJ6oPOh5EElutVpZRWSR5yrfFs2lvDzTkvOifus5brTgrCSfgAFr2pIlS3DppZcim80qymJu2bIF1dXVmDRpEi666CKJVa0QxONxvPzyy8hms2hpacHbb7+tOKaurg7nnnvuiIX5iXDkyBFs2LABa9euHdYM+Pv27WN/P//88wiFQliwYMGwtV9EEWcDRO7KvKJtsVhQWVmJYDCIbDarqObT2toKu92OkpISjB8/Hg6Hg4UT8AoOPyHxHgZkWUkmkzh06BBaW1tx4sQJhQsyMGDNKS8vh9PpzLvAKxSiyTUcDiMUCqGrqwttbW3DWrqaT6De0tLCFCY+94q8f1r3Kj9etHgaipKlthCid6hFQOm19Gsdxx9P5JzoeMopwS+OC7lvrWP5ey4ST6cOWuOC8haRtyaPnTt3oqSkBNXV1Vi8eDFKSkrgcrmYB0y+RV4ul0MoFEI4HMaWLVuwY8cO7Ny5E3v27FH0hyzofIU9PfehB2oLDiLSqArbcIF/jtQ2VecS9W0kvoWhfGP885JX79N7rrwvWv9rHZ9vkagWliK6plbfRIaeIkYeau/aZDKhrKwMvb29Qr1p27ZtKC0tRW1tLRYtWgS/3w+PxyPJM6d2LfodCoXQ19eHbdu2YceOHdi1a5ciDBgYCFUj4ok8ZAohgrUIUvlxBoOBpSPo7u5Ge3v7sOYJikQiLIT4xIkTSKfTKC8vV9WbBot887zadjUiJl8bevQOka6e7/ry7aLE9XKPJDVyfKjzl/zv0YKzlnwifPOb38QFF1yAJUuWKBji559/HmvWrMHhw4eZdwEPNXc9/kX39PTg+uuvVw1no1jkv//970O8E30gVvc///kPvvjFL6oeV0jFFTUF44477sD111+PRx99lLU3GllYkUdJEUWMJIxGI8rKytDQ0ACHwyFUbg4dOoQjR45gyZIlaGhoQG1tLSoqKmA2m5lXEz/B8Yu+YDCIrq4unDhxAo8++qjQfZpQXV2N5cuXs/b4CVk0oapBzWLPbzcajWhra8Phw4dx4MABzeejF2ryaefOnThx4gSmTJmCyZMnA8CgFTb5fYlIqaGgUGWMwOcFy6fMiogs3tsCGLDskSzkZTof9qm2qFPrB//+880PRRl8+kHviEIWgsGg4pi1a9di/fr1+NznPoeFCxdi1qxZmDBhAstxxI8V/p1ms1n09fXh0KFD2LZtG2699VZN8tlut6OsrEziAaAFLe8X0aJOjmw2y3LNqWE4ZFMwGITdbmceUKSDUL/4BctwfBN6vXvUFmRqx+rRnfLJNr0yYSiLN61j1Mg/+UK5KJtGHrwuIxqzBoMBTqcTY8aMgdPpFOpNq1evxttvv40vf/nLWLp0Kc455xzU1dVJ5iDRHEZEe0tLCzZt2oSbb75ZUzZVVlZK1pWFhvWpEaQ8+Dm4r68PR48elTgAqB2vB2qyZe/evejs7MSUKVPYcxts1ePhWg8WSrTw+oxeclmtDdEYpG18BVT5HEXzIB9ymO86g3le/NwxmnDWk08AMHv2bOzbtw/XX389tm/fLtkXiUSwcOFCBdE0bdo0PPPMM4rB8MQTT+Db3/42+5+ST6rhmWeeOaWeQblcDpdeeqniPnlMnDgRzz//vO42v/vd7+Kxxx4T7vvPf/6DGTNm4MUXX0Rtbe2orMjW0tKCiy66CK2trae7K0WcJVBL2A28O5mlUimUlZXB4/HA4/Fgx44dEs8dYGDy3LhxI7Zt28ZIJ4PBAK/Xi/POO0+SbyMUCuH48ePYu3cvIxHS6bQm8bRq1SpUVFRIPJ7UlDTapjUp85ArDKFQCEeOHMHOnTuFiXoJwymfent7sWXLFsTjcdTU1KC6ulpStlzPwkee+FZNERqKhVCN0DIYBlzt29vbFe+RSKFCFA81yyM9BxpffK4v+iEvMl4hHm5jw3CGORUhRr7nS+OOJ5KCwaBi/KVSKTz00EP417/+xcIPgAEy+wtf+AIcDgcbRx0dHdi2bRtefvlllicskUhoLu6qqqpgsVh0WaYJgxmPtLhKJpPo6+vTJKiHUzYlEgl0dnay5LN8tUg9soSeI2+EKARqi3s95xHS6TSampoU71HLw0GN2FG7ttqiPh8pJbqmXhJODUXZNLLQYwROp9Nwu91M5uzbt0+hTySTSTzwwAP4xz/+wSpPAgPVxr785S8zL+9cLoeTJ09i06ZNePHFF5HL5XTJpgsvvBB+v1/XeNJDRKnBaDQiGo3ixIkT2LNnj0I/5DGcsqmnpwebN29GKBRCdXU1KisrJZU9efJFBMqDRAZR/riR+Ib490Dtx+NxrF69WpGHi/IxFeLhz+s9/DX5XJdyj18ihXi9aajyRw2j0Xli9DEFg4DdbsfEiRNxww03oKqqCv/973/ZvlwuJ4zljcfj+P3vf6/Y/vbbb+PgwYOa17viiitQX18PAJgzZw6qqqqGeAf6cOTIETz//PPYvn27Iqmc0+nEjTfeyCoVTZgwQfdH8P73v595hr3wwguSvAzhcBj79+/HX//6V1x44YU477zzhG1UVFTgC1/4Ap5++mlh6M/pRCqVwqFDhzQX6YUgl8vh0UcfVcSki3DFFVdgzJgxw3LdIs4cyMkntUmH4sbLy8sxZswYdHV1KZL9xuNxRSWhcDiMHTt2SHIUUBlYUbJgHuXl5XC73fB4PKioqIDT6VQcQwqGyEKkZSlWa6e3txednZ04duwYwuGwYoE3UvIpm80iFovhxIkTbEFNnhS88mG1WlFTU4Ouri6JMUF+nNb9alm2ClFy5FZ9g8EgXBCTQqNFPvFt8YRke3s7y30lvxavZPn9fjgcDhbuKVImRdcqBPxzGy4ZXIQ28o1JniAwm81wOp1IJpMKD+9gMKjwEurp6cFzzz3HchrRcYcPH86rO1FuJ16pFxG8Irk6WMWeSJxoNMqKFPAYKdmUy+VY7jtAmZ+ENwLYbDYkk0mFF1kymWTpHAoNl85HxuhZzGSzWd1FbPjriv6mOVN+n2rnUt4wNRJcdH96jA1DeR5FDA1yr1s1kN7k9/tRW1uLnp4edHV1SY7p6+tT6ODd3d145plnYLPZ2DV6e3tx6NChvLLJ7/fD5XLB4XAoCiAMFSJjkMFgQDgcRk9PD44fP45QKHTK9aaTJ0+yXGtut5vto2/LYrGgqqoK3d3dErIunU4jHo/D4XAwYlyvvlQI5AS0XJ5EIhFVjzI+1568TV7/Jb0pk8mgq6tLYSCT68oA4PP5WKJxPiRPr9GT74ceFD2fznDceeedmDx5MtauXQsAmkm4jx8/jltuuUV32zy7ftttt2HlypVD73ABiMVi2LRpE770pS9JtlMZ7KqqKvz6178eVN6pj370o/joRz8KALjuuuuYkI/FYszt8Pvf/z66u7sxd+5cdk0eY8eOxe9+9zts27btjCOfRCBLpB7wCiQA9jy0wooIVGGCYDabT2lusCJGBvkmXNpOZaVLSkowZcoUtLa2oru7W+JxIkIsFsOWLVt094cnFsaNG4e6ujrU19cjlUpJKgjxfZOfr6UsaBFPFGrX0tKiSCg8UvIpl8shHo+zSbmtrY0l5ywrKwMw8J2SYmC32zFlyhRs3rxZSD7JXaf1eCbIj81HYBW6cCQySN6WqJ1MJoN4PI5kMolIJIJt27ZpVuYhzJgxAxUVFfB6vUKSUg2FEgH0jIqeTyOPfM9XTuaYTCa43W42fvK10dvbq2pRz3ddp9PJctvRWJB7vqh9M4MlDWihJPcqOBW6EwBJbim32y2R+3T/brcbwWBQsvikfuvpl8iIIPIc0vPt8ecN9luVk4akR2YyGfT39+taTHk8HlitVuYRLEKhZJPIs4r+LsqlkQevN4nmWn7M0HcxYcIEnDx5Er29vXn1pt7eXjz88MO6+8MTC/X19aiqqkIgEGAe5aJxV8i8p+Z9SNsodcKp0psAqWwij+tcLodp06ZJjHG5XA5WqxXjx49HJBKRkE+pVArhcBgul4t92+T5owWRnMoHNTmmZiBTq1osOpb3hItGo9i9e7fCECzC5MmTEQgE4PF44HA4FPOWmjF3KAaU0Saf3lPkEwBceuml7EP+05/+hG9961vD0u4999yDG264AQAkFYNOFa677jq88cYbkm0OhwPbtm1jJdv1kilaePDBB5kCunLlSkl435/+9Cc899xz2L59+2l5BsOJBx54AMuWLdN17O7du3HBBRdItunxegKAj33sY6yCCwBcf/31+MMf/qC7n0WcmUgmk0in03m/OZpokskkrFYrxowZg+rqanR1daG1tVXolTkYULu1tbXwer0wm80IhUIsoaS8P4MFf77JZEIymcSRI0ewY8cO9Pb2So51OBx46623UFVVxaqtDRUPPvggYrEYotEorrzySklOiK6uLvT398PhcKCurg5+v58pWpSDSx42nEgk0NfXJyGI1SDy0hD9rbWNQEoIJY6Xo6GhAdXV1ZrKitlsZt5wb7/9tkRJ05v7au/evdi3bx9TnqqrqzFjxgz4/f4hjxU5yOthNFrxRhPUiHE55PvtdjuqqqpYSIVWCEghcDqdcDgcLEyPviO+LPVIgL6Hvr4+hRFyJHWnbDaLiy66SKI7UZgPX5KblyVyOQ0MLBI7OzuF+UrVoLaoF+3XasNgMDAiWw4qjpGvDUrsLvec07uICoVCkmdit9vh8XhUK+LxbWsR9Wr9HY2hLaMNZAyjcNt8ciqbzcJqtaK+vh41NTXo6+sbVr2prq4OVVVVqK2tZaF66XSa6Ql6yRQ9+3mCIpPJoK+vD7t371ZUJ3Y4HNi6dSvKysqGVTYlEgmk02lccskl2LFjB9vX3d2NUCgEj8eDsrIyuFwulrrAaDSitLRUQcIFg0EcPHgQlZWVeT0shwO83DKbzYhGo8KqzvX19aioqBB6IPF/x2IxlnQeePc969WbDhw4gEOHDrF3WlFRgcmTJ0sqVxOG8mzovkej3vSeI5+sViuzfK9atYptp0SY9957r+6XuGrVKubhtHz5ctbuqURrayvuu+8+Rb6YhQsX4oMf/CATmsMFj8cDYOCDue222/DSSy/h0UcfBTBgwWtra8P3vvc9XHvttbrIm3Xr1uG73/0uvvnNbw5rP4eKqqoqlJeXq+4PBoO45557WD4WkaDTA3klwrVr1+Kb3/wmAGDFihW49NJLB9VuEacX5GVD7r2i0ADevZdAVtxAIACr1YqSkhIWdheLxdDe3q67Dz6fD2VlZfB6vQgEAigpKUFJSQlTFPiQPV5BKEQh19qWSqXQ39+Pffv2IRwOS+TqwoULcf3116OhoQFut1vVcl0oPB4PXC4XUqkUvvrVr+Lll19m8okm6cOHD8NqtcJut7PYfwDCfpAFz+fzsQUIn+RbDUNVtug9JBIJYViL2+2G0+lU9IMsflTlMJlMIhaLaeYl1II8DK67uxt79+6Fw+FAZWUlqqurFYSd3nunMccfLwp7KmJ4IVpEa3kNyRV0k8kkqfCUyWRYCXC9sFgsrIodES7UNzWIPATyQeTVQ99WJpNhoSz8cSOpO9F4l+tOwMC9h8NhOJ1OhSeDSD5Go1F0dHSgoaFh2OQnQe0bpO1Go5FV35KDL05A4D0NMpkMC4cZqsWePzeZTCIcDrMFuWhRPhiZTHJqtC3uRiMoxEntW1ebWwwGAywWC7xeLwwGA1wuF5v7YrGYIiRPCz6fD36/H06nEz6fj3nY8eOVLw7A/5b3V+1/EXiPr2g0ir179wr1pg9+8IOoq6tjHjXDAY/HA7fbjWw2i9tuu02oNzU3NwOAJM8oeY3LwyT7+vpw4MABzJ8/XyEL9HqMD/YYo9HIqgLKjyNDBw96hqQ3HT58GKlUCvF4fNCVmPlE5MCAx93Bgwdht9sRCARY4SC5lyvfHz1emzQHy+ew0YD3HPnEY/78+Zg/fz6AAaHX2tqKxx9/XDe7edlll+H2228fyS5qoqenBzt37sTPf/5zyfaKigqsWLECX/va10bs2gaDAZ/4xCfg9/uxevVqdHR0MAX0V7/6FUpLSzFx4kRUVFRIPqLy8nL4/X5G1mzduhX79+/HV77yldNCPgWDQXR0dCg+XJfLpdqf/v5+HDhwAPfcc8+wljsFBryodu/eDWAgr8/s2bNRWVlZUBWLIk4/aEHGx5ZrQb7AI2WguroaoVAIoVAIwWBQooyoLSDpd1VVFcaNG4eKigoWFmw0GtlExYe2yPug9b9okhNNlJFIBF1dXQqX8bKyMpx33nm444478j6XwYAWH5/85Cfh9/vxyiuvoLu7my26T5w4gdLSUng8HlRVVTHCw+FwsDAO+q7JvZ5XiOWWPJHbtx6vpnznGAwGFlojB+9dIA9fSSQS6O/vx+7du4ddIQmHw2zBmUwm4fV6mcI/WBTJp1MLUWiL1qJOfq7BYIDVaoXNZmOeeeTpqRd2ux1Op1Pi9csr4nq9MdW8W7TOIRI5nU4rjD+BQADnn3/+iOlORHyR7vTaa6+hs7OTyfRoNAqz2czyGfFkD+8VBgx4S3V3d7PQOzUvH7VtIuJa3letbzEWiymeHwBJhSd52/TctQpODBaZTAbRaJRdh4hNLYhksRYRW8TIguZbrVAoNdAc7nA4UFFRgWg0iv7+fgSDQdXcP6J2Kf+mz+djY5n0OQASr0QRKTYY4olHPB5HX18fI3sIp0I2mUwmpjfxsimXy6G1tZUVxyktLWUyy2azsVx99IxCoRALZXa73Yq0BWoyeigyi2+vv79fkfcYeFdvkreZy+WQSCQQCoVw8ODBYf/WI5EIk3nJZJLlXNWCXDZpzc+jUW96T5NPPIxGI+rr67F//37d5wy3talQ3HrrrfjXv/4l2WY0GvHaa6+x0uIjjcsvvxwHDhzA1KlT0dLSwrb/8Ic/xD/+8Q/s2bNHYhl/4okn8Oyzz+L6668/Jf3Lh+9///v47W9/W5BV62c/+xl++ctfDjvxJMcf/vAHPPnkkzhw4ABL9lfE6EA0GkUikci7oFNTVPjxWFpaysKcZs2axRQ0+k2TjsViYQsXPtEhkSfJZFJyPfpf70JPzzH8ZLlu3TpFEk+DwYCHHnoI55xzTt7rDAdWrFiBl19+GZdeeqkk19zevXtx/PhxfPjDH5ZYqaZMmQKXy4WmpiZJO319ffB4PCzxciEeYnLosWjRTygUEobwer1e5uHFl7UPhULYv38/jhw5MuLKyMGDB3Hs2DFccMEFKC0thcPhKNg7gCfycrmcIq9NEcMPuVUWEI9JLRKHJ4qIiCopKVFti9+mRZ7rNbJohXJoLVzpp7e3V0GAGAwGPPnkk5g5c6auPgwVF110EdavX48lS5bgxIkTbHt/fz+i0Sjq6urYooLyblFIMSGbzeLYsWOora1FWVkZotGoInH5YCEKDaF2yQv3+PHjivNowS5/v0Q66ck1N1REo1HE43EEAgEhGcZDr8fvaPQuGG2g8FOt71sLvKHP5XLB7XajtraW5SsiAw3/HvkCB4BUByNvJ3meIDkK8WwSgcafyWTC5s2bFWGDBoMBTzzxxCmTTatWrcJbb72F888/XyKbmpqa0Nraig984AOIxWLI5XKw2WyYMGECXC4XDh06xI7NZrPYsWMHpk6dijFjxiAYDEqKSOSbXwYDg8GAYDCI/fv3Y9euXYr9LpcLdrudVaCj64dCITQ3N+P48eMj/o0fPnwYra2tWLp0KTwej4QMK5R0pWcZiURGnWfmqCWfvvOd7+B973tfQUnBtUAvdzjiZ08V0um00C2QFqGnAiaTSVj1geL55eBd7AmJRAJf+MIX8LGPfQzvf//7R6yvPCKRCG677Ta8+eabkmfY2NiI73//+5gwYYLinFgshttuuw1r165VdcecNWsW7rzzzoL6snv3bvzsZz9TbM9kMujp6cHNN9+Mm2++WRImOhgcPnwY3/3udxUL6yKGH62trTAajaipqQHwrnKhZdlXs5zJ3bxJWZJ/R7yCTefwE6wa0TRcrts8yBNCtMCsqqoqKE/JUOB0OlFfXy8MDaPktpTgOJlMwu/3KxaluVwO/f39bHFstVoV1Qz1Qkux4Rf0mUwGnZ2dioWa3W7H2LFj4XK5mAeH1WpFPB5nIY6UeFUEqlzGV4nirwsoQ2RSqZRwwUju+Nu3b8f48eNRXV0tIcnVvFL4a9A9GAwDIYa7d++WLK6LGH6QJ52evDw8MZjP64D3WNDyysz3DYjOk/+v99tTu57aAtLn850yQw+lgBAZMeXeablcjhkW5Me1tbUxApCXTfLj9MoqtfdDbWQyGTQ1NSlIcaPRyEKZqQon/SbiSSuMxeVyob6+Hi6XC2azWZjnivqRTCaZzJN71hKy2SyCwSDzdqA8QoWA7plCIovVOEcWbW1tMBgMwpQXakYy+dzFk0ciHUdNJ1KrfkZtia5N/xfipSKSkbwHiygU1WAwwO/3nzLZZLPZUF5eLvRgpAJLtC+VSqG0tFQxb2ezWezevRs2mw1OpxMul0sSESDXO7Sgx/vJYDAglUph9erVaGtrkxxns9lQV1cHl8vFcpGSzheJRHDw4EEEg0HV/vh8PkyfPh0+nw9Wq5XJYfk7Jc/zcDiMzs5OljNKjlQqhT179qCurg4VFRWSkOxCdcpEIoH9+/efElJ/ODFqyacXXngBXq932MinswEejweNjY2nnEAzGAyYNm0a0uk02tra8h7v9Xoxa9Ys7Nu3jy1S//Wvf6G6uhqNjY2YMmXKiIaZdXR0oKmpCY888ohCYAYCAdxwww0KAdDV1YX9+/fj0UcfVbia2+12TJo0CQCwbNky3HjjjQX1Z8OGDXjhhRcADMQG8x5kyWQSjz/+OBobG1FXV4fJkycPmizo6ekpqNJHEYNHMBhkBEsh70uNEOLJJz4EQ04oEenEE09qx+ZbTKot/OTHyY/J5QZyFsgVdZJPfr//lFV0pDwQ06dPRyaTkcinbDaLUCgEi8UCq9WKVCoFl8vFKruRZQ8YWLATca5Xvg7WgpZOp5FMJhEKhRRtWK1W1NXVSZQfyqHS2dmJtrY24QKJyDc+1xWNDX6xyo+RXG4glwAlWeXHFn+PbW1tcDgcsFgskkqnpGDqGUfAgEJWSE6zIgYH8pjkISKZ8hFPImJRFFahFpKiRkzy+/NZx/PJVtE3KCJnSDZ5vd68oVrDBcqdpaY78dZ5CiPjiR1Cf38/ent74XQ6UVVVBUCb+NX6Ox9osUZVsHgQ+STX3cgQKQofNhqNjAwvLS1FXV0dSxrOk0/yOS6RSCAWi6Gnpwf9/f2q10gkEmz+UzPIqhmFeJDncBEji1AoxIw/hcwdcvBkAP2v1ZbIACOfC2l7PrkzGP2c2o3FYqp6k9frFRr6RwJkpBLpTblcDuFwGB6Ph6UocDqdrLIbVe/M5XJob29HS0sLq+Ysf875DAN6ZZbBYEA0GkVvby8OHDig8J62WCyoqqqS6E3ZbJbJkPb2doXnkMlkQklJCcxmM6qqqjBt2jQEAgFG8ouMxtRmf38/Wltb0d7ezvJH8fnx6NkQKe5yuTTfBz8X89cEBuYJUYjhmY5RSz4VocT555+P55577pRf12Qy4T//+Q/uvfdeXV4/K1aswObNmzF16lRJWM5vfvMbPPHEE2hubh5RAu2vf/0rvvGNbxR0zqOPPoovf/nLwn1TpkwpqOy9HAsWLGAM+cMPP4yPf/zjimN+8pOf4J///Cf27dt32sM9i9AHkWVHz2JJNMmIQimoff5Yo9HIlHY1AkvkfaJVzlyrr3IQGXL8+HEFsXumyadMJoOTJ0/C7XYzV2y3242KigrMmTMHmzdvlixmQqEQotEoHA4HSwyfTqcV+Qzkf+sFvftQKKSqTJASReSew+HAyZMncfToUUWII8FsNsPn87EE82R9lBNOci8oGhcOhwNOp5NZPOXVqQCgubkZ7e3tLByQ9zLIRyDIc2oUMfJQ83YTkUOFLPjkXgV0Lf63/G/+XJGlXe1bKtTzidrmS4kTzjTZRAs88gIiOWOxWODxeBAKhST3cPz4cXR2duL8889nidzVcufo8SJQ6+uRI0ewb98+4X6DwcASM9PxyWQS0WhU1ZvR6XRiwYIFrMAGeUmRx6XIYGIwGBhZ5ff7MWHCBPT29uLYsWOSKl0EKrhA3lQiw6baWBqsoa+IwYOMHGpjV40IF23n9SYt2cRvU2tbTQfTcz/5xhHNgSdOnFB4sJxpsimdTuP48eMYP348bDYb4vE4nE4nysrKMGPGDOzYsUNSfGLXrl04cuQIampqWJ4/fq6Xy6N8BJXomZvNZuzZswevv/668F4sFgsCgQASiQSy2Szsdjs6Oztx/Phx1cqIpaWluOqqq1BbWwu73c48LimRPW/UJZBsKi8vR2VlJRYsWIATJ05g586deOWVVxTXOHbsGLq6ulhKh3yGD9H4G23hdoRiFuNRiPb2dlx00UXCD03vwnE4oXbN9vZ2rFq1CmvWrNF1PDDgYXTJJZfg5ZdfHvZ+plIpfPCDH8T9998v3P+DH/wAv/3tbyV9y2QyuOGGG3DfffcJz/n2t7+NP/7xjwAG/+x5pf2iiy7Cf//7X2HlxNbWVqxcuRJvvfVWwdco4tSDXJSHIweHnBSg35SrgH54AoG8VPgQMSKnyIuHEmzzBEo2m1W4fssVOPkPf814PI6dO3cKSYozST6lUik0NTWhp6cH6XQaFouFWcrHjRsnVASIWAsGg6w0OqCs0sUrJiIlRa1/J06cEOZ4AgZIbsr5Re8sFothz549aG1tFZ7j8XhY4lTKEyYfN/LxSZ518jwXREQFAgHhAi4Wi+Gtt95iVWbknjBaJMJoVqLeK5B/8yLwciedTrOqn3JvIzUlms7hzxUtTuTnqm0Tbe/r6xN6sZxJsonCvCh0jSd0RMnFgQGvpE2bNqG1tRXRaFRVNokIRkC8COT7s2XLFhw7dkx4Hy6XiyXQ5WUGJR4WYcqUKVi4cCHKysqYNxMRTpTOQZ7HkEh/ItFTqRTzWG1oaMAFF1ygmgair69PEfan930P1ou1iMLBk09a3kpq8kjNSEd6Df2mv0WySa1NuV4luma+sSIi/nO5HAvFOtP1pnQ6jebmZkSjUbY/lUrBbDajpqZG6GEYi8Xwz3/+E7t27WKpDgAo9ANeZ+Ir6hH4d0nHZrNZPP3009i6davwPsaPH4/Jkycz71GDwYB4PI6mpibVSJ1ly5bh6quvRm1tLYABz3fK9WmxWFgor9VqZT984nVKiROPx1FaWoq5c+fiE5/4hLCIVTwex6ZNmzTTJYhAHrCjVW8qej6NQiQSCaxevVriWrhgwQLMnTv3NPYKGDduHC688EKsWbMGmUwG8Xgca9asUbXiL1u2DBaLBXv37mXbkskk1qxZg3PPPRculwuLFy8eFqHb1taGLVu24PXXX1eUXXU4HFi2bBkuvPBCzJs3j21vb2/Hli1b8Nprr0mSFQMDMcTnnXceVq5ciQULFgy5f4SqqiqUlZXh4osvxqZNm3DgwAG2LxaLYc2aNXj55ZdhNptx7rnnDtt1ixh+0GKKJmN+ctUDreO0lDK1vsiP06u45bsmb9mj8Ie+vj7JuTNmzMC0adM0+zjSqKurw+LFi7FhwwZGroXDYVZS1+FwMAXD6XSyvBPyMNtYLMbcrkUKElCYFxQpw4lEQhiuaDQa4fV6WaXQTCYDs9mMWCyGjo4O9PT0CMvc2+12Sa4TNWuyXtCikMJr5BXOstksuru7cfLkSZhMJlRUVOhul4ixIk4NaDzIvfYK8QDRWnDlG/OFykCRrJF7FIj6IJdttMjjMXv2bMyYMUNXf0YK9fX1WLZsGd555x32/avlfqFqnvLvL5fLobe3F263W/Kt8gYCvaDj0+k0EokEq1wqytlkNpsVeVAo90kqlRIS8+Xl5aioqIDf72eeXfxClK/sp0V0EkwmE1wuFxwOB6qrq9HT06OQ21SV0WAwFBS+pEWcFzH8oHEn15sKgdbx+XQaNX1IHp5Ov+Ve44V+ZwTKQcmfP2vWLEyfPl13eyOB+vp6LF26FOvWrWMyKRKJIJlMMp2C3hGfK4r//shoV1ZWxgxfZECTh/4D6voTTziRVyVVVJZ7jBmNRrjdbpSVlbHqfEajEYlEAj09PQgGgwq9yWQyYdy4cWhoaEBNTQ0sFguTYSRTqR88+PEgN3yYzWaUlpbC7XZj4sSJaG1tlaxBs9ksent70dnZybym6Hny40009kaz3lQkn4aIwU5Mw81k33vvvTjvvPOGrb3B4LrrrsOqVaswduxY9Pf3ax5rMpnw4IMP4ne/+x2+9KUvKZ7hPffcgxdffBFbt24VKpF6wL+b119/HTfccIPwuJqaGrzwwgsKxv6tt97CtddeKzynvLwczz///IjEYFssFjzyyCP42c9+hrvuukvxbH7wgx/gpZdewttvvz3s1y5i+EBeQGQR1iMntBZ5on2iSUrubcNXx0ulUsyjgCZTWjyQ1YZKfPMeU6K+yydcmthFIRZf//rXsXz58rz3P5K49NJLMXXqVCxbtkwSfx+PxxGPx1lJYCINFyxYgAMHDghDaql8czqdRklJiYTgkXv8EOTeQvR+YrEYwuGwghQnWK1WzJgxA+Xl5bBarcyrobe3F++8847wHCJ/6H2LSrWrQW1M0b5sNouysjJWxlqOHTt24OTJk7j88ss1E7PzZCxZCYs4NZCTT2ooREcRzdH5CHT54k0LIk86nlgRjW35dtG1vvOd7+D888/X1YeRwvvf/37MmzcPc+fOlSzaRPqlwTCQGD0SiQi9JFtaWtDZ2YlEIoHKyko4nU7mPSXy9JCDJyT7+/vR3t4uqWIlP9bj8cBqtUqSjKdSKfT29grPsdvtWLFiBetPMplUeO3KCXiR0YTfTvOZ0WjEsmXLsGfPHqEnRH9/P6xWqyShtRYZAaAYEnyKQYYYIjO1dI980Fo3qBFPvNcNXZ9PBM4fwxOl1AZ9Y6KKj/z9yIkt0Rj7f//v/5122XTFFVdgzpw5mDdvnkRvSiaTkpxq9N3OmzcPhw4dEibb3r59Ow4dOoQlS5Zg8uTJKCkpYYQO73GvJp8opUQ2m0VnZycOHDigug6yWCyYMmUKC+mNxWKw2+0IBoPYtGmT8ByXy4WPf/zj7Jun+6PxoOYlx/8tN+oS+W4ymfCRj3wEq1evxosvvqi49t69e9HZ2YlVq1ZJxpoaDAaDai690YAi+TREdHd346KLLhJantVQWlqKV155ReiC917Dhz/8YSxcuBCrVq1SLGSampqYRXLRokX43//9X1WXcxE2bdqEm266CQBUybC77roLn/jEJwrKo3T77bfjc5/73IgnJr355ptx/vnnY9WqVaOukkERA5bWUCgkIZ/kVrJ8yHeMWq6mSCSCUCiEvr4+7Nq1iyk2Ipdv/lyDYcCteNGiRfB6vcy9WDQZ8gs7uje1ymi1tbWorq7Oe78jCY/Hg5qaGsUClJQo+bO22+2YMGECysvL8dprryms/ul0Gl1dXejt7YXVaoXb7WYEFj1HfpHMu4wT4UWu1mqu07W1taipqUF1dTXzKnM6nQiHwxJFkAd5AESjUQmZqIV8ni38NnIrp7HR2dmpaD+dTqO3txclJSVsUapW1ctkMiEWiymqDBYxsiAPusGClwdq5KKcwOQXKalUSkheasFgMKCsrIyFXwHKsDL58VqkBgD4/f5TVn1TDXa7HT6fT/EceeJDLrcdDgdMJhN6enoU318ikcDBgwdx+PBhuFwuVFdXo7S0lBkZ+PdOC6psNsvkdzAYxNGjRzUt6zabDXa7HQ6Hg4UwUZ4ntap2EydOxPjx4yWLTD6Bumg8Dcbw2NjYiPLycrz66qvC5Pp8yLRW27TQLZJPpw7pdJoltAakVeuGE3LDkMlkQjweRzQaRTgcxq5duxRkN0E0Ji0WCxYsWACPxwO73c5C3fXMvZRHSI5AICBMwXEq4XA4mMcSD9KbHA4H20b6wZgxY+DxePDOO+8o5Ec0GsVbb72FTZs2wefzYcqUKaitrYXD4YDdbmcGfV5mE0l98uRJnDx5Elu2bGGFWUSoqqpCZWUlKisrmd7kcDgQDAYVHpGEc889F/PmzZN4YdL3D7yra8vJRv7eeYgMj5lMBgsWLEBjYyP++Mc/CnXKYDAIl8ulWrCFb5PG62jEqCafmpub8de//hXXX3993mzxw4WmpiasXbuW/d/f349du3YV5Prmcrnw17/+FTabDV6vF9dee+2IVnc7k+H3++F0OvHxj38ca9askSSMTCQSkpC8v/3tbyxprh7s379fcj4Pq9WKD33oQ7jwwgsxceJExf7nnnsOr776qmSb2WzGhz70IaxatYpVtxtJBAIB2O12fOITn8Drr78uSfTZ0dGBP//5z7jyyiuFZWnleP3117F69eoR7G0RcsRiMbS1taGqqkoykQzWA0rrWHJVp2TV8XicedQUGktuMpnQ3NwMl8sFp9OJ6upqlvhWHvYiL5lLCxg5KGfH6YTJZFLN46Qmv6kyXENDA9rb2xWLZVoc8qEypJzIyRbeHZsSV6opTwaDAZWVlSwMl3dNNxgMOHnypDCcmfIOmM1mScJhuZIkUmrUxpyW8kN5oBKJhGSBFo/HcfjwYUyfPh12ux3ZbFY1jMJgMKCrq0sR2lzEyIGsunzVHkK+UCe5x6PaeKJjCLRYIKKDPDELgcFgkJCqVDWTJ5n4vvHnqeXHoETUpxO0+JWDr1zKg543VZhMJBKKEDwyiFLFSvKY5Ik7XibRHELeq2rkNjAgZ/iQXh4iuWYwGFBRUYGysrIhlRWXtylCLpeDzWZDaWkp6uvr0dXVJbkXqkhFYyjfNVKpVEHG5SKGhng8js7OTlRWVqqGtfPQ42UJiOcdg8HAwt16enoYoUIEbKF609GjR+F0OuFwOFBZWcmS/9P16boi2aQW0nqmyiY+3xpPsuVyOVitVvh8PowZMwZdXV0S4382m0UkEkEkEmEebsFgUKK7UDu8wY6MuT09Peju7hb21WAwoLy8HOXl5fD5fCyRO6Grqws9PT2KcxoaGlBfX8/yzxXy3vNBPi4psfj06dNx7NgxSX8SiQSOHTuGCRMmsCTnvL4tb4vC9UYjRjX5tGHDBmzduhWrVq0acfKJJvPXXnsNX/ziF4fUViQSwS233AJgwEJz2WWXsfj8kazydqbCbrfjN7/5Db7zne9g//79AMDcXAl79+4d8nMnmEwm+P1+/Pa3v2XWFTl+/OMfY/369Yp+3nfffafUSup2u/G73/0OX/ziFyXk06FDh3DzzTdjw4YNusinP/zhD/jnP/85kl0tQoZwOIxDhw5h5syZquGZWhYUvVYVmixjsRiOHDmCzZs3D6nfmUwGu3btAjAw5ufNm4exY8fC6/VK+kKEAt9f8mgYTeCTj/Ig13m73Y65c+di586dCIfDQk+lTCaj6Y1UCGhROXnyZPh8PpaLChhQBNPpNA4dOiRUoqjSnMEgLS0uUrz1Qq4AUT+AgWfk9XrR398vscBFo1Fs374d48ePh8PhEIZD8Th+/Diam5t196mIoSGTySAajbL8QDz0LPREkIeT8GEslANILRRLL3K5HCOATSYTAoGAxCCVjzgbbclZyeuG96IEpN9haWkp+vv7VS365DEwXKBcKhQqJ3+msVhMMQcYjUZMnDgRpaWl7By5TNEjk/ItxvhtZrMZs2bNwo4dOyRyOZPJIBQKMc+xfCBDThGnBtFoFEePHsWUKVMkepNeuaTHiEIGIkoVcOLECWzfvn1I/c5kMtizZw+AAb1pwYIFLOxV5DHO92s06k2UQ40IHt4AaTAYYLfbMXv2bOzZs4fpTfJ5PxKJqFbPLBSkN02YMAEejwc2m409U5I5x48fV8xBJpMJixYtQlVVFUwmk+Q95JNN+eSRmt5kNpuxcuVKvPLKKxI9LhaLYffu3airq5N4lImuCwzkMlYrAnGmY1STT6cSuVwOq1atws6dO4e13SNHjmDChAkAgPnz5+Pf//73sLY/mvD1r3+dkXJf+tKX8OSTT47IdT7/+c/ju9/97inzlivivQs1d+18eSbytUnnUMWz1tZWbN26dVjIDx7xeBwbNmzA5s2bUVZWhqVLl6Kqqorts9lsbGLn8yWNJogWdaSYAu+SbOeccw6mT5+O48ePY//+/ao5moaKcePGYcqUKSgtLWWeCHyIUTQaVV1Ek/FCns9nuDwM+BAmAHkt01QlRr7I49sZTitjEacW+bwOMpkMYrEY+vv7h10uZDIZZvW12WyoqKjQ9CAfjZWB+PwxWqFfbrcbTqcTqVQK4XBY1aNyqHA4HIzgJk9MPkeUWh/J84lCswtJc1AoeJlSWlqqatAtyp4zG1r5Agl6SGcRcrkc87DavXv3sId8x+NxrFu3DkajEX6/H0uWLIHH42GedPLxrxVCdqaCPJ8o1FZOxJDeNHXqVIwfPx5dXV1obm5W9VoaKurq6hjxRGQeL5tisZhQPlF1Y5PJxHI8jRR4A0hVVZVq6h0q1sB7gQFQkJijWX4Vyac8+Nvf/oajR48il8uhqalJM5F2IBDAF77wBeG+TCaD3/zmN4rFYSaTQXt7O4CBRK133303Pv3pT7MSj+8leDwe5on0kY98hFXHeuihh3DkyJEhtT19+nRcc801AAaq7OmtxERYsGABrrrqKubmf6rxvve9DyaTCb/97W9HtcB5LyKRSLDKHloThlbYipy0ot/79+9Hb28vgsEgwuGw5gLP7XZj+fLlkhA68ugMBoNYu3atUAEiJaOnpwe7d+9m3i42m03hTUDeDqMNekKNyP08EAggl8uhoqIC4XAY7e3tQw7L8Hg8qK6uhtVqZaHIpCjxYU1q5BMljafj1EKh8t0nodB3aLPZWDgLj3A4DJfLBa/Xqwg7oH7KQ/aKOHUgYiNfyJwIaqQ6fSvhcJh5MPN5NEQoLS3Fddddx5L3U98ikQi6u7vx7LPPCr1P6DtIJpMsdMNsNsNisbAxxSf+PVvnTr7AhMvlgtVqZQvaoRJuJpMJNpsNRqMRFotFkkNOPkZEOW7cbjfKy8t1h0cBYm/LQj2laH8gEEAsFlN4CJDHqzwsij83X3L2IkYOlJdLjagsxJOXH3tGoxGHDx9GX18fC//S0ptKS0tx/fXXo6SkhM2x5Dna3d2NZ555RiibyIOmr68Pe/bswbhx41geTT7HmcggORqgV9cj3besrAzZbBZ+v59VqRuq3uRyuVBRUQGz2Qyfz8dC/An59KaysjKMGTMmr27OtyWXEyK9Rg412TV27FiEQiEWaUCIx+MsLF6kB5LeNNqMKTyK5JMKqFrH/fffr1pRyOl0SrxnJk2ahO9///tC5jSZTOK5556TuD+HQiFJpvqWlhZ873vfw6JFi+B2u1FSUjKMdzS6cO2117JKc7t27ZJYJuLxuKqLOYXUybF06VLcfffdea9L713uAnvuuefi29/+diG3MKy44oorMHnyZPzud7+TCD8iHt7LY+VMB3kI0cSoNWnnC4HhleJEIoE9e/aoxnzTNSkspbKyEtdffz0qKioYcUT5DlpbW3HkyBFW6jeRSDDrC4Fcgh0OB2pra1FfXy/xJqD7Go3kE0GugIj+LikpgdfrRTKZREdHB+LxOAsFouehRaZQqCL/rMrKyjB16lTmak05DiivEi2S6H3J2zebzZLwNt6zSE1J55WpfOFU+fZTtSu5Ek7JM30+H7sfPuzGYDCoWiSLGHnw3iui0Eh+fOghLvn90WhUdXHhdDol4Shjx47Fl770JdTW1sLpdCKXG8g/1N3dzSpOUrhEKpVCNBqVEOWZTAZ9fX1scScPcx7NMkkU2kbb5f/TQs9mszHiiSf+8i1wRbLCYrHA5XKpkgD8+EilUopreL1ejBkzRiKP1Cz58vHGH1MImc4T8BUVFTCZTAryiXJhkRcXncf3X0/C6CJGBolEguUB4hfgasinU9G7pbB1Nc9lkWy69dZbUVdXx2RTMplEd3c3Dh48iM2bN2vKplgshr1798JsNqOmpoblSOJ1gNGoN5FuoqbTynUQr9cLp9PJnl08HpeE6uXzTKUwX/5aPp8PjY2NzAOfdFq5AS6bzSIUCinaLy8vx+zZsxV6E/1NEBFP/Hb5PcvPlz8X6tO4ceNgsViwe/duSduhUAgulwslJSVIpVKMNOU92uPx+KjWm4rkkwp2796NJUuWaDKzt99+O771rW+x/9UsiMDABL5+/XrJALvtttvwpz/9SXHslVdeiWuuuQaPPPLIEO7g7MGjjz4q+cj+/ve/q3qYNTY2YsuWLYr3oDdp39atW7FixYpRU76yOFbOfPT19cFmszFvFj1Khmgy52VHX18fnn/+ec3J5+qrr8YNN9yAefPmMWu4KGE/KQif/exnEY1G0dfXh+eeew7//Oc/hcT7li1bcOzYMfT19WH27NkS0sFsNo+6vHV8Qk3RQkNOQNH/VqsVY8aMQX19PdLpNGKxGPr6+tDa2ooDBw4Ir2W32zF9+nS4XC7Y7Xa2qCPlgs/txJcwJkSjUWzZskWhRJF3Ak/w5EMhngiiZ8H/r7Yw3blzJyKRCMaNG8fmUpPJJElAfvLkyVEjb8820HgRvT/5+NA7TlKplLACIo8vfvGL+NrXvsbyyBmNRmHyc4/Hg7Fjx2Lbtm1s4bh+/Xr85je/EaYo6O/vRzKZhMFgYLKOvtmRDPUaKVDCYdHiSA66T1oQ2e12iXdqOp3WrI7E53IymUwFJTqmxZSoeiFVy9IbGjWci/BsNguHwyE0zvX398PpdAq92akPo32BN5oRCoXYHJlOpwc9LvhxFwwGhRUQedxyyy2444474Ha7AYhlk81mg9vtxpgxYySyadOmTfjVr36F5557TtHurl27mJc0edsQmWCxWDRz/JyJsFqtkkrIcsj1JjJkWq1WVFdXo7KykqUVCIVCaG9vx+HDh4XXstlsmDRpEvteXS6XhIjiqzHLvYyoKtzOnTuFXpk1NTVCworHcMokaj+TycDr9QpzfVGeLKoQzd8X/R4Oz7HTiVFPPmUyGdx555249tprcd111w1Lm3/84x/xn//8R+hKuWzZMtx0000AgLlz56rGbMphMBgUwuWmm27CuHHj8P/+3/+TfBSJRALvvPMOPvvZz+InP/kJAoHAEO5m9EO+mL3ggguEpB0w4JUgT/BXCEShI2cyEomEZqx4d3c37rrrLmzcuPEU9qoIQi6Xw9GjR2E2m4Ulc0ULu3yW3P379+P48eNCBWrChAlYunQp5syZgxkzZmDSpElwOBxssuOtVHKCixYfdrsdF198Merq6rB161b89Kc/lcgnWmQ0NTUhEAigpKREQnyoJVc/U2GxWCQha3IFRb6NV27omeZyAxWW/H4/7Ha7qsw2Go3w+XxsgceHsGiVlOYXllrWwXxKoPy++P1aXgdq0FoM8/0WXQcY8D7Yv3+/qidrESOLeDzOvlm58l4ojEYjIpEIYrGYcEzMmTMHV155JaqrqzF37lz4/f681WtpH+8ROHPmTHz5y1/G4sWLFboTMEB+kTcwhe1QbpLRRkDxnoJquUj0eDPRAlcun+VeRbxXpqhtte9dK2SFrs97cpKsky/01OSslveTGnjSkQh+NfJcfg36HY1Gi+TTaUAul8Px48dhMpmExGE+fUl0fHNzM9ra2oTvc+7cubjqqqtQVVWFuXPnwufzSYqpqLUJSGXT9OnTceutt2LRokUK2ZTL5dDf34+mpibm1eJwOJhsGm3kE1Uwloe5AfrfCXlqms1m2O12RdQKfbNGoxFer5cV5uK/VTXjIP+/mnwyGAaqEqfTaYVs4iGXSyKdiY7TI7fofLVqhnK9Sa6XkffecOd4PZUY9eRTNpvFY489hjFjxgwb+fT666/jmWeeUWxvaGjA8uXLcfPNNw/LdZYuXYq6ujo8/PDDjPQg1+AjR47gL3/5Cz70oQ9hxowZqKys1Gzr2LFjOH78OOrq6oalb4NBT08PDh06NOJxqJMnT8bkyZNH9BpnCyKRCP7yl7+MuiTQZxO6u7tRWVkpVKzpb71KdTqdxokTJ4QVLiorKzF79my8//3vx4UXXgin0wmj0chi3cm6w+cHkS/GzGYznE4npkyZgjFjxmDSpEl4+umnEQwGmVcUMEB6njx5Eq2trcjlcqiqqmILJNFkeibLJ558IqgRMvIFDE/okbeA0+lEIBAQKhtEHvFEEq9cjISFLR8KUeTzkU1q/RAtYoGB8Xzy5MmC2yxieJBKpRT5mESKst5xGY/HhV5s48aNw+LFi/HhD38YEyZMGHT5cKPRiKqqKlRVVWHSpEl4+OGHEY1GEY1GWfgxJTl3OBxMHtE9iAicM1k2UZ+1CBA1clx+DMkoNfJJ/rsQIjsf5H0UkT1aY0x0jNq4lB+r9t7zIZfLjWrPgtGO3t5eBAIBXeuJfCQR5dZtbW1V7B83bhyWLFmCj370oxg3btyQZFNlZSUuuugiVdkUj8fR1taGjo4OmM1muFwuZLNZxXdJOJNlE+XWUwtZJYgIX34b6U0OhwN+v19I/PC6Ev+brqsFPcQ4T+7Ljxf1R04qiQxrarKJZDGvN+brv/z/dDqNjo6OUa03jXry6VTBYDDg+eefx5QpU4a13TFjxrBkY2+//TbOO+88ti+TyeCiiy7CV77yFfx//9//p9nOxz72MVx++eVCd89ThQcffBB33nnnqP4giihiJEBhD2oEg55FfyaTQUtLi7Ayi8FgwN13343Fixdj+vTpTOmh5ODUvtzzSU0pj0ajsFqtmDlzJnbt2oWnn34ar776Kn7/+99Ljlu3bh2mTJnCCBeyhslxJssnyo0lWhCJwCsYfHgKuX7LvZRECdn5ccArPYShLPKGcv5gkI84y2azrCQzjWOyNhbD7c4MaCnbeokntQSoBoMBTz75JKZNmzasIbmkO23evBmrV6/G17/+dcn+np4elJSUsLAqtTF6JssmssYPF0ReCjxERpGhgp9n5Bb94Sbb811fDyj/WdHj6fSDihUMlhCiRX5bW5swosFgMOCZZ57B1KlThXrLYEGyacuWLVizZg3uuOMOyf6NGzdi6tSpKCkpEZLChDNZNlmtVlitVklVOTWo6TZyYkm+jcDL7kL1Ji3yiTeWynW3wXhbFgLy6FIb2/QM+H5Q3s+zgRQfuZqCoxBdXV14//vfjzVr1ki2z58/H88//zzq6+uHfRDSxKimZORyOTzzzDO47rrrNF3stD6wU4UzoQ9FFHEmIh6Po6+vT5JbSG9uHmDAQyQcDmPXrl2KvBoTJ07ED3/4Q1xwwQWorq5Gb28vDAYDbDYbHA4HksmkJIF4Op1mP1TJLplMIpVKsQnfbrezkDCDwYClS5figgsuEPatpaUFb7zxBqvqJ3IfPxNkg1ofbDYbbDYb8w5U81ji25B7Mql5LJB1kH7IbVzelsjjQGvfcD0P/m9R+/lIOFLu6X+16/C5zmjsU66HIk4veGIcKHyc0RgIBoOK/BVz587F008/jcbGRpY3Zbh0KPrGJk2axCrjyhGJRNDe3i4h3+U4k2UTyRYigoazn3IiXMtjStTfQqDneL3yTr5dq+3BPi8iPYo4vUgmkwiHw5L8h4XIDyrMsm/fPoXeNG/ePDz77LNoaGhQhJsOFSSbJk6ciKlTpwqPOXbsGNasWaNZcfRMlk388yrkm5QfQ++UXwdTIQCLxcJC8+TvZzDXFPWB9z4X6UT832p6mqgPam1q7Rf1TT4u4vE4+vv7C77XMw1nDfl07NgxrF27dtATRnNzM15//XW8+OKLaGtrY9tnz56NCy+8EJdddhlLQDdS8Hq9WL58OTwej2T7kSNH8PLLL7N7s9lsOP/881FeXj6i/RkqRks/z1YcOnQI69atO+2TVxFgpWVpAhUpUWqKj8FgQH9/P9ra2tDT0yPJ8VVbW4vZs2fj4osvRmVlJauox0/oapYlrcmRcmQQqqqqMHXqVKF8ikQiaGtrY4lsyX1abknMZDKIRCKnvDxsLpdDOBxW5EYzGo0oLS2F3W5nrtf8OfK/tX5rKRJ6FnBq72EoCy093nSi89SUqqEowvLxbjAYEAqF0NHRMaj2ihg+ZDIZzbyBWjAYDEin00gmk6y6GmHChAk499xzcemll8Lj8QyrBw+PkpISjB07Viib0uk0otGoZOzZbDZFXyjtwemQTbFYTJh0lk+YrocA0vNtFrK4zifT+GMGCz3n65F/w63jUCLkIk4vYrEYenp6VPfnC7eLRCLo6OhQVLCeOHEiFi1ahMsuu2zEZdOYMWNU9aYTJ06wdZ3JZEJZWZnCA+p0yqZoNKqQTUajkeXTy3d+PhmlpS9pEeNqpFC+66v1Uw/0kOJqbQ5Vf+K9UMPhMLq7u0f9uu6sIZ8ee+wxvP/97x90suj7778fH/zgBxXk1a9+9Sv8/Oc/H44u5sWMGTPw+uuvq4b20eCtrKzEq6++KvREOF1MueiaVVVVePXVV7F8+fJT3p8igN///vf40Ic+VHQfPwPQ0dGBnTt3CnNsaH2vRCA1Nzfj7bffVhx7/fXX4xOf+ATmz5/Pks97PB62oEwmkxIrElmS+B/KeUSeObncuyEHPFk2ffp0VfmUy+XQ1dWFdDoNr9eL+fPnK5JHxmIxHD16VLjQGmk0NzcriA6r1Yp58+axPAPyiidaCoYWYcOXDSYLejqdZvmhROF5orYKhZYirkc5kyt5eheq1IbW8UTu8ccePXoUW7ZsGfVK1GhHMpkctAeawWBANBoVLhBvu+02fOlLXxKSPcONfLoT8O44raioUIT/xeNxyULwVKKtrY3l0iNQYQKLxaK5QOO/YS2vAH672raR+g4LIdDl52jNk8Ot6/JtxePxolfmGYDu7m7s27dPc4yqeexZLBYcPXoUGzZsUJxHsilfUvHhgJZs4gkem82GRYsWKQrTxONxtLa2nhbZdPz4cYVst1qtmDNnDkpKSnTpsXq/W153ymQy7EdkOFXDYEkeLbJISw6pGeq07lWvkVDuWUY4ceIE9uzZo/vezlScNeTT2QKDwYCHHnoI99xzj2R7OBzGihUr8PDDD6ue++abb2L+/PnCZMQjiXQ6jcsvvzxvXqoiingvg6zcuVxOEtKWL1+OyPpEWLx4MebMmYP+/n5YrVaYTCYkEglW4UcU4iXvk5wQoRwEcus2nfujH/0It912m6SddDqNN998E4cPH0Ymk0F1dbUi/G7z5s24/vrrJZ6lpwKZTAZf+cpX8Mgjj0i2k6WR8g9RYuJ8ykU+yAkc+TserLKrx0NAS5HRghbplE/Zy5dnitzoqW2DwYB4PF4MaznDMBjLupai39jYiPHjxw+1W7qhpjvlcjm0t7cjEokwMl8+xjdu3Iirr74aJ06cOGX9BQZk02c+8xn89a9/lWw3GAwsTFG0WClEHskJZjmGQx7lW3ySMUNrkTZSEIVFi8CHEZ9qL5Mi1EF6EyXmJuQztiSTSVXD6/jx4zFu3Ljh7qoq1GRTOp3GmjVrcPToUQCAz+dTeD5t3LgRH/jAB06LbPrCF76Av//975LtRqMRfr8fZrN5xAzbwxkCqQXSfQFtHXm4IDI+5ysmQb/PNr2pSD6pwOfz4cMf/jAqKipO+bUnT56MhoYGybZsNosdO3agvb2dbVuyZAkuueQS9n9/fz+2bt2KJ598Ehs2bDglfT169Cgee+wxbNiwQSIcqazyqRAgRRQxGpDL5RCJRFhZV5HFWhSKJwrLcLlcWLx4McaOHQuv18sSOsvb1Ut4FPKdzpw5E5MmTVJs7+/vRyQSQSqVgsvlQnl5OQKBANsfDoexd+9ePPXUU6dcPu3cuZNVnAEGnt//396ZR8lR3ff+2/s2S8+i2bWPJARCgLEdwPAMDvJTHMsOwcHOeSex8+zYMQnhvThGtt85JiFwchx8bBwc82yMTeLYJBG2IYfHImQwGBASEkL7MpJmpFk1+/T0XlVd74/JLaqrb1Xd6mV6lt/nnDndXXXr1u2eql/97vf+7u82NTUhHA7n5S0yjnLxXhnFjOhbleWNsImO5Nm1UXQ0kHd+s/YYr1+r+o3X1+zsbNFTvYjKwARoJ46/flSaUVdXh49+9KPo7OzUkn3PFzzfCYCWz44JN2yRAUY8Hsfx48erYpsOHz6cF5Xp8/m0BRAAczFYJNLA7H7mHeM0ctJJZKRxSrOV/SsmcsHJ+e1g9wGxcEgmk1AUJc+/MYMJzLyOel1dHXbs2LGgbFMsFtPENa/Xi6amprxUJQvJNtXW1mLFihXalDs7MVk0YolhlaLAzpbZ+Wc8jOKPqL3knc9smxnM73SykmkikVgyftOSE5+s1G4eZgr5mjVr8LOf/cw0kWWlcbvdtnNq7777bjzwwAN521RVxZe+9CU8+uijyGazFX2ISpKE119/HX/0R3+EiYmJvH1//Md/jH/8x3+0XUZyocHCdReLaOb1egt+Y7tRH6I6qOrc1LRMJmPpROkFI4/Hg1gsVpB/YsWKFbjrrru0pYGZY2ZcuEBflz5pI287+8yLxtKXa29vR2trK/fezmazSKfTCIVCWL9+PTZt2lTwGywE+9Ta2ooNGzYgHA4DKFwFSlRwMitj9t5K0LE6hmElDJTaQWTlnQoQdnk3eKLo6Ogod9VGonqwnE0i/3d2fciyXNCx7+rqwkMPPYTu7u5KNdUSO99JVVXU1NSgvr6+YPtCsE3hcBj19fWmKwda3f9G21HMPVwJ8YfXwdOfy0knz0q8MtapX7lOxD6S77TwUFUV09PTkCTJtj+hf97w/Kauri585zvfWXC2SS9CrF27tmCK3kKxTe3t7Xk+nch9KyJQmb23Ol5fXkQ04tlC9rvbDaBZ1ctrg9X3Ze9ZqgezWQ3GCF2Xy4Wpqakls0LwkhKfZmZmsHXr1oIwQSsSiQSuueYafP/7369gy5yzfft2nDlzBl1dXUUd/8QTT2DLli2Ympoqc8vmUFUVH//4x3HXXXdVpP5qcfXVV+P8+fO4+uqrq90UIZ566il873vfy9sWj8dxzTXX4Ic//GGVWkXwUBQFhw8f1iJwjA8yoyikqioymUxBVCEwF7lz0003wePxIJ1OIxwOa/PjzUaOWJQCm1bAHpjGOfUiXHvttXj00UfzIpuAubxOMzMzUBQFTU1NaG1t5R5fbfvU0NCA9vZ27UHOOilWzsdCIBwOY+vWrZpoxsjlciXn0tKLQ+yzqBDBVkwzcuWVV2LDhg15HWlZlnH48OG8KF6iuqiqqkWjiV7rZs6w3+/HqlWr5j2ygHHrrbfi4MGD6OjoyNvORAg2fcdMoKq2bdJPU3XSkSqmjCh2danq3FTyurq6AoFAv2IZK1tugYvXVma/UqkUN39TbW2tZkfZMblcjitaENVDURScOnUK4+PjQlOUgLn/46FDhzAyMpJXxu/3Y+XKlVWzTdu2bcM777yDzs7OvO2SJCGVSkFRFNTW1qKhoYF7fLVtUyQSQUNDQ16ULKNUe1Nue8Dqy+VyCAaD2Lx5c0EqiFQqhbGxMc1m8Va+sxO6zc7NE9T0+91uNxKJBDdf4mWXXYa1a9fm+fPZbBYnTpzA+Pi48G+wkFlS4pOqqhgaGkI8Hq/oMfNBOBxGV1eXrdLf2tqKe+65p0CkSiQS6Ovrw3e+8x3s3bu3rG3r7+/HP/zDP+DIkSPcZHR33303rr322rKec74IBALo6uoqmHf99ttv49vf/nbVVOfdu3fj0UcfLTBiLS0tBQkKc7kcBgcHF9w1TbzrZKRSKaEHN0scbnS6PB4PotGoNnpizIVglkvKLmqHN+2PV099fT22bt1acJ/oVwlyu92oqanBVVddhUgkkleuWvbJ7Xaju7sbzc3Necl89eHNdq8iZexG48yin+wcFpfLxe3gybKcd0057dzx/sciziRrUzab1VY71FNXV4eamhqtw89WPMxkMpRXZYHBxBmRqA99fhyeDZmPRL5mRCIRbfl0PbIsQ5IkTWg2u5eqZZuAufuF2SXRCCe2zQwn0Y+ldgCNvzkwN8W2v7/f1I6a2TzR72lma1kHb3x8XMupY2wry/PHjmXiJLGwkCQJ6XQa6XRay0fJ7hGzazaTyRTYMhZNXk3bxKLV9aTTacTjca1twWAQW7ZsKRhkqqbftHHjxoJFZMwikYyIRjeZCT9W/pSdmM2uk9ra2gJbPz4+jmPHjuWlXTBrs/E7O7WVxuM8Hg8uXLiAI0eOFNTFhHG935RMJgtWlF3MFD4plgDJZBIzMzOoq6srysiEw+GCZTEXCiyygH23rq4ufOMb38DRo0cxNTWVN5VBkiTcd999UBRFC+MMh8MFK72IoCgKYrEYAODo0aP4yle+UlAmEAigtbUV9913H+rq6or8hguTN954A0eOHMFnPvOZqoyaPPXUU3jkkUdsy6XTaczMzCyYSA2iEGafWlpauDmZ9KOwvOkCPp8P4XAY4XAYmUxGc7KZo8VGmHlT50QwRsDwCIfDWL16NXeUm604qqoqIpEIrrvuOkxMTCCdTuc5g/Ntn9xuNwKBALZs2aItr2x0Tq0EJ+NnUZGKdwyvbpEyLpcL4XC4YPUwtpoes7t2979V59Z4brtpfiy/Bm8aXSQSQTAYhKIoCAQC2tLZZJ8WJmx1Rp/Ppzm5+g6e/j1vBbtAIFAwujzfeDweBIPBguuWCeN+v1/7DtFoVHPo9dfkfNsm1m4WVcCmUev/B8UiYgvKVSevYx+LxZBMJnHZZZeZDqbq7RHPNpnZIjs7xqb49vb2ctvKfmP2ulSS+S5FWARbJBLR/k/MHhmvA941sRBsk9vtLhiwA971Cbu6upDNZhEIBHDttddicnKyQESrpt/EhBBAbMqd1XaRwT27Y0TOy66NUChU8MwaGxvDzMwMbrjhhjzR3yhs8t47GZwzez1//jwOHjxYcBz7fyqKAp/Pp/X7l5LftKQinxj33nsvbrrppqIVwocffhjPPvtsmVtVHh544AFcf/31BQ/JJ598Ej/+8Y+5xzz44INYtWoVVq1ahSeffLKo8/b29mLNmjVYtWoVPvGJT3DLfP7zn8exY8cWrHC3HHjsscdwxRVXaA8UYuFx9uxZ7N+/33IEjkUV8KZS/d7v/R4++9nPaqN4+ika7FgryhEq7fP5UF9fX/Aw7+vrw8GDB7XOHBNLbrzxRrzvfe/j1jVf9mnVqlW4+eabtYSZ7LdV1cKEuE4pdhTMCUyI5DlRxjJ25zabmqlHNO8TL/qFEQ6H4ff7kU6n4Xa7MTg4iF//+tfUyVugsE4Qc5BFEvHr+bM/+zP87d/+7fw12AGs88qiDth3W7FiRUH0MGO+bFNNTQ3a29u1jqaxs1NOePe5k+PM7IddPqpYLIZsNlu272Nl51hbJicnTaPVjTlVSBhf2PT19eGdd94Rys/Di9784he/iPvuu6+ibSyWwcFBHDt2LO+7+Xw+3HDDDVX3m1avXo1bbrmFG9VoRyWE72LbEAgETP0eNjjKE8ftormsorP05wfezUnm8XgwOjrKjRYHgGAwCL/fD0mSoKpzs7PefPPNJZWLbklGPmUyGSQSiaIv7FAoVDBNZKGQyWS406nC4TDe+9734qGHHsIDDzyQt7JTNpvVMuQ//vjjePPNN7V9mzZtwl/8xV8U1PfCCy/gmWee0T5PT0+bChputxv33nsvPvShDy0Z4emv/uqvsHv3bjz22GPatkwmg507d+KOO+7ArbfeOi/tSCQSuPfee/Haa6/lbV+7di3+9//+31i1alXedkmSaLrdAoeJSul0Gj6fLy9SCXh3PriZE1VbW4toNFqw3Zgvygwz8clJp8Cso8HabMwpVV9fj1WrVkGWZRw9ejQvp4YT+8S+1+7du4XtEwBs3LgRXV1dWLFihSbQeDwergOhfy1mm8h+I1bljJ1QFvEaCATyclqoqop4PI5gMIhAIMCNXNHXIzJabGyP8f+uqipmZmYKVmAJhUJYt26dFmXi9/uRzWa5UyGIhYVedOJFT5o548BcLjX9Sk0LDb1tZe9ZpFdzczOmpqbyrs9K+07A3FS7QCCgtUcP77c3fh+z72mGXefdqi67yANg7t5n9zojl8vh7NmzWLlyJVpbW7kCmNNoAuNn4/ZcLocTJ05wpxCFw+G8wR99HkRiYaKqKmRZ1u5H3jRxZrd4gQeNjY1VWb1cBGZzmW1iuX4CgQBaWlrw/ve/H4cPHy7ab2I4tU2bNm1CW1sbIpGIqaCi/w6lvBbz3qwtZtvb29vh9/vz+seKomD//v3YsmUL1q9fX7CqotlAAM8G6d/zjmHbJEnCr3/9awwODua1LxgMYuXKlVoUm9fr1f7PS81vWpLiEzD3z+3t7UVHR8eCFZLKzdq1a3HXXXfhP//zP3HkyBFuYrI9e/Zgz5492ucbbrgBv/M7v1NQbvfu3fjud79re85IJILOzk587nOfK0jwuZi544474PV688QnSZLw6KOPoqGhARs2bMCqVasqOnd8enoa58+fxyOPPFKgkLe1teUlBVRVFf39/UsmGd1SJ5fLYWpqCg0NDdqy2rxOAe8Bql8m3Oh08xwyq/1GRJ1/u/165y+XyyEQCKC5uRnBYBCDg4NaOLmRctsnr9erCSFNTU2IRCJIJpPaiji8CByrzpZxn9WImFV9xvd2+xjs/9Pa2opcLleQUDWVSsHtdhfk3DETDYyOkhNYZyCZTBYcHwwGsX79ei2nis/nw/T0tOlIH7GwYLmRnD7fQqEQampqKtSq8sDrQHg8HoTDYcTj8QL7xSi3bWKRq5FIJC8PlWhnqlihxGhnzIQckXp4og8TnPX2nY3eh8Nh1NXVFaQuMNbF67jxypt9liQJyWQSFy5c4OZLDIfDeefhrdpILDxyuRymp6dRU1OjTV/jXQu863ex2SYAWhL/aDSKixcvYmpqal79prVr16K2thY+n08TukQG0USEJuNnJ++txC/edva7Njc3I5fL5YlPuVwOp0+fRjQaxYoVKxAOh03FJJ69syprbJfb7dam0B0+fLhgZkMgEMDq1as1v8nr9WJiYkJLZbGUWLLiU39/PzZv3oxdu3bhtttuq3Zz5g2Xy4Xdu3fjBz/4Ae68807b8m+88UbBcugAf+SAx+/8zu/giSeesE2MvpR48MEH8W//9m/o6enhzt8uF9///vfxta99Teh/oSgKbrnlFm5uA2LhkUqlsHv3bmzbtg2rVq1CKpUqmLPPQnSN6FdDYuWM8CKT7HJjiGAV9WBWr9vt1hyXxsZG/O7v/i5OnjyJ119/3fb4Uu1Te3s7brzxRkSjUUiShFgspkUZMOFJREzjbXMaEVDM6B3vnLlcDpFIxHRQJZFIIJ1Oo6WlJW91L5F2AXwB09gGv9+PWCyG6elpbp1+vx9tbW2YnZ2FLMsIh8PYs2cPd9UpYmGhKApGR0fR0NDgOEeKfhrwQsXsPpRlGa2trZidneUmAzdSqm0KhUJYsWKFtsKglehTrEBsh5NnhNmxxk6W1TVw9uxZDA4OYtu2bdoxemGcF3Fg7OzZtdPj8eD06dM4fPgw9zdzuVzw+/15U8MnJiaWXGTBUiSdTuPll1/GDTfcgM7OTu3/J3Lder1e0xUuFxLGaDxgzufbtm0bzpw5g3379tnWUapt6ujowAc+8AHtHrFbSddsYEv/WmmsbCT7LUOhkOkzbd++fTh58iQ+//nPa36WcTaCMQcfu/aM16FZhJTf78fevXvx/PPPc9vq8/nQ0tKi5Uf1eDzYu3fvkpzNsmTFJ0As/8VSg42mbd++HT//+c8BAD/72c+09zycPnQ3b96M+++/HwDQ2dlZ1FzgxcBv/dZvYdeuXfiLv/iLvGXBVVXF6Ogo7rjjDnzpS1/CTTfdVNbzSpKEL37xi3jzzTe5D4udO3di+/btBduX4/W+2GEhtXqnm8HuZSOZTKZgJKSUCLxijhWJoNJfu+z7ybIMr9eLdevWIRqNYnR0FP39/QURPHqc2qdIJIINGzagsbERtbW1Ws4hAHmdDkBsRM64zc7JMouSMttmdj67ttTV1WHr1q04depUwbQ3RVEwNTWFcDict6qfGVbT7/RtZ/smJiYKzsnYtGkTOjs7IUmS9mxIpVIUWbDIYA67mdDNswHpdHrBR7eZTUdlHahgMIiWlhaoqopEImH5fZzaJq/Xi/r6ek2Ul2U5bxqgGVZ2gzetQ6SeUsrYHe/1elFbW6tFkunJZDJ46623sG7dOu7qWbxOnFnkrjFCSlVV7Nu3D+Pj49zvwRZAMEbmEosLNq2TRY0DhYKAkVQqxV0UYyGhtwPMtui/S1dXF+rq6pBIJHDhwoWCaVt6ivGbNm3ahEgkgnA4nJdYXHTQ0UmEkxOfqJiBOzO/qba2FpdddhnOnTtXIKolk0k8/fTTeM973oPOzs6CdrJry/jH4A3UsYUNAODnP/85Ll68yG3b+vXr0dbWBlmWtXrS6fSStU9LUzXQcebMGRw7dgxbtmwRPqanpwdHjx7Fli1bKjqtqhhWrVqFq6++2rZda9euxdq1awEAo6OjGBgY0PYlk0kcPXpU+Jxr167Nmyt91VVX4fd///cdtnzx0dnZidtuuw1PPPEEDh48mLdcbzqd1oxUNBot27UyPj6OkydP4umnny6YQhcIBHDVVVfhIx/5CP7bf/tv2vaJiQluB5RY+LAQ8qamJq74xIt8Gh4exsWLFwu2m11/TqOg7LDKGeL3+xGJRArKsI4ey2tQX1+PaDSqhTiz0TVFUbQpE6IEAgH4/X54vV54PB7U19dj5cqVaG5u1lZnYfP4PR4PZFkWFp3shCX9azkdLDtUVUUgEEBbWxsGBwcxOztbcP+n02l4vV5tiqHV/1zfieVFGjDYCow8McntdqOmpgYdHR1obW2FLMvweDxIp9MUWbAIkWUZkiQVRAtYRRr09fXh1KlT2Lx583w00RHs/td3Inj3u9fr1aaOsdX/mJjOrn8n52R/wNzIdigU0s7N7JIZdhFPosKTmWBlF3HlBGOdgUAA6XQ6z94CczZkeHgYdXV1mkjFE5XMpgPyrj2WRzGRSGBgYIA7Ncnr9Wr58FgkA3ve0KDd4iIWixWIJHbCeG9vL06ePImNGzfOWztF8fv9mi/EMN6nqqqipqYGDQ0N2vOerXYsSRIkSXI0Pcvv98Pv92t5R+vq6tDZ2alNTRRdFMSp+GP2uRy+ksg5/X4/WlpacOnSJSQSiTy/SZZl9PT0YMWKFQgEAmhsbCzwnXiCt/4zg31WFEVbyOP48eMFvq3L5UIkEkFrayuam5u1Z0Imk8Hk5OSS9ZuWvPj01a9+FU899RT27t0r3OG699578dRTT3GXQKw2d911F770pS856jx+4QtfwBe+8AXt87Fjx7B161bh43fu3InPf/7zjtq5VPB4PHjyySfx3e9+F3/5l39ZsL/c18rzzz+PP/qjP+LuW7lyJd54442CaJiXX34Zf/AHf1CW8xPzy+HDhzE4OIjf/d3f1R5i+g4SL/Lp//2//4ehoSHcfffdeQ9W3sOP17GwCw22Qj8VgvdQbGtrw+rVqzXRRz9qpj8H29fR0YGOjg4oioJLly5henoa4+PjOHTokFB7gDmRuKOjA01NTaivr4ff79ce3kzsYr+jfiUpOwHKSkAybi9GeCoVtmzzpk2bMDQ0hL6+voIy8Xgc6XSaG2FgbA/vejBGITAnigdbHrq9vR3BYBDJZBJ+vx8TExN48cUXS/quxPyTSCQgSZKWHwewFiYB4Ic//CEOHjy4IFMdsKXWjYK48brX27aamhrU1tZquTpYvg5R2DQP/VQPfeSlnfBUCUqt1+4a0J8jEolwI3UB4PTp0xgaGsL73/9+hEIhLQG4foVFI/qOoF7YSyaTuHjxIg4fPsxtD+tcBwIBTXRyuVyQJAkTExOOvj9Rfc6cOYOJiYmCPLNmA3YA8Oijj+LAgQP4+Mc/Ph9NdERraytWrlyp3Vv6SHg2aMfujUwmg0AggCuuuAJXXHEFstksRkdHMTo66iiooL29He3t7Whra0MwGNSmlenFPKNvw4sWZa9OBCGzMuUYmLM7D/Ob1q9fj5GRkbzADMYbb7yB06dP4/d///dRW1ur2Sa9IMdsCPDudcf8JVbe6/Vienoax44dw+7du7ltCgQC2Lp1qyZ4ZbNZeL1eTE5OFiw0tZRY8uLTUsSp82Asv379euzdu1f4+LVr1y64CLD5xOVyYceOHWhra8Of/MmfFITunj59Gtdffz0A4Prrr8e3v/1tR/UfOHBAW5nCLGH4X//1X+N//I//YemsEouTXC6n5XwyTnExJo5m6KOI9J0BK2GpGLGJh8vlQjwex8DAQMHoGIt8sjsPu47ZyJ2qqmhsbEQ0GkVnZyfWrVuHbDarRV/oR6f9fr+WV8Tn8yEcDmuRT6zjyObLs9+K92q1z+mr3bZi3luh70A3NjZqDk9vb29BRJIsy5icnNSup5qamjxHyYjR6cxms9qKOGYh4EwAZHk4MpkM/H4/MpkMNwqBWBzohRizKU+LBY/Ho027NYMX1cl+A5/Pp90/rKzxXjEK7Oyz/py8Th2vDTx4tsIucsmuU+j0/2gV+WqERc0x4dpIIpHAW2+9pUXDdnd3IxgMFuTnMf4miqIgk8lgenoaJ0+ehKIoppHfLNqJ5VRkz01ZloWjO4iFh6IoSCQSWuSOPqJxsfnJgUAANTU1eXbCLKLGuN/r9aKtrQ0rVqzAunXr8gb99CsPG6MwWdSTfmDOWLfV4KaoD2RXphx+Ew+zKCh2nbDpz16vFxcvXix4LszMzODpp5+G2+1Ga2sr3v/+92uJ7vW5fvV+lKq+uwjL8PAwfvOb30CWZdOItLa2NrS2tqKtrU071u/3I5lMLskk43qWhfg0OTmJX/7yl7j55psLRoC9Xi8++tGPYt++fejp6alSC+eXcDiM6667rtrNWFS0tbXhxhtvxO/93u9h//79eddKMpnUkgBms1n84he/KDi+u7sbXV1dePXVVwuM3NGjR02TCPp8Pmzfvh2//du/jauvvjpvn6qq+PWvfy2UgJBYuGSzWfT392sRQwy32w2fz4doNIqZmZm8TryiKJientY6RHrHiyc2mWFXhudEsI5Eb28vV3wKhUJcJ0r/3hhODkDLD+T3+xEMBrUViIydBDaHnkU0MSGFPbz17TSeVx+JVWzkUzkEqHKO8LEVs5qbmzEzM6NFO+nR/y6ZTKZAfGKfjQ4o+03NEo66XC40NTWhtbUVK1asgM/n065Tj8eDoaEhjI6OOv5OxMIgl8shmUwiGAxqEZl6vF7vglspLJVKYWxsjLvKmf47mE3jMuu08Dq2ZtEBwLt57qyEJuMxZufXbzezbVbHiG4X3S8KE8V9Ph98Pp/WGWbkcjlN2JZlGTU1NQgEAvB6vdrzgE2rZkl32cCLJEmYmZmxjFzy+XxaZ1Ev0rlcLmQyGdtEysTCRZIkDAwMoLOzsyD3ExMXZmdnF9Tgh5lt8vl8ebnIjD6clZjDBBQ2pdcoPukFF/1zn9XBphNb+TXG81q1R2RbuQQos/OIwFa9bGxsRCwWQyKRyLtWZFnWfJdsNovGxkZEIhFNtAPm+tKhUAhTU1N5/lI6nS5Id6PH5XIhGo2iubkZTU1NeekgXC4XxsfHhRa9WMwsC/Gpp6cHt99+O/bu3VsguoRCIfzkJz/Bzp078Q//8A/adnbjsvC5+cZpbgGisgSDQbS3t+Nf//Vf8ZWvfAUPPvgg1+E+dOgQbr/99oLtd999Nz71qU/hk5/8pHBuJmagfvazn5kuEXvPPffgwIEDzr4MsaCIx+PYu3cvmpqa8vKBuN1uLTl3X19fXlLuTCaD8+fPY9OmTVpuDb2tEol24k2t4qGPsGI2cXJyEgcOHChw7EKhEOrq6jSxQz+Ngn3Wd8b0YpuxY8JGNI05i2RZ1qKbWM4O3vfhdfxEO2MiwpSxXjMHqtwOlf5/xRxHv9+PFStWwOVy4eLFixgaGuIeK8uy1tnTwxwqpwlZvV4vtmzZojlmkiRp14vX68Xhw4fzljUmFhdM5F6xYoUmuuivv0gkgmQymWcHqu07TUxM4M033yywTUwE0Uck8dB3zIz3Netc6DtrvOONAwF69KsoGUUkY8eQbTfWb2ynEaeClF7Qsuo0GgUc3vH6z+w5xsSfVCplKgbE43EcP368YPuKFSsQjUZx9uxZRx1Nl8ulRSoYRUd2PhKfFi+JRAJvv/02GhoaEAwG865Nt9uNNWvW4OLFi3mDH9W2TZOTk9i3b1/BPRAMBlFTU5PnN+nhDdYxmBjLG2DTH8/8JWOdxrrszmklHJnZDtHjee1wMlAnah+YHff5fGhqagIADA4O5i0spWdychIvv/xywfbVq1ejvb0d+/btc2SbPB4PNm7ciMbGRoTDYc0OsWfs6dOnl7z4tLhiE+eREydOYNOmTdi/f39Vzr97925s3rzZcjUDojp8+ctfxquvvupolb/HH38ct99+u6Ok4J///Oexf/9+hMPhYppJLDJY1Ip+ZN3tdqOpqangGujt7cVtt92G48ePI5fLIZ1O50VBWWEnNhnRdzq9Xi9yuRxOnTqFhx56qEDICAQC2rQ7q2ldZu1i0Qks/4AkSUin00gkEojH41pUD3PSmMjBEmuLTFmxikSw2m4lSJVTeLKDV545lo2Njbjsssvwvve9z9H/OJvNOl6lbPXq1fjgBz+Ijo6OvMTxrKM5PDxMiyAsEZjgou+Q5HI5LUpFT7V9p3feeQd33XUXNyKm1A6nPpKHTeUKBoPan37xAys7xxN7KtkZFnkm2O23GqwQ+ez3+1FTU4O6ujrRZgOYExP7+voc2clQKISmpiYtl43xN85ms0VHTBALi3g8jlQqlRcBraoqmpub81IAANW3TYcOHeLaJhb5VKzvxqLAmW3y+/2afWIDS/oE4/qIcSvsBsWcREKJ1C9Kue5d9hyLRqPo7u7GVVdd5cgODw4O4tChQ47a09XVhRtuuEHLtcWEQ/YcHR8fXxai+LKIfGLs2rULk5OT+MhHPmJbNpvN4vz581WbdxmPx9Hb26t99vv9+MxnPoP3vOc9VWkP8S5NTU24/PLL8ed//udQFAVjY2P493//d8tjZmZmhBKVbtq0Cdu2bQMAbNu2DWvWrOGWGx4expNPPklTWpYQLES3vr4ewLujdHV1dXlzzIG5kHM2UjM7O4tgMKiN6Nt1BOy288roH66nTp3CqVOnMDU1lVeus7MTDQ0N8Hq9edFIxYzOG89vNuJuVr+Ik2TXLrPoByf7zM7ttC0Mq+gEtj8QCMDlcmHt2rXIZDLaanN2iPw/WJg6m+ZXV1fHnYaUSqVw7ty5BTXlgSgeNo1TL4Izh9mYX6VavpOqqhgaGiqIdgDm2s0T5s2iiPT3mVW0j/7VuN0KEZHcri4ndtXKDlsdZxbRJIr+92PTftj0IBa1adfRYuXsYHWz1Qr1AqD+u7HVpxbSVFGieIaHh6GqcyvBsf93LpdDJBIpWKlzIdgmfXSNy+VCR0cHd8VHK6z8Hiv7YYyKKsW+2PlYVn5ZKVFOpbSdwRP+/X4/amtrsXLlSkiSpK02Z4Vo3rhgMKit7tzU1KTl3dS3h/lNFy5cWBaDdstKfPrWt76F3t5ervjERuyN0w6SySSSyeS8Rp8kEomCnB3BYBDf+MY3EI1G560dhDkNDQ146KGHAMytWPbss8/mGTxR54at8sK46aab8PDDD9se19vby119j1i8sGTR3d3dAN51umtraxEKhbRoID0DAwMYGRnB5ZdfjlQqpUUnORmJMcsfYswLwPa/9tprePvtt/Pq8Hg82Lx5M1asWAGPx4NsNst1kEQ6QMY28AQ1Vo6NGolGNTl1iKzqtttntZ33WeR/ZlWGTXFkAtQVV1yBeDyOqakpzMzM5LVJtONlnEIUjUaxadMmtLW1AXg34ortZ7kLYrEYTp48KXQOYuGTSqWgqqo2LRjIF59493o1fKfjx48X5O50uVyora2Fz+fLi97SIyK86MvZdeCspjubncPKbpnZaP1+J50xoyhkJWbry5v9dsZyVu12u92oqamBoih5nTcnzyxeG30+HyKRCILBoFafUTRU1bnpNk6nFxMLl4sXL0JRFKxevTovz1ooFNKmXBpTmCwU2+R2u7Fx40Y0NTU5fv7bTQ+28oWcnMfOp+J9tjpeRLS3Ky8iQFnBO7fb7UYwGMSmTZu0VX1ZwIDRD7bD6LfW19dj3bp1aGlp0erR5/diftPs7CzOnj1b1HdabCwr8cmKr371q/jkJz+Ja665Jm8k5pOf/CS2b9+OXbt2zUs7VFXFjh07qhYWSjjniiuuwIULF7TPuVwO119/vVAC+5/85Cf40Ic+pH02RrgQy4t4PI6enh5s2bIFiqIgHo8jHA5j3bp18Pl8eOutt/IenDt37sS2bdvws5/9TFvJSZZlBAIBLYeSmYBjhrHTIMsyPB4PEokEjh07hv/7f/8vTpw4kXcMG8Fj89fLNYVEL3o5dTSKdZpEOpiiwpPIOXn7isFYh6Io2lLxXV1d2pTFRCKBM2fOCEUlrVu3Dk1NTdqoHQvbZ/9j3qpCk5OTlOdpCcIiRiKRCDfCwLhS63z7TgBw//33c30nJkgYE/pawYuw1EdKWcGzPTyRx1ivHXZClyii30PkHGZCm13dbJpQIBDQOmPsmSfSydPbI30iZbMIYGAuYng5RBUsN5LJJPr6+tDd3Q2Xy6UNfq1duxY1NTUFOXkWim1iK6n5/X7Isly032R234kMqDlB1J8SPb6Y48rhK5mdg/0Fg0GEQiG0tLQglUohm80ilUrh7NmzQvZj9erVaGhoQH19PYLBoLbgAjvWOKgHANPT00s+z5OeZSc+HTt2DDt37sQ999yjJRoD5iJQ2HQXPfF4HAcPHsQ999yDv/7rv9aUy0rQ19eHf/qnf8LJkyfzRmZuvPFGfOITn9AcKGJh4fV60dDQoH1WVRU7d+4UMiTvec978o4V4fHHH8eLL77ouJ3EwieRSOD8+fNYuXKl9tCSJAmRSAStra0F5ZPJJA4fPoz/83/+D+655x6sWLECAPJyIvEEAvaQ1S9RzNCPErMysVgMp0+fxsMPP4z+/v48gb6hoQGdnZ1adJaTzhQ7jx1mkU8in+3EITunzGk5u3OYffdSR/55sOTfbrdbGwkOh8Nwu90FK9vx8ro0NDQgFAohEAjA5/NpnTseqqoim81iaGgIw8PDRX0XYuGiKApSqVReh59dX7xBk2r4Tj09PXmiKlt90yzyxwzefqeRnCI20CzyyBjhUApWbRSNtrCLzuLhpN1MPGJRUSLn4eWuMfu/MpudyWRoKvASJJlMor+/Hy0tLZoYLssyQqFQwQrnwMKwTdFoFO3t7dpz1Swq0wy7e8TK97CyOXa+SqVe7bZZtY1X1gq76Ff23uVyIRgMaiswb9iwQfN/jL+n3neKRqPacSyXkz6ZvFEglCQJly5dWlZpVJad+NTT04NvfvOb+NjHPobLL788r+Pv8XjQ2dmJS5cu5c0J7u3txTe/+U185CMfgdfr5RqzUhkfH8c777yDb37zmwX7rr32Wtx9991lPydRGVwuFz772c+WvV5ZljEyMoInnngCu3fvLnv9RPVJp9MYGhrC2NiYljCTRTJFo1FEIhGkUqk8AaCvrw/f+c538NGPfhRbt25FNBqFLMsFq8TxHsxmnR+2j41GX7x4EW+99RaeeOKJgnINDQ3o7u7WIq9EBRVjOWM7eFECvONEXtl7p+V45xFx0uyEMbPvaLZNj9lUILOpLywSgOVCcbvdeQMt+vPpIwj0oiX7v7K6eNeVqqqIxWIYGRmhyKclSC6XQyaTQTab1RLc5nI5eL1eLYrFeP9X23diU7FEOmpWUTt296nxHjQ7h9V2K1tsRbHikpMOnNWzw/jZ6ntY2S5mb8wWcjH7bfX21aqMLMva9UssLTKZDEZGRjAxMQG3242GhgZNKK+pqUE4HEY6nc7zm6ptm6LRKNatW5e3EqPZdVysTeD5MnblecdVUngS8Y2c+E+8fSK/p9GWsTJsUZtgMJiXm8vMbzIO3uqjOHmrLOZyOczOzmJ8fHxZRT4ty9Xucrkcbr75Zvzt3/5t3va2tjacPn0aH/vYxwqOUVUV27Ztw1e/+tWKtOkLX/gC/uAP/qAidRNLg76+PmzYsIGinpYBv/rVr3Dy5EkEg0Fks1koioJwOIwdO3agq6uroLyqqti+fTu+/OUvY3Z2FoFAQJtHnkwm8yKVmChlFBCYuKBPFi5JEg4ePIi7774b/+t//S9uW+vr67F69WpIkuR49I5h17FguYXYn9VS56KOmqhTZiU8GesSEaKctrOYduvRT5GSZRmSJOX96X9TfR4WfRkAptcMMOdUZTIZPP/888tq9G45Mj09rU2NYh0nVVXR0dGBUChUUL6avpPH4xGaym7XOeFN49LbUf0qnXbTnM1shd1ovGjbS6XYqXhOp/IZ0XfWRP+sOpj67aqqYnx8nISnJc6+fftw9uzZPL/B5/Nh+/bt6OjoKChfTdvEotnZs9eMYvwE/b3I8/ecnMfM1xEt53R7Me8rAbPher84m81q0ZOSJEGW5bx9+j/j7AMmrhsHG7LZLF555ZWCaetLnWUX+cRgF40el2su4/1f/uVf4qqrrsLXvva1gmP27NmDT3/603j44YcdLxlr5Ec/+pEmJOzbt68ga77b7ca3v/1t3HjjjSWdh1gaqKpKSwQvE1RVxczMDPr7+9HW1oZcLodsNouamhp0d3cjGAzi9OnTecfIsoxXXnkFX/ziF/Fnf/Zn6O7uRkdHR8HUBH3eE2OHgZVLJpP46U9/il/96leYnJzE8ePHufbyhhtuQEdHB3cqlpNRdyunwhjJY1WO59jYjf5ZjcJZjSCKjOLZOU7lEqCMuWP0I6j67cZj2CvvWjC+mtXpdrsxOzuLiYkJWkFqmcCiSNjy4Ox6iEQi8Hq9iMViBeWZ73TfffehpaWFK1SJYuc7AXOr0rJozFJwInKLikWiwrdZ/pZi2ma3XXRqnZk9EcF4rF09IuexK8OEdGLpo6oqZmdnMTQ0pPlNsiwjGAxi3bp1CIVCOHPmTN4xetv0wAMPoLm5uaQUJyK26bd+67fQ0tJiOoXd6vsZP5tFjIv4K3b1W9VpNShXzGsxglOpA428yE0zjHbLOMDA86F47dD7TYlEAlNTU8vSb1q24hMAjI2N4fDhw7jiiivyQn1vuOEGNDY2YteuXejp6UE8Htf2nT9/HoODg/jjP/5jNDQ0wOfz4YorruDmVeExMjKCoaEhAMDzzz9vmvCuvr4eGzZswCc+8QmuYk8sL/r7+wuSPBNLm3g8jsHBQbS3t2sPLK/Xi9bWVrjdbgwNDSGZTBZMwRsYGMBll12GyclJdHd3o729PW/lFz3McWFTaiYmJjA+Po54PI7nnnsOTz31FLdtfr8fdXV1WL9+PSKRSF7Ek3E02q7DU46RLZHOlhMHyqnzI+KAib53gnGqnV4gMm7nRWOYCU/G+vV1GfczoXS5jdwtZxRFQTqdLuikBQIBuN1upFIpyLKcd12fP38eAwMD+MhHPoLOzk7U1dVh3bp1Wj4xO0R9JzZNguU2s3PseXaIbbdDRKgRPYYnKDspX8r3MJbjCV+lRjYZzyPa0bMrY2aXGJRkfHmRSCQwMjKi5XFS1bm8lc3NzXC73RgeHi7wm5ht2rFjB9rb21FbW4t169YhGAyaTgPVI2qb/H4/amtrsWbNGgSDQa5tshOcjfusBtx4/pWI38EbbOMdU6zwZFeH6Hur72CFna9qfG8lPIkM2vGOV9W5NAXLaaqdnmUtPv37v/87nn32WVy4cKEg6fOmTZtw8OBB3HLLLXjllVfy9mUyGdx6660AgNbWVvT19Qkr5Y8//rhQiOett946rysxEAubv//7v8cjjzxS7WYQ88j4+Dimp6exatUqNDY2IhKJIBaLaatouN1u7N+/H1NTU3nHybKM++67DwBQW1uL+++/H1deeSVWrVqFtrY2BIPBPLGcLT196tQp/PM//zO+//3v27ats7MT27ZtQyAQgKrOhSWzZOOAWGSPSAdDxFly0gG0E5ucdNTMnCmRdjo9n1U7nHQG9eX1bTAbwWOfrepLJBLo7e3NW/GTWNqwKQdsUQQ2/Y5Fjzc3N2NiYqKg05/NZvGpT30KANDY2Ihf/OIX2Lx5s1DCX1Hfia1SJMuyJoqbCTvG904RjWKaD+ymnZVSV7mn9pUTqygDliQ/nU7Pc6uIajE1NYVYLIaOjg5Eo1GEQiFks1mEw2EEg0Fcd911OHDgQIHflM1mtSlyjY2NePrpp7Fp0yZtERcrRG1Te3s7br75Zu3zfEQbiiAqNtkdY+bXiAhP80kpfhP7bBTRRSKf9CQSCQwMDGBgYMBJ05cMy1p8AuZWSdixYwf+/M//HH/4h3+obWcXz0MPPYQXXngBX/nKV7jHT05O4sMf/rBw5NPFixdtyzzyyCO46aabFvQDn5gfYrEY7rjjDhw9erTaTSGqgKIo+M1vfoOrrroKGzduhN/vRyaTgcvlwrp165DL5TAwMICTJ09yj08mk3j44YcRiUQQCAS0hNN628LyZySTSYyMjNi26YMf/CA6Ojq0fFT6kRwrKu1A6c+jfy3leKfvzc7vZGRPFDvH1Sz6ya5OuzL6eiRJwr59+zAzM+O0+cQiR1VVTE9PIxKJIBwO5yXOZQl80+k0pqenucfHYjHcfffdCIfDQnmZRHynpqYmBAKBvGXLK9W5EYlK0H+2iwIVrcdpe4o5RgQ7uyNyfCnPA6vjmV2emZnhTnsiljaKouDAgQPYuHEj1q5dq+W/BOYCBq655hoMDw+b+k2xWAx33XUXwuGwUFSmiG26/vrr0dLSUvRz38yHEIked+qTiL7qjxM5xkx4EvGLRAYhRX0ifRlehJLZe7P6eH6Tvn5jfbIs49ChQ5idneXWuxxY9uKToih4/fXXsXHjRrS1teGDH/xgnpB09dVXQ5IkbN++HQAwMDCAY8eOafslScJvfvObktvxnve8Rxv9+9CHPoSNGzeWXCexuDl37hwOHjyIV155hUbulimqOpcodXBwEJFIBO3t7VAUBaqqwu/3o62tDS6XC7FYDMlkEul0Om+lTkVRcPbs2ZLbUV9fj1AohGAwiK6uLkSjUcs283CS68QpdiNwog5NMWKT1fmKda6scBIyrv9sPM4qukEkZ0E8HsfU1BTGx8eXZc4CYs7/yWQy8Hg8CIfD2nYWAaWqKoLBYF5Ce4Ysyzh8+HDJbWCRVy7X3LLYvNWjWJt4I9hWnQZeObPOiNX9W0z0kWhny6m4VCkbbDxWNLKVYfd/MZazaqM+CTCxPJmamsKlS5cQCoXyFmnxeDxoamoCMLd4QjqdLvCbZFnGO++8U3Ib6urqEAwG4ff7tel8vOvWSkAyoxgfw2xfKQKUU+Gpkr6SWRkr34fnN1mlMDDC85vMnhcu11w+1enp6WWb64mx7MUnxo9//GPs3r0b58+fLxiFe9/73ofnnnsOAPDYY4/hT//0TwGUZ0SNXZRf//rX8fGPf7zk+oilw65duyq2CgexuDh16hQGBgbw6U9/Gi6XC4qiIB6Po6GhAdFoFG1tbVq+p/Pnz5f9/Js2bcKaNWu05OK5XA6SJGk5pIrp0Ih0rpyUt6vHTlByKjxZCV5OHTyz72LmzDCsnB1eR1t/TKn09/fjyJEjZamLWLykUilks9m86bxsulsgEEBLSwuSySRSqRQSiUTZz19bW4twOAyv16sJ8/pcT1aiqtU9xSvH3hfr+5ndk/r3VtMEzQRn3nmcbBfd7wQnwpKo8GR1Ln30QTqdXtZRBcQcfX19GB0dRUdHB7xeL1RVRSqVQjAYRGdnJ1asWIHBwUEMDg6it7e37OffsGEDVq5ciebmZkiSZHpf698X4/fYlTfzi4xlzcpbbRfxe0REKbPziAppVljZTZFoJ71PpT/G7DxmzxCWc4zy95L45Jjbb78dH/jABwAADz/8ML73ve8VXdfXv/51bapfZ2dnWdpHEMTSRJIknDp1CitXrkRtba2Wy8LlciEUCmHDhg3o6urC5s2bMTIygsHBQaFpdGZs2LABq1atQktLC+rq6uD3+7WRZPYgBcrbYbHCaeSUExFJVGAyO5+dM2XWPivKkZfGyhkSGfEzGykcHR0tWNGMWL6oqop0Og2/3w+v11twvbGoyfr6ek2IymQyRZ+vpqZGmxKjF7wYC21EWVT4FY0WqtT05VKENSfnKGW/UWgydhpZPjKCAOaimC5cuIC2tjZEIhH4fD5NHPf7/Vi9ejXa29uxefNmDAwMYHh4GGNjY0Wfb926dejq6kJTU5OWsFwkAq+U+1pk8M5sm9N62XYr/0h0kK6Uti0W9GkpxsbGSBT/L0h80pFIJPDYY49h27Zt6O7u5paJRqPalJP//t//O3cJ12effRaDg4Pa5+7ubtxyyy0F5W655RZcdtll5Wk8sWRQFAX/9m//hv3791e7KcQCQlEUXLhwQVvOnI3kAXMrPLHV7Px+P/x+P0KhEKLRKLLZLGRZhqIoUBQFk5OTec5QMBhENBrV6vT5fPD5fOjq6tKEJ/2KL06mnJS63cmol5WIJFKfk/OKiFpWdYkKUFY4EY2MI3e8fVbvGSzibXh4mPI8ERosooA52vqISLaNCdahUEizV6o6t9KmqqraVCn9Naq3a3rBgU1lYVPsnAjFxXTwePdPqccY7YLddDLePS1ar127eTZOZDoib5/TY52ez2if9N+PiaAkPhEMRVEwODiIQCAAj8eDQCCg2Rxmq9jCCao6N024oaFBEzFlWYYkSZiZmcnr7zExnQnuXq8Xbrcb7e3taGpqQk1NjVZWL4aL2h8nA21OytiJUmY+ipXPYnW8WR2ixzg5txlm0aZ2PpSZPTOe325KN/ObLl26ROLTf0Hik47p6WnceeedePzxx9HV1YVAIGB50X3sYx/Dxz72sYLtO3bsyFs+8aabbsIPfvCDirSZWFrIsox4PI4vf/nLGB4ernZziAWELMs4e/Ys6urq4PP5tClw+gezx+NBJBJBQ0MDOjs7kc1mMTMzo0VJpdNpnDhxIm+ll4aGBmzcuBHhcBjhcBg1NTWora3VOnzM+QKgdSoB++iCYkfjnAhQbJuxjKi447TjWozwZOVQFSM+mXU+RXLSlBIxoapzUQXxeBx9fX2UT4XQUFUVyWQSHo8HbrebuwALu14DgQACgQAAaHmgZFlGJpNBIpHIEw78fj9qamq0XE76aEur+8fJdc67b60EDqs6jMeInNusfjPhyIlo5aTdZm3T12XVfl45XofM2Dan0V5mIpyqziXyTSaTRdlVYmmiKAr6+vq0SMm2tjZNfNL7MG63G52dnejo6NCuIxalGYvFcO7cubxo3/r6enR3dyMajSIcDiMUCmnJydm16BT9tWwUVY1lzI7llbHyu+x8GLMyVvuclNPvtxOfzL4LDyvbKDrwZrVfX5edHWN+U39/P/lN/wWJTxzuuusu/Mu//Av27NlT1PE/+clPCiILCEKEX/7yl7jzzjvzxEuC0HPkyBEMDg7i1ltvRU1NjRYBpX8wsgT1Pp8PLS0teSMwl19+ed7In9vtzpsqo6qqFiUFIK8zyXNYRClnh8BpXTzHyE7IsjqmHMJTsTgRl4wdNbNjzMrpo1ZSqRQGBwdx/PhxbsQvQcTjcWQyGTQ3Nxesqsne6ztlzP4EAgGEQiE0NDTk1cc6iEabpK/PidDkVJTSdyxEI5+ctsfsfhapp5QornLUW2o95TpPLpdDJpPB7OwsCU8El9OnT2N0dBQ33ngjwuEw3G53wTM5mUxqn4PBIEKhEIA5H2jLli3cepmAxfwuvRirf3VyXVZqWq2VIGRWXmSfnXBlJUpZtcuqbXaU8ze085OsSKVSGBkZQU9PD/lNOkh84jA7O4sTJ07g3nvvxZ/8yZ9g7dq1jo63WgmKIHioqopHHnkEL774IsbHx6vdHGIBI8syZmZmcPjwYWzdujXP3vBGa4wPfP0UOj3GUTf9dt6Ij4gTYYXTusyELzPHplQRqZRjrNop8t2tsJtWJzLtzi6s3Pg/lyQJfX19GBsbIweKMEVV50b8Y7GYJoybTZsyfmZ5WHiITHtwut943/HaZWb7RM8lYtfs2m71mbddtJ2l7LfD2NkuJrrJyfQklvSehCfCDEVRtL7dxo0bUVdXVyCOO5kWyrbrj+dFfOr3iyJyP9v5EyLH8bZb+SsiPpBVObPzifpNdt9BBLupdvr3TqIzWbv09SiKgoGBAUxMTJDfZIDEJxNGRkbwd3/3d7jmmmsQjUYLRuQIolxkMhlMTU3hn/7pn2gVBEKIdDqNY8eOobOzU4sa4D08VVXNm5pndLCMD3h9pIseJ46AmZih3ycqxDgRoCohIhV7jL69TkUnK8dKxHFin3n12nXujKIVMOdAJRIJXLhwAfF43LRtBAHMiUjxeBx+vx9utztvqq4RK5GcwSKozGyKHXadRjPBSCTayWnHSPSeFxGHzNrG2+6ksybafrtpKXYdNqsyZoMfxm3s+ZZKpfKi4giCRyaTwZkzZ9Dc3Ayfz4dwOJy33xjhzaIujfaJ2QZW3sxvYnWJ3Asi2N2bZoOEVnbKTPix872s3hvrcCJOWQlRZucSwc5O8d5b+Ul2QmUul0M6ncbg4GBFVnld7JjLtAQA4FOf+hQ+85nPVLsZxBJm7969WLNmDU6ePFntphCLjBdffBEvvfRSnuOdy+Xylhln0+p8Ph+8Xi88Ho+WP4W9ZwkzWZ4nI+Wa2lJsKLSd87RQhCerNosIT5WgGMdW73xPTEzgpZdeIuGJcMTk5KQ2fdyqY6bv0DF7pP/Tl7MSqczgXdd24ngp09mcjJIXS6Wm5YiclzetaL7bxDqGkiRhYmKChCfCEW+++aa2oI8+rQDznZiNYTbJ6/XC7/cjGAxqix2wqE47AV3kvijHvSMaXcj7bCdqObW3PFGJd8758pHKPQVP/8ojl8thcnISr7/+OglPJpD4ZEM2m8Xbb7+Nz33uc5QAmig73/rWt/CNb3wDmUxmXjukxNIgl8thfHwcr7zyCuLxuGkHSFXVPKeKN6Jn5WQUc23y6ixW9DG+2rXHyYhcucUqq+NF/qx+Q6v3Zt/P7PewOh6Yc9jOnj2Lnp6eBbd0PbE4kCQJk5OTwuKA3f2gFz+MQoiIjeKVNQooxXaA7KKk9HU6sWVmbRG11U7aVAn776Qeszbw2pdMJqljRxRFLpfD1NQU3nzzTSQSCaiqmjdlzsqHUhRF85/02EWNGzGzM3b2R8Qf4H02bje7N+18J5E2mPls5fC1nPpUxZzDyW/G+90uXLiAvr4+8pssIPFJgIGBAfzoRz/C22+/jaGhoWo3h1gCZDIZnDhxAj//+c/x/PPPV7s5xCImkUjg1KlTGB0d1ZxxK0fIrqOhL8v7bJejxOoBLvqe90DnlRXtKBbjxDlxVJw6QU6OEWmv6O9h52Cy/y3LjzE0NIRLly6Z/q4EYQWbspnNZgsSjZuJSEbs9uvL2W03s00iETxWtoh9thKg9PZTJBJM/9nK7pmV47VR5BgevGmJovDsi7ENVsfw9rHVEWnlKKJYkskkzp07h/HxcSSTSVubxLtfRGyYiF3S189D9D5lZXnH2vlA+mPN/AvePiu/SfT4Ys8h+nvY+U7G98WeS1EUxONxjI6OYmJiQvi45QiJT4KoqoqPfvSjuPfee6vdFGIJcO7cOVx55ZV44403qt0UYonw3HPPYd++fZBl2XT6HKOUzpzVw7gc4c0iTpLZPlERye54USeI114rh87qO4ritLPm9JwulwvJZBJ79uyhVTeJsjA2NoaZmRnbcqKClB3lvB/0bbPb77RTZHeOck0XKZftAYpfYa/Uc7LzyrKMyclJSuBLlIVXX30Vhw8fzhPHebAUBixlQSWmmVbifhfdbif4GsuJiEh2x4u0TXS/CKJ2sJhng6qqSCQSeOONNzA9PV1sE5cNJD455LnnnsOOHTvo4iKK5lvf+hb+9E//lEIyibLT39+PF154AalUquBBazZiVyxORBAnYg7vGOP3KMYZMjtXOYQnJ+0p9Y9Xn9n3MJYxaytDURScPXsW77zzDu/fSBBFk06nMTY25vi5V4ydEknwaxURJdoZs9smUpdVuWI7XDx7r69PpKNXjF2yq1MUsylPyWQSs7OzwvUQhAhDQ0P49a9/rflNxkhIng1yIpKb2Qv9veM0Z5PZM92sfrvtvH08/8K43aqtTv0mp35PMbbJ6jdy+r3YnyzL6Ovro7y9DqDV7hwyODiIsbExvPTSS7jmmmuwdu3aajeJWCRkMhns3bsXL774IkU8ERUhmUxiYGAA/f39aG5uRm1tbcEKLk5ypJSCaEfKyomych6sHDGzzyKOlZNjRM4j0mZR9NEV+tVYjK9mWJVTFAWTk5MYGxvD1NSU47YRhBWKokBRFKTTafj9fvh8PqHjRO8TkWufobeBrPMoIsyUw2aKCjVm0/Ls6hLdVkwZu+ONv6tVGavtRhunqnPJxY3TNwmiHKRSKQwPD2NkZATNzc2oq6vT9hnthp2d4eWNE5m2aicsiR7j5P63KitSt4gvxl7thCeReqy+ixnG/4edD6U/j5lN0m/L5XKYnp7G5OSkUHQvMQdFPhVBNpvF7bffjn/5l38RUkoJQlVVTE1NYfv27ZTjiagouVwOzz//PE6ePAlZli2dfSdRBVadIad20E7sES3jBLsRLjNHTFSEMttnldzdyZ/o78T7DrxybBqB2+2GqqpIp9N46623MDY2JvJzEkRRTExMIB6Pl32FsmKiOK1yPVnZNDNxmVdO5LNIh9Hqs5VNsOu8ltOHZXU5nYJoRy6XQywWo6l2RMXI5XJ47bXXcO7cOc1vMksebvZc5t1L5cqX5sTXsrNbZr6V2fezqlvUP7I6D++7ivhBduV4v5eV3TT7Trz/Kfu/ZrNZHDlyhFIUOITEpxJ45JFH8Nu//duU9JCwha4VYr45ceIEnnnmGczOzkJRFE1k4GElQpUi+JSK3blFHZtKHGNsn11doh1CEcycR6v26dFHKLDEq/v376epwMS8kEgkMD4+rglQ+pWm5gs7cccuCbrT+isJa4/xtZoUMxXJuD+XyyGVSiEWi5WzaQRhSk9PD/bs2aOtguf1ernPxXKlLbC6D0qNUrcTnkXqLkZEshOXrPYVK6zZlRM5zknd6XQaFy5cwDvvvEN+UxGQ+FQCly5dwsGDB/HTn/4UZ8+erXZziAWILMvYtWsXXnzxRZw4caIqHXhieZJKpTA+Po6enh5MTU1BkiR4PJ68MsaHPm+kz2nHxmxkzbjPSTmzV6fOEK+dIsfYndOpM+bkz669Tp0+Ri6XQyaTwcjICMbHx2nZcmLeyOVyyGazSCaTyGazUBSlZMHEaSfHaoqFSL3FLthgVr/VZ54d4LXPSYerEh1aYxut7K7dFElVVbUV7codJUcQZqTTaUxOTqKvrw9TU1PIZDJFi+MiwhJvmp7I8WY2wGyb2b1odc5SfC07H67cfpRZ+0W+j93vpCeXy0GSJC09QTKZtCxP8CHxqURisRg++9nP4qWXXkI2my36gU4sHZhhY8tu3nnnnXjqqaeq3SxiGSJJEt544w309fUhmUzC651L88emggHvPmx5UyV4STad2DizDoixjNlns31mTonVvnI4UHYOk1m9TvZZleP9DsX+LtlsFrOzszhz5gwtC0zMO6o6NxU9kUhAkiRHYg3PpojmYzHbbna/GPNBWXVurLbbHWd3DO+zVTmrdonYZCe2qxwY61QURbs2CGI+kWUZBw4cQG9vL2ZmZrTVg51G89lNubO6T+3eG4+3Ek9E9zl5z2tbJX0t3vmtfgurOkR/F56dk2UZ8Xgcvb29lBuzBEh8KhM7d+7Ehz/84bI9iInFjSRJ+OlPf4rLL7+c5gITVefQoUN47rnncPr0aUiSBL/fnydAAWKjdJW0b1Z1mzkPTuo2O96po2Pl2Ojrt3PUisHOURU5XlXnOv19fX04dOgQJfAlqko8HtfyQKmqahllwMSgUqbDsXrs0J9HJOrTyX1YzmlxC2GKXTmRJEmbakf+NFFNTp06hddeew29vb3IZrOWkeOA+b3o9DouVxSo1X4RccbJ+UTqEvWvRL+HaNvKUZ+qqpienkZ/fz+OHz9OflOJ0Gp3ZWJ6ehonT57EN77xDbhcLqxevRp/+Id/WO1mEfPMuXPnsGvXLiiKggMHDmB4eLjaTSIISJKE2dlZ9PT0YHx8HE1NTVi3bl3BSnjG98VEOpm9txoF5I3eiYxUORWBjE6XsQ12xzgZUeO11ey34mEWicZ+S95vylttSl8+lUphbGwMyWQS8XicogqIqqOqc0tVJ5NJSJIEn8+HUCjE7YA57ZSZ2aBiVjmyeq9vmxOB2Hguu+0i9RYrUJfaMbPqeIt8R0VRtCl2iqKQ8ERUHVmWkUgktCl40WgUq1atyhPIyzWQJCqSlHrPi9Qt4tNY+WdmdTnxm3htLVbgZ8eZrXzH85X021KpFCYmJpBOpykas0yQ+FRGRkdH8bWvfQ0AcNNNN+HDH/4w6uvrtakuxNImFovh4MGD+OpXv1rtphBEAdlsVstN197ejq6uLgSDQQD8h7pxJahinBmr40XqMxOKjPucODZWopJZXaLljN+hWAHKSngyfrZyoFg5YM6RnpmZQU9PD/ecBFEtVFXVcmf4/X74/f6y+01WAojxvtLvt6vDrCxvezGCFa+NvGNEz1+pKFaz39BYhvf76gVIglhISJKEvr4+AEBLSwtaWlo0cZx3zRufu06x8iPMypmVYduLEbp4PpCxPiv/jFcH7z2vnaUKUFb/G95Ag1Gc0peRZRmzs7PaNUCUB5p2VyHeeOMNrFmzBidPnqx2U4h54o477sCnP/3pajeDIGwZGRnBP//zP+PChQvIZDJ5IpSIo1MNnDpDVk5XMcfPl/Akgp2jZtyWTqdx5MgReh4RC55sNovh4WGk02nkcrmKTkFxmjTcqjNoVV50fzF1OsE4oDDf8M6Zy+UwOzuLeDw+7+0hCCeMjY3hl7/8JYaGhpDJZODz+QrKiKwcXC2c+j3F+FrFiFV2Ipa+XCUxilCZTAYnT56kAbsKQOJThWDJpu+//348/vjj1W4OUSFSqRROnTqFO++8E0ePHkU6na52kwjCFlVVIUkSjhw5gqNHj2J4eBgul0tLrMnKiD7sixF9rPZZCTrldobsvkMxIhTvnLztvN/BWE7kWOPxwJwDxcLFz549i0QiQUsCE4sCVVUxOzuL2dlZZDIZR8cZMYvaFIkActrZsRObrI6xEqnthGtRm6Cvr5IdOZHvoCgKJElCMpmk1eyIRYGqzkXonTx5EqdOncLo6Gie32R8bhuve6PNsROzeec3frayBaXYL7tjSxWe7I43+x3t9ou2w+q3T6VSmJqawoULF5BKpSpqK5crNB+swvzHf/wH0uk0PvCBDwAAGhoa0NzcXOVWEaUiyzL6+voQi8Vw9OhRPPLII9VuEkE45sKFC9oqeB6PB8FgEH6/X9uvqpWZpiHqMIk4LyLHiDo6ImVEHSuRttr9LgAKwsKtjjPmKYjFYojFYhgZGTE9J0EsRFKpFGRZhsvlgtvthtvttl1xqpScUKL7ROwgs5uliETG7WZCkvGcxZzHaRmguMgpVncul4OiKJBlGdls1nE9BFFNBgcHkUql4PF44PP5EAwG4fP5hHNk2q3MaXXfW9kBM9/Eqk5RG2gmHOm3ifhHpfp3Zm0WmWpn/M31fhM7vyRJSCQSmJ2dxdjYmNlPQ5QIiU/zwH/+53/imWeeAQDcc889+Pu///sqt4golZGREWzZsgWSJJEqTixqxsbGMDY2htdffx1btmzBe9/7XtTV1UGW5bJMe6kWViNcTkbFnLw3+8x7X+p3Awo7gC6XC4qiIJVK4e233ybbRCxqJEnC9PQ0pqenUVNTg/r6evh8voJ7zApeJ8/Y6eCh75AYV7uzO7dTmylS3q5juxjstKqqyOVyiMVi1W4KQZTE5OQkJicncfDgQWzatAlXXnklotEoZFnWRHM9VmJTORARkZz4MyK+jtPzGMsWIzxVCkVRkE6ncfz4cfKb5gESn+YJNt3hySefRH9/P374wx9qeVaIxYGiKDh37hyeeeYZvPDCC8hms2SkiCWDqqro6+tDPB7HlVdeicbGRkQiEQDv2i9jh8zu+ncyeiUq6Ig4TaJ1OzmnSF28V7vfwQpeMkz9e1WdW5qedeoSiQSmpqYwNTVFtolYUqRSKSiKgpqaGvh8Pm3Zc54gJNrJ09+rdqtxOll0wayz5fSYYiim3mLO7eT3VlVV65TTEuXEUmNwcBCJRAKbN29GfX09QqEQ3G533jR3pysH6xGxJ3bbRc9T7OCbE5tnd3ypNsxqqjXPh0okEpiZmUEsFiO/aZ4g8WmeOXv2LEZHR/H6668jFAohGAzimmuuWRSjVssRVVWhKAouXbqE8+fP4/Tp03jhhRewe/fuajeNIMrO7OwskskkotEoMpkMotEo6urqCnJBmWHnEDntlImOiFnVW6ozZRS1nApXIm01wls5x3gcK8OWKGfLAE9NTWFmZsb2HASxmGARfV6vF4qiwOfzaQl/rZJyWy2jrd9uhtkqeXb7SqFc4lUxtroYeL8hqz+XyyGXy0GWZUiSRPmdiCVHPB5HKpVCfX090uk06urqEI1G4XYXplV2IhoVK1jzxCCn/ohVeTO/x6qNor6WXT1W2A1E6J8BuVwOkiQhk8kgmUxiZmaGFj2YR0h8qgKxWAy33norAKC7uxunTp3SjBSJUAsDvfFKJBL413/9V3zlK1+pYosIYn5QFAWHDh0CANTU1GD79u1obGxEIBCAJEkFCcmLiQao5Ki/lTNj5TSZHe/kPW8f7zuafV8z54nX2WX5b+LxOMbGxjA0NGTxyxDE0mB2dhYA4PF40NzcDL/f7yiqQC9A2XX49KKKVYfGDDNhy0nHUN9Os3aLCk9WttosL4pVOYAv7jFyuRyy2ayjpPEEsRhRFAXHjx8HAITDYdxyyy2or6+H3+/nTsPT43Rwyk7gMe4T9WGc+GF2IhLvOxUjPJXiN+mPM/7+bDGW0dFR0a9MlBESn6pMf38/rrvuOgDA1q1b8dhjj1W5RQQwJzi98sor+Ju/+RsoikKJ54hlSTKZxK9+9St4vV40NjbihhtuQDAY1ELK9WHldo6Lkw5isSIQrw7je31Z/Xnszilar50zZfe97XJFuFwu5HI5TE9PY2BgQEvcSxDLCUVRMDExAbfbDZ/PZxppoIfdS04SA9vV5/R4Jx08XhJdu+OddiCNSdxFo8DMvpuqzk2xy2Qyjju0BLEUSKfTeO211+DxeBCNRnHttddqfpOqqo78JiNWAjJ7LaZOp4NspRxvJXaV22/Sv+ZyOczOzmJkZESLxiSqA4lPVSaTyeDAgQMA5iKidu3aBQDo6urC9ddfX82mLUsmJibw0ksvIZVKYf/+/dr/hiCWI7lcDlNTUwDmbNX58+cRCARQU1Njumqn6KiVyOi9aH1OnBmR0TqzcnYOlJ3YJYKxrN6BkiQJ8XgcuVwO8XicwsSJZQ3rPORyOaRSKW3ZcxYNxbC7F0VEX+M2nv2q1DQ8s7qcdM707/UJ1PWdM6cYo2AVRdHEJ5peRyxXcrmcNvU9m83i4sWLCAQCCIfDaGpqyrMTeiHKCWaDbsb9vM9OfCqz904G5uwG7Ky+k53tNrPHepsmyzISiQQURUEymUQymSyoh5hfSHxaQJw5cwZ33HEHAOC2227Df/zHfwCA5lAR5YcZJ+YonTp1SvsfEATxLrFYDK+88goAYNWqVbj55pu1RRPMOnQinSXR0TUzeM4MTyzSn9/OAbJrjxMHjHcOHlZT7tgqdslkEmfOnLGshyCWG7IsY3JyEgAQDAbR2NjoyGfiiUZWedYYRuFG/2o83k4Y52G1vxjxHuBPGSxWINMfx+wTQRDvEo/HsW/fPgBAZ2cnrrvuOoRCobJMwxPxm0RFJKtzWPlNTnw6M9/IrG6793aJxVmUeDKZRG9vr+X3JOYXEp8WKC+88AK6u7sBAP/zf/5PfP3rX69yi5YmLJpjx44dWuJegiCsGRwcxC9+8Qu4XC50d3dj69atCAaD2kPfGM5c6uh/sQ6M2fHG7aKjdTxRqxzCkxm5XA6ZTAZnz54tSpgjiOVGJpPBpUuXAMzlXqmtrc0TopzcQ3YRQcYIIuN2J3UtNlRV1SLOltL3IohKMTIygueeew4ulwtr1qzB5s2b8/wmRVEKVhZmiD7/Re9FEb/HrG4rv0nkHGb18b5DMbZFURRkMhlcvHiR/KYFColPC5RkMokLFy4AAH71q1+hrq4OAHDTTTfh2muvrWbTFg3M6OgdQSYwzc7OYteuXUilUhgdHUVvby8ZKIIQRFEUbcrX0NAQvF4vfD4fmpub0dDQAL/fr5XN5XLce9EOUWdGRATiiUa8cqLH2zlNVs4UD72jyXIRzMzMaPmcKGEvQYjBOnHAnBDlcrngdrvh9/vh9XoL8kJZ3ZuinT0nq+ex/WYdsVLaInJMKX4Os2uyLGvvi502RBDLDX104KVLl7Qpwo2Njaivr4fP58uzT7zcUE4EKKeCjqhvY3eMiJhkJnw5bS+D5SCNxWLaSnYUTLBwIfFpEfDqq6/i1VdfBQDcf//9WkRUOBzWlhom+OgNIZuHHYvFMDg4iJ07d1KYOEGUyKVLl7RIgyuuuAIbNmxAQ0MDvF5vQTJbwNr54JWxE6HMPutfzY63E6jsxC4R4YrXDuMKduy9Xmzq7+8nQZwgSiCbzWodkEgkgnA4rOWDskrmbSXa2CUBF1lFzw6ngpiokFVqG5gflU6nheshCKKQ8fFxjI+PAwA2bNiAtWvXIhqNwuPxmIrZVj6PESsfhlfOuK2UY6zaI9o2JzZMURQtsGB4eJj8pkUAiU+LjPvvvx8PPvggAODHP/4xbrvttiq3aGGjqiouXbqE4eFhnDlzBl/72tcwOTkJVVVJeCKIMnPy5EmcOXMGLpcLGzZsQFtbG1paWhCJROByubTpeCLCjR47x4ZXzk5cciJwWY322R3DK6fv/GazWUiShEwmg6GhobzfiCCI8pBIJLRnfiQSQSAQQCAQgNvtFpoSZxat5CSak9WzWNAP3KXTabJJBFEBzp07h97eXrhcLqxfvx4tLS1obGxEKBSC2+3WpuOJRAmJIuID8crbCUdOBuys/CszmP2UJEkbqLt06ZK22AHZqMUBiU+LjHQ6rY06/ehHP8Lrr7+u7du8eTM++9nPVqtpCwLmKJ0/fx49PT3Ys2cPEokE4vE4JiYmcOnSJRq1I4gKwUKfgbnpeCzK0OfzoaamBu3t7YhEIlqHz+12a8cYQ8ztRsp4FBNx4NSBMqtb1JnL5XLIZrPIZDJaiDgbuZMkiZwngqgQ7N7KZDKQZRnpdBputxsej0dbCp3ZJd49bBSOihGSnNqoSkVBmR3HOrn6qXXUqSOIyqH3f0ZGRjA7O6ulM4hEImhpadGEKGaj2DHFiDhW23k+jdXgm50P5FSssmqXLMvIZrOIx+OaIMeixck+LS5IfFrEPPPMM3jmmWe0zx/60Iewbds27bPL5UJHR8eSXCmPGRrWaZNlGfF4HOl0GrIs46233sLevXvx3e9+t8otJYjlydTUFKamprTPjY2N8Hq9yOVy2pS8UChk2bGxG+mzimTiRSDx/uzOYyUqmbWJ9x30IlsqlUIikcDY2JjYj0kQRNmQJAmSJGmfWa4VlhOKN12Yh130gV1nUETQtisvsk/0nKqq5gnhBEHML9PT05ientY+R6NRuN1uRKNR+Hw+eDweBAIBW1sgOpAmOshndqydXybSHrN2AMiL+kqlUkilUpiYmDD97sTigMSnJcTLL7+M9evXa5/D4TDOnTuH5ubmKraqckiShEuXLmFoaAh9fX147LHH8PLLLwMQn6ZDEMT8MDk5iddee0377PF48N73vhd1dXWIRCKora3V7lk2ssdCqRkiwpGZwMT2G4/RY2U3mANkVo638hXr5KbTaUxMTGB2dtbBL0YQxHwgSRImJye1zy6XC3V1dVpnzziAtxBWriv1/EwQV9W5qb8sSTtBEAuH6elpHDhwQPvsdrtx9dVXo7a2FqFQCDU1NXn+iDEiym4wTuS9na9kN/hn5Yvp/SYW/cXE70wmg6mpKSQSiZJ/R2JhQeLTEkJV85c4TyQS+NznPodAIJBXbuXKlXjwwQcXVe6BbDaLmZkZDA8P4+2338azzz4LVVWRTqe1KILz588XLPFOEMTCQe98yLKMM2fOwOfzwev1wuudexwFAgGsX78efr8fHo9H267Pk6SPJtLX7eTP7BjjdgYvSbG+HbIsQ5ZlJJNJxGKxvH0sGSZBEAsfVZ3LCcnuebYCldvt1qa/GKOj2FQ9djxgLVLxIgvM9um3qWphnimrc+g7pSxK3HgcrVhHEAsXYyTQ+fPn4fV68/wjv9+PVatW5flTRhvF/BHj/V6sbyTiNzGM7WB/zG9KpVKIx+N5fhNLUUAsPUh8WsIoioKnn366YPv69evxyU9+kis+uVwuXHnllXlLpc8XLNw7k8lgeHgYsVhM28cU8AsXLuA3v/kNdu3aNe/tIwiivOijDRjBYBA1NTUIBALw+Xx54jmbqqdf/cXY4RPBrlPIc6jYaCJbxpd14piTxKKc4vF4Xtg8QRCLD960M5ZzRf8HvNux0i+T7jQ6ymwFTB68KAb2yosw0IvgNEBHEIsbfToDRiAQQCgUKvCbmAAVCATyBu8YpURQmi3CwF6Nf5IkaRGWzG9ieZzYoB2xPCDxaRly7tw5vP/97+fuCwQCOH/+PDo6Oua5VUAqlUIsFsOZM2fwwAMPYM+ePfPeBoIgqks6ncbbb7/N3edyuXDVVVchEonA7/dr02JYJAIrwxOneEnNeaOA+uP0DhITnLLZLEZHRxGPx8v91QmCWMDkcjnLqbO1tbV5wpTeFvGSlRs7bk4FKL1tY58zmQxNoSOIZUYmk8Hx48e5+1wuFy677DKEQiH4fD4tqtzj8RQI5yJT6AB+GgJjlCUTu9k0uvHxcZpCRwAg8YkwkM1mcdtttxUd+RQMBvFXf/VXePnll7F3715HxzJjlUql0N/fX9T5CYJYuqiqip6eHs1psurcsfJ6XC4XWltbMTs7q4V4m5W3GsGjUHCCIIwkk0kA+bbIKr2BcVqv3+/XOmtWWE3Loyl0BEHoUVUVfX19QqK48ThWprm5GfF4XLNxxjL692a+Ey1iQDBIfCLyUFUV+/fvL/r4QCCALVu24LXXXstLkkcQBFEOShk5c7lc8Hq9XCeKIAiiFMoRccRWdyIIgigXqVSq6GNdLhc8Hg8SiQTS6XQZW0UsV0h8IspKJpPBQw89VO1mEARBFKCqKkZHR6vdDIIgiAIoMoAgiIWGqqqYmJiodjOIJYTbvghBEARBEARBEARBEARBFAeJTwRBEARBEARBEARBEETFIPGJIAiCIAiCIAiCIAiCqBgkPhEEQRAEQRAEQRAEQRAVg8QngiAIgiAIgiAIgiAIomKQ+EQQBEEQBEEQBEEQBEFUDBKfCIIgCIIgCIIgCIIgiIpB4hNBEARBEARBEARBEARRMUh8IgiCIAiCIAiCIAiCICoGiU8EQRAEQRAEQRAEQRBExSDxiSAIgiAIgiAIgiAIgqgYJD4RBEEQBEEQBEEQBEEQFYPEJ4IgCIIgCIIgCIIgCKJikPhEEARBEARBEARBEARBVAwSnwiCIAiCIAiCIAiCIIiKQeITQRAEQRAEQRAEQRAEUTFIfCIIgiAIgiAIgiAIgiAqBolPBEEQBEEQBEEQBEEQRMUg8YkgCIIgCIIgCIIgCIKoGCQ+EQRBEARBEARBEARBEBWDxCeCIAiCIAiCIAiCIAiiYpD4RBAEQRAEQRAEQRAEQVQMEp8IgiAIgiAIgiAIgiCIikHiE0EQBEEQBEEQBEEQBFExSHwiCIIgCIIgCIIgCIIgKgaJTwRBEARBEARBEARBEETFIPGJIAiCIAiCIAiCIAiCqBgkPhEEQRAEQRAEQRAEQRAVg8QngiAIgiAIgiAIgiAIomKQ+EQQBEEQBEEQBEEQBEFUDBKfCIIgCIIgCIIgCIIgiIrhFSkkyzIAoLm5uaKNIQhiecBsCbMtpUD2iSCIclIu+0S2iSCIckK2iSCIhYqofRISn6anpwEAt99+e2mtIgiC0DE9PY2VK1eWXAdA9okgiPJSqn0i20QQRCUg20QQxELFzj65VFVV7SpJJpM4d+4cotEovF4hvYogCMIUWZYxPT2N9evXIxwOl1QX2SeCIMpJuewT2SaCIMoJ2SaCIBYqovZJSHwiCIIgCIIgCIIgCIIgiGKghOMEQRAEQRAEQRAEQRBExSDxiSAIgiAIgiAIgiAIgqgYJD4RBEEQBEEQBEEQBEEQFYPEJ4IgCIIgCIIgCIIgCKJikPhEEARBEARBEARBEARBVAwSnwiCIAiCIAiCIAiCIIiKQeITQRAEQRAEQRAEQRAEUTH+P3yBCu5UWGHwAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "importlib.reload(ps)\n", - "ps.plotTemporalEvolution()\n" + "# Define environment variables for BART and OpenMP\n", + "os.environ['TOOLBOX_PATH'] = \"/content/bart\"\n", + "os.environ['OMP_NUM_THREADS']=\"4\"\n", + "\n", + "# Add the BARTs toolbox to the PATH variable\n", + "os.environ['PATH'] = os.environ['TOOLBOX_PATH'] + \":\" + os.environ['PATH']\n", + "sys.path.append(os.environ['TOOLBOX_PATH'] + \"/python\")" ] }, { "cell_type": "markdown", - "id": "74857a61", - "metadata": {}, - "source": [ - "### T1 Map from Reconstructed Images\n", - "Using `bart mobafit` we obtain T1 parameter map via pixel-wise fitting. " - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "cb9b6bbe", + "id": "1150a41e", "metadata": {}, - "outputs": [], "source": [ - "%%pybash\n", - "\n", - "### create vector with inversion times nREP*TR\n", - "bart index 5 {REP} - | bart scale {TR} - TI\n", - "\n", - "bart mobafit -g -B subbasis -L --init 1:1:1 TI subspace_reco - | bart looklocker -t0 - -| bart fmac roi_mask - t1map" + "Test, if BART is installed correctly" ] }, { "cell_type": "code", - "execution_count": 20, - "id": "79442445", + "execution_count": 3, + "id": "decdec9a", "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "# BART used in this notebook:\n", + "/home/vtelezki/Repos/Groups/AG_Uecker/barts/bart/bart\n", + "# BART version: \n", + "v0.9.00-1131-g7dd53c3\n" + ] } ], "source": [ - "ps.plotT1Map()" + "%%bash\n", + "echo \"# BART used in this notebook:\"\n", + "which bart\n", + "echo \"# BART version: \"\n", + "bart version" ] }, { @@ -807,7 +236,9 @@ "source": [ "## Reconstruction Pulseq Data\n", "\n", - "Now, that we are familiar with subspace reconstruction, we apply this method on real-world data. In this case, we aim to reconstruct data obtained with Pulseq and a sequence prepared by `bart seq`.\n", + "Now, we aim to reconstruct data obtained with Pulseq and a sequence prepared by `bart seq`.\n", + "First, we create a signal dictionary, then we perform a SVD and finally create the temporal basis used in subspace reconstruction.\n", + "\n", "\n", "### Convert dat file to cfl\n", "First, we need to convert Siemens `.dat` file to bart `.cfl/.hdr` file format using `bart twixread` and check input file dimensions." @@ -962,9 +393,20 @@ { "cell_type": "markdown", "id": "5b4111b9", - "metadata": {}, + "metadata": { + "notebookRunGroups": { + "groupValue": "2" + } + }, "source": [ - "### Parameter for Dictionary" + "## Create Dictionary\n", + "\n", + "The signal model according to Look-Locker in voxel $r$ at time $t$ is\n", + "$$ \n", + "M(t,r)~=~M_{ss}(r)~-~\\left[M_{ss}(r)~+~M_{0}(r)\\right]~e^{-tR_1^*(r)}.~\n", + "$$\n", + "\n", + "Using `bart signal` we create our signal dictionary with `nR1s` values for R1star and `nMss` values for steady-state magnetization. " ] }, { @@ -1011,6 +453,14 @@ "bart svd -e subspace_dict U S V" ] }, + { + "cell_type": "markdown", + "id": "9ac84bc2", + "metadata": {}, + "source": [ + "### Visualize simulated dictionay and PCA coeffcients" + ] + }, { "cell_type": "code", "execution_count": 28, @@ -1032,6 +482,25 @@ "ps.plotSubspace()" ] }, + { + "cell_type": "markdown", + "id": "366196ff", + "metadata": {}, + "source": [ + "### Estimate Coil Sensitivities Using Subspace\n", + "We realized, that 4 PCA coefficients contribute to more than 99% of the observed signal. Hence, we can reduce our basis to only contain the first 4 eigenvectors. We create a subspace basis spanned by those 4 eigenvectors." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "34d0599a", + "metadata": {}, + "outputs": [], + "source": [ + "nCoe = 4 ## use 4 coefficients" + ] + }, { "cell_type": "code", "execution_count": 29, @@ -1082,6 +551,15 @@ "head -n2 traj.hdr\n" ] }, + { + "cell_type": "markdown", + "id": "cf545179", + "metadata": {}, + "source": [ + "\n", + " Now, we estimate coil sensitivities using `bart ncalib` and reduced subspace basis in one go. " + ] + }, { "cell_type": "code", "execution_count": 31, @@ -1161,6 +639,16 @@ "DEBUG_LEVEL=4 bart ncalib -N -i16 -t traj -B subbasis data/ksp_MID00019 sens_ncalib" ] }, + { + "cell_type": "markdown", + "id": "d7a097cd", + "metadata": {}, + "source": [ + "### Perform reconstruction \n", + "\n", + "Using estimated coil sensitvities, we can now perform parrallel imaging reconstruction with `bart pics`. We use the following parameter for iterations and regularization." + ] + }, { "cell_type": "code", "execution_count": 32, @@ -1353,6 +841,14 @@ "bart pics -g -e -d5 -i {ITER} -R W:$(bart bitmask 0 1):$(bart bitmask 6):{REG} -B subbasis -t traj data/ksp_MID00019 sens_ncalib subspace_reco" ] }, + { + "cell_type": "markdown", + "id": "7d0461f8", + "metadata": {}, + "source": [ + "We can visualize the first 4 coefficients projected onto our data set" + ] + }, { "cell_type": "code", "execution_count": 34, @@ -1376,23 +872,86 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 8, "id": "649fe1a6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " : No such file or directory\n", + "Loading cfl file subspace_reco\n", + "\u001b[31mERROR: \u001b[0m\u001b[31mERROR: Reading input from -\n", + "\u001b[0mbash: line 2: 816448 Aborted bart slice 6 1 subspace_reco -\n", + " 816449 | bart threshold -B 0.3 - mask\n", + " : No such file or directory\n", + "Loading cfl file mask\n", + "\u001b[31mERROR: \u001b[0mbash: line 3: 816480 Aborted bart fmac mask subspace_reco subspace_reco\n" + ] + }, + { + "ename": "CalledProcessError", + "evalue": "Command 'b'## by chance, 2nd coefficient map also suitable for mask \\nbart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\\nbart fmac mask subspace_reco subspace_reco\\n'' returned non-zero exit status 134.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbash\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m## by chance, 2nd coefficient map also suitable for mask \u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart fmac mask subspace_reco subspace_reco\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2565\u001b[39m, in \u001b[36mInteractiveShell.run_cell_magic\u001b[39m\u001b[34m(self, magic_name, line, cell)\u001b[39m\n\u001b[32m 2563\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m 2564\u001b[39m args = (magic_arg_s, cell)\n\u001b[32m-> \u001b[39m\u001b[32m2565\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2568\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2569\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2570\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:160\u001b[39m, in \u001b[36mScriptMagics._make_script_magic..named_script_magic\u001b[39m\u001b[34m(line, cell)\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 159\u001b[39m line = script\n\u001b[32m--> \u001b[39m\u001b[32m160\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshebang\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcell\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:343\u001b[39m, in \u001b[36mScriptMagics.shebang\u001b[39m\u001b[34m(self, line, cell)\u001b[39m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m args.raise_error \u001b[38;5;129;01mand\u001b[39;00m p.returncode != \u001b[32m0\u001b[39m:\n\u001b[32m 339\u001b[39m \u001b[38;5;66;03m# If we get here and p.returncode is still None, we must have\u001b[39;00m\n\u001b[32m 340\u001b[39m \u001b[38;5;66;03m# killed it but not yet seen its return code. We don't wait for it,\u001b[39;00m\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# in case it's stuck in uninterruptible sleep. -9 = SIGKILL\u001b[39;00m\n\u001b[32m 342\u001b[39m rc = p.returncode \u001b[38;5;129;01mor\u001b[39;00m -\u001b[32m9\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m343\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m CalledProcessError(rc, cell)\n", + "\u001b[31mCalledProcessError\u001b[39m: Command 'b'## by chance, 2nd coefficient map also suitable for mask \\nbart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\\nbart fmac mask subspace_reco subspace_reco\\n'' returned non-zero exit status 134." + ] + } + ], "source": [ "%%bash\n", - "## coefficient map also suitable for mask \n", + "## by chance, 2nd coefficient map also suitable for mask \n", "bart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\n", "bart fmac mask subspace_reco subspace_reco" ] }, + { + "cell_type": "markdown", + "id": "498cd337", + "metadata": {}, + "source": [ + "### Temporal Signal Evolution\n", + "\n", + "We can also project our subbasis onto all spokes, resulting in temporal signal evolution." + ] + }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 9, "id": "337338b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " : No such file or directory\n", + "Loading cfl file subbasis\n", + "\u001b[31mERROR: \u001b[0mbash: line 1: 816529 Aborted bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\n" + ] + }, + { + "ename": "CalledProcessError", + "evalue": "Command 'b'bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\\n'' returned non-zero exit status 134.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbash\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2565\u001b[39m, in \u001b[36mInteractiveShell.run_cell_magic\u001b[39m\u001b[34m(self, magic_name, line, cell)\u001b[39m\n\u001b[32m 2563\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m 2564\u001b[39m args = (magic_arg_s, cell)\n\u001b[32m-> \u001b[39m\u001b[32m2565\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2568\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2569\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2570\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:160\u001b[39m, in \u001b[36mScriptMagics._make_script_magic..named_script_magic\u001b[39m\u001b[34m(line, cell)\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 159\u001b[39m line = script\n\u001b[32m--> \u001b[39m\u001b[32m160\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshebang\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcell\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:343\u001b[39m, in \u001b[36mScriptMagics.shebang\u001b[39m\u001b[34m(self, line, cell)\u001b[39m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m args.raise_error \u001b[38;5;129;01mand\u001b[39;00m p.returncode != \u001b[32m0\u001b[39m:\n\u001b[32m 339\u001b[39m \u001b[38;5;66;03m# If we get here and p.returncode is still None, we must have\u001b[39;00m\n\u001b[32m 340\u001b[39m \u001b[38;5;66;03m# killed it but not yet seen its return code. We don't wait for it,\u001b[39;00m\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# in case it's stuck in uninterruptible sleep. -9 = SIGKILL\u001b[39;00m\n\u001b[32m 342\u001b[39m rc = p.returncode \u001b[38;5;129;01mor\u001b[39;00m -\u001b[32m9\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m343\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m CalledProcessError(rc, cell)\n", + "\u001b[31mCalledProcessError\u001b[39m: Command 'b'bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\\n'' returned non-zero exit status 134." + ] + } + ], "source": [ "%%bash \n", "bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs" @@ -1420,6 +979,15 @@ "ps.plotTemporalEvolution()\n" ] }, + { + "cell_type": "markdown", + "id": "6662df65", + "metadata": {}, + "source": [ + "### T1 Map from Reconstructed Images\n", + "Using `bart mobafit` we obtain T1 parameter map via pixel-wise fitting. " + ] + }, { "cell_type": "code", "execution_count": 38, From bdcd068c2e8467628d78d8ae36eebb7a01bd8afb Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Mon, 8 Sep 2025 15:37:49 +0200 Subject: [PATCH 12/17] Add badge colab --- README.md | 7 + tutorial.ipynb | 269 +----- tutorial_colab.ipynb | 2082 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 2130 insertions(+), 228 deletions(-) create mode 100644 tutorial_colab.ipynb diff --git a/README.md b/README.md index ccb4634..4c6ca3b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,13 @@ # Subspace Tutorial for ISMRM DACH-NORDIC 2025 Demonstrate subspace reconstruction for inversion recovery FLASH acquisition both on numerical phantom and data acquired with pulseq sequence generated with `bart seq`. +- [Jupyter Notebook](./tutorial.ipynb) +- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mrirecon/bart-workshop/blob/master/dach-ismrm_2025/subspace/tutorial_colab.ipynb) + + + + + ## Requirements ``` bart version v0.9.00-1131-g7dd53c3 diff --git a/tutorial.ipynb b/tutorial.ipynb index b3e5c79..3d7624b 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -33,25 +33,12 @@ " Simply prefix your cell with `%%bash`, and you can run any shell command, including calls to BART tools, just as you would in a terminal.\n", "\n", "- **`%%pybash` Cells in this Jupyter Notebook:**\n", - " Since it is cumbersome to redefine bash variables over and over, we use a custom magic command `%%pybash` instead. This custom magic command allows to access python variables inside the `bash` environment, making execution more convenient and consistent. The caveat here is that variables need to be enclosed by `{}` and not preceeded by `$`. Be careful, when copy-pasting code to your terminal. We use `%%bash` wherever possible for simple translation.\n", - "\n", - "\n", - "## Python Requirements " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b0258fb8", - "metadata": {}, - "outputs": [], - "source": [ - "!pip install -r requirements.txt" + " Since it is cumbersome to redefine bash variables over and over, we use a custom magic command `%%pybash` instead. This custom magic command allows to access python variables inside the `bash` environment, making execution more convenient and consistent. The caveat here is that variables need to be enclosed by `{}` and not preceeded by `$`. Be careful, when copy-pasting code to your terminal. We use `%%bash` wherever possible for simple translation.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "90fab0a9", "metadata": {}, "outputs": [], @@ -70,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "id": "8496d154", "metadata": {}, "outputs": [], @@ -92,108 +79,7 @@ "metadata": {}, "source": [ "## Bart Setup\n", - "### Google Colab\n", - "The cell will setup BART on Google Colab. For a detailed explanation, see **How to Run BART on Google Colaboratory** [here](https://github.com/mrirecon/bart-workshop/blob/master/ismrm2021/bart_on_colab/colab_gpu_tutorial.ipynb). You can skip this part if you want to run this notebook on your local machine.\n", - "\n", - "This tutorial do need a GPU, you can select one by going to **Edit → Notebook settings**: Choose **GPU** from **Hardware accelerator** drop-down menu." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fe98b350", - "metadata": {}, - "outputs": [], - "source": [ - "%%bash\n", - "\n", - "# Use CUDA 10.1 when on Tesla K80\n", - "\n", - "# Estimate GPU Type\n", - "GPU_NAME=$(nvidia-smi --query-gpu=gpu_name --format=csv,noheader)\n", - "\n", - "echo \"GPU Type:\"\n", - "echo $GPU_NAME\n", - "\n", - "if [ \"Tesla K80\" = \"$GPU_NAME\" ];\n", - "then\n", - " echo \"GPU type Tesla K80 does not support CUDA 11. Set CUDA to version 10.1.\"\n", - "\n", - " # Change default CUDA to version 10.1\n", - " cd /usr/local\n", - " rm cuda\n", - " ln -s cuda-10.1 cuda\n", - "else\n", - " echo \"Current GPU supports default CUDA-11.\"\n", - " echo \"No further actions are necessary.\"\n", - "fi\n", - "\n", - "echo \"GPU Information:\"\n", - "nvidia-smi --query-gpu=gpu_name,driver_version,memory.total --format=csv\n", - "nvcc --version\n" - ] - }, - { - "cell_type": "markdown", - "id": "468e5400", - "metadata": {}, - "source": [ - "Install BART" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c32f68fb", - "metadata": {}, - "outputs": [], - "source": [ - "%%bash\n", - "\n", - "# Install BARTs dependencies\n", - "apt-get install -y make gcc libfftw3-dev liblapacke-dev libpng-dev libopenblas-dev &> /dev/null\n", - "\n", - "# Clone Bart\n", - "[ -d /content/bart ] && rm -r /content/bart\n", - "git clone https://github.com/mrirecon/bart/ bart &> /dev/null\n", - "\n", - "cd bart\n", - "\n", - "# Define specifications \n", - "COMPILE_SPECS=\" PARALLEL=1\n", - " CUDA=1\n", - " CUDA_BASE=/usr/local/cuda\n", - " CUDA_LIB=lib64\n", - " OPENBLAS=1\n", - " BLAS_THREADSAFE=1\"\n", - "\n", - "printf \"%s\\n\" $COMPILE_SPECS > Makefiles/Makefile.local\n", - "\n", - "make &> /dev/null\n" - ] - }, - { - "cell_type": "markdown", - "id": "1b488cbf", - "metadata": {}, - "source": [ - "Set environment variables: enables correct path to BART " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b35dc3fa", - "metadata": {}, - "outputs": [], - "source": [ - "# Define environment variables for BART and OpenMP\n", - "os.environ['TOOLBOX_PATH'] = \"/content/bart\"\n", - "os.environ['OMP_NUM_THREADS']=\"4\"\n", - "\n", - "# Add the BARTs toolbox to the PATH variable\n", - "os.environ['PATH'] = os.environ['TOOLBOX_PATH'] + \":\" + os.environ['PATH']\n", - "sys.path.append(os.environ['TOOLBOX_PATH'] + \"/python\")" + "This notebook is intended for local use, with functional bart installation" ] }, { @@ -206,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "id": "decdec9a", "metadata": {}, "outputs": [ @@ -216,7 +102,13 @@ "text": [ "# BART used in this notebook:\n", "/home/vtelezki/Repos/Groups/AG_Uecker/barts/bart/bart\n", - "# BART version: \n", + "# BART version: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "v0.9.00-1131-g7dd53c3\n" ] } @@ -246,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 13, "id": "a591618d", "metadata": {}, "outputs": [ @@ -287,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "id": "d2b2a771", "metadata": {}, "outputs": [ @@ -317,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 15, "id": "cfa3809f", "metadata": {}, "outputs": [], @@ -329,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 16, "id": "c14782ff", "metadata": {}, "outputs": [ @@ -371,7 +263,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 17, "id": "07b9dded", "metadata": {}, "outputs": [ @@ -411,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 18, "id": "bb12ae41", "metadata": {}, "outputs": [], @@ -423,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 19, "id": "f00cf4a5", "metadata": {}, "outputs": [ @@ -463,13 +355,13 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 20, "id": "997f83b8", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -493,7 +385,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "id": "34d0599a", "metadata": {}, "outputs": [], @@ -503,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 22, "id": "86725660", "metadata": {}, "outputs": [], @@ -526,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 23, "id": "dbc79fd8", "metadata": {}, "outputs": [ @@ -562,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 24, "id": "09aa77bc", "metadata": {}, "outputs": [ @@ -629,7 +521,7 @@ "\t cg: 100\n", "Step: 15, Res: 0.244523\n", "\t cg: 55\n", - "Total time: 5.91 s\n" + "Total time: 5.56 s\n" ] } ], @@ -651,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 25, "id": "7122e0f6", "metadata": {}, "outputs": [], @@ -662,7 +554,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 26, "id": "3a3d91b5", "metadata": {}, "outputs": [ @@ -797,7 +689,7 @@ "#It 099: 0.000430 \n", "\n", "\t\tFISTA iterations: 100\n", - "Total Time: 20.350636\n", + "Total Time: 18.773693\n", "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", "Freeing 8 bytes.\n", @@ -851,7 +743,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 27, "id": "53cca807", "metadata": {}, "outputs": [ @@ -872,39 +764,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 28, "id": "649fe1a6", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " : No such file or directory\n", - "Loading cfl file subspace_reco\n", - "\u001b[31mERROR: \u001b[0m\u001b[31mERROR: Reading input from -\n", - "\u001b[0mbash: line 2: 816448 Aborted bart slice 6 1 subspace_reco -\n", - " 816449 | bart threshold -B 0.3 - mask\n", - " : No such file or directory\n", - "Loading cfl file mask\n", - "\u001b[31mERROR: \u001b[0mbash: line 3: 816480 Aborted bart fmac mask subspace_reco subspace_reco\n" - ] - }, - { - "ename": "CalledProcessError", - "evalue": "Command 'b'## by chance, 2nd coefficient map also suitable for mask \\nbart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\\nbart fmac mask subspace_reco subspace_reco\\n'' returned non-zero exit status 134.", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbash\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m## by chance, 2nd coefficient map also suitable for mask \u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mbart fmac mask subspace_reco subspace_reco\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2565\u001b[39m, in \u001b[36mInteractiveShell.run_cell_magic\u001b[39m\u001b[34m(self, magic_name, line, cell)\u001b[39m\n\u001b[32m 2563\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m 2564\u001b[39m args = (magic_arg_s, cell)\n\u001b[32m-> \u001b[39m\u001b[32m2565\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2568\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2569\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2570\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:160\u001b[39m, in \u001b[36mScriptMagics._make_script_magic..named_script_magic\u001b[39m\u001b[34m(line, cell)\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 159\u001b[39m line = script\n\u001b[32m--> \u001b[39m\u001b[32m160\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshebang\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcell\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:343\u001b[39m, in \u001b[36mScriptMagics.shebang\u001b[39m\u001b[34m(self, line, cell)\u001b[39m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m args.raise_error \u001b[38;5;129;01mand\u001b[39;00m p.returncode != \u001b[32m0\u001b[39m:\n\u001b[32m 339\u001b[39m \u001b[38;5;66;03m# If we get here and p.returncode is still None, we must have\u001b[39;00m\n\u001b[32m 340\u001b[39m \u001b[38;5;66;03m# killed it but not yet seen its return code. We don't wait for it,\u001b[39;00m\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# in case it's stuck in uninterruptible sleep. -9 = SIGKILL\u001b[39;00m\n\u001b[32m 342\u001b[39m rc = p.returncode \u001b[38;5;129;01mor\u001b[39;00m -\u001b[32m9\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m343\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m CalledProcessError(rc, cell)\n", - "\u001b[31mCalledProcessError\u001b[39m: Command 'b'## by chance, 2nd coefficient map also suitable for mask \\nbart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\\nbart fmac mask subspace_reco subspace_reco\\n'' returned non-zero exit status 134." - ] - } - ], + "outputs": [], "source": [ "%%bash\n", "## by chance, 2nd coefficient map also suitable for mask \n", @@ -924,34 +787,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 29, "id": "337338b7", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " : No such file or directory\n", - "Loading cfl file subbasis\n", - "\u001b[31mERROR: \u001b[0mbash: line 1: 816529 Aborted bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\n" - ] - }, - { - "ename": "CalledProcessError", - "evalue": "Command 'b'bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\\n'' returned non-zero exit status 134.", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mCalledProcessError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mget_ipython\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_cell_magic\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbash\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mbart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2565\u001b[39m, in \u001b[36mInteractiveShell.run_cell_magic\u001b[39m\u001b[34m(self, magic_name, line, cell)\u001b[39m\n\u001b[32m 2563\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.builtin_trap:\n\u001b[32m 2564\u001b[39m args = (magic_arg_s, cell)\n\u001b[32m-> \u001b[39m\u001b[32m2565\u001b[39m result = \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2567\u001b[39m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[32m 2568\u001b[39m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[32m 2569\u001b[39m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[32m 2570\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:160\u001b[39m, in \u001b[36mScriptMagics._make_script_magic..named_script_magic\u001b[39m\u001b[34m(line, cell)\u001b[39m\n\u001b[32m 158\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 159\u001b[39m line = script\n\u001b[32m--> \u001b[39m\u001b[32m160\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshebang\u001b[49m\u001b[43m(\u001b[49m\u001b[43mline\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcell\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/Repos/Groups/AG_Uecker/subspaceT1/workshopKiel2025/.venv/lib/python3.11/site-packages/IPython/core/magics/script.py:343\u001b[39m, in \u001b[36mScriptMagics.shebang\u001b[39m\u001b[34m(self, line, cell)\u001b[39m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m args.raise_error \u001b[38;5;129;01mand\u001b[39;00m p.returncode != \u001b[32m0\u001b[39m:\n\u001b[32m 339\u001b[39m \u001b[38;5;66;03m# If we get here and p.returncode is still None, we must have\u001b[39;00m\n\u001b[32m 340\u001b[39m \u001b[38;5;66;03m# killed it but not yet seen its return code. We don't wait for it,\u001b[39;00m\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# in case it's stuck in uninterruptible sleep. -9 = SIGKILL\u001b[39;00m\n\u001b[32m 342\u001b[39m rc = p.returncode \u001b[38;5;129;01mor\u001b[39;00m -\u001b[32m9\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m343\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m CalledProcessError(rc, cell)\n", - "\u001b[31mCalledProcessError\u001b[39m: Command 'b'bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs\\n'' returned non-zero exit status 134." - ] - } - ], + "outputs": [], "source": [ "%%bash \n", "bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs" @@ -959,7 +798,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 31, "id": "6e62143e", "metadata": {}, "outputs": [ @@ -975,7 +814,6 @@ } ], "source": [ - "importlib.reload(ps)\n", "ps.plotTemporalEvolution()\n" ] }, @@ -990,7 +828,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 36, "id": "4d5e4eaa", "metadata": {}, "outputs": [ @@ -998,7 +836,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Temp file for pipe: bart-aT5vlj\n", + "Temp file for pipe: bart-twf2BI\n", "Step: 0, Res: 5748.667991\n", "\t cg: 11\n", "Step: 1, Res: 144.627954\n", @@ -1015,31 +853,7 @@ "\t cg: 50\n", "Step: 7, Res: nan\n", "\t cg: 50\n", - "Step: 8, Res: nan\n", - "\t cg: 50\n", - "Step: 9, Res: nan\n", - "\t cg: 50\n", - "Step: 10, Res: nan\n", - "\t cg: 50\n", - "Step: 11, Res: nan\n", - "\t cg: 50\n", - "Step: 12, Res: nan\n", - "\t cg: 50\n", - "Step: 13, Res: nan\n", - "\t cg: 50\n", - "Step: 14, Res: nan\n", - "\t cg: 50\n", - "Step: 15, Res: nan\n", - "\t cg: 50\n", - "Step: 16, Res: nan\n", - "\t cg: 50\n", - "Step: 17, Res: nan\n", - "\t cg: 50\n", - "Step: 18, Res: nan\n", - "\t cg: 50\n", - "Step: 19, Res: nan\n", - "\t cg: 50\n", - "Total Time: 2.49 s\n", + "Total Time: 2.30 s\n", "Freed 3611607760 bytes.\n" ] } @@ -1049,18 +863,18 @@ "### create vector with inversion times nREP*TR\n", "bart index 5 {REP} - | bart scale {TR} - TI\n", "\n", - "DEBUG_LEVEL=4 bart mobafit -g -i20 --init 1:1:1 -B subbasis -L TI subspace_reco - | bart looklocker -t0 -D15.3e-3 - t1map" + "DEBUG_LEVEL=4 bart mobafit -g -i8 --init 1:1:1 -B subbasis -L TI subspace_reco - | bart looklocker -t0 -D15.3e-3 - t1map" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 37, "id": "a6cfbe43", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1070,7 +884,6 @@ } ], "source": [ - "importlib.reload(ps)\n", "ps.plotT1Map()" ] } diff --git a/tutorial_colab.ipynb b/tutorial_colab.ipynb new file mode 100644 index 0000000..e485837 --- /dev/null +++ b/tutorial_colab.ipynb @@ -0,0 +1,2082 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1f4124b4", + "metadata": { + "id": "1f4124b4" + }, + "source": [ + "# Non-Cartesian T1 | Subspace-Constrained Reconstruction\n", + "This tutorial uses the [`BART`](http://mrirecon.github.io/bart/) command-line interface (CLI) and presents how to work with radial data using BART, with the goal of implementing a full processing pipeline from raw data to T1 maps.\n", + "\n", + "\n", + "## Outline\n", + "1. Bart Setup\n", + "6. Reconstruction Pulseq Data\n", + " 1. Prepare data\n", + " 2. Subspace reconstruction\n", + " 3. Postprocessing\n", + " \n", + "\n", + "\n", + "**Author**: [Vitali Telezki](mailto:vitali.telezki@med.uni-goettingen.de)\n", + "\n", + "**Institution**: University Medical Center Göttingen\n", + "\n", + "Based on previous material written by [Daniel Mackner](mailto:daniel.mackner@tugraz.at), [Moritz Blumenthal](mailto:blumenthal@@tugraz.at) and [Jon Tamir](mailto:jtamir@utexas.edu).\n", + "\n", + "In this interactive session, we recommend running BART calls in the terminal, and use this notebook as a reference. Nevertheless, we will provide some examples of how to run BART commands in this notebook to be self-contained.\n", + "\n", + "**💡CAVE:💡**\n", + "\n", + "- **`%%bash` Cells in Jupyter Notebooks:**\n", + " Magic commands like `%%bash` allow you to run bash commands directly within your notebook.\n", + " Simply prefix your cell with `%%bash`, and you can run any shell command, including calls to BART tools, just as you would in a terminal.\n", + "\n", + "- **`%%pybash` Cells in this Jupyter Notebook:**\n", + " Since it is cumbersome to redefine bash variables over and over, we use a custom magic command `%%pybash` instead. This custom magic command allows to access python variables inside the `bash` environment, making execution more convenient and consistent. The caveat here is that variables need to be enclosed by `{}` and not preceeded by `$`. Be careful, when copy-pasting code to your terminal. We use `%%bash` wherever possible for simple translation.\n", + "\n", + "\n", + "## Python Requirements" + ] + }, + { + "cell_type": "code", + "source": [ + "%%bash\n", + "mkdir -p ./src\n", + "wget https://owncloud.gwdg.de/index.php/s/ofa0uJGjLlGSFk4/download -O ./src/plotSubspace.py\n", + "wget https://owncloud.gwdg.de/index.php/s/uvUdR8epcdNUE36/download -O ./src/customStyle.mplstyle" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "T6ehqtBx-5X2", + "outputId": "3821c51a-984b-4400-ccee-c0351b915a04" + }, + "id": "T6ehqtBx-5X2", + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "--2025-09-08 09:43:25-- https://owncloud.gwdg.de/index.php/s/ofa0uJGjLlGSFk4/download\n", + "Resolving owncloud.gwdg.de (owncloud.gwdg.de)... 134.76.23.45\n", + "Connecting to owncloud.gwdg.de (owncloud.gwdg.de)|134.76.23.45|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3150 (3.1K) [text/x-python]\n", + "Saving to: ‘./src/plotSubspace.py’\n", + "\n", + " 0K ... 100% 1.19G=0s\n", + "\n", + "2025-09-08 09:43:25 (1.19 GB/s) - ‘./src/plotSubspace.py’ saved [3150/3150]\n", + "\n", + "--2025-09-08 09:43:25-- https://owncloud.gwdg.de/index.php/s/uvUdR8epcdNUE36/download\n", + "Resolving owncloud.gwdg.de (owncloud.gwdg.de)... 134.76.23.45\n", + "Connecting to owncloud.gwdg.de (owncloud.gwdg.de)|134.76.23.45|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 349 [application/octet-stream]\n", + "Saving to: ‘./src/customStyle.mplstyle’\n", + "\n", + " 0K 100% 390M=0s\n", + "\n", + "2025-09-08 09:43:25 (390 MB/s) - ‘./src/customStyle.mplstyle’ saved [349/349]\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8496d154", + "metadata": { + "id": "8496d154" + }, + "outputs": [], + "source": [ + "from IPython import get_ipython\n", + "from IPython.core.magic import register_cell_magic\n", + "\n", + "ipython = get_ipython()\n", + "\n", + "\n", + "@register_cell_magic\n", + "def pybash(line, cell):\n", + " ipython.run_cell_magic('bash', '', cell.format(**globals()))" + ] + }, + { + "cell_type": "markdown", + "id": "638eb164", + "metadata": { + "id": "638eb164" + }, + "source": [ + "## Bart Setup\n", + "### Google Colab\n", + "The cell will setup BART on Google Colab. For a detailed explanation, see **How to Run BART on Google Colaboratory** [here](https://github.com/mrirecon/bart-workshop/blob/master/ismrm2021/bart_on_colab/colab_gpu_tutorial.ipynb). You can skip this part if you want to run this notebook on your local machine.\n", + "\n", + "This tutorial do need a GPU, you can select one by going to **Edit → Notebook settings**: Choose **GPU** from **Hardware accelerator** drop-down menu." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fe98b350", + "metadata": { + "id": "fe98b350", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7ac91cb0-5ce1-415d-d506-8b1f6bbc1aa2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Reading package lists...\n", + "Building dependency tree...\n", + "Reading state information...\n", + "The following additional packages will be installed:\n", + " cuda-cccl-12-4 cuda-command-line-tools-12-4 cuda-compiler-12-4 cuda-crt-12-4\n", + " cuda-cudart-12-4 cuda-cudart-dev-12-4 cuda-cuobjdump-12-4 cuda-cupti-12-4\n", + " cuda-cupti-dev-12-4 cuda-cuxxfilt-12-4 cuda-demo-suite-12-4\n", + " cuda-documentation-12-4 cuda-driver-dev-12-4 cuda-drivers cuda-drivers-580\n", + " cuda-gdb-12-4 cuda-libraries-12-4 cuda-libraries-dev-12-4 cuda-nsight-12-4\n", + " cuda-nsight-compute-12-4 cuda-nsight-systems-12-4 cuda-nvcc-12-4\n", + " cuda-nvdisasm-12-4 cuda-nvml-dev-12-4 cuda-nvprof-12-4 cuda-nvprune-12-4\n", + " cuda-nvrtc-12-4 cuda-nvrtc-dev-12-4 cuda-nvtx-12-4 cuda-nvvm-12-4\n", + " cuda-nvvp-12-4 cuda-opencl-12-4 cuda-opencl-dev-12-4 cuda-profiler-api-12-4\n", + " cuda-runtime-12-4 cuda-sanitizer-12-4 cuda-toolkit-12-4\n", + " cuda-toolkit-12-4-config-common cuda-tools-12-4 cuda-visual-tools-12-4\n", + " default-jre default-jre-headless dkms fakeroot fonts-dejavu-core\n", + " fonts-dejavu-extra gds-tools-12-4 keyboard-configuration libatk-wrapper-java\n", + " libatk-wrapper-java-jni libcublas-12-4 libcublas-dev-12-4 libcufft-12-4\n", + " libcufft-dev-12-4 libcufile-12-4 libcufile-dev-12-4 libcurand-12-4\n", + " libcurand-dev-12-4 libcusolver-12-4 libcusolver-dev-12-4 libcusparse-12-4\n", + " libcusparse-dev-12-4 libfakeroot libgail-common libgail18 libgtk2.0-0\n", + " libgtk2.0-bin libgtk2.0-common libgudev-1.0-0 libjansson4\n", + " liblocale-gettext-perl libnpp-12-4 libnpp-dev-12-4 libnvfatbin-12-4\n", + " libnvfatbin-dev-12-4 libnvidia-cfg1-580 libnvidia-common-580\n", + " libnvidia-compute-580 libnvidia-decode-580 libnvidia-encode-580\n", + " libnvidia-extra-580 libnvidia-fbc1-580 libnvidia-gl-580\n", + " libnvidia-gpucomp-580 libnvjitlink-12-4 libnvjitlink-dev-12-4 libnvjpeg-12-4\n", + " libnvjpeg-dev-12-4 librsvg2-common libtinfo5 libudev1 libxcb-icccm4\n", + " libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-util1\n", + " libxcb-xinerama0 libxcb-xinput0 libxcb-xkb1 libxcvt0 libxkbcommon-x11-0\n", + " libxtst6 libxxf86dga1 nsight-compute-2024.1.1 nsight-systems-2023.4.4\n", + " nvidia-dkms-580 nvidia-driver-580 nvidia-firmware-580\n", + " nvidia-kernel-common-580 nvidia-kernel-source-580 nvidia-modprobe\n", + " nvidia-persistenced nvidia-settings openjdk-11-jre python3-xkit\n", + " screen-resolution-extra switcheroo-control systemd-hwe-hwdb udev x11-utils\n", + " xcvt xserver-xorg-core xserver-xorg-video-nvidia-580\n", + "Suggested packages:\n", + " menu gvfs mesa-utils xfonts-100dpi | xfonts-75dpi xfonts-scalable\n", + "Recommended packages:\n", + " libnvidia-compute-580:i386 libnvidia-decode-580:i386\n", + " libnvidia-encode-580:i386 libnvidia-fbc1-580:i386 libnvidia-gl-580:i386\n", + "The following NEW packages will be installed:\n", + " cuda-12-4 cuda-cccl-12-4 cuda-command-line-tools-12-4 cuda-compiler-12-4\n", + " cuda-crt-12-4 cuda-cudart-12-4 cuda-cudart-dev-12-4 cuda-cuobjdump-12-4\n", + " cuda-cupti-12-4 cuda-cupti-dev-12-4 cuda-cuxxfilt-12-4 cuda-demo-suite-12-4\n", + " cuda-documentation-12-4 cuda-driver-dev-12-4 cuda-drivers cuda-drivers-580\n", + " cuda-gdb-12-4 cuda-libraries-12-4 cuda-libraries-dev-12-4 cuda-nsight-12-4\n", + " cuda-nsight-compute-12-4 cuda-nsight-systems-12-4 cuda-nvcc-12-4\n", + " cuda-nvdisasm-12-4 cuda-nvml-dev-12-4 cuda-nvprof-12-4 cuda-nvprune-12-4\n", + " cuda-nvrtc-12-4 cuda-nvrtc-dev-12-4 cuda-nvtx-12-4 cuda-nvvm-12-4\n", + " cuda-nvvp-12-4 cuda-opencl-12-4 cuda-opencl-dev-12-4 cuda-profiler-api-12-4\n", + " cuda-runtime-12-4 cuda-sanitizer-12-4 cuda-toolkit-12-4\n", + " cuda-toolkit-12-4-config-common cuda-tools-12-4 cuda-visual-tools-12-4\n", + " default-jre default-jre-headless dkms fakeroot fonts-dejavu-core\n", + " fonts-dejavu-extra gds-tools-12-4 keyboard-configuration libatk-wrapper-java\n", + " libatk-wrapper-java-jni libcublas-12-4 libcublas-dev-12-4 libcufft-12-4\n", + " libcufft-dev-12-4 libcufile-12-4 libcufile-dev-12-4 libcurand-12-4\n", + " libcurand-dev-12-4 libcusolver-12-4 libcusolver-dev-12-4 libcusparse-12-4\n", + " libcusparse-dev-12-4 libfakeroot libgail-common libgail18 libgtk2.0-0\n", + " libgtk2.0-bin libgtk2.0-common libgudev-1.0-0 libjansson4\n", + " liblocale-gettext-perl libnpp-12-4 libnpp-dev-12-4 libnvfatbin-12-4\n", + " libnvfatbin-dev-12-4 libnvidia-cfg1-580 libnvidia-common-580\n", + " libnvidia-compute-580 libnvidia-decode-580 libnvidia-encode-580\n", + " libnvidia-extra-580 libnvidia-fbc1-580 libnvidia-gl-580\n", + " libnvidia-gpucomp-580 libnvjitlink-12-4 libnvjitlink-dev-12-4 libnvjpeg-12-4\n", + " libnvjpeg-dev-12-4 librsvg2-common libtinfo5 libxcb-icccm4 libxcb-image0\n", + " libxcb-keysyms1 libxcb-render-util0 libxcb-util1 libxcb-xinerama0\n", + " libxcb-xinput0 libxcb-xkb1 libxcvt0 libxkbcommon-x11-0 libxtst6 libxxf86dga1\n", + " nsight-compute-2024.1.1 nsight-systems-2023.4.4 nvidia-dkms-580\n", + " nvidia-driver-580 nvidia-firmware-580 nvidia-kernel-common-580\n", + " nvidia-kernel-source-580 nvidia-modprobe nvidia-persistenced nvidia-settings\n", + " openjdk-11-jre python3-xkit screen-resolution-extra switcheroo-control\n", + " systemd-hwe-hwdb udev x11-utils xcvt xserver-xorg-core\n", + " xserver-xorg-video-nvidia-580\n", + "The following packages will be upgraded:\n", + " libudev1\n", + "1 upgraded, 123 newly installed, 0 to remove and 34 not upgraded.\n", + "Need to get 3,422 MB of archives.\n", + "After this operation, 7,802 MB of additional disk space will be used.\n", + "Get:1 http://archive.ubuntu.com/ubuntu jammy/main amd64 liblocale-gettext-perl amd64 1.07-4build3 [17.1 kB]\n", + "Get:2 http://archive.ubuntu.com/ubuntu jammy/main amd64 keyboard-configuration all 1.205ubuntu3 [206 kB]\n", + "Get:3 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libudev1 amd64 249.11-0ubuntu3.16 [76.7 kB]\n", + "Get:4 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 udev amd64 249.11-0ubuntu3.16 [1,557 kB]\n", + "Get:5 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 dkms 1:3.2.1-1ubuntu2 [53.5 kB]\n", + "Get:6 http://archive.ubuntu.com/ubuntu jammy/main amd64 libjansson4 amd64 2.13.1-1.1build3 [32.4 kB]\n", + "Get:7 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcvt0 amd64 0.1.1-3 [5,494 B]\n", + "Get:8 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 xserver-xorg-core amd64 2:21.1.4-2ubuntu1.7~22.04.15 [1,477 kB]\n", + "Get:9 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 libtinfo5 amd64 6.3-2ubuntu0.1 [100 kB]\n", + "Get:10 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-xinerama0 amd64 1.14-3ubuntu3 [5,414 B]\n", + "Get:11 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-icccm4 amd64 0.4.1-1.1build2 [11.5 kB]\n", + "Get:12 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-util1 amd64 0.4.0-1build2 [11.4 kB]\n", + "Get:13 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-image0 amd64 0.4.0-2 [11.5 kB]\n", + "Get:14 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-keysyms1 amd64 0.4.0-1build3 [8,746 B]\n", + "Get:15 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-render-util0 amd64 0.3.9-1build3 [10.3 kB]\n", + "Get:16 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-xkb1 amd64 1.14-3ubuntu3 [32.8 kB]\n", + "Get:17 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxkbcommon-x11-0 amd64 1.4.0-1 [14.4 kB]\n", + "Get:18 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxcb-xinput0 amd64 1.14-3ubuntu3 [34.3 kB]\n", + "Get:19 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxtst6 amd64 2:1.2.3-1build4 [13.4 kB]\n", + "Get:20 http://archive.ubuntu.com/ubuntu jammy/main amd64 default-jre-headless amd64 2:1.11-72build2 [3,042 B]\n", + "Get:21 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 openjdk-11-jre amd64 11.0.28+6-1ubuntu1~22.04.1 [214 kB]\n", + "Get:22 http://archive.ubuntu.com/ubuntu jammy/main amd64 default-jre amd64 2:1.11-72build2 [896 B]\n", + "Get:23 http://archive.ubuntu.com/ubuntu jammy/main amd64 libfakeroot amd64 1.28-1ubuntu1 [31.5 kB]\n", + "Get:24 http://archive.ubuntu.com/ubuntu jammy/main amd64 fakeroot amd64 1.28-1ubuntu1 [60.4 kB]\n", + "Get:25 http://archive.ubuntu.com/ubuntu jammy/main amd64 fonts-dejavu-core all 2.37-2build1 [1,041 kB]\n", + "Get:26 http://archive.ubuntu.com/ubuntu jammy/main amd64 fonts-dejavu-extra all 2.37-2build1 [2,041 kB]\n", + "Get:27 http://archive.ubuntu.com/ubuntu jammy/main amd64 libxxf86dga1 amd64 2:1.1.5-0ubuntu3 [12.6 kB]\n", + "Get:28 http://archive.ubuntu.com/ubuntu jammy/main amd64 x11-utils amd64 7.7+5build2 [206 kB]\n", + "Get:29 http://archive.ubuntu.com/ubuntu jammy/main amd64 libatk-wrapper-java all 0.38.0-5build1 [53.1 kB]\n", + "Get:30 http://archive.ubuntu.com/ubuntu jammy/main amd64 libatk-wrapper-java-jni amd64 0.38.0-5build1 [49.0 kB]\n", + "Get:31 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libgtk2.0-common all 2.24.33-2ubuntu2.1 [125 kB]\n", + "Get:32 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libgtk2.0-0 amd64 2.24.33-2ubuntu2.1 [2,038 kB]\n", + "Get:33 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libgail18 amd64 2.24.33-2ubuntu2.1 [15.9 kB]\n", + "Get:34 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libgail-common amd64 2.24.33-2ubuntu2.1 [132 kB]\n", + "Get:35 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 libgtk2.0-bin amd64 2.24.33-2ubuntu2.1 [7,936 B]\n", + "Get:36 http://archive.ubuntu.com/ubuntu jammy/main amd64 libgudev-1.0-0 amd64 1:237-2build1 [16.3 kB]\n", + "Get:37 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 librsvg2-common amd64 2.52.5+dfsg-3ubuntu0.2 [17.7 kB]\n", + "Get:38 http://archive.ubuntu.com/ubuntu jammy/main amd64 python3-xkit all 0.5.0ubuntu5 [18.5 kB]\n", + "Get:39 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 screen-resolution-extra all 0.18.2ubuntu0.1 [4,306 B]\n", + "Get:40 http://archive.ubuntu.com/ubuntu jammy/main amd64 switcheroo-control amd64 2.4-3build2 [16.5 kB]\n", + "Get:41 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 systemd-hwe-hwdb all 249.11.5 [3,228 B]\n", + "Get:42 http://archive.ubuntu.com/ubuntu jammy/main amd64 xcvt amd64 0.1.1-3 [7,140 B]\n", + "Get:43 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-toolkit-12-4-config-common 12.4.127-1 [16.4 kB]\n", + "Get:44 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cudart-12-4 12.4.127-1 [165 kB]\n", + "Get:45 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvrtc-12-4 12.4.127-1 [17.6 MB]\n", + "Get:46 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-opencl-12-4 12.4.127-1 [24.0 kB]\n", + "Get:47 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcublas-12-4 12.4.5.8-1 [231 MB]\n", + "Get:48 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcufft-12-4 11.2.1.3-1 [171 MB]\n", + "Get:49 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcufile-12-4 1.9.1.3-1 [850 kB]\n", + "Get:50 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcurand-12-4 10.3.5.147-1 [41.4 MB]\n", + "Get:51 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcusolver-12-4 11.6.1.9-1 [78.9 MB]\n", + "Get:52 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcusparse-12-4 12.3.1.170-1 [115 MB]\n", + "Get:53 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnpp-12-4 12.2.5.30-1 [95.5 MB]\n", + "Get:54 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvjitlink-12-4 12.4.127-1 [15.5 MB]\n", + "Get:55 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvfatbin-12-4 12.4.127-1 [721 kB]\n", + "Get:56 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvjpeg-12-4 12.3.1.117-1 [2,327 kB]\n", + "Get:57 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-libraries-12-4 12.4.1-1 [2,606 B]\n", + "Get:58 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-common-580 580.82.07-0ubuntu1 [16.8 kB]\n", + "Get:59 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-decode-580 580.82.07-0ubuntu1 [2,722 kB]\n", + "Get:60 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-cfg1-580 580.82.07-0ubuntu1 [147 kB]\n", + "Get:61 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-gpucomp-580 580.82.07-0ubuntu1 [18.5 MB]\n", + "Get:62 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-persistenced 580.82.07-0ubuntu1 [82.5 kB]\n", + "Get:63 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-compute-580 580.82.07-0ubuntu1 [54.7 MB]\n", + "Get:64 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-gl-580 580.82.07-0ubuntu1 [148 MB]\n", + "Get:65 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-kernel-source-580 580.82.07-0ubuntu1 [83.0 MB]\n", + "Get:66 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-firmware-580 580.82.07-0ubuntu1 [74.6 MB]\n", + "Get:67 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-modprobe 580.82.07-0ubuntu1 [14.9 kB]\n", + "Get:68 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-kernel-common-580 580.82.07-0ubuntu1 [700 kB]\n", + "Get:69 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-dkms-580 580.82.07-0ubuntu1 [14.7 kB]\n", + "Get:70 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-extra-580 580.82.07-0ubuntu1 [73.1 kB]\n", + "Get:71 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-encode-580 580.82.07-0ubuntu1 [107 kB]\n", + "Get:72 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 xserver-xorg-video-nvidia-580 580.82.07-0ubuntu1 [1,693 kB]\n", + "Get:73 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvidia-fbc1-580 580.82.07-0ubuntu1 [86.8 kB]\n", + "Get:74 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-driver-580 580.82.07-0ubuntu1 [498 kB]\n", + "Get:75 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-drivers-580 580.82.07-0ubuntu1 [2,558 B]\n", + "Get:76 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-drivers 580.82.07-0ubuntu1 [2,506 B]\n", + "Get:77 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-runtime-12-4 12.4.1-1 [2,498 B]\n", + "Get:78 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cuobjdump-12-4 12.4.127-1 [225 kB]\n", + "Get:79 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cuxxfilt-12-4 12.4.127-1 [191 kB]\n", + "Get:80 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cccl-12-4 12.4.127-1 [1,200 kB]\n", + "Get:81 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-driver-dev-12-4 12.4.127-1 [28.6 kB]\n", + "Get:82 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cudart-dev-12-4 12.4.127-1 [1,000 kB]\n", + "Get:83 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvvm-12-4 12.4.131-1 [19.5 MB]\n", + "Get:84 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-crt-12-4 12.4.131-1 [78.0 kB]\n", + "Get:85 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvcc-12-4 12.4.131-1 [32.0 MB]\n", + "Get:86 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvprune-12-4 12.4.127-1 [58.8 kB]\n", + "Get:87 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-compiler-12-4 12.4.1-1 [2,510 B]\n", + "Get:88 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-profiler-api-12-4 12.4.127-1 [18.7 kB]\n", + "Get:89 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvrtc-dev-12-4 12.4.127-1 [16.9 MB]\n", + "Get:90 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-opencl-dev-12-4 12.4.127-1 [87.0 kB]\n", + "Get:91 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcublas-dev-12-4 12.4.5.8-1 [249 MB]\n", + "Get:92 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcufft-dev-12-4 11.2.1.3-1 [342 MB]\n", + "Get:93 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcufile-dev-12-4 1.9.1.3-1 [2,435 kB]\n", + "Get:94 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcurand-dev-12-4 10.3.5.147-1 [41.6 MB]\n", + "Get:95 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcusolver-dev-12-4 11.6.1.9-1 [51.4 MB]\n", + "Get:96 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libcusparse-dev-12-4 12.3.1.170-1 [116 MB]\n", + "Get:97 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnpp-dev-12-4 12.2.5.30-1 [92.0 MB]\n", + "Get:98 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvjitlink-dev-12-4 12.4.127-1 [13.9 MB]\n", + "Get:99 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvfatbin-dev-12-4 12.4.127-1 [591 kB]\n", + "Get:100 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 libnvjpeg-dev-12-4 12.3.1.117-1 [2,025 kB]\n", + "Get:101 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-libraries-dev-12-4 12.4.1-1 [2,646 B]\n", + "Get:102 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cupti-12-4 12.4.127-1 [16.8 MB]\n", + "Get:103 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-cupti-dev-12-4 12.4.127-1 [3,830 kB]\n", + "Get:104 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvdisasm-12-4 12.4.127-1 [49.9 MB]\n", + "Get:105 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-gdb-12-4 12.4.127-1 [4,920 kB]\n", + "Get:106 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvprof-12-4 12.4.127-1 [2,431 kB]\n", + "Get:107 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvtx-12-4 12.4.127-1 [51.5 kB]\n", + "Get:108 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-sanitizer-12-4 12.4.127-1 [9,148 kB]\n", + "Get:109 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-command-line-tools-12-4 12.4.1-1 [2,538 B]\n", + "Get:110 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nsight-compute-2024.1.1 2024.1.1.4-1 [594 MB]\n", + "Get:111 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nsight-compute-12-4 12.4.1-1 [4,060 B]\n", + "Get:112 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nsight-systems-2023.4.4 2023.4.4.54-234433681190v0 [316 MB]\n", + "Get:113 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nsight-systems-12-4 12.4.1-1 [3,348 B]\n", + "Get:114 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nsight-12-4 12.4.127-1 [119 MB]\n", + "Get:115 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvml-dev-12-4 12.4.127-1 [145 kB]\n", + "Get:116 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-nvvp-12-4 12.4.127-1 [115 MB]\n", + "Get:117 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-visual-tools-12-4 12.4.1-1 [2,942 B]\n", + "Get:118 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 gds-tools-12-4 1.9.1.3-1 [39.0 MB]\n", + "Get:119 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-tools-12-4 12.4.1-1 [2,462 B]\n", + "Get:120 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-documentation-12-4 12.4.127-1 [50.0 kB]\n", + "Get:121 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-toolkit-12-4 12.4.1-1 [3,336 B]\n", + "Get:122 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-demo-suite-12-4 12.4.127-1 [3,999 kB]\n", + "Get:123 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 cuda-12-4 12.4.1-1 [2,526 B]\n", + "Get:124 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 nvidia-settings 580.82.07-0ubuntu1 [923 kB]\n", + "Preconfiguring packages ...\n", + "Fetched 3,422 MB in 2min 10s (26.4 MB/s)\n", + "Selecting previously unselected package liblocale-gettext-perl.\r\n", + "(Reading database ... \r(Reading database ... 5%\r(Reading database ... 10%\r(Reading database ... 15%\r(Reading database ... 20%\r(Reading database ... 25%\r(Reading database ... 30%\r(Reading database ... 35%\r(Reading database ... 40%\r(Reading database ... 45%\r(Reading database ... 50%\r(Reading database ... 55%\r(Reading database ... 60%\r(Reading database ... 65%\r(Reading database ... 70%\r(Reading database ... 75%\r(Reading database ... 80%\r(Reading database ... 85%\r(Reading database ... 90%\r(Reading database ... 95%\r(Reading database ... 100%\r(Reading database ... 126374 files and directories currently installed.)\r\n", + "Preparing to unpack .../liblocale-gettext-perl_1.07-4build3_amd64.deb ...\r\n", + "Unpacking liblocale-gettext-perl (1.07-4build3) ...\r\n", + "Selecting previously unselected package keyboard-configuration.\r\n", + "Preparing to unpack .../keyboard-configuration_1.205ubuntu3_all.deb ...\r\n", + "Unpacking keyboard-configuration (1.205ubuntu3) ...\r\n", + "Selecting previously unselected package dkms.\r\n", + "Preparing to unpack .../dkms_1%3a3.2.1-1ubuntu2_all.deb ...\r\n", + "Unpacking dkms (1:3.2.1-1ubuntu2) ...\r\n", + "Preparing to unpack .../libudev1_249.11-0ubuntu3.16_amd64.deb ...\r\n", + "Unpacking libudev1:amd64 (249.11-0ubuntu3.16) over (249.11-0ubuntu3.12) ...\r\n", + "Setting up libudev1:amd64 (249.11-0ubuntu3.16) ...\r\n", + "Selecting previously unselected package udev.\r\n", + "(Reading database ... \r(Reading database ... 5%\r(Reading database ... 10%\r(Reading database ... 15%\r(Reading database ... 20%\r(Reading database ... 25%\r(Reading database ... 30%\r(Reading database ... 35%\r(Reading database ... 40%\r(Reading database ... 45%\r(Reading database ... 50%\r(Reading database ... 55%\r(Reading database ... 60%\r(Reading database ... 65%\r(Reading database ... 70%\r(Reading database ... 75%\r(Reading database ... 80%\r(Reading database ... 85%\r(Reading database ... 90%\r(Reading database ... 95%\r(Reading database ... 100%\r(Reading database ... 126435 files and directories currently installed.)\r\n", + "Preparing to unpack .../000-udev_249.11-0ubuntu3.16_amd64.deb ...\r\n", + "Unpacking udev (249.11-0ubuntu3.16) ...\r\n", + "Selecting previously unselected package libjansson4:amd64.\r\n", + "Preparing to unpack .../001-libjansson4_2.13.1-1.1build3_amd64.deb ...\r\n", + "Unpacking libjansson4:amd64 (2.13.1-1.1build3) ...\r\n", + "Selecting previously unselected package cuda-toolkit-12-4-config-common.\r\n", + "Preparing to unpack .../002-cuda-toolkit-12-4-config-common_12.4.127-1_all.deb ...\r\n", + "Unpacking cuda-toolkit-12-4-config-common (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-cudart-12-4.\r\n", + "Preparing to unpack .../003-cuda-cudart-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cudart-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvrtc-12-4.\r\n", + "Preparing to unpack .../004-cuda-nvrtc-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvrtc-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-opencl-12-4.\r\n", + "Preparing to unpack .../005-cuda-opencl-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-opencl-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package libcublas-12-4.\r\n", + "Preparing to unpack .../006-libcublas-12-4_12.4.5.8-1_amd64.deb ...\r\n", + "Unpacking libcublas-12-4 (12.4.5.8-1) ...\r\n", + "Selecting previously unselected package libcufft-12-4.\r\n", + "Preparing to unpack .../007-libcufft-12-4_11.2.1.3-1_amd64.deb ...\r\n", + "Unpacking libcufft-12-4 (11.2.1.3-1) ...\r\n", + "Selecting previously unselected package libcufile-12-4.\r\n", + "Preparing to unpack .../008-libcufile-12-4_1.9.1.3-1_amd64.deb ...\r\n", + "Unpacking libcufile-12-4 (1.9.1.3-1) ...\r\n", + "Selecting previously unselected package libcurand-12-4.\r\n", + "Preparing to unpack .../009-libcurand-12-4_10.3.5.147-1_amd64.deb ...\r\n", + "Unpacking libcurand-12-4 (10.3.5.147-1) ...\r\n", + "Selecting previously unselected package libcusolver-12-4.\r\n", + "Preparing to unpack .../010-libcusolver-12-4_11.6.1.9-1_amd64.deb ...\r\n", + "Unpacking libcusolver-12-4 (11.6.1.9-1) ...\r\n", + "Selecting previously unselected package libcusparse-12-4.\r\n", + "Preparing to unpack .../011-libcusparse-12-4_12.3.1.170-1_amd64.deb ...\r\n", + "Unpacking libcusparse-12-4 (12.3.1.170-1) ...\r\n", + "Selecting previously unselected package libnpp-12-4.\r\n", + "Preparing to unpack .../012-libnpp-12-4_12.2.5.30-1_amd64.deb ...\r\n", + "Unpacking libnpp-12-4 (12.2.5.30-1) ...\r\n", + "Selecting previously unselected package libnvjitlink-12-4.\r\n", + "Preparing to unpack .../013-libnvjitlink-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking libnvjitlink-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package libnvfatbin-12-4.\r\n", + "Preparing to unpack .../014-libnvfatbin-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking libnvfatbin-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package libnvjpeg-12-4.\r\n", + "Preparing to unpack .../015-libnvjpeg-12-4_12.3.1.117-1_amd64.deb ...\r\n", + "Unpacking libnvjpeg-12-4 (12.3.1.117-1) ...\r\n", + "Selecting previously unselected package cuda-libraries-12-4.\r\n", + "Preparing to unpack .../016-cuda-libraries-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-libraries-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package libnvidia-common-580.\r\n", + "Preparing to unpack .../017-libnvidia-common-580_580.82.07-0ubuntu1_all.deb ...\r\n", + "Unpacking libnvidia-common-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-decode-580:amd64.\r\n", + "Preparing to unpack .../018-libnvidia-decode-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-decode-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-cfg1-580:amd64.\r\n", + "Preparing to unpack .../019-libnvidia-cfg1-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-cfg1-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-gpucomp-580:amd64.\r\n", + "Preparing to unpack .../020-libnvidia-gpucomp-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-gpucomp-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-persistenced.\r\n", + "Preparing to unpack .../021-nvidia-persistenced_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-persistenced (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-compute-580:amd64.\r\n", + "Preparing to unpack .../022-libnvidia-compute-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-compute-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-gl-580:amd64.\r\n", + "Preparing to unpack .../023-libnvidia-gl-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "dpkg-query: no packages found matching libnvidia-gl-535\r\n", + "Unpacking libnvidia-gl-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-kernel-source-580.\r\n", + "Preparing to unpack .../024-nvidia-kernel-source-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-kernel-source-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-firmware-580.\r\n", + "Preparing to unpack .../025-nvidia-firmware-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-firmware-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-modprobe.\r\n", + "Preparing to unpack .../026-nvidia-modprobe_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-modprobe (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-kernel-common-580.\r\n", + "Preparing to unpack .../027-nvidia-kernel-common-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-kernel-common-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-dkms-580.\r\n", + "Preparing to unpack .../028-nvidia-dkms-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-dkms-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-extra-580:amd64.\r\n", + "Preparing to unpack .../029-libnvidia-extra-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-extra-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-encode-580:amd64.\r\n", + "Preparing to unpack .../030-libnvidia-encode-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-encode-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libxcvt0:amd64.\r\n", + "Preparing to unpack .../031-libxcvt0_0.1.1-3_amd64.deb ...\r\n", + "Unpacking libxcvt0:amd64 (0.1.1-3) ...\r\n", + "Selecting previously unselected package xserver-xorg-core.\r\n", + "Preparing to unpack .../032-xserver-xorg-core_2%3a21.1.4-2ubuntu1.7~22.04.15_amd64.deb ...\r\n", + "Unpacking xserver-xorg-core (2:21.1.4-2ubuntu1.7~22.04.15) ...\r\n", + "Selecting previously unselected package xserver-xorg-video-nvidia-580.\r\n", + "Preparing to unpack .../033-xserver-xorg-video-nvidia-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking xserver-xorg-video-nvidia-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package libnvidia-fbc1-580:amd64.\r\n", + "Preparing to unpack .../034-libnvidia-fbc1-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking libnvidia-fbc1-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package nvidia-driver-580.\r\n", + "Preparing to unpack .../035-nvidia-driver-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-driver-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package cuda-drivers-580.\r\n", + "Preparing to unpack .../036-cuda-drivers-580_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking cuda-drivers-580 (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package cuda-drivers.\r\n", + "Preparing to unpack .../037-cuda-drivers_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking cuda-drivers (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package cuda-runtime-12-4.\r\n", + "Preparing to unpack .../038-cuda-runtime-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-runtime-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package cuda-cuobjdump-12-4.\r\n", + "Preparing to unpack .../039-cuda-cuobjdump-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cuobjdump-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-cuxxfilt-12-4.\r\n", + "Preparing to unpack .../040-cuda-cuxxfilt-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cuxxfilt-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-cccl-12-4.\r\n", + "Preparing to unpack .../041-cuda-cccl-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cccl-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-driver-dev-12-4.\r\n", + "Preparing to unpack .../042-cuda-driver-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-driver-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-cudart-dev-12-4.\r\n", + "Preparing to unpack .../043-cuda-cudart-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cudart-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvvm-12-4.\r\n", + "Preparing to unpack .../044-cuda-nvvm-12-4_12.4.131-1_amd64.deb ...\r\n", + "Unpacking cuda-nvvm-12-4 (12.4.131-1) ...\r\n", + "Selecting previously unselected package cuda-crt-12-4.\r\n", + "Preparing to unpack .../045-cuda-crt-12-4_12.4.131-1_amd64.deb ...\r\n", + "Unpacking cuda-crt-12-4 (12.4.131-1) ...\r\n", + "Selecting previously unselected package cuda-nvcc-12-4.\r\n", + "Preparing to unpack .../046-cuda-nvcc-12-4_12.4.131-1_amd64.deb ...\r\n", + "Unpacking cuda-nvcc-12-4 (12.4.131-1) ...\r\n", + "Selecting previously unselected package cuda-nvprune-12-4.\r\n", + "Preparing to unpack .../047-cuda-nvprune-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvprune-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-compiler-12-4.\r\n", + "Preparing to unpack .../048-cuda-compiler-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-compiler-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package cuda-profiler-api-12-4.\r\n", + "Preparing to unpack .../049-cuda-profiler-api-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-profiler-api-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvrtc-dev-12-4.\r\n", + "Preparing to unpack .../050-cuda-nvrtc-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvrtc-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-opencl-dev-12-4.\r\n", + "Preparing to unpack .../051-cuda-opencl-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-opencl-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package libcublas-dev-12-4.\r\n", + "Preparing to unpack .../052-libcublas-dev-12-4_12.4.5.8-1_amd64.deb ...\r\n", + "Unpacking libcublas-dev-12-4 (12.4.5.8-1) ...\r\n", + "Selecting previously unselected package libcufft-dev-12-4.\r\n", + "Preparing to unpack .../053-libcufft-dev-12-4_11.2.1.3-1_amd64.deb ...\r\n", + "Unpacking libcufft-dev-12-4 (11.2.1.3-1) ...\r\n", + "Selecting previously unselected package libcufile-dev-12-4.\r\n", + "Preparing to unpack .../054-libcufile-dev-12-4_1.9.1.3-1_amd64.deb ...\r\n", + "Unpacking libcufile-dev-12-4 (1.9.1.3-1) ...\r\n", + "Selecting previously unselected package libcurand-dev-12-4.\r\n", + "Preparing to unpack .../055-libcurand-dev-12-4_10.3.5.147-1_amd64.deb ...\r\n", + "Unpacking libcurand-dev-12-4 (10.3.5.147-1) ...\r\n", + "Selecting previously unselected package libcusolver-dev-12-4.\r\n", + "Preparing to unpack .../056-libcusolver-dev-12-4_11.6.1.9-1_amd64.deb ...\r\n", + "Unpacking libcusolver-dev-12-4 (11.6.1.9-1) ...\r\n", + "Selecting previously unselected package libcusparse-dev-12-4.\r\n", + "Preparing to unpack .../057-libcusparse-dev-12-4_12.3.1.170-1_amd64.deb ...\r\n", + "Unpacking libcusparse-dev-12-4 (12.3.1.170-1) ...\r\n", + "Selecting previously unselected package libnpp-dev-12-4.\r\n", + "Preparing to unpack .../058-libnpp-dev-12-4_12.2.5.30-1_amd64.deb ...\r\n", + "Unpacking libnpp-dev-12-4 (12.2.5.30-1) ...\r\n", + "Selecting previously unselected package libnvjitlink-dev-12-4.\r\n", + "Preparing to unpack .../059-libnvjitlink-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking libnvjitlink-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package libnvfatbin-dev-12-4.\r\n", + "Preparing to unpack .../060-libnvfatbin-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking libnvfatbin-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package libnvjpeg-dev-12-4.\r\n", + "Preparing to unpack .../061-libnvjpeg-dev-12-4_12.3.1.117-1_amd64.deb ...\r\n", + "Unpacking libnvjpeg-dev-12-4 (12.3.1.117-1) ...\r\n", + "Selecting previously unselected package cuda-libraries-dev-12-4.\r\n", + "Preparing to unpack .../062-cuda-libraries-dev-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-libraries-dev-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package cuda-cupti-12-4.\r\n", + "Preparing to unpack .../063-cuda-cupti-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cupti-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-cupti-dev-12-4.\r\n", + "Preparing to unpack .../064-cuda-cupti-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-cupti-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvdisasm-12-4.\r\n", + "Preparing to unpack .../065-cuda-nvdisasm-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvdisasm-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-gdb-12-4.\r\n", + "Preparing to unpack .../066-cuda-gdb-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-gdb-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvprof-12-4.\r\n", + "Preparing to unpack .../067-cuda-nvprof-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvprof-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvtx-12-4.\r\n", + "Preparing to unpack .../068-cuda-nvtx-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvtx-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-sanitizer-12-4.\r\n", + "Preparing to unpack .../069-cuda-sanitizer-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-sanitizer-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-command-line-tools-12-4.\r\n", + "Preparing to unpack .../070-cuda-command-line-tools-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-command-line-tools-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package nsight-compute-2024.1.1.\r\n", + "Preparing to unpack .../071-nsight-compute-2024.1.1_2024.1.1.4-1_amd64.deb ...\r\n", + "Unpacking nsight-compute-2024.1.1 (2024.1.1.4-1) ...\r\n", + "Selecting previously unselected package cuda-nsight-compute-12-4.\r\n", + "Preparing to unpack .../072-cuda-nsight-compute-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-nsight-compute-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package libtinfo5:amd64.\r\n", + "Preparing to unpack .../073-libtinfo5_6.3-2ubuntu0.1_amd64.deb ...\r\n", + "Unpacking libtinfo5:amd64 (6.3-2ubuntu0.1) ...\r\n", + "Selecting previously unselected package libxcb-xinerama0:amd64.\r\n", + "Preparing to unpack .../074-libxcb-xinerama0_1.14-3ubuntu3_amd64.deb ...\r\n", + "Unpacking libxcb-xinerama0:amd64 (1.14-3ubuntu3) ...\r\n", + "Selecting previously unselected package libxcb-icccm4:amd64.\r\n", + "Preparing to unpack .../075-libxcb-icccm4_0.4.1-1.1build2_amd64.deb ...\r\n", + "Unpacking libxcb-icccm4:amd64 (0.4.1-1.1build2) ...\r\n", + "Selecting previously unselected package libxcb-util1:amd64.\r\n", + "Preparing to unpack .../076-libxcb-util1_0.4.0-1build2_amd64.deb ...\r\n", + "Unpacking libxcb-util1:amd64 (0.4.0-1build2) ...\r\n", + "Selecting previously unselected package libxcb-image0:amd64.\r\n", + "Preparing to unpack .../077-libxcb-image0_0.4.0-2_amd64.deb ...\r\n", + "Unpacking libxcb-image0:amd64 (0.4.0-2) ...\r\n", + "Selecting previously unselected package libxcb-keysyms1:amd64.\r\n", + "Preparing to unpack .../078-libxcb-keysyms1_0.4.0-1build3_amd64.deb ...\r\n", + "Unpacking libxcb-keysyms1:amd64 (0.4.0-1build3) ...\r\n", + "Selecting previously unselected package libxcb-render-util0:amd64.\r\n", + "Preparing to unpack .../079-libxcb-render-util0_0.3.9-1build3_amd64.deb ...\r\n", + "Unpacking libxcb-render-util0:amd64 (0.3.9-1build3) ...\r\n", + "Selecting previously unselected package libxcb-xkb1:amd64.\r\n", + "Preparing to unpack .../080-libxcb-xkb1_1.14-3ubuntu3_amd64.deb ...\r\n", + "Unpacking libxcb-xkb1:amd64 (1.14-3ubuntu3) ...\r\n", + "Selecting previously unselected package libxkbcommon-x11-0:amd64.\r\n", + "Preparing to unpack .../081-libxkbcommon-x11-0_1.4.0-1_amd64.deb ...\r\n", + "Unpacking libxkbcommon-x11-0:amd64 (1.4.0-1) ...\r\n", + "Selecting previously unselected package libxcb-xinput0:amd64.\r\n", + "Preparing to unpack .../082-libxcb-xinput0_1.14-3ubuntu3_amd64.deb ...\r\n", + "Unpacking libxcb-xinput0:amd64 (1.14-3ubuntu3) ...\r\n", + "Selecting previously unselected package libxtst6:amd64.\r\n", + "Preparing to unpack .../083-libxtst6_2%3a1.2.3-1build4_amd64.deb ...\r\n", + "Unpacking libxtst6:amd64 (2:1.2.3-1build4) ...\r\n", + "Selecting previously unselected package nsight-systems-2023.4.4.\r\n", + "Preparing to unpack .../084-nsight-systems-2023.4.4_2023.4.4.54-234433681190v0_amd64.deb ...\r\n", + "Unpacking nsight-systems-2023.4.4 (2023.4.4.54-234433681190v0) ...\r\n", + "Selecting previously unselected package cuda-nsight-systems-12-4.\r\n", + "Preparing to unpack .../085-cuda-nsight-systems-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-nsight-systems-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package default-jre-headless.\r\n", + "Preparing to unpack .../086-default-jre-headless_2%3a1.11-72build2_amd64.deb ...\r\n", + "Unpacking default-jre-headless (2:1.11-72build2) ...\r\n", + "Selecting previously unselected package openjdk-11-jre:amd64.\r\n", + "Preparing to unpack .../087-openjdk-11-jre_11.0.28+6-1ubuntu1~22.04.1_amd64.deb ...\r\n", + "Unpacking openjdk-11-jre:amd64 (11.0.28+6-1ubuntu1~22.04.1) ...\r\n", + "Selecting previously unselected package default-jre.\r\n", + "Preparing to unpack .../088-default-jre_2%3a1.11-72build2_amd64.deb ...\r\n", + "Unpacking default-jre (2:1.11-72build2) ...\r\n", + "Selecting previously unselected package cuda-nsight-12-4.\r\n", + "Preparing to unpack .../089-cuda-nsight-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nsight-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvml-dev-12-4.\r\n", + "Preparing to unpack .../090-cuda-nvml-dev-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvml-dev-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-nvvp-12-4.\r\n", + "Preparing to unpack .../091-cuda-nvvp-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-nvvp-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-visual-tools-12-4.\r\n", + "Preparing to unpack .../092-cuda-visual-tools-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-visual-tools-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package gds-tools-12-4.\r\n", + "Preparing to unpack .../093-gds-tools-12-4_1.9.1.3-1_amd64.deb ...\r\n", + "Unpacking gds-tools-12-4 (1.9.1.3-1) ...\r\n", + "Selecting previously unselected package cuda-tools-12-4.\r\n", + "Preparing to unpack .../094-cuda-tools-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-tools-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package cuda-documentation-12-4.\r\n", + "Preparing to unpack .../095-cuda-documentation-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-documentation-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-toolkit-12-4.\r\n", + "Preparing to unpack .../096-cuda-toolkit-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-toolkit-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package cuda-demo-suite-12-4.\r\n", + "Preparing to unpack .../097-cuda-demo-suite-12-4_12.4.127-1_amd64.deb ...\r\n", + "Unpacking cuda-demo-suite-12-4 (12.4.127-1) ...\r\n", + "Selecting previously unselected package cuda-12-4.\r\n", + "Preparing to unpack .../098-cuda-12-4_12.4.1-1_amd64.deb ...\r\n", + "Unpacking cuda-12-4 (12.4.1-1) ...\r\n", + "Selecting previously unselected package libfakeroot:amd64.\r\n", + "Preparing to unpack .../099-libfakeroot_1.28-1ubuntu1_amd64.deb ...\r\n", + "Unpacking libfakeroot:amd64 (1.28-1ubuntu1) ...\r\n", + "Selecting previously unselected package fakeroot.\r\n", + "Preparing to unpack .../100-fakeroot_1.28-1ubuntu1_amd64.deb ...\r\n", + "Unpacking fakeroot (1.28-1ubuntu1) ...\r\n", + "Selecting previously unselected package fonts-dejavu-core.\r\n", + "Preparing to unpack .../101-fonts-dejavu-core_2.37-2build1_all.deb ...\r\n", + "Unpacking fonts-dejavu-core (2.37-2build1) ...\r\n", + "Selecting previously unselected package fonts-dejavu-extra.\r\n", + "Preparing to unpack .../102-fonts-dejavu-extra_2.37-2build1_all.deb ...\r\n", + "Unpacking fonts-dejavu-extra (2.37-2build1) ...\r\n", + "Selecting previously unselected package libxxf86dga1:amd64.\r\n", + "Preparing to unpack .../103-libxxf86dga1_2%3a1.1.5-0ubuntu3_amd64.deb ...\r\n", + "Unpacking libxxf86dga1:amd64 (2:1.1.5-0ubuntu3) ...\r\n", + "Selecting previously unselected package x11-utils.\r\n", + "Preparing to unpack .../104-x11-utils_7.7+5build2_amd64.deb ...\r\n", + "Unpacking x11-utils (7.7+5build2) ...\r\n", + "Selecting previously unselected package libatk-wrapper-java.\r\n", + "Preparing to unpack .../105-libatk-wrapper-java_0.38.0-5build1_all.deb ...\r\n", + "Unpacking libatk-wrapper-java (0.38.0-5build1) ...\r\n", + "Selecting previously unselected package libatk-wrapper-java-jni:amd64.\r\n", + "Preparing to unpack .../106-libatk-wrapper-java-jni_0.38.0-5build1_amd64.deb ...\r\n", + "Unpacking libatk-wrapper-java-jni:amd64 (0.38.0-5build1) ...\r\n", + "Selecting previously unselected package libgtk2.0-common.\r\n", + "Preparing to unpack .../107-libgtk2.0-common_2.24.33-2ubuntu2.1_all.deb ...\r\n", + "Unpacking libgtk2.0-common (2.24.33-2ubuntu2.1) ...\r\n", + "Selecting previously unselected package libgtk2.0-0:amd64.\r\n", + "Preparing to unpack .../108-libgtk2.0-0_2.24.33-2ubuntu2.1_amd64.deb ...\r\n", + "Unpacking libgtk2.0-0:amd64 (2.24.33-2ubuntu2.1) ...\r\n", + "Selecting previously unselected package libgail18:amd64.\r\n", + "Preparing to unpack .../109-libgail18_2.24.33-2ubuntu2.1_amd64.deb ...\r\n", + "Unpacking libgail18:amd64 (2.24.33-2ubuntu2.1) ...\r\n", + "Selecting previously unselected package libgail-common:amd64.\r\n", + "Preparing to unpack .../110-libgail-common_2.24.33-2ubuntu2.1_amd64.deb ...\r\n", + "Unpacking libgail-common:amd64 (2.24.33-2ubuntu2.1) ...\r\n", + "Selecting previously unselected package libgtk2.0-bin.\r\n", + "Preparing to unpack .../111-libgtk2.0-bin_2.24.33-2ubuntu2.1_amd64.deb ...\r\n", + "Unpacking libgtk2.0-bin (2.24.33-2ubuntu2.1) ...\r\n", + "Selecting previously unselected package libgudev-1.0-0:amd64.\r\n", + "Preparing to unpack .../112-libgudev-1.0-0_1%3a237-2build1_amd64.deb ...\r\n", + "Unpacking libgudev-1.0-0:amd64 (1:237-2build1) ...\r\n", + "Selecting previously unselected package librsvg2-common:amd64.\r\n", + "Preparing to unpack .../113-librsvg2-common_2.52.5+dfsg-3ubuntu0.2_amd64.deb ...\r\n", + "Unpacking librsvg2-common:amd64 (2.52.5+dfsg-3ubuntu0.2) ...\r\n", + "Selecting previously unselected package python3-xkit.\r\n", + "Preparing to unpack .../114-python3-xkit_0.5.0ubuntu5_all.deb ...\r\n", + "Unpacking python3-xkit (0.5.0ubuntu5) ...\r\n", + "Selecting previously unselected package screen-resolution-extra.\r\n", + "Preparing to unpack .../115-screen-resolution-extra_0.18.2ubuntu0.1_all.deb ...\r\n", + "Unpacking screen-resolution-extra (0.18.2ubuntu0.1) ...\r\n", + "Selecting previously unselected package nvidia-settings.\r\n", + "Preparing to unpack .../116-nvidia-settings_580.82.07-0ubuntu1_amd64.deb ...\r\n", + "Unpacking nvidia-settings (580.82.07-0ubuntu1) ...\r\n", + "Selecting previously unselected package switcheroo-control.\r\n", + "Preparing to unpack .../117-switcheroo-control_2.4-3build2_amd64.deb ...\r\n", + "Unpacking switcheroo-control (2.4-3build2) ...\r\n", + "Selecting previously unselected package systemd-hwe-hwdb.\r\n", + "Preparing to unpack .../118-systemd-hwe-hwdb_249.11.5_all.deb ...\r\n", + "Unpacking systemd-hwe-hwdb (249.11.5) ...\r\n", + "Selecting previously unselected package xcvt.\r\n", + "Preparing to unpack .../119-xcvt_0.1.1-3_amd64.deb ...\r\n", + "Unpacking xcvt (0.1.1-3) ...\r\n", + "Setting up cuda-cupti-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-nvml-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up libnvidia-gpucomp-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up default-jre-headless (2:1.11-72build2) ...\r\n", + "Setting up cuda-cccl-12-4 (12.4.127-1) ...\r\n", + "Setting up libnvidia-fbc1-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libxcb-xinput0:amd64 (1.14-3ubuntu3) ...\r\n", + "Setting up cuda-cupti-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up gds-tools-12-4 (1.9.1.3-1) ...\r\n", + "Setting up libxtst6:amd64 (2:1.2.3-1build4) ...\r\n", + "Setting up cuda-documentation-12-4 (12.4.127-1) ...\r\n", + "Setting up libxcb-keysyms1:amd64 (0.4.0-1build3) ...\r\n", + "Setting up libxxf86dga1:amd64 (2:1.1.5-0ubuntu3) ...\r\n", + "Setting up libxcb-render-util0:amd64 (0.3.9-1build3) ...\r\n", + "Setting up openjdk-11-jre:amd64 (11.0.28+6-1ubuntu1~22.04.1) ...\r\n", + "Setting up libxcb-icccm4:amd64 (0.4.1-1.1build2) ...\r\n", + "Setting up default-jre (2:1.11-72build2) ...\r\n", + "Setting up cuda-profiler-api-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-demo-suite-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-nvdisasm-12-4 (12.4.127-1) ...\r\n", + "Setting up nvidia-kernel-source-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libfakeroot:amd64 (1.28-1ubuntu1) ...\r\n", + "Setting up libxcb-util1:amd64 (0.4.0-1build2) ...\r\n", + "Setting up libjansson4:amd64 (2.13.1-1.1build3) ...\r\n", + "Setting up dkms (1:3.2.1-1ubuntu2) ...\r\n", + "Setting up libxcb-xkb1:amd64 (1.14-3ubuntu3) ...\r\n", + "Setting up nvidia-modprobe (580.82.07-0ubuntu1) ...\r\n", + "Setting up libxcb-image0:amd64 (0.4.0-2) ...\r\n", + "Setting up fakeroot (1.28-1ubuntu1) ...\r\n", + "update-alternatives: using /usr/bin/fakeroot-sysv to provide /usr/bin/fakeroot (fakeroot) in auto mode\r\n", + "Setting up cuda-nvvm-12-4 (12.4.131-1) ...\r\n", + "Setting up cuda-nvprune-12-4 (12.4.127-1) ...\r\n", + "Setting up libnvidia-extra-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libxcb-xinerama0:amd64 (1.14-3ubuntu3) ...\r\n", + "Setting up libnvidia-common-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up cuda-nvtx-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-cuxxfilt-12-4 (12.4.127-1) ...\r\n", + "Setting up nvidia-firmware-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libxkbcommon-x11-0:amd64 (1.4.0-1) ...\r\n", + "Setting up udev (249.11-0ubuntu3.16) ...\r\n", + "invoke-rc.d: could not determine current runlevel\r\n", + "invoke-rc.d: policy-rc.d denied execution of start.\r\n", + "Setting up fonts-dejavu-core (2.37-2build1) ...\r\n", + "Setting up librsvg2-common:amd64 (2.52.5+dfsg-3ubuntu0.2) ...\r\n", + "Setting up cuda-nsight-12-4 (12.4.127-1) ...\r\n", + "Setting up systemd-hwe-hwdb (249.11.5) ...\r\n", + "Setting up fonts-dejavu-extra (2.37-2build1) ...\r\n", + "Setting up nsight-compute-2024.1.1 (2024.1.1.4-1) ...\r\n", + "Setting up cuda-driver-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-nvprof-12-4 (12.4.127-1) ...\r\n", + "Setting up libnvidia-cfg1-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libxcvt0:amd64 (0.1.1-3) ...\r\n", + "Setting up x11-utils (7.7+5build2) ...\r\n", + "Setting up libgtk2.0-common (2.24.33-2ubuntu2.1) ...\r\n", + "Setting up libatk-wrapper-java (0.38.0-5build1) ...\r\n", + "Setting up python3-xkit (0.5.0ubuntu5) ...\r\n", + "Setting up libtinfo5:amd64 (6.3-2ubuntu0.1) ...\r\n", + "Setting up cuda-cuobjdump-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-toolkit-12-4-config-common (12.4.127-1) ...\r\n", + "Setting alternatives\r\n", + "Setting up libnvjitlink-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-nvrtc-12-4 (12.4.127-1) ...\r\n", + "Setting up liblocale-gettext-perl (1.07-4build3) ...\r\n", + "Setting up cuda-sanitizer-12-4 (12.4.127-1) ...\r\n", + "Setting up libgudev-1.0-0:amd64 (1:237-2build1) ...\r\n", + "Setting up libcurand-12-4 (10.3.5.147-1) ...\r\n", + "Setting up libnpp-12-4 (12.2.5.30-1) ...\r\n", + "Setting up nvidia-persistenced (580.82.07-0ubuntu1) ...\r\n", + "Warning: The home dir /var/run/nvpd/ you specified can't be accessed: No such file or directory\r\n", + "Adding system user `nvpd' (UID 104) ...\r\n", + "Adding new group `nvpd' (GID 111) ...\r\n", + "Adding new user `nvpd' (UID 104) with group `nvpd' ...\r\n", + "Not creating home directory `/var/run/nvpd/'.\r\n", + "Created symlink /etc/systemd/system/multi-user.target.wants/nvidia-persistenced.service → /lib/systemd/system/nvidia-persistenced.service.\r\n", + "Setting up libgtk2.0-0:amd64 (2.24.33-2ubuntu2.1) ...\r\n", + "Setting up libcufft-12-4 (11.2.1.3-1) ...\r\n", + "Setting up cuda-nvvp-12-4 (12.4.127-1) ...\r\n", + "Setting up libnvjitlink-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up libcublas-12-4 (12.4.5.8-1) ...\r\n", + "Setting up libcusparse-12-4 (12.3.1.170-1) ...\r\n", + "Setting up libatk-wrapper-java-jni:amd64 (0.38.0-5build1) ...\r\n", + "Setting up xcvt (0.1.1-3) ...\r\n", + "Setting up libnvfatbin-12-4 (12.4.127-1) ...\r\n", + "Setting up libcurand-dev-12-4 (10.3.5.147-1) ...\r\n", + "Setting up libnvjpeg-12-4 (12.3.1.117-1) ...\r\n", + "Setting up nvidia-kernel-common-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up cuda-nsight-compute-12-4 (12.4.1-1) ...\r\n", + "Setting up libcufile-12-4 (1.9.1.3-1) ...\r\n", + "Setting alternatives\r\n", + "Setting up nsight-systems-2023.4.4 (2023.4.4.54-234433681190v0) ...\r\n", + "update-alternatives: using /opt/nvidia/nsight-systems/2023.4.4/target-linux-x64/nsys to provide /usr/local/bin/nsys (nsys) in auto mode\r\n", + "update-alternatives: using /opt/nvidia/nsight-systems/2023.4.4/host-linux-x64/nsys-ui to provide /usr/local/bin/nsys-ui (nsys-ui) in auto mode\r\n", + "Setting up libnpp-dev-12-4 (12.2.5.30-1) ...\r\n", + "Setting up cuda-opencl-12-4 (12.4.127-1) ...\r\n", + "Setting up libcusparse-dev-12-4 (12.3.1.170-1) ...\r\n", + "Setting up cuda-nvrtc-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up libcublas-dev-12-4 (12.4.5.8-1) ...\r\n", + "Setting up nvidia-dkms-580 (580.82.07-0ubuntu1) ...\r\n", + "Loading new nvidia/580.82.07 DKMS files...\r\n", + "Building for 5.15.0-153-generic\r\n", + "\r\n", + "Building initial module nvidia/580.82.07 for 5.15.0-153-generic\r\n", + "Sign command: /usr/src/linux-headers-5.15.0-153-generic/scripts/sign-file\r\n", + "Binary update-secureboot-policy not found, modules won't be signed\r\n", + "\r\n", + "Building module(s)................................................................... done.\r\n", + "Installing /lib/modules/5.15.0-153-generic/updates/dkms/nvidia.ko\r\n", + "Installing /lib/modules/5.15.0-153-generic/updates/dkms/nvidia-modeset.ko\r\n", + "Installing /lib/modules/5.15.0-153-generic/updates/dkms/nvidia-drm.ko\r\n", + "Installing /lib/modules/5.15.0-153-generic/updates/dkms/nvidia-uvm.ko\r\n", + "Installing /lib/modules/5.15.0-153-generic/updates/dkms/nvidia-peermem.ko\r\n", + "Running depmod... done.\r\n", + "Setting up cuda-cudart-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-gdb-12-4 (12.4.127-1) ...\r\n", + "Setting up screen-resolution-extra (0.18.2ubuntu0.1) ...\r\n", + "Setting up libgail18:amd64 (2.24.33-2ubuntu2.1) ...\r\n", + "Setting up libgtk2.0-bin (2.24.33-2ubuntu2.1) ...\r\n", + "Setting up switcheroo-control (2.4-3build2) ...\r\n", + "Created symlink /etc/systemd/system/graphical.target.wants/switcheroo-control.service → /lib/systemd/system/switcheroo-control.service.\r\n", + "Setting up nvidia-settings (580.82.07-0ubuntu1) ...\r\n", + "Setting up libcusolver-12-4 (11.6.1.9-1) ...\r\n", + "Setting up keyboard-configuration (1.205ubuntu3) ...\r\n", + "Your console font configuration will be updated the next time your system\r\n", + "boots. If you want to update it now, run 'setupcon' from a virtual console.\r\n", + "Setting up cuda-libraries-12-4 (12.4.1-1) ...\r\n", + "Setting up cuda-nsight-systems-12-4 (12.4.1-1) ...\r\n", + "Setting up libcusolver-dev-12-4 (11.6.1.9-1) ...\r\n", + "Setting up libcufft-dev-12-4 (11.2.1.3-1) ...\r\n", + "Setting up cuda-command-line-tools-12-4 (12.4.1-1) ...\r\n", + "Setting up cuda-opencl-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up libnvfatbin-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up libgail-common:amd64 (2.24.33-2ubuntu2.1) ...\r\n", + "Setting up cuda-cudart-dev-12-4 (12.4.127-1) ...\r\n", + "Setting up cuda-crt-12-4 (12.4.131-1) ...\r\n", + "Setting up xserver-xorg-core (2:21.1.4-2ubuntu1.7~22.04.15) ...\r\n", + "Setting up libnvjpeg-dev-12-4 (12.3.1.117-1) ...\r\n", + "Setting up libcufile-dev-12-4 (1.9.1.3-1) ...\r\n", + "Setting up cuda-nvcc-12-4 (12.4.131-1) ...\r\n", + "Setting up cuda-compiler-12-4 (12.4.1-1) ...\r\n", + "Setting up xserver-xorg-video-nvidia-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up cuda-libraries-dev-12-4 (12.4.1-1) ...\r\n", + "Setting up cuda-visual-tools-12-4 (12.4.1-1) ...\r\n", + "Setting up cuda-tools-12-4 (12.4.1-1) ...\r\n", + "Setting up cuda-toolkit-12-4 (12.4.1-1) ...\r\n", + "Setting up libnvidia-compute-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libnvidia-gl-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libnvidia-decode-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up libnvidia-encode-580:amd64 (580.82.07-0ubuntu1) ...\r\n", + "Setting up nvidia-driver-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up cuda-drivers-580 (580.82.07-0ubuntu1) ...\r\n", + "Setting up cuda-drivers (580.82.07-0ubuntu1) ...\r\n", + "Setting up cuda-runtime-12-4 (12.4.1-1) ...\r\n", + "Setting up cuda-12-4 (12.4.1-1) ...\r\n", + "Processing triggers for hicolor-icon-theme (0.17-2) ...\r\n", + "Processing triggers for libc-bin (2.35-0ubuntu3.8) ...\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libur_adapter_opencl.so.0 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtbbmalloc.so.2 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtbbbind.so.3 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtbbbind_2_5.so.3 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtcm.so.1 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtbbmalloc_proxy.so.2 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtbbbind_2_0.so.3 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libur_adapter_level_zero.so.0 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libumf.so.0 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtcm_debug.so.1 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libur_loader.so.0 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libhwloc.so.15 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libur_adapter_level_zero_v2.so.0 is not a symbolic link\r\n", + "\r\n", + "/sbin/ldconfig.real: /usr/local/lib/libtbb.so.12 is not a symbolic link\r\n", + "\r\n", + "Processing triggers for man-db (2.10.2-1) ...\r\n", + "Processing triggers for dbus (1.12.20-2ubuntu4.1) ...\r\n", + "Processing triggers for libgdk-pixbuf-2.0-0:amd64 (2.42.8+dfsg-1ubuntu0.4) ...\r\n", + "Processing triggers for mailcap (3.70+nmu1ubuntu1) ...\r\n", + "Processing triggers for fontconfig (2.13.1-4.2ubuntu5) ...\r\n", + "GPU Information:\n", + "name, driver_version, memory.total [MiB]\n", + "Tesla T4, 550.54.15, 15360 MiB\n", + "nvcc: NVIDIA (R) Cuda compiler driver\n", + "Copyright (c) 2005-2024 NVIDIA Corporation\n", + "Built on Thu_Mar_28_02:18:24_PDT_2024\n", + "Cuda compilation tools, release 12.4, V12.4.131\n", + "Build cuda_12.4.r12.4/compiler.34097967_0\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "WARNING: apt does not have a stable CLI interface. Use with caution in scripts.\n", + "\n", + "Cloning into 'bart-webinars'...\n", + "Updating files: 12% (19/156)\rUpdating files: 13% (21/156)\rUpdating files: 14% (22/156)\rUpdating files: 15% (24/156)\rUpdating files: 16% (25/156)\rUpdating files: 17% (27/156)\rUpdating files: 18% (29/156)\rUpdating files: 19% (30/156)\rUpdating files: 20% (32/156)\rUpdating files: 21% (33/156)\rUpdating files: 22% (35/156)\rUpdating files: 23% (36/156)\rUpdating files: 24% (38/156)\rUpdating files: 25% (39/156)\rUpdating files: 26% (41/156)\rUpdating files: 27% (43/156)\rUpdating files: 28% (44/156)\rUpdating files: 29% (46/156)\rUpdating files: 30% (47/156)\rUpdating files: 31% (49/156)\rUpdating files: 32% (50/156)\rUpdating files: 33% (52/156)\rUpdating files: 34% (54/156)\rUpdating files: 35% (55/156)\rUpdating files: 36% (57/156)\rUpdating files: 37% (58/156)\rUpdating files: 38% (60/156)\rUpdating files: 39% (61/156)\rUpdating files: 40% (63/156)\rUpdating files: 41% (64/156)\rUpdating files: 42% (66/156)\rUpdating files: 43% (68/156)\rUpdating files: 44% (69/156)\rUpdating files: 45% (71/156)\rUpdating files: 46% (72/156)\rUpdating files: 47% (74/156)\rUpdating files: 48% (75/156)\rUpdating files: 49% (77/156)\rUpdating files: 50% (78/156)\rUpdating files: 51% (80/156)\rUpdating files: 52% (82/156)\rUpdating files: 53% (83/156)\rUpdating files: 54% (85/156)\rUpdating files: 55% (86/156)\rUpdating files: 56% (88/156)\rUpdating files: 57% (89/156)\rUpdating files: 58% (91/156)\rUpdating files: 59% (93/156)\rUpdating files: 60% (94/156)\rUpdating files: 61% (96/156)\rUpdating files: 62% (97/156)\rUpdating files: 63% (99/156)\rUpdating files: 64% (100/156)\rUpdating files: 65% (102/156)\rUpdating files: 66% (103/156)\rUpdating files: 67% (105/156)\rUpdating files: 68% (107/156)\rUpdating files: 69% (108/156)\rUpdating files: 70% (110/156)\rUpdating files: 71% (111/156)\rUpdating files: 72% (113/156)\rUpdating files: 73% (114/156)\rUpdating files: 74% (116/156)\rUpdating files: 75% (117/156)\rUpdating files: 76% (119/156)\rUpdating files: 77% (121/156)\rUpdating files: 78% (122/156)\rUpdating files: 79% (124/156)\rUpdating files: 80% (125/156)\rUpdating files: 81% (127/156)\rUpdating files: 82% (128/156)\rUpdating files: 83% (130/156)\rUpdating files: 84% (132/156)\rUpdating files: 85% (133/156)\rUpdating files: 86% (135/156)\rUpdating files: 87% (136/156)\rUpdating files: 88% (138/156)\rUpdating files: 89% (139/156)\rUpdating files: 90% (141/156)\rUpdating files: 91% (142/156)\rUpdating files: 92% (144/156)\rUpdating files: 93% (146/156)\rUpdating files: 94% (147/156)\rUpdating files: 95% (149/156)\rUpdating files: 96% (150/156)\rUpdating files: 97% (152/156)\rUpdating files: 98% (153/156)\rUpdating files: 99% (155/156)\rUpdating files: 100% (156/156)\rUpdating files: 100% (156/156), done.\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "# Why Google?! As of May 13 cuda installed in colab (12.5) is incompatible with the driver (12.4)\n", + "# We install cuda 12.4 and link it here but it takes time!\n", + "apt install cuda-12-4\n", + "\n", + "cd /usr/local\n", + "rm cuda\n", + "ln -s cuda-12.4 cuda\n", + "\n", + "[ -d bart-webinars ] && rm -r bart-webinars\n", + "git clone https://github.com/mrirecon/bart-webinars.git > /dev/null\n", + "\n", + "echo \"GPU Information:\"\n", + "nvidia-smi --query-gpu=gpu_name,driver_version,memory.total --format=csv\n", + "nvcc --version\n" + ] + }, + { + "cell_type": "code", + "source": [ + "%%bash\n", + "apt-get install -y make gcc-12 g++-12 libfftw3-dev liblapacke-dev libpng-dev libopenblas-dev &> /dev/null\n" + ], + "metadata": { + "id": "sv7ztMQPoxPm" + }, + "id": "sv7ztMQPoxPm", + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "%%bash\n", + "[ -d /content/bart ] && rm -r /content/bart\n", + "\n", + "git clone https://github.com/mrirecon/bart/ bart &> /dev/null" + ], + "metadata": { + "id": "itXAoZaUpOLl" + }, + "id": "itXAoZaUpOLl", + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "468e5400", + "metadata": { + "id": "468e5400" + }, + "source": [ + "Install BART" + ] + }, + { + "cell_type": "code", + "source": [ + "%%bash\n", + "cd bart\n", + "COMPILE_SPECS=\" PARALLEL=1\n", + " CUDA=1\n", + " CUDA_BASE=/usr/local/cuda\n", + " CUDA_LIB=lib64\n", + " OPENBLAS=1\n", + " BLAS_THREADSAFE=1\n", + " CC=gcc-12\"\n", + "\n", + "\n", + "printf \"%s\\n\" $COMPILE_SPECS > Makefiles/Makefile.local\n", + "make &> /dev/null\n" + ], + "metadata": { + "id": "Hu30GZYSpUAm" + }, + "id": "Hu30GZYSpUAm", + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "1b488cbf", + "metadata": { + "id": "1b488cbf" + }, + "source": [ + "Set environment variables: enables correct path to BART" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b35dc3fa", + "metadata": { + "id": "b35dc3fa" + }, + "outputs": [], + "source": [ + "# Define environment variables for BART and OpenMP\n", + "import os\n", + "import sys\n", + "os.environ['TOOLBOX_PATH'] = \"/content/bart\"\n", + "os.environ['OMP_NUM_THREADS']=\"4\"\n", + "\n", + "# Add the BARTs toolbox to the PATH variable\n", + "os.environ['PATH'] = os.environ['TOOLBOX_PATH'] + \":\" + os.environ['PATH']\n", + "sys.path.append(os.environ['TOOLBOX_PATH'] + \"/python\")" + ] + }, + { + "cell_type": "markdown", + "id": "1150a41e", + "metadata": { + "id": "1150a41e" + }, + "source": [ + "Test, if BART is installed correctly" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "decdec9a", + "metadata": { + "id": "decdec9a", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "920219e7-464e-4fec-b75f-92d95c899cc4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# BART used in this notebook:\n", + "/content/bart/bart\n", + "# BART version: \n", + "v0.9.00-1156-gd911ee9\n" + ] + } + ], + "source": [ + "%%bash\n", + "echo \"# BART used in this notebook:\"\n", + "which bart\n", + "echo \"# BART version: \"\n", + "bart version" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Download phantom data. **Replace URL to get data we just recorded.**" + ], + "metadata": { + "id": "BGJK8pkBzArm" + }, + "id": "BGJK8pkBzArm" + }, + { + "cell_type": "code", + "source": [ + "!wget https://cloud.tugraz.at/index.php/s/TJ8TcxR456t88MP/download/ksp_irraga.ra -O meas.ra" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KEiZUz3mzAHD", + "outputId": "82c47cc8-70c7-4967-c462-1fda798b17fb" + }, + "id": "KEiZUz3mzAHD", + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2025-09-08 09:59:49-- https://cloud.tugraz.at/index.php/s/TJ8TcxR456t88MP/download/ksp_irraga.ra\n", + "Resolving cloud.tugraz.at (cloud.tugraz.at)... 129.27.2.164\n", + "Connecting to cloud.tugraz.at (cloud.tugraz.at)|129.27.2.164|:443... connected.\n", + "HTTP request sent, awaiting response... 303 See Other\n", + "Location: https://cloud.tugraz.at/public.php/dav/files/TJ8TcxR456t88MP/?accept=zip [following]\n", + "--2025-09-08 09:59:50-- https://cloud.tugraz.at/public.php/dav/files/TJ8TcxR456t88MP/?accept=zip\n", + "Reusing existing connection to cloud.tugraz.at:443.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 83386544 (80M) [application/octet-stream]\n", + "Saving to: ‘meas.ra’\n", + "\n", + "meas.ra 100%[===================>] 79.52M 4.59MB/s in 18s \n", + "\n", + "2025-09-08 10:00:08 (4.50 MB/s) - ‘meas.ra’ saved [83386544/83386544]\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "90fab0a9" + }, + "outputs": [], + "source": [ + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "# import os\n", + "# import sys\n", + "import src.plotSubspace as ps\n", + "# import numpy as np\n", + "# import importlib\n", + "\n", + "mpl.rcParams.update(mpl.rcParamsDefault)\n", + "plt.style.use(['ggplot', 'src/customStyle.mplstyle'])" + ], + "id": "90fab0a9" + }, + { + "cell_type": "markdown", + "id": "ce287e47", + "metadata": { + "id": "ce287e47" + }, + "source": [ + "## Reconstruction Pulseq Data\n", + "\n", + "Now, we aim to reconstruct data obtained with Pulseq and a sequence prepared by `bart seq`.\n", + "First, we create a signal dictionary, then we perform a SVD and finally create the temporal basis used in subspace reconstruction.\n", + "\n", + "\n", + "### Convert dat file to cfl\n", + "First, we need to convert Siemens `.dat` file to bart `.cfl/.hdr` file format using `bart twixread` and check input file dimensions." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a591618d", + "metadata": { + "id": "a591618d", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "62f86b70-e8e7-48f0-af3e-26d624457ff3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# Dimensions\n", + "1 512 1131 18 1 1 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash\n", + "# bart twixread -A -r 1 meas.dat tmp_ksp\n", + "\n", + "bart copy meas.ra tmp_ksp\n", + "head -n2 tmp_ksp.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "ab8c08e4", + "metadata": { + "id": "ab8c08e4" + }, + "source": [ + "We notice `PHS2_DIM` should be `TE_DM` instead." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d2b2a771", + "metadata": { + "id": "d2b2a771", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1b8da333-b4c5-4d48-c3aa-266e70117a50" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# Dimensions\n", + "1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash\n", + "bart transpose 2 5 tmp_ksp tmp_ksp\n", + "head -n2 tmp_ksp.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "e887aaff", + "metadata": { + "id": "e887aaff" + }, + "source": [ + "### Trajectory and Sequence Params\n", + "You should have all relevant information from initial use of `bart seq`, when preparing Pulseq sequence. In case that is lost, we rerun the following commands." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cfa3809f", + "metadata": { + "id": "cfa3809f" + }, + "outputs": [], + "source": [ + "FIBO=377 # fibonacci number satisfying Nyquist when using RAGA\n", + "FRAMES=3\n", + "REP=int(FIBO*FRAMES)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c14782ff", + "metadata": { + "id": "c14782ff", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e1872b36-0ec9-485f-fb00-573522b30e6f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# Dimensions\n", + "3 512 377 1 1 1 1 1 1 1 3 1 1 1 1 1 \n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "loops: 3837483 \t dims: [ 1 377 1 1 1 1 3 3 377 1 3 1 1 1 1 1 ]\n", + "kernels: 1131 \t dims: [ 1 377 1 1 1 1 1 1 1 1 3 1 1 1 1 1 ]\n", + "Nr. of RF shapes: 2\n" + ] + } + ], + "source": [ + "%%pybash\n", + "\n", + "bart seq --IR_NON --raga -t {REP} -r {FIBO} grad mom adc\n", + "bart vec 1 1 0 tmp_a\n", + "bart extract 0 2 5 adc - | bart fmac - tmp_a traj\n", + "bart scale 0.5 traj traj\n", + "head -n2 traj.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "5b5d1ff1", + "metadata": { + "id": "5b5d1ff1" + }, + "source": [ + "For subspace reco, all spokes in dim 5:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "07b9dded", + "metadata": { + "id": "07b9dded", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "cd04823c-53e0-4085-dfbf-ac679e70d359" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# Dimensions\n", + "3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%pybash\n", + "bart reshape $(bart bitmask 2 10) 1 {REP} traj - | bart transpose 5 10 - traj\n", + "head -n2 traj.hdr" + ] + }, + { + "cell_type": "markdown", + "id": "5b4111b9", + "metadata": { + "notebookRunGroups": { + "groupValue": "2" + }, + "id": "5b4111b9" + }, + "source": [ + "## Create Dictionary\n", + "\n", + "The signal model according to Look-Locker in voxel $r$ at time $t$ is\n", + "$$\n", + "M(t,r)~=~M_{ss}(r)~-~\\left[M_{ss}(r)~+~M_{0}(r)\\right]~e^{-tR_1^*(r)}.~\n", + "$$\n", + "\n", + "Using `bart signal` we create our signal dictionary with `nR1s` values for R1star and `nMss` values for steady-state magnetization." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bb12ae41", + "metadata": { + "id": "bb12ae41" + }, + "outputs": [], + "source": [ + "TR=0.00311 # [s] , BlockDurationRaster x DUR = 1e-05 x 311 = 0.00311\n", + "nR1s=1000\n", + "nMss=100" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f00cf4a5", + "metadata": { + "id": "f00cf4a5", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "af760dcf-455a-4677-9c72-8837ba1cb5dc" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# Dimensions\n", + "1 1 1 1 1 1131 100000 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "1131 100000 \n" + ] + } + ], + "source": [ + "%%pybash\n", + "### create vector with inversion times nREP*TR\n", + "bart index 5 {REP} - | bart scale {TR} - TI\n", + "bart signal -F -I -n {REP} -r {TR} -1 5e-3:5:{nR1s} -3 1e-2:1:{nMss} tmp_dict\n", + "# reshape the dictionary to have all the elements on the 6th dimension\n", + "bart reshape $(bart bitmask 6 7) $(({nR1s} * {nMss})) 1 tmp_dict tmp_dict1\n", + "head -n2 tmp_dict1.hdr\n", + "# squeeze the dicc1 before SVD\n", + "bart squeeze tmp_dict1 subspace_dict\n", + "head -n2 subspace_dict.hdr\n", + "# perform SVD on dictionary\n", + "bart svd -e subspace_dict U S V" + ] + }, + { + "cell_type": "markdown", + "id": "9ac84bc2", + "metadata": { + "id": "9ac84bc2" + }, + "source": [ + "### Visualize simulated dictionay and PCA coeffcients" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "997f83b8", + "metadata": { + "id": "997f83b8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 401 + }, + "outputId": "74109a32-2242-427d-db69-a73e1eafac0d" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKAAAAGACAYAAACazRotAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FNX6wPHv7qb33ishECDUEKr03gUCKipixasiqIiiP9u1XQUFy9UrFkAFUYqo9I406aGXENJI773uzu+PJQshCQRII7yf59knyZk5M2dLZnbeOec9KkVRFIQQQgghhBBCCCGEqCPqhm6AEEIIIYQQQgghhGjaJAAlhBBCCCGEEEIIIeqUBKCEEEIIIYQQQgghRJ2SAJQQQgghhBBCCCGEqFMSgBJCCCGEEEIIIYQQdUoCUEIIIYQQQgghhBCiTkkASgghhBBCCCGEEELUKQlACSGEEEIIIYQQQog6JQEoIYQQQgghhBBCCFGnJADVyE2ZMgU/P7963290dDQqlYpFixbV+74BfvrpJ4KCgjA2NsbOzq5B2lDbGvo17du3L3379m2QfVdn0aJFqFQqoqOja33btf2/U5dtFULUj7vtOHi3OHjwID169MDS0hKVSkV4eDgAGzZsoEOHDpiZmaFSqcjKyrrlc4Ofnx9Tpkyp1XYLIcSdprEfCxvjeV5UJAGoWnbixAnCwsLw9fXFzMwMT09PBg0axBdffNHQTavS0qVLmT9/fkM3o4KzZ88yZcoUAgIC+Pbbb1mwYEFDN+mG/vrrL/r06YOLiwsWFhY0a9aMiRMnsmHDhoZu2m0rKCjg7bffZseOHQ3WhrfffhuVSmV4WFhY4OPjw6hRo1i4cCHFxcW1tq8PPviA1atX19r2hGhMvvrqK1QqFV27dm3optxRGutxsHXr1vzf//0fOTk5ldaPjIxk6tSpNGvWDDMzM2xsbOjZsyefffYZhYWFldbXarV4eHigUqlYv379TbcvOTmZmTNnEhQUhIWFBZaWloSEhPDee++RlZV1K0+5RkpLS5kwYQIZGRnMmzePn376CV9fX9LT05k4cSLm5ub897//5aeffsLS0rLO2lEb1q1bx9tvv93QzRDirnX1MfZ6j4Y8F9wprn3NLC0tad26Ne+99x4FBQUN3TzRgIwaugFNyd69e+nXrx8+Pj48+eSTuLm5ERcXxz///MNnn33GtGnTGrqJlSxdupSTJ08yY8aMCuW+vr4UFhZibGxc723asWMHOp2Ozz77jObNm9f7/m/W3Llzefnll+nTpw+zZ8/GwsKCCxcusGXLFpYtW8bQoUOBhn1Nb0dBQQHvvPMOQIPfUfj666+xsrKiuLiY+Ph4Nm7cyGOPPcb8+fNZs2YN3t7ehnW//fZbdDrdTe/jgw8+ICwsjHvvvbdC+cMPP8z999+Pqanp7T4NIRrMkiVL8PPz48CBA1y4cOGOOMY2Bo3xOJiXl8emTZt4//332bZtG3v27EGlUgGwdu1aJkyYgKmpKZMnTyY4OJiSkhJ2797Nyy+/zKlTpyrd3Nm2bRuJiYn4+fmxZMkShg0bVuM2HTx4kOHDh5OXl8dDDz1ESEgIAIcOHeI///kPf//9N5s2baq9F+EqkZGRxMTE8O233/LEE08Yyjds2EBubi7vvvsuAwcONJTf6rnh3LlzqNV1e9923bp1/Pe//5UglBAN5Keffqrw948//sjmzZsrlbdq1ao+m3XHGjRoEJMnTwYgLy+PXbt28cYbb3Ds2DGWL19eJ/usq3ONqD0SgKpF77//Pra2thw8eLDSsLGUlJSGadQtUqlUmJmZNci+y1+rGw29UxSFoqIizM3N66FVVSsrK+Pdd99l0KBBVR7wrn7fG/I1bSrCwsJwcnIy/P3mm2+yZMkSJk+ezIQJE/jnn38My2o70KfRaNBoNLW6zdpUVlaGTqfDxMSkoZsiGqmoqCj27t3LqlWrmDp1KkuWLOGtt95q6GaJm3T1cfDpp59m/PjxrFq1in/++Yfu3bsTFRXF/fffj6+vL9u2bcPd3d1Q99lnn+XChQusXbu20nZ//vlnOnXqxCOPPMJrr71Gfn5+jXoMZWVlMXbsWDQaDUePHiUoKKjC8vfff59vv/32Np919ar7zlBd+a2eG+TmgxBN30MPPVTh73/++YfNmzdXKm8qdDodJSUldXZ90qJFiwqv3dNPP01JSQmrVq2iqKioTvYr34MbPxmCV4siIyNp06ZNlYETFxeXSmU///wzISEhmJub4+DgwP33309cXNwN96PT6Zg/fz5t2rTBzMwMV1dXpk6dSmZmZqV1169fT58+fbC2tsbGxobQ0FCWLl0K6O/irl27lpiYGEP3yPK8CNXlK9q2bRu9evXC0tISOzs7xowZw5kzZyqsUz5M4MKFC0yZMgU7OztsbW159NFHb9jl0s/Pz3BB5OzsjEqlMtwJ9PPzY+TIkWzcuJHOnTtjbm7ON998A8DFixeZMGECDg4OWFhY0K1bt0pfsHfs2IFKpeK3337jnXfewdPTE2tra8LCwsjOzqa4uJgZM2bg4uKClZUVjz766A2HdqWlpZGTk0PPnj2rXH71+17VazplyhSsrKyIjY1l5MiRWFlZ4enpyX//+19AP6Szf//+WFpa4uvra3jvrn2tr1WTnCIlJSW8+eabhISEYGtri6WlJb169WL79u0V2uzs7AzAO++8Y/icXH139uzZs4SFheHg4ICZmRmdO3fmzz//rLS/U6dO0b9/f8zNzfHy8uK99967pbvQ13rwwQd54okn2L9/P5s3bzaUV5Xno7xnXdu2bTEzM8PZ2ZmhQ4dy6NAhQB8kzM/PZ/HixYbnWj7OvbrX9KuvvqJNmzaYmpri4eHBs88+W2m4Sd++fQkODub06dP069cPCwsLPD09+fjjjyusV5P3BK58lubOncv8+fMJCAjA1NSUAwcOYGlpyfTp0yu9TpcuXUKj0fDhhx/exKsrmpIlS5Zgb2/PiBEjCAsLY8mSJVWul5WVxQsvvICfnx+mpqZ4eXkxefJk0tLSDOsUFRXx9ttv06JFC8zMzHB3d2fcuHFERkYCV4631w5TkONg7R8H+/fvD+gDjAAff/wxeXl5fP/99xWCT+WaN29e6RhRWFjI77//zv3338/EiRMpLCzkjz/+qNH+v/nmG+Lj4/n0008rBZ8AXF1d+b//+78KZTU5bgLs37+foUOHYmtri4WFBX369GHPnj2G5VOmTKFPnz4ATJgwAZVKZcj/8cgjjwAQGhpa4Vh+K+cGqDrvSVZWFjNmzMDb2xtTU1OaN2/ORx99VOE9vfp4vWDBAsPxOjQ0lIMHD1Z4LuWf+auHrZRbtmwZISEhhu9zbdu25bPPPqv0mgkh6lZNr8PKr1t27NhhuG5p27at4by4atUqwzEnJCSEo0ePVqhffm68ePEiQ4YMwdLSEg8PD/7973+jKEqFdfPz83nppZcMx6KWLVsyd+7cSuupVCqee+45lixZYjgGl6cLmTt3Lj169MDR0RFzc3NCQkJYsWJFLb964ObmhkqlwsjoSj+YXbt2MWHCBHx8fDA1NcXb25sXXnih0nDxpKQkHn30Uby8vDA1NcXd3Z0xY8ZUOM9XlQPqiy++oE2bNlhYWGBvb0/nzp0rfZcQ9Ud6QNUiX19f9u3bx8mTJwkODr7uuu+//z5vvPEGEydO5IknniA1NZUvvviC3r17c/To0ev2/pk6dSqLFi3i0Ucf5fnnnycqKoovv/ySo0ePsmfPHsPdvUWLFvHYY4/Rpk0bZs+ejZ2dHUePHmXDhg1MmjSJ119/nezsbC5dusS8efMAsLKyqna/W7ZsYdiwYTRr1oy3336bwsJCvvjiC3r27MmRI0cqfaGbOHEi/v7+fPjhhxw5coTvvvsOFxcXPvroo2r3MX/+fH788Ud+//13wzCDdu3aGZafO3eOBx54gKlTp/Lkk0/SsmVLkpOT6dGjBwUFBTz//PM4OjqyePFiRo8ezYoVKxg7dmyFfXz44YeYm5vz6quvcuHCBb744guMjY1Rq9VkZmby9ttv888//7Bo0SL8/f158803q22vi4sL5ubm/PXXX0ybNg0HB4dq162OVqtl2LBh9O7dm48//pglS5bw3HPPYWlpyeuvv86DDz7IuHHj+N///sfkyZPp3r07/v7+N72fa+Xk5PDdd9/xwAMP8OSTT5Kbm8v333/PkCFDOHDgAB06dMDZ2Zmvv/6af/3rX4wdO5Zx48YBGN6TU6dO0bNnTzw9PXn11VextLTkt99+495772XlypWG1z4pKYl+/fpRVlZmWG/BggW11nvt4YcfZsGCBWzatIlBgwZVu97jjz/OokWLGDZsGE888QRlZWXs2rWLf/75h86dO/PTTz/xxBNP0KVLF5566ikAAgICqt3e22+/zTvvvMPAgQP517/+xblz5/j66685ePBghf9FgMzMTIYOHcq4ceOYOHEiK1as4JVXXqFt27aGoS41eU+utnDhQoqKinjqqacwNTXFx8eHsWPH8uuvv/Lpp59W6LH1yy+/oCgKDz744K28xKIJWLJkCePGjcPExIQHHnjA8FkNDQ01rJOXl0evXr04c+YMjz32GJ06dSItLY0///yTS5cu4eTkhFarZeTIkWzdupX777+f6dOnk5uby+bNmzl58uR1/2eqI8fBW1ce9HN0dAT0OQmbNWtGjx49aryNP//8k7y8PO6//37c3Nzo27cvS5YsYdKkSTWqa25uTlhYWI32VdPj5rZt2xg2bBghISG89dZbqNVqFi5cSP/+/dm1axddunRh6tSpeHp68sEHH/D8888TGhqKq6srAC1btmTBggX8+9//xt/f/7qfyxudG6pSUFBAnz59iI+PZ+rUqfj4+LB3715mz55NYmJipfyaS5cuJTc3l6lTp6JSqfj4448ZN24cFy9exNjYmKlTp5KQkFDlcJ/NmzfzwAMPMGDAAMN3qDNnzrBnz54qbzgIIepOTa/DAC5cuMCkSZOYOnUqDz30EHPnzmXUqFH873//47XXXuOZZ54B9NcmEydOrDTUV6vVMnToULp168bHH3/Mhg0beOuttygrK+Pf//43oB8RMnr0aLZv387jjz9Ohw4d2LhxIy+//DLx8fGGa7xy27Zt47fffuO5557DycnJcP322WefMXr0aB588EFKSkpYtmwZEyZMYM2aNYwYMeKWXquioiLDzav8/Hz27NnD4sWLmTRpUoUA1PLlyykoKOBf//oXjo6OHDhwgC+++IJLly5VGKo3fvx4Tp06xbRp0/Dz8yMlJYXNmzcTGxtb7eQS3377Lc8//zxhYWFMnz6doqIijh8/zv79+2t0jhN1QBG1ZtOmTYpGo1E0Go3SvXt3ZdasWcrGjRuVkpKSCutFR0crGo1Gef/99yuUnzhxQjEyMqpQ/sgjjyi+vr6Gv3ft2qUAypIlSyrU3bBhQ4XyrKwsxdraWunatatSWFhYYV2dTmf4fcSIERW2Xy4qKkoBlIULFxrKOnTooLi4uCjp6emGsmPHjilqtVqZPHmyoeytt95SAOWxxx6rsM2xY8cqjo6OlfZ1rfL6qampFcp9fX0VQNmwYUOF8hkzZiiAsmvXLkNZbm6u4u/vr/j5+SlarVZRFEXZvn27AijBwcEV3pMHHnhAUalUyrBhwypst3v37lW+Ntd68803FUCxtLRUhg0bprz//vvK4cOHK61X1Wv6yCOPKIDywQcfGMoyMzMVc3NzRaVSKcuWLTOUnz17VgGUt956q9Jrda2FCxcqgBIVFWUo69Onj9KnTx/D32VlZUpxcXGFepmZmYqrq2uF9y41NbXSfssNGDBAadu2rVJUVGQo0+l0So8ePZTAwEBDWfl7tH//fkNZSkqKYmtrW6mdVanuM3F1uwFl7NixhrJr/3e2bdumAMrzzz9fqf7V/xOWlpbKI488Ummda1/TlJQUxcTERBk8eLDhM6YoivLll18qgPLDDz8Yyvr06aMAyo8//mgoKy4uVtzc3JTx48cbymr6npR/lmxsbJSUlJQK62/cuFEBlPXr11cob9euXYX3X9xdDh06pADK5s2bFUXRf+a9vLyU6dOnV1iv/Hi2atWqStso/z/54YcfFED59NNPq12n/Hi7ffv2CsvlOHj7x8Fz584pqampSlRUlPLNN98opqamiqurq5Kfn69kZ2crgDJmzJjrbutaI0eOVHr27Gn4e8GCBYqRkVGl40tV7O3tlfbt29doPzU9bup0OiUwMFAZMmRIheNzQUGB4u/vrwwaNMhQVv5ZW758eYV9lb//Bw8erFB+q+cGX1/fCueGd999V7G0tFTOnz9foc6rr76qaDQaJTY2VlGUK595R0dHJSMjw7DeH3/8oQDKX3/9ZSh79tlnq/wsT58+XbGxsVHKysoqLRNC1J1r/ydreh2mKFeuW/bu3WsoK/+OZm5ursTExBjKv/nmm0rnzPJz47Rp0wxlOp1OGTFihGJiYmL4Trx69WoFUN57770KbQoLC1NUKpVy4cIFQxmgqNVq5dSpU5Wea0FBQYW/S0pKlODgYKV///4Vyq89FlYHqPJx7733VjhfVrVvRVGUDz/8UFGpVIbXqfy7/pw5c66732vP82PGjFHatGlzw/aK+iND8GrRoEGD2LdvH6NHj+bYsWN8/PHHDBkyBE9Pzwpd8VetWoVOp2PixImkpaUZHm5ubgQGBlYabnO15cuXY2try6BBgyrUDQkJwcrKylB38+bN5Obm8uqrr1YaX1vVUIUbSUxMJDw8nClTplTo5dOuXTsGDRrEunXrKtV5+umnK/zdq1cv0tPTq5ytp6b8/f0ZMmRIhbJ169bRpUsX7rnnHkOZlZUVTz31FNHR0Zw+fbrC+pMnT65wd6Jr164oisJjjz1WYb2uXbsSFxdHWVnZddv0zjvvsHTpUjp27MjGjRt5/fXXCQkJoVOnTpWGJ1bn6sSpdnZ2tGzZEktLSyZOnGgob9myJXZ2dly8eLFG27wRjUZjGCet0+nIyMigrKyMzp07c+TIkRvWz8jIYNu2bUycOJHc3FzDZzE9PZ0hQ4YQERFBfHw8oH+PunXrRpcuXQz1nZ2da603TnnPvdzc3GrXWblyJSqVqsqcN7fyP7FlyxZKSkqYMWNGhbtVTz75JDY2NpWGgFpZWVUYB29iYkKXLl0qvJ83+56MHz/eMDSo3MCBA/Hw8KgwvOrkyZMcP368yeYwEDe2ZMkSXF1d6devH6D/zN93330sW7YMrVZrWG/lypW0b9++Us/R8jrl6zg5OVU5scat/C+Vk+NgzbRs2RJnZ2f8/f2ZOnUqzZs3Z+3atVhYWBjOr9bW1jXeXnp6Ohs3buSBBx4wlI0fP94wZP1GcnJyary/mh43w8PDiYiIYNKkSaSnpxte1/z8fAYMGMDff/9dK0O44dbPDcuXL6dXr17Y29tX+D42cOBAtFotf//9d4X177vvPuzt7Q1/9+rVC6BGn2U7Ozvy8/MrDDMXQtS/ml6HlWvdujXdu3c3/F0+A23//v3x8fGpVF7V8eC5554z/F4+hK6kpIQtW7YA+nOLRqPh+eefr1DvpZdeQlGUSrOa9unTh9atW1faz9W9cTMzM8nOzqZXr141OhdWZ8yYMWzevJnNmzfzxx9/MHv2bMNIHOWq4YFX7zs/P5+0tDR69OiBoiiGoYnm5uaYmJiwY8eOKtPOVMfOzo5Lly5VGPIsGpYMwatloaGhrFq1ipKSEo4dO8bvv//OvHnzCAsLIzw8nNatWxMREYGiKAQGBla5jeslyIyIiCA7O7vKnFJwJelmeZf8Gw0FrKmYmBhA/8X3Wq1atWLjxo2VEpZefWAFDF+8MjMzsbGxuaV2VDXkIiYmpsopxctnqIiJianwOlzbLltbW4AKM6iVl+t0OrKzsw1DG6rzwAMP8MADD5CTk8P+/ftZtGgRS5cuZdSoUZw8efK6SfbK801cu28vL69KX35tbW1v6qB7I4sXL+aTTz7h7NmzlJaWGsprMrTlwoULKIrCG2+8wRtvvFHlOikpKXh6elb7HlX1eboVeXl5wPUvuiIjI/Hw8LilYZJVqe5/wsTEhGbNmhmWl6vq/bS3t+f48eMVym7mPamqTK1W8+CDD/L1119TUFCAhYUFS5YswczMjAkTJtzckxRNglarZdmyZfTr18+QJwj0X3g/+eQTtm7dyuDBgwH9/8n48eOvu73IyEhatmxZofv87ZLjYM2tXLkSGxsbjI2N8fLyqjC0rPzcer1g/LV+/fVXSktL6dixIxcuXDCUd+3alSVLlvDss89et76NjU2N91fT42ZERASAIY9TVbKzsysEdG7VrZ4bIiIiOH78eKXPbblrJ5+53neiG3nmmWf47bffGDZsGJ6engwePJiJEycaZtkVQtSPml6HlbuZaw6ofDxQq9U0a9asQlmLFi0ADHmPYmJi8PDwqPQd+OrroKtVd25bs2YN7733HuHh4RVy4N7OjSUvL68Ks5COHj0aR0dHZs6cyZo1axg1ahQAsbGxvPnmm/z555+VXoPs7GxAPxHERx99xEsvvYSrqyvdunVj5MiRTJ48GTc3t2rb8Morr7Blyxa6dOlC8+bNGTx4MJMmTao2f6+oexKAqiMmJiaEhoYSGhpKixYtePTRR1m+fDlvvfUWOp0OlUrF+vXrq5xV63p5mHQ6HS4uLtUmj63ui1BDqG7GsKsj3jerNnIGVdeu2mivjY0NgwYNYtCgQRgbG7N48WL2799vSJJa2+2p7qRwdY+G6vz8889MmTKFe++9l5dffhkXFxdDkuryAOb1lN99njlzZqVeaeXqa4r3kydP1uv+bkVN3s+bfU+q+3+YPHkyc+bMYfXq1TzwwAMsXbqUkSNHGr7giLvLtm3bSExMZNmyZSxbtqzS8iVLlhgCULXlZo9Nchysud69e1eYDfRqNjY2eHh4GI6JNVH+faK6L+MXL16sdAF0taCgIMLDwykpKam12YfKX9c5c+ZUyn1X7nrfleqDTqdj0KBBzJo1q8rl5ReJ5W7nO4aLiwvh4eFs3LiR9evXs379ehYuXMjkyZNZvHjxzTdeCHFLbvY6rC6vOW5VVd8dd+3axejRo+nduzdfffUV7u7uGBsbs3DhwlpP1j1gwAAA/v77b0aNGoVWq2XQoEFkZGTwyiuvEBQUhKWlJfHx8UyZMqVCb9cZM2YwatQoVq9ezcaNG3njjTf48MMP2bZtGx07dqxyf61ateLcuXOsWbOGDRs2sHLlSr766ivefPNN3nnnnVp9bqJmJABVD8oTWCYmJgL6pMaKouDv71/pC8qNBAQEsGXLFnr27HndYEz5HdGTJ09e98tvTaPavr6+gD4J+LXOnj2Lk5NTjaZrrgu+vr7Vtqt8eUPo3LkzixcvNrzvdaH8DmpWVlaFxPXX3u2oyooVK2jWrBmrVq2q8Dm4dhhCdZ+R8gsSY2PjCnc3quLr62u4o321qt63W1GesLW6C0DQ/09s3LiRjIyM697pvpX/iasvzkpKSoiKirrha1KVmr4nNxIcHEzHjh1ZsmQJXl5exMbG8sUXX9x0e0TTsGTJElxcXAwzbF1t1apV/P777/zvf//D3NycgICAGwYvAgIC2L9/P6WlpdX22L362HS1mhybbpYcBysaOXIkCxYsYN++fRWGflQlKiqKvXv38txzz1W6UaLT6Xj44YdZunRppVnsrjZq1Cj27dvHypUrKwzjq0pNj5vl32FsbGxu6Vh6M2p6bqiqXl5eXq2273rnHxMTE0aNGsWoUaPQ6XQ888wzfPPNN7zxxhuN+uaLEE1JTa/DaotOp+PixYsVrhfPnz8PYEi67evry5YtW8jNza3QC+pmroNWrlyJmZkZGzduxNTU1FC+cOHC2ngaFZSnNikfvXDixAnOnz/P4sWLmTx5smG96oYcBwQE8NJLL/HSSy8RERFBhw4d+OSTT/j555+r3aelpSX33Xcf9913HyUlJYwbN47333+f2bNnX3eUiqgbkgOqFm3fvr3KyHV5fqTyLufjxo1Do9HwzjvvVFpfURTS09Or3cfEiRPRarW8++67lZaVlZUZvuwPHjwYa2trPvzwQ4qKiirto5ylpaWha+P1uLu706FDBxYvXlzhguLkyZNs2rSJ4cOH33AbdWX48OEcOHCAffv2Gcry8/NZsGABfn5+VY5zri0FBQUV9nu18jHXtTXMrCrlX9KvzjWRn59fozui5Xdfrv487N+/v9LzsbCwACpfSLq4uNC3b1+++eabKoNsqampht+HDx/OP//8w4EDByosr+4O0s1YunQp3333Hd27dzfcVanK+PHjURSlyrsd1/5PVDUd+LUGDhyIiYkJn3/+eYX633//PdnZ2bc0Y0hN35OaePjhh9m0aRPz58/H0dHRMNOeuLsUFhayatUqRo4cSVhYWKXHc889R25uriFP4fjx4w3Dx69V/rkcP348aWlpfPnll9Wu4+vri0ajqZQH56uvvqrtpyjHwWvMmjULS0tLnnjiCZKTkystj4yM5LPPPgOu9H6aNWtWpc/GxIkT6dOnzw3b9/TTT+Pu7s5LL71kuDC6WkpKCu+99x5Q8+NmSEgIAQEBzJ0713CRcrWrX9fbVdNzw7UmTpzIvn372LhxY6VlWVlZN8wfWZXyG3nXfs6u/V6oVqsNszBePVRGCFG3anodVpuuPtcqisKXX36JsbGx4Tvv8OHD0Wq1lc7J8+bNQ6VS1ej7n0ajQaVSVeg5HB0dzerVq2vnSVzlr7/+AqB9+/aGfUPF462iKIbzVLmCgoJK17QBAQFYW1tf9zh47fHTxMSE1q1boyhKhWH3ov5ID6haNG3aNAoKChg7dixBQUGUlJSwd+9efv31V/z8/Hj00UcB/T/Le++9x+zZs4mOjubee+/F2tqaqKgofv/9d5566ilmzpxZ5T769OnD1KlT+fDDDwkPD2fw4MEYGxsTERHB8uXL+eyzzwgLC8PGxoZ58+bxxBNPEBoayqRJk7C3t+fYsWMUFBQYvpiHhITw66+/8uKLLxIaGoqVlZVhPO615syZw7Bhw+jevTuPP/44hYWFfPHFF9ja2vL222/XyWtaE6+++iq//PILw4YN4/nnn8fBwYHFixcTFRXFypUrKyQ6rW0FBQX06NGDbt26MXToULy9vcnKymL16tXs2rWLe++9t9ouobVh8ODB+Pj48Pjjj/Pyyy+j0Wj44YcfcHZ2JjY29rp1R44cyapVqxg7diwjRowgKiqK//3vf7Ru3brCF35zc3Nat27Nr7/+SosWLXBwcCA4OJjg4GD++9//cs8999C2bVuefPJJmjVrRnJyMvv27ePSpUscO3YM0F/c/PTTTwwdOpTp06cbph/39fWtlAPpelasWIGVlRUlJSXEx8ezceNG9uzZQ/v27StM01qVfv368fDDD/P5558TERHB0KFD0el07Nq1i379+hmSPIaEhLBlyxY+/fRTPDw88Pf3rzJvi7OzM7Nnz+add95h6NChjB49mnPnzvHVV18RGhp6Swm/a/qe1MSkSZOYNWsWv//+O//617+um1tONF1//vknubm5jB49usrl3bp1w9nZmSVLlnDffffx8ssvs2LFCiZMmMBjjz1GSEgIGRkZ/Pnnn/zvf/+jffv2TJ48mR9//JEXX3yRAwcO0KtXL/Lz89myZQvPPPMMY8aMwdbWlgkTJvDFF1+gUqkICAhgzZo1lfJj1Ia77Th4IwEBASxdupT77ruPVq1aMXnyZIKDgw3fSZYvX86UKVMAfQCqQ4cOlfKRlBs9ejTTpk3jyJEjdOrUqcp17O3t+f333xk+fDgdOnTgoYceIiQkBIAjR47wyy+/GHpi1fS4qVar+e677xg2bBht2rTh0UcfxdPTk/j4eLZv346NjY3hIuZ21fTccK2XX36ZP//8k5EjRzJlyhRCQkLIz8/nxIkTrFixgujo6GqHSlan/HV7/vnnGTJkCBqNhvvvv58nnniCjIwM+vfvj5eXFzExMXzxxRd06NDBkOdFCFH3anodVlvMzMzYsGEDjzzyCF27dmX9+vWsXbuW1157zTDcb9SoUfTr14/XX3+d6Oho2rdvz6ZNm/jjjz+YMWNGhTyB1RkxYgSffvopQ4cOZdKkSaSkpPDf//6X5s2b39b56fz584aeSQUFBfzzzz8sXryY5s2b8/DDDwP6YdwBAQHMnDmT+Ph4bGxsWLlyZaVcUOfPn2fAgAFMnDiR1q1bY2RkxO+//05ycjL3339/tW0YPHgwbm5u9OzZE1dXV86cOcOXX37JiBEjbmrCDlGL6nqavbvJ+vXrlccee0wJCgpSrKysFBMTE6V58+bKtGnTlOTk5Errr1y5UrnnnnsUS0tLxdLSUgkKClKeffZZ5dy5c4Z1rp0uuNyCBQuUkJAQxdzcXLG2tlbatm2rzJo1S0lISKiw3p9//qn06NFDMTc3V2xsbJQuXboov/zyi2F5Xl6eMmnSJMXOzk4BDPuqaqpsRVGULVu2KD179jRsb9SoUcrp06crrFM+VXT59KDlqpoSuyrV1ff19VVGjBhRZZ3IyEglLCxMsbOzU8zMzJQuXbooa9asqbDOzU7VXF07rlZaWqp8++23yr333qv4+voqpqamioWFhdKxY0dlzpw5Fab3rm76cUtLy0rb7dOnT5VThlb1Ghw+fFjp2rWrYmJiovj4+CiffvppjaYf1+l0ygcffGBod8eOHZU1a9ZU+Znbu3evEhISopiYmFSaijwyMlKZPHmy4ubmphgbGyuenp7KyJEjlRUrVlTYxvHjx5U+ffooZmZmiqenp/Luu+8q33///U19JsofZmZmipeXlzJy5Ejlhx9+qDSdq6JU/b9TVlamzJkzRwkKClJMTEwUZ2dnZdiwYcrhw4cN65w9e1bp3bu3Ym5urgCGqWar+/x++eWXSlBQkGJsbKy4uroq//rXv5TMzMwK61T3fl7bxpq+J+WfpRtNRTt8+PBKUwCLu8uoUaMUMzMzJT8/v9p1pkyZohgbGytpaWmKoihKenq68txzzymenp6KiYmJ4uXlpTzyyCOG5YqinzL59ddfV/z9/RVjY2PFzc1NCQsLUyIjIw3rpKamKuPHj1csLCwUe3t7ZerUqcrJkyflOHibx8HrnZOudv78eeXJJ59U/Pz8FBMTE8Xa2lrp2bOn8sUXXyhFRUXK4cOHFUB54403qt1GdHS0AigvvPDCDfeXkJCgvPDCC0qLFi0UMzMzxcLCQgkJCVHef/99JTs7u8K6NTluKoqiHD16VBk3bpzi6OiomJqaKr6+vsrEiROVrVu3Gta52XP7rZ4bqpp6PDc3V5k9e7bSvHlzxcTERHFyclJ69OihzJ07VykpKVEU5frH62s/R2VlZcq0adMUZ2dnRaVSGaZ/X7FihTJ48GDFxcXF8BmfOnWqkpiYWGmbQoja8+yzzypVXS7X5DqsuusWQHn22WcrlFV1nCg/N0ZGRiqDBw9WLCwsFFdXV+Wtt95StFpthfq5ubnKCy+8oHh4eCjGxsZKYGCgMmfOHEWn091w3+W+//57JTAwUDE1NVWCgoKUhQsXGs47V6vqWFiVq7+3A4pGo1G8vLyUp556qtJ18enTp5WBAwcqVlZWipOTk/Lkk08qx44dq/B9IS0tTXn22WeVoKAgxdLSUrG1tVW6du2q/PbbbxW2de15/ptvvlF69+5tOI8EBAQoL7/8cqXzkqg/KkWph2xnQggh6t3YsWM5ceJEhZmthBBCCCFE4zZlyhRWrFhx0z3ghWjsJAeUEEI0QYmJiaxdu9bQxVkIIYQQQgghGpLkgBJCiCYkKiqKPXv28N1332FsbMzUqVMbuklCCCGEEEIIIT2ghBCiKdm5cycPP/wwUVFRLF68GDc3t4ZukhBCCCGEEEIgOaCEEEIIIYQQQgghRJ2SHlBCCCGEEEIIIYQQok5JAEoIIYQQQgghhBBC1CkJQAkhhBBCCCGEEEKIOiUBKCGEEEIIIYQQQghRpyQAJYQQQgghhBBCCCHqlASghBBCCCGEEEIIIUSdkgCUEEIIIYQQQgghhKhTEoASQgghhBBCCCGEEHVKAlBCCCGEEEIIIYQQok5JAEoIIYQQQgghhBBC1CkJQAkhhBBCCCGEEEKIOiUBKCGEEEIIIYQQQghRpyQAJYQQQgghhBBCCCHqlASghBBCCCGEEEIIIUSdkgCUEEIIIYQQQgghhKhTEoASQgghhBBCCCGEEHVKAlBCCCGEEEIIIYQQok5JAEoIIYQQQgghhBBC1CkJQAkhhBBCCCGEEEKIOiUBKCGEEEIIIYQQQghRpyQAJYQQQgghhBBCCCHqlASghBBCCCGEEEIIIUSdMmroBjRVBQUFREZGYmdnh5GRvMxCiPpXVlZGVlYWAQEBWFhYNHRzxA3IeUMI0dDkvHHnkXOHEKKh3cy5Q45SdSQyMpJVq1Y1dDOEEIJx48bRtm3bhm6GuAE5bwghGgs5b9w55NwhhGgsanLukABUHbGzswP0b4KTk1PDNkYIcVdKS0tj1apVhuORaNzkvCGEaGhy3rjzyLlDCNHQbubcIQGoOlLeBdbJyQl3d/cGbo0Q4m4mXfLvDHLeEEI0FnLeuHPIuUMI0VjU5NwhSciFEEIIIYQQQgghRJ2SAJQQQgghhBBCCCGEqFMSgBJCCCGEEEIIIYQQdUoCUEIIIe5aeXl5vPXWWwwdOhQHBwdUKhWLFi2qcf2srCyeeuopnJ2dsbS0pF+/fhw5cqTuGiyEEEIIIcQdSjIMCiGEuGulpaXx73//Gx8fH9q3b8+OHTtqXFen0zFixAiOHTvGyy+/jJOTE1999RV9+/bl8OHDBAYG1l3DRZOj1WrZtWsXiYmJuLu706tXLzQaTb3VlzZIG4QQQoi6JgEoIYQQdy13d3cSExNxc3Pj0KFDhIaG1rjuihUr2Lt3L8uXLycsLAyAiRMn0qJFC9566y2WLl1aV80WjcztXuyvWrWK6dOnc+nSJUOZl5cXn332GePGjavz+tIGaYMQQghRH2QInhBCiLuWqakpbm5ut1R3xYoVuLq6Vrigc3Z2ZuLEifzxxx8UFxfXVjNFHdNqtezYsYNffvmFHTt2oNVqa1x31apV+Pn50a9fPyZNmkS/fv3w8/Nj1apVNa4fFhZWIVgAEB8fT1hY2A23c7v1pQ3SBiGEEKK+SABKCCEaOZ1WR0FmIYU5RQ3dFHGVo0eP0qlTJ9TqiqfSLl26UFBQwPnz5xuoZeJm3E4A6XYv9rVaLdOnT0dRlErLystmzJhRbUDsduvXdBvTp0+nqKiIkpISiouLKSoqorCwkMLCQnJzc3n++eevW//5558nPT2drKwssrKyyMzMNDwyMjJITU1l2rRpN9xGcnIyaWlppKamVngkJSXdsP60adNITEwkJSWlykdiYiLPPffcLW+jpvUTEhJITk6u8pGQkHBb26hJ/Rt9Hu5mxcXFvPLKK3h4eGBubk7Xrl3ZvHlzjerGx8czceJE7OzssLGxYcyYMVy8eLHSeiqVqsrHf/7zn9p+OvWurERLcX5JlZ8/IYQoJ0PwhBCigWhLtRRkFJKfUUB+uv5nYWYRBVmF+oBTVhEFmYUU5RSj6BQ6hgXT5eEODd1scVliYiK9e/euVO7u7g5AQkICbdu2rbS8uLi4yt5ReXl5td/Iu8DtDH8rDyBde8FUHkBasWJFtUOWahK4efrppzE1NaW0tJSioqJKj7Nnz1YKXl27nbi4OLp164aNjQ1arZaysjLDIysrq0b1HRwc0Gg06HQ6dDodiqIYfi/f1vW2cenSJczNzatd53oURSE+Ph4nJ6dbqn/1Nm61t6KiKCQkJODh4XFbbbidbZTX9/T0vO023Oo2yj8Pu3btom/fvrfcjqZqypQprFixghkzZhAYGMiiRYsYPnw427dv55577qm2Xl5eHv369SM7O5vXXnsNY2Nj5s2bR58+fQgPD8fR0bHC+oMGDWLy5MkVyjp27Fgnz6k+xBy6xNHfTpISkY6iUzC3M6NZDx/ajWmFjZt1QzdPCNHISABKCCHqQGlhKXlpBeSnX/XIKCQ/Lf/yzwIKs2+iR5MKSourv0gU9a+wsBBTU9NK5WZmZoblVfnwww955513KpW7u7szderU2m1kE3c7uW5qEkB68skniYqKIicnx9B7p/xx6dKl6wZ/AFJTUxk5cuQtPLOKDh06dFv1c3JybrsNoulITExs6CY0OgcOHGDZsmXMmTOHmTNnAjB58mSCg4OZNWsWe/furbbuV199RUREBAcOHDDkERw2bBjBwcF88sknfPDBBxXWb9GiBQ899FDdPZl6oigK/yw6wvHVZyqUF2YVcWrdec5uiaTzA+1of29rVGpVA7VSCNHYSABKCCFuQWlxGXnJeeSm5JObcs3P5DyKcmqW/0dtpMbKyQILBwssHcyxsNc/zO3NsLAzx9zODAt7c8xsTFFrZNR0Y2Jubl5lT6aioiLD8qrMnj2bF198sVJ5cnKyJC6/CTfbe0lRFFJTU4mMjCQyMpItW7bcMICUkZFhuBi9Vb6+voYhPWZmZhUe6enp/PHHHzfcxuzZs2nbti1GRkYYGRmh0WgwMjLi1KlTzJo164b1Fy5cSLdu3VCpVKjV6gqP/fv3c999991wG3/++Se9evVCpdJfSJYPHdq9ezfDhw+/Yf1NmzbRp08fQ/1yKpWKnTt3MnDgwBtuY+vWrfTr169S+c6dO6ssv9b27dur7fmzY8eO29rG7davzzaU99IUV6xYsQKNRsNTTz1lKDMzM+Pxxx/ntddeIy4uDm9v72rrhoaGVpjEIigoiAEDBvDbb79VCkCB/gaFSqUy3LC4Ex1dftIQfGo7Ooh2o1tham1K0pkUwleeIuFEMvsXHyX5XBr9X+iJsZlcdgohJAAlhBDVKsotJjshl+yEHMPP3MtBp5r0XjKxNMbS0QJLBwssna766Whu+N3M2rTSBZm4M5TPoHet8rLqhuqYmppW2XMqPz+/dhvYhNWk99ITTzzBvn37iIqKMgSdcnNzb3pf3bt3p2PHjtjZ2VV4xMTE8PLLL9+w/qJFi6oNOGi1Wvz8/IiPj6/yuahUKry8vHj33XerHFY4ZMgQPv/88xvWf/jhh6sdlujl5YWXl9cNtzF8+PAqtzF48OAa1e/fv3+1bejbt2+NtlFVAAugV69eNarfq1evKvdfG9toKm24Wx09epQWLVpgY2NTobxLly4AhIeHVxmA0ul0HD9+nMcee6zSsi5durBp0yZyc3Oxtr4yFG3RokV89dVXKIpCq1at+L//+z8mTZpUy8+obiWfS+XQL8cBuOfpLrQZ1sKwzLujB14d3Dm7+QK7vzlI9D9xrH1rKyPe7o+xuXFDNVkI0UhIAEoIcVcrLS4jOz6HrPgcchJzyU7IJSshh5yEXIpyr9+LycTCGGtXK6xdLLF2sarwu5WLJaaWJvX0LERD6NChA7t27UKn01VIRL5//34sLCxo0aLFdWqL27Fr164b9l7KzMxk7ty5FcrKL8ADAgKwsLBg3bp1N9zXBx98UGUASavV8tlnn93Wxb5Go+Gzzz4jLCwMlUpVYTvlgZb58+dXG7i53frSBmmD0CvPIXetq3P6VSUjI4Pi4uIb1m3ZsiUAPXr0YOLEifj7+5OQkMB///tfHnzwQbKzs/nXv/513TY2lvyBik7h76/2o+gUAvv6Vwg+lVOpVLQaHIi9ty3r391B8tlUNry3g6Fv9sPYVC4/hbibyXgOIcRdoaxES9rFDCJ2RLH/p6NseH8Hv0xdzQ/3LWPlC+vYOnc3B5cc4/z2i6ScSzMEnywczPEIdiVocHO6PtKRQa/2Zvy84UxZMoFHf7mPsPkjGPJaX3o80Zm2o4Lw6+qNo7+9BJ+amMTERM6ePUtpaamhLCwsjOTk5AoznaWlpbF8+XJGjRpVZS8nUZlWq2XHjh388ssv7Nix47ozdCmKwtmzZ/nuu+9qtO0hQ4Ywf/58/vrrL06fPk1BQQGxsbFs376dP//8Ey8vr2p7IKpUKry9vasNIJVf7Jeve21dqNnF/rhx41ixYkWlxNJeXl7XTYJeW/WlDdIGces5/crLa1p3z549TJ8+ndGjR/P0009z+PBhgoODee2116rdR7kPP/wQW1vbSo8+ffrU7EnWkot7Y8mIzsLEwpgej3e+7rpurVwMPZ8STiazde5udFpdPbVUCNEYSQhaCNGkKIpCbko+aRczSL+YSUZsFpmxWeQk5aHoqp4a2MzaFFtPG2w9rLH1uPzTXf+Q7uJN35dffklWVpbhDvdff/1l6F0zbdo0bG1tmT17NosXLyYqKgo/Pz9AH4Dq1q0bjz76KKdPn8bJyYmvvvoKrVZbZZJxUVlNkogXFhayY8cO1q5dy7p164iKiqrx9l999dVqh7/VRm+R8ov9qp7D/Pnza3yxP27cOMaMGXPLs/ndbn1pg7ThbnerOf3Ky2+lLoCJiQnPPfecIRh1vdn2Gkv+wPCVJwFoO6YVZjY3vtHi0sKJ4W/1Y80bW4g5cIkDP4XTbUqnum6mEKKRkgCUEOKOpdPqyIrPMQSb0i5mkHYxk5L8kirXN7Uywd7HFntvOxx8bLH3scPBxw5zuzs3Cai4fXPnziUmJsbw96pVqwy9mh566CFsbW2rrKfRaFi3bh0vv/wyn3/+OYWFhYSGhrJo0SLDcAtRvRslEX/iiSeIj49n27Zthgs50F+w9enTh4MHD5KdnX1buW5qI4BUWxf7Go2m2mBZfdSXNkgb7mbu7u7Ex8dXKr9RTj8HBwdMTU1vKR9gufLcUhkZGdddrzHkD0yNTCftYiZqIzXBw2t+nnNr5ULf57uz9ZM9HPv9NPbetrQcEFCHLRVCNFYSgBJC3BEURSEnKY+U82mknEsjJSKdjOhMykoqD9dRG6lx8LHFsZkDDr76IJO9jy0W9uaS8FtUEh0dfcN1Fi1axKJFiyqV29vb891339V4SJjQq0kS8W+//dZQVp4Ee8SIEfTv3x8rKytDAOt2c93URgBJLvaFuLN16NCB7du3k5OTUyER+f79+w3Lq6JWq2nbti2HDh2qtGz//v00a9asQgLyqly8eBEAZ2fnW2x9/Tm7ORIA/+7eNer9dLXmvf3JjMvhyG8n2PW/AzgFOODoZ18XzRRCNGISgBJCNErF+SWkRqSTcj6N5HNppJxPoyinchd3YzMjHJvZ4+TvgGMzB5ya2WPvbYvGWIYaCNFY1SSJOMCTTz7JtGnTCA4OrhQ8rq3hbyABJCHudmFhYcydO5cFCxYwc+ZMQD+sbuHChXTt2tXQSyk2NpaCggKCgoIq1H311Vc5dOgQnTvrcyKdO3eObdu2GbYFkJqaWinIlJuby/z583FyciIkJKSun+Zt0ZZqufC3fgh00KDmt7SNzg+0IzUynbjDCWz+6G/GfTIcEwtJdSDE3UQCUEKIRiE/o4DEUymXH8lkxmXDNZ0j1EZqnJo54NLSCdcWjjgFOGLrbo1KLb2ahLiTVDVcpSr9+vWjbdu21S6XXDdCiNrQtWtXJkyYwOzZs0lJSaF58+YsXryY6Ohovv/+e8N6kydPZufOnRV6XT7zzDN8++23jBgxgpkzZ2JsbMynn36Kq6srL730kmG9//73v6xevZpRo0bh4+NDYmIiP/zwA7Gxsfz000+YmDTuyUsST6dQkl+Kua0ZHsGut7QNlVpFvxk9WDljHdkJuez6ej/9X+wpvdOFuItIAEoI0SByU/L0waaTySSeTiE7IbfSOtauVri2dMKlhf7h1MxeejYJ0QS4uLjUaL2qpja/lvReEkLUhh9//JE33niDn376iczMTNq1a8eaNWvo3bv3detZW1uzY8cOXnjhBd577z10Oh19+/Zl3rx5FXo89ezZk7179/Ldd9+Rnp6OpaUlXbp04YcffqB///51/fRuW8xBfY4sn86eqDW3PpG6uY0ZA1++hz9f28yFv6Px6uAu+aCEuItIAEoIUS+KcouJP57EpaOJXDqWSF7KNUkzVeDkb49bG1fc27jg1soZC7vqZ44RQtyZcnJy+PTTT6+7Tk2TiAshRG0xMzNjzpw5zJkzp9p1duzYUWW5l5cXy5cvv+72Bw0axKBBg26niQ1GURRiD+qHOvuGet729txauRD6YHsO/BTOnm8P4R7sio2r1W1vVwhRveJSLblFZeQWlpJdWEpuUSm5haXkFpaRU1hKTlEp+ekFmBxNwsTWlBffGlgn7ZAAlBCiTmhLtSSfT9MHnMITSb2QXmFInUqtwrm5I+5tXHAPdsEtyAVTq8bd/VwIcXsiIyMZPXo0p0+fxtjYmNLS0ttOIi6EEKJu5STlkZOUh9pIjVeHG/dMrYn2Y1sTeyiepDOpbJ+/l1HvDbytnlVC3C0URaGoVEtWQSnZBaVkF5SQXVhKVr7+Z3ZBSeVlBSUUl+qq3aZpmY62yQW0SivESIEyjYri/BJMLWv/2kwCUEKIWlOQWUjMwUvEHIwn/ngSZUVlFZbb+9ji1d4drw7uuLdxwdhcEk8KcbfYvn07YWFhZGRk4OHhwerVq4mLi6uVJOJCCCHqTuKpFABcWjjW2nc3tUZNvxd6suL5NSSdTuH46jN0GN+mVrYtxJ1EURTyi8vIyCshI7+EjPxiMvJKyMwrIcsQTLoSSMopKKW4rPpg0vWoVWBlZoyNuRE25sbYatS4R2Vjcy4T1eUAlbG3DX4jWtZJ8AkkACWEuA2KopARk0XMgUvEHLhESkR6heVmtqaGgJNXB3csHS0aqKVCiIb0v//9j2nTplFWVkZoaCirV6/Gw8OD0NBQSSIuhBCNXNIZfQDKrVXN8vfVlI2rFT2eDGXnF/s4uPQYXh3dcWrmUKv7EKIh6HQKWQUlZOZfDirlFet/z7vm73z9OiW3EFAy1qiwszDB1sIYWwsT7CyMsTHX/ywvs7Uw1q9jboyNuTGWpkao1SpKi8s4tfYc4atOUZxbAoBTM3tCH+yAd4hHnU4M0KQCUMXFxbz55psVkge+9957NxxvvWrVKn799VcOHjxIUlIS3t7ejBw5kjfeeAM7O7v6abwQdwidVkfSmVSi9sYSffBSpVxOzs0d8O3ihU9nT5z8HWSGOiHuYqWlpcyYMYOvvvoKgEmTJvHdd99hbn4lv5skERdCiMYt6bQ+AOXeunYDUAAtBzQj5sAlovfHsW3eHsZ9MhwjE7kJIRonRVHIKSwlNbeYtMuP1JyiK79f/pmeV4xWp9x4g1exMNXgYGmKg5UJ9pYmOFiaYm95Jbh0bZDJ3ERz04EibamWk+svcHT5CQoyiwCw87IhdFJ7/Lv71Mt1W5MKQE2ZMoUVK1YwY8YMAgMDWbRoEcOHD2f79u3cc8891dZ76qmn8PDw4KGHHsLHx4cTJ07w5Zdfsm7dOo4cOVLhi7IQdyNFp5B0JpXIPTFE7Y0xHLAANCYaPNu74RvqhW9nT+nlJIQAICMjgwkTJrBt2zZUKhUffPABr7zyiky3LYQQd5CCrEL9TMUqcA1yqvXtq1Qqej/bleSzqWTGZnNwSTjdHw2p9f0IcSNlWh1pucUk5xSRnK1/pOUWVQgspeUW31RvJVsLYxwsTXCwMr0cVNL/7mBpgr2VSYVlZnU407dOq+P89igO/3rc0HnA2sWSkAfaEdjHv17zrzWZANSBAwdYtmwZc+bMYebMmQBMnjyZ4OBgZs2axd69e6utu2LFikp3X0NCQnjkkUdYsmQJTzzxRF02XYhGSdEpJJ1N5eLuGC7ujaUgs9CwzMTSGL+u3vh388azvTvGZk3mUCKEqAVnzpxh1KhRREZGYmlpyZIlSxgzZkxDN0sIIcRNSjmXBoCDjx2mVqZ1sg9zWzN6P9uVjR/s5PgfZ/Dr4o17m9rvbSXuXuU9l5Kzi/QBpqwikrILr/ydXURqThE17bRka2GMk7UpztZmOFub4nT54WxjZvjdwdIEowZOrK/oFCL3xHD4l+NkxecAYGFvTqf72hI0MABNHQa9qtNkrhpXrFiBRqPhqaeeMpSZmZnx+OOP89prrxEXF4e3t3eVdavq+j927FgeeeQRzpw5U1dNFqJRyk7I4fz2KCJ2XCT3quF15UGngJ6+eLZ3a5ADlhCicdFqtZXyN23cuJEHHniAnJwc/Pz8+PPPP2nbtm1DN1UIIcQtSIvKBMApoG5zM/l19ablgADObY1kx+d7CZs/4pYSnheWFRKfd4n4vHhSClLIKc4htySHgrICw4yrKpUKcyNzrIytsDS2xNbUDhcLF1wt3HCxcMHMyKy2n56oB3lFpSRkFhKfWUhCZoHhZ9Ll3kyFJdobbsNIo8LFxgxXWzNcbcwMAaUrQSYzHK1MMG3k10GKohB7KJ6DS46Rfvl/2MzalA5hbWgzrAVGpg0XBmoyAaijR4/SokULbGxsKpR36dIFgPDw8GoDUFVJSkoCwMmp9ruaCtHYFOcVE7k7hvPbo0g+m2ooNzY3xr+bN83u8cGrvbsEnYQQBqtWrao0g52trS3Z2dkA9OrVi5UrV+Ls7NxQTRRCCHGb0i/qL14d/e3rfF89nggh/ngSOUl57Ft4hN7PdL1hnfzSfA4lH+Rk2gnOpJ8hNjfmttvhZO6Mv40//rb++Nn609yuOa4WbjKEvIGVaXWk5BQRn1lIfEZBpWBTTmHpDbdhb2miDy5dDjC52prjZqf/283WHAdLE9R3eP7a+ONJHPg53NB70cTCmHZjWtF2dBAmFnUzs93NaDIBqPK7r9cqL0tISLip7X300UdoNBrCwsKuu15xcTHFxcWVyvPy8m5qf0LUN0WnEH88iTObIog5cAnt5ak3VWoVXh3cadGvGX5dvRo0Qi6EaJxWrVpFWFiY4W5yufLg04ABA1i3bh0mJg3/RUcIIcStS4/KAMCpHgJQJhYm9H2+O2ve2MKZjRH4dfXCJ8Sz0nqlulL2Jexle9w2jqWEU6aUVVhua2KLp7UXbhZu2JraYWNijYWxJSqVChUqFEWhoKyA/NI88krzyCzKJLkgmZT8ZPLL8kkrTCWtMJWDyQcM23Qwc6CVQ2taO7ahtWNr/Gz90ajkxmxt0+kU0nKLiU3PJyYtn7j0AmLT84lNLyAxq/CGib3tLU3wsDfHw84cD3sL/e/25rjamOFia1aneZYaWvK5VA78fIyE4/qONEYmGoJHBtF+XGvMrOtm+OytaDJXloWFhZiaVn5hzczMDMtraunSpXz//ffMmjWLwMDA66774Ycf8s4771Qqd3d3Z+rUqTXepxD1pTC7iHNbIzmz6QI5ibmGcgdfO1r0b0bz3n5YOkgicSFE1bRaLdOnT68UfLra+fPn0Wia7pc8IYS4GxTnlRjSMdRHDygAz3ZuBI8K4uRfZ9n5xT9M+GKk4eI5rySPPyP/YH30OrKLswx1vKy8CHENpY1jG4IcW2FnanfL+88rySUmJ4aonCiis6O4mH2R6OwoMooy2JOwmz0JuwGwNramg0tHOrmG0MmlE/ZmdTtEsanJLSwlJv1ygCkt3xBkiksvoKi0+qFyJkZq3O3M8bTXB5g8LweYyoNNlnfhjfP0qEwOLgkn5mA8AGojNa2HBNJxQjAW9o1vMrUm8w6Zm5tX2ROpqKjIsLwmdu3axeOPP86QIUN4//33b7j+7NmzefHFFyuVJycns3Tp0hrtU4i6pigKiadSOLMxgot7Y9Fdnr3B2NyYwL7+tBrcHEd/e+laLIS4oV27dlUYdleVuLg4du3aVWWORSGEEHeG9Gj98DtrF8s6S0Bela4Pd+DSkQSy4nPYs+Ag98wI5Y8Lq/n9wkryS/UBMQczBwb5Dqa3Vx+8rX1qbd9WJta0cQqmjVOwoaxYW0xEZgSn009xJuM0Z9JPk1uay674v9kV/zcA/rbNCHXtQnePHjSzbSbfqS/LKyolKjWfiyl5RKXkcTFV/zM1t/J1ezmNWoWnvTnejpb4OFrg42iJj5Ml3g4WOFmb3vFD5GpL1qVsDv1ynMjd+mGnKrWKFv2bEXJfW6xdrBq4ddVrMgEod3d34uPjK5UnJiYC4OHhccNtHDt2jNGjRxMcHMyKFSswMrrxy2Nqalplz6v8/Pwq1haifpWVaLmwM4oTf50lIybLUO7c3IFWQwJp3svvlhI8CiHuXuXn1dpaTwghRONUnry4vno/lTMyNaLfjB6sfmUjF/6OZpP5Ws54HAfA29qH+1s+QHePHhip6+dS1lRjSrBTMMGXg1JanZZzmec4knyYIymHuZAVQVT2RaKyL/Lb+WW4WrjS3aMH3d170NIhCLWqYWdCqw8FxWVcTMnTP1LziE7N42JKPik5RdXWcbI2xcfRAl8nywrBJg978wafPa4xy03J4/CvJzi/7SLK5SGJAb186fxAe+w8bW5Qu+E1mQBUhw4d2L59Ozk5ORUSke/fv9+w/HoiIyMZOnQoLi4urFu3Diurxhs1FOJGCrIKObXuPKc3nKcoW3+HwchUQ/M+/rQeEohzc8cGbqEQ4k5VVb7F21lPCCFE41Q+bbudt22979s2wJqyewrQ/G2O147mZNyXyoNdHqSXV+8Gz72kUWto7dia1o6teaj1w2QVZ3E0+Qj/JO7jcMphkguSWX3hd1Zf+B0HMwd6ePSkj1dfWti3vON7RimKPkdTRFIu55NyiUjK4XxSLpcyCqhuZL6zjSn+zlY0c7bC38WKZi5W+DtbYmUmN8FvRkFmIUeXn+T0xgjDaBbfLl6EPtgeR7/6DRLfjiYTgAoLC2Pu3LksWLCAmTNnAvoE4QsXLqRr166GGfBiY2MpKCggKCjIUDcpKYnBgwejVqvZuHGjzNgj7ljp0Zmc+PMsETujDAcmKycL2oxoSavBgZhaSUJgIcTt6dWrF15eXtUOw1OpVHh5edGrV696bpkQQojalF0egPKo314Vl3Iv8dHBD4n1i6XnyUHYZjgw5uT99BnXt1EGcOxM7ejn059+Pv0pLivicMph9iXs5WDSATKKMlhz8S/WXPwLd0sP+nj1oY93PzytKidXb2y0OoWYtHzOJ+UQkZRreGTml1S5vqOVCc1crGnmYqkPOLlY4e9shbWMtrgtxXnFhP9+mpN/naWsWJ8fy7OdG6EPtce15Z0Xt2gyAaiuXbsyYcIEZs+eTUpKCs2bN2fx4sVER0fz/fffG9abPHkyO3furJA8dejQoVy8eJFZs2axe/dudu/ebVjm6urKoEGD6vW5CHGzks+lcXT5CUPyOQCXFk60HR1Esx4+qKUbqxCilmg0Gv7973/z2GOPVVpWfmEwf/58SUIuhBB3uPIeULb1OKznWGo4H+5/n4KyAmwt7Og1vQsn371I/JEkzm2JJGhQ83pry60wNTKjh0dPenj0pFRXSnjKUf6+tJN/EveRmJ/AsnO/sOzcLzS3C6SPV196e/VuFAnMFUUhMauQU/HZnInP4Ux8NmcTcygsqZwQXKNW4etkSaCbNYGu1gS663861GOesLtBaWEpJ9ac49jvpyjJLwX013ehD7XHq/2d28u8yQSgAH788UfeeOMNfvrpJzIzM2nXrh1r1qyhd+/e16137NgxAD7++ONKy/r06SMBKNEoKYpC4slkjvx2kvjL022igmbdfWg7phVuQXdeRFwIcWcoH95ubGxMaWmpodzLy4v58+czbty4hmqaEEKIWlBaVEZ+egFQfz2gdsRt5/Mj8ylTymjt2IZZoa/iYOaA+YPW7F98lL3fHcKjnRs2rndGqhRjtTGhbl0IdetCYVkh+xP/YeelHRxNOcKFrAguZEWw8NT3dHYNZZDvYEJcO9dbXquMvGJOXw42nU7I5nR8NtkFpZXWMzfREOhmTQs3awLdbGjhZo2/ixVmxnKTqa5oS7Wc3hDB0eUnKczW59By8LUj9MH2+HbxapS9AG9GkwpAmZmZMWfOHObMmVPtOjt27KhUdr2ppIVobBRFIe5oIkd+PUHy2VQA1BoVzfv403F8G+y86n+cvhDi7nH8+HG+/fZbADZt2gToE467u7vTq1cv6fkkhBBNQHaCvveTmbUpZjZ137Nlc8wmvjj6GQC9PHszo9OLGGv0Q7fajWlFzMFLJJ1OZcfnexn17iBUd9hMaOZG5vT17kdf735kFWexO34XO+K2cz7zHAeS9nMgab9+KJ/3AAb5DsLL2rvW9q3TKUSn5XMsJpPjcVkcj80kPrOw0npGGhUt3Kxp5WFLK09b2nja4uNkieYOe63vVDqtjvPbLnJ42XHy0vTBXxt3a0IntSPgHr877jNfnSYVgBKiqUs4lczBn8JJOqMPPGmM1bQc2JwOY1tjfYfcDRJC3LkURWHGjBnodDomTJhA3759G7pJQggh6kB2Qi4Ath7Wdb6v7bHb+PLo5wCM8B/Jk+2mVpg5Tq1R0/f5HqyYsZbEkymc+Oss7ca0qvN21RU7UztGNhvFyGajiM2JZWvsZrbFbSOrOIvfL6zk9wsrCXJoxUCfQdzj2QsLY4ub2n5RiZbTCdkcj9UHm07EZZFbVFZhHZUK/JwsaeVpS+vLj+au1pgYSdqO+qboFCL3xHBo6THD/52lowUh97elRf8ANE3sPZEAlBB3gNSIdA78HM6lcP205hoTDa2HBtL+3tZYOt7cSUkIIW7V6tWr2b59O2ZmZlUOWxdCCNE0ZMVnA3Wf/+lg0gE+OzIPBYVh/sN5qt3TVQ4xsnW3pvujndj19QEO/HQU704e2DfA7Hy1zcfGh0eDH+fh1o9wKOkgW2I3cSj5EGczznA24wzfnVhAT89eDPEbSstqZtErKtFyLC6TI1EZHI7K4ExCDlpdxRE+5iYa2nja0s7HjnY+9gR72cosdA1MURRiD8dz8OdjpEdlAmBmY0rHsGBaD2uBkUnT7FEuASghGrHMuGwOLgknal8coB9qFzQ4kE4TgiXwJISoV0VFRbz00ksAzJw5Ez8/v4ZtkBBCiDqTk5gHgG0d5n+Kyo5i7qGP0aFjgM9Aprb713Xz27QaEkj0/kvEHUlg+/w9jPloaJPpHWKkNqKbR3e6eXQnoyiD7XHb2BKzifi8eLbGbmZr7Gb8bPwZ6j+MHm59uJhcwuGLGRyOzuDkpSzKtBUDTs7WpoZgU3sfO5q7WmMkkxI1GgknkjjwUzjJ59IAMLEwpt29rWg7qhUmFk07MCgBKCEaocLsIg79cpwzGyNQdAqoILCPP50faIeNW913hRZCiGvNnz+fqKgoPDw8eOWVVxq6OUIIIepQbqo+AGXtYlkn288qzuK9f96hsKyQtk7teKbDcxWG3VVFpVLR57lu/DZtDakXMji64iSd729XJ+1rSA5mDowPDGNc8/GcyTjDpugN/H3pb6Jzovjfsa/4+si3FGW2oDAtmLJCVwBcbc0I8XMgpJkDHX0dcLczu+OTVTdFKRFpHPz5mGFUi5GJhjYjW9JhbJt6ybXWGEgASohGRFuq5eSacxxZfsIw3aZfVy9CH+qAg49dwzZOCHHXSkxM5P333wfgP//5D1ZWknNOCCGasryUfKBuAlA6Rce8w5+QWpiKp5Uns7u8hrG6Zr0+LB0tuGdqKNs+3cPR307gE+KBS6BTrbexoWUXlHAgMp19F7Tsv9CRjMIAzBzOYu54AiPzTMydTmHudApHYx8G+w5lTMubzxUl6k9GbBYHlxwj+p/Lo1qM1AQNan5XjmqRAJQQjYCiKETti2P/4iPkJOnvODk1s6f7YyF4tHVr4NYJIe52r7/+Onl5eXTt2pUHH3ywoZsjhBCiDum0OvLT9bNwWTnXfgDq94iVHE05gonGlNld/g8rk5vr3d+8tx/R++O4uCeWLXN2M/7T4ZhamdR6O+uTTqdwJiGbfRFp/HMhjdPx2VydxsncxJIQh0F08b8PB6dUjmXtYE/CbtJLY/nlwgJWR/9EH6++DPEbRoBdQMM9EVFBTlIuh345TsTOKFBApVYR2NefkPvbYXOXTiAlASghGlhWfA67/3eA+ONJAFjYmxH6UEda9PNHLWO1hRAN7NChQyxcuBCAzz77DLVajktCCNGUFWQUotMqqDUqLOzNa3Xb5zLO8tOZHwF4qu1UfGx8bnobKpWK3s90IzUindzkPHZ+uY9Br/S+44acFZdqORyVwd9nU9h1LoX0vJIKywNcrejW3InuzZ1o52N/1Qx1fgwklCeLn2Jr7FY2xWwgPi+eDdHr2RC9nhb2LRjiN4xenr0xMzKr/ycmyE8v4MhvJzi7+QK6y/m5/Lv7EDqpHfZ3+agWCUAJ0UDKiss4uuIk4atOoyvToTFW035sazqMa4OxedNOPidqSFGgKBtyE/QPG09wvnOnHRZ3HkVRmDFjBgAPPfQQXbt2bdgGCSGEqHO5qfrhd5ZOlrV6M7RUW8rnRz9Dp+jo5dmbQb6Db3lbplYmDJzViz9e3UTUvjhOrTtP8IiWtdbWupJTWMqe86nsOpvCPxfSKCjRGpZZmhrRNcCRbs2d6NbcCRfb6wePbExtGRs4jnubj+VE2nE2Rm9gX8Jezmee53zmeb4/8S19vfsz1G8YfrZ+dfzMBOjz+IavOsWpdefRXn5vvTq60+XBDjgHOjZw6xoHCUAJ0QBiD8Wze8FBcpP1w+28O3nQ86lQbN0lwfhdo7QQci5BTvyVAFNVj7LCK3V6vgKD/tNwbRZ3nV9//ZU9e/ZgYWHBf/4jnz0hhLgbGPI/1fLwu+XnfyMuNxZbUzumtr/+jHc14RLoRLcpndj73SH2/XAY1xZOjfIiPyu/hO2nk9l6KomjMZlorxpb52xjSu+WLvQOcqGTnwPGtzCrn0qlop1ze9o5tyerOIutMZvZGL2BpIIk1kWtYV3UGoIcghjiN4x7PO7BVHpF1bqi3GKOrz7DiTVnKSsqA8CtlTOhD3XAI9i1gVvXuEgASoh6VJBZyO5vDhK1LxbQJ1Ls8URn/Lt733HdhsV1KArkp0B2bPWP/JSab8/MHqw9wNy+7tosxDUKCgqYNWsWALNnz8bT07OBWySEEKI+lPeAsqrFBOQxOdGsOP8bAFPbPY2NiU2tbDd4ZEsSTiQTvT+OLXN3Me7T4ZhaNnw+qNzCUnaeTWHLyUQOXsyoEHQKcLGid5A+6BTkYVOr1wB2pnaMbzGBsYHjOZZ6jI3R69mf+A9nM85yNuMs351YQL/LvaJ8bHxrbb93q+L8Ek78eYYTf56lpEA/gZRTgAOhk9rjHeIh13dVkACUEPVAURQidkSx97tDFOeVoFKraDs6iJD72mFiIcPt7khFOZAZCRmRV/28eCXApC2+8TaMLcHGSx9cqvbhDsa1m39BiJqYO3cucXFx+Pr68tJLLzV0c4QQQtSTvFR9D/3aSkCuKAoLjn9DmVJGF7eu9PS4p1a2C/reP32f78bKFzLIScpjx2d7GfxqH1Tq+r/wLyguY9e5FDafTGL/hTRKtVeCTi3dbRgY7Ea/1q54OdT9rGdqlZqOLh3p6NKRzKIMNsdsZlPMRlIKkllz8S/WXPyLVg6tGeo3jB6ePTHVmNZ5m5qS0sJSTqw5x/HVpym+nLvLwdeOzpPa49fVSwJP1yEBKCHqWH56AX9/tZ/YQ/GAPired1p3HP2lN0ujpihQkAZp56oINEXql12XSh9AsvWp+mHnC2Z2ICco0QjFxcUZhtx9/PHHmJtLEFQIIe4Wean6GfCsa6kH1P6kfziRdhxjtTFPtXu61i/OTa1MGTSrN3/M3kj0/ksc/u0Ene9vV6v7qI5Op3A0JoO1RxPYfiaZwqtyOgW4WDEg2I2BwW74ONb+bII1ZW/mwMSW9xHWYgLhKUfZEL2eA0n7OZNxmjMZp/n2xDf08x7AUP+heFvffFL4u0lpcRmn150nfNUpinL0N5vtvGzp/EA7mvXwaZDA551GAlBC1BFFUTi3NZJ9PxymJL8UtZGakPvb0X5sazS3ML5b1BFtGWRFQdrZyo/CjOvXtXAGhwCwD7j8sxnY+ekDTNaeYNTwXcCFuBWvvvoqhYWF9OrViwkTJjR0c4QQQtSj/HR9AMrS8fZ76pTqSll48gcAxjQfi4uFy21vsyrOgY70+ldXdny+j8O/HMfRzx7/bt51si+ASxkFrAuPZ92xBJKyigzlXg4WDG7rxsBgd5q5WNXZ/m+FWqWmk2sInVxDSC9MZ0vsZjZFbyC1MJW/Lv7BXxf/oLVjG32vKI+emGjke2y5shItZzZGEL7yJAWZ+vfbxt2azve3I6CXr8xcfhMkACVEHSjMKmLHl/uIPajv9eQS6Eif57vjcJdPu9mgtGWQcQGSj0PKCUg9rQ8ypUeArrSaSip9TyWH5vogk32zKwEn+2ZgVjv5C4RoTPbt28fSpUtRqVTMnz9fupELIcRdpiBDPwGKZS0MFVsftY7E/ATsTO0IC6zbGxotBwSQdjGDk2vOsX3eHuzmDK3VKe+LSrRsOZXEX0cucSw2y1BuaWrEoGA3RnT0JNjL9o44bzqaO3Jfy/uv9IqKWs/BpAOcTj/F6fRTfHv8G/r7DGCI31C8rOsukNfYaUu1nN0SydHlJw2BWWsXSzrd144W/fwl8HQLJAAlRC2LPZLAjs/2UphVhMZYTedJ7Wk3ppUcoOpTXjIkn7gSbEo+Dimnqs/LZGQOTi3BKejyo5X+p2Og5F8SdxWdTsf06dMBeOyxx+jUqVMDt0gIIepHcXExb775Jj/99BOZmZm0a9eO9957j0GDBt2wbnx8PC+88AKbNm1Cp9PRr18/5s2bR7NmzSqt+/333zN37lyioqLw9vbm+eefZ9q0aXXxlG6JtlRLUa7++5K5/e3NllZcVsTyy4nHJ7V6CAvjus991O3REDJiskg4kcyGD3Yyds5QzKxvL79RdGoeqw9dYm14PLmXZzhTq6BLgCMjOnjSK8gFM2NNbTS/3mlUGkJcOxPi2pn0wjQ2x2xiU8wm0gpT+SNyNX9EribYsS1D/IfSw70nxpq7I3ettkxHxPaLHP7thGFWSEtHCzpNDKblgAA0d+j73RhIAEqIWlJWomX/4iOcXHMOAHsfWwa8dA+OfpLrqc4oij7hd8JhSDgEiYchKbz6GeaMLcClLbi2Bec24Hw50GTjDWoJEDZ2Op2OhIQE8vLy0Ol0Va7TunXrem5V0/Lzzz9z8OBBrK2tef/99xu6OUIIUW+mTJnCihUrmDFjBoGBgSxatIjhw4ezfft27rmn+qTZeXl59OvXj+zsbF577TWMjY2ZN28effr0ITw8HEdHR8O633zzDU8//TTjx4/nxRdfZNeuXTz//PMUFBTwyiuv1MfTvKGCy8PJ1Ebq2w7cbIheT3ZxFq4Wrgz0uXEgrzZojNQMfLkXq2auJycxl03/2cmItwfcdMCgtEzHzrMp/H4ojsNRV1IyuNuZc2+IF8M6eOBic3sBusbG0dyJ+4MmMaHlfRxJPszG6PUcSjrEyfQTnEw/wbcm3zDAZyCD/YbiadU0Z8bVaXVc+Duaw8uOk5OkT8ZvYW9Gx7BgggYHYmQigafbJQEoIWpBenQm2z7dQ0ZMFqCfErbr5I4Ymcq/WK1RFMiO0weZEg7pg06Jh6tJBq7SD5tzbacPNrm20z/s/CXQdIdasWIFa9eupaCg4Lrr/frrr/XUoqYnLy+PV199FYD/+7//w9XVtYFbJIQQ9ePAgQMsW7aMOXPmMHPmTAAmT55McHAws2bNYu/evdXW/eqrr4iIiODAgQOEhoYCMGzYMIKDg/nkk0/44IMPACgsLOT1119nxIgRrFixAoAnn3wSnU7Hu+++y1NPPYW9fcPftCwffmdhZ3ZbQ8mKy4pYGaF/nhNa3IeRuv6+E5vbmjH09b78OXsTiSdT2PH5Pvq/0LNGCaIz80v4/WAcKw/Gkn55djO1Cnq0cGZcqDfdApxQN/FE0xqVhlC3LoS6dSG1IJXNMZvYHLOR9KJ0fr+wit8vrKKtUzsG+w2hm3v3JjGDnrZMx4WdURxZfpKcxFwAzGxN6Ti+Da2GtsBYrulqjbySQtyms1si2f3NAbQlWsztzOj7fHd8QprmXYF6VVqoDzLF7dU/Lu2rumeT2kjfq8kjBNxDwL0TuLQBk4abbUTUrj/++IPly5djYWFB7969cXR0RKORO1C1QavVsmvXLhITE1m7di2JiYkEBAQYhuEJIcTdYMWKFWg0Gp566ilDmZmZGY8//jivvfYacXFxeHtXnQdnxYoVhIaGGoJPAEFBQQwYMIDffvvNEIDavn076enpPPPMMxXqP/vssyxZsoS1a9fy0EMP1cGzuzkFmZcDUPa3l4JgQ/QGsoqzcDF3oZ9P/9po2k1x9LNn0Cu9Wf/vbVz4OxorF0u6Ptyx2vWjU/NYti+G9ccSKC7T97J2tDJhdCcvxoR44WZ3d6ZkcLZwZlKrB7mv5f0cSj7Ixuj1HE4+zIm045xIO46lkSW9vfsw0Gcwze2a3xH5r66mLdVyfvtFjq44RW6yvseTmbUp7e5tRfCIlhib3x1DDuuTBKCEuEVlxWXsXnCQc1siAfDu5EG/6T0wt2ta3XHrTfYlfZCpPOCUeLRycnC1kX7onEdnfcDJo7M++GQsr3lTtnXrVhwcHPjoo4+wsZHE77Vl1apVTJ8+nUuXLlUoDwsLw9T0zr+bKYQQNXX06FFatGhR6RzTpUsXAMLDw6sMQOl0Oo4fP85jjz1WaVmXLl3YtGkTubm5WFtbc/ToUQA6d+5cYb2QkBDUajVHjx5tXAEoh1sPuGh1Wv6IXA1AWIuJGKsb5iLeq4M7vZ/rxo7P9hG+4hTWzpa0HtrCsFxRFA5HZfDLvhj2nE81lAd52DCphx/9W7tiJDlcAdCoNXR170ZX926kFKSwJWYTW2O3kFqYyvqodayPWoevjR8DfQbS17s/tqa2Dd3k69KWajm3JZKjK0+Rl6rP8WRma0r7e1vTZlgLCTzVIQlACXELshNy2PzxLtKjMlGpVXR+oB0dw4Jr1LVXXJYVA1HbIXqH/pEdU3kdKzfw7qF/eHUH946SFPwulJ6ezoABAyT4VItWrVpFWFgYiqJUWvbxxx/TpUsXxo0b1wAtE0KI+peYmIi7u3ul8vKyhISEKutlZGRQXFx8w7otW7YkMTERjUaDi4tLhfVMTExwdHSsdh/liouLKS6uPJlKXl7edevdLMMQvNvoAbUvcS9phanYmtjS32dAbTXtlrTsH0BuSj6HfznO7m8OYmptin93H3afT2XhzkjOJOQAoFJBr5YuPNDdlw6+9ndcT5765GLhwqRWD3F/0CSOpx5jS+xm9iXsJSYnmu9PfsfiU4sIdevCQN9BdHIJQaNuPL3Wy0q0nN18gfCVpwyz2lnYm9F+bBtaDQ2UoXb1QF5hIW5S1L5Ydny+j5KCUsxtzRgw8x4827k1dLMav+y4qwJO2yEruuJylRpc218JOHl3Bzs//TcCcVeztbVFq9U2dDOaDK1Wy/Tp06sMPpWbMWMGY8aMkaGOQoi7QmFhYZU9P83MzAzLq6sH1KhuYWEhJiYmVW7HzMys2n2U+/DDD3nnnXcqlbu7uzN16tTr1r0ZtTEE78/IPwAY5j8cE03Vz7k+hdzXlvz0As5uusCWubs51d6FA4p+mJ2psZpRHT2Z2M0XH0dJ33Az1Co1HVw60sGlI3klufwd/zdbYjZzISuCfYl72Ze4FwczB/p5D2Cg76AGTVxeWlzGmY0RHFt1ukIvv47j2xA0qLnk7a1H8koLUUOKTuHQsuMc+fUEAG6tnRk4sxeWjnU/pewdqSgHorZB5EaI3ASZFysuV2nAMxT8+oJfP33QydSqQZoqGrfu3btz4MABSktLMTaWLtG3a9euXZWG3V1NURTi4uLYtWsXffv2rb+GCSFEAzE3N6+yd1FRUZFheXX1gBrVNTc3p6SkpMrtFBUVVbuPcrNnz+bFF1+sVJ6cnMzSpUuvW/dm3O4QvIjM85zNOIORyohh/sNrrV23Q6tTyO/hTdLxRNyS8mkZnkxKS3v6DArk/u5+2Fs2fJDsTmdlYs1w/xEM9x9BdHY0W2M3sz1uGxlFGayMWM7KiOW0cmjNAJ+B9PS8B0vj+gn2FeeXcHr9eU78eZbCbP3/pJWTBR3Cgmk5IEBmtWsAEoASogZKC0vZ/tleovbFAdB2dBBdH+mExkjGhRvodJAUrg84Xdigz+OkK7uyXKXR52zy66t/+PQEU+sGaqy4k0ycOJGIiAg++eQTHnvssUrDF25HcXExb775Jj/99BOZmZm0a9eO9957j0GDbjxd9LJly/j44485ffo01tbWjB49mo8++ggnJ6daa19dSExMrNX1hBDiTufu7k58fHyl8vLjoIeHR5X1HBwcMDU1rfJ4eW1dd3d3tFotKSkpFc5jJSUlpKenV7uPcqamplX2tMrPz79uvZt1uz2gyns/9fLqjb2ZQ62161YoisL2M8l8s/UCMWn5qFzNGVRchmdmMQOjchjhbifBpzrgZ+vH422fZHKbKRxMOsCWmM0cST7MmYzTnMk4zYLj/6OLe1f6efeno0unOpkhsSCzkBN/neX0+vOUFOhzylq7WNJxQjAt+jVDYyyBp4bSpAJQt3MhER8fzwsvvMCmTZvQ6XT069ePefPm0axZs3pouWjMcpPz2PDBDjKis1Abqen9TFdaDgho6GY1DkU5+oDTub/0P6+dpc4hEJoPgYAh4NsbzCSHj7h5L730ElqtloyMDKZNm4aFhQWWlpXvnKlUKr744oub2vaUKVNYsWIFM2bMIDAwkEWLFjF8+HC2b9/OPffcU229r7/+mmeeeYYBAwbw6aefcunSJT777DMOHTrE/v37DUMvGqOqcpXcznpCCHGn69ChA9u3bycnJ6dCvsH9+/cblldFrVbTtm1bDh06VGnZ/v37adasGdbW1hW2cejQIYYPv9Iz6NChQ+h0umr3Ud9uJwdUbkkuexJ2AzCy2ehabdfNOngxna+3nOd0vD7Hk62FMQ/28OPeDp7s+mQ3l44msu7trQx5vS9eHeR8VxeM1cb08OhJD4+epBemsz1uK9vjthGXG8fu+F3sjt+FjYkNvTx708+nP4F2LW4791Z2Yi7HV5/m3NZItKX6YZb23rZ0GNeGgN5+0nmgEWhSAahbvZDIy8ujX79+ZGdn89prr2FsbMy8efPo06cP4eHhODo61uOzEI1J4qkUNv1nJ0U5xZjbmTF4dh/cgpwbulkNKycezv0JZ//Q53LSXtWd3MQK/PtD86H6oJODBHDF7VMUBbVaXaFnUVX5i66X06gqBw4cYNmyZcyZM4eZM2cCMHnyZIKDg5k1axZ79+6tsl5JSQmvvfYavXv3ZvPmzYYvSz169GDUqFF8++23TJs27abaUp969eqFl5cX8fHxVb5mKpUKLy8vevXq1QCtE0KI+hcWFsbcuXNZsGCB4XxQXFzMwoUL6dq1q2EGvNjYWAoKCggKCqpQ99VXX+XQoUOGGe7OnTvHtm3bDNsC6N+/Pw4ODnz99dcVAlBff/01FhYWjBgxoj6e6nUpimIYpmRue/M3UnbGbadMV4a/bTMC7QNru3k1cjo+m6+2nOfQxQwAzE00PNDdl0k9/LAy0w/jHzK7D5s++pu4wwlseG87A2f1xq+LV4O0927haO5IWIuJjA+cwMXsSLbHbePvSzvJKs5ibdQa1katwdPKkz5e/ejr3Q83y5vLr5selUn4qlNE7o5B0em/27i0dKLj+Db4hnrJRFHXoZSUoE1NRZeScvlnKhgbY3nfxDrZX5MJQN3qhQTAV199RUREBAcOHCA0NBSAYcOGERwczCeffMIHH3xQL89BNC7nd1xk5xf/oCvT4RTgwJDZfbByvguTEyoKpJyCs6vh3B+QcM1dPodACBoDgSP0eZyMpCuzqF3//e9/62S7K1asQKPR8NRTTxnKzMzMePzxx3nttdeIi4urctrtkydPkpWVxX333VfhTt3IkSOxsrJi2bJljToApdFo+OyzzwgLC6u0rPz5zJ8/XxKQCyHuGl27dmXChAnMnj2blJQUmjdvzuLFi4mOjub77783rDd58mR27txZIXj/zDPP8O233zJixAhmzpyJsbExn376Ka6urrz00kuG9czNzXn33Xd59tlnmTBhAkOGDGHXrl38/PPPvP/++zg4NOxwNYCS/FLDxbuZTeXhfjeyOXYzAIN8B9dqu2oiJaeIr7dEsP6YfjZBI42KcZ29mdK7GQ5WFZ+LkakRQ2b3Yesnu4naF8fm/+yk3ws9ad7Lr97bfbdRqVQE2DUnwK45j7Z5nPDUo+yI286+xH3E58Wz9OzPLD37M60d29DXux89Pe7B2qTqlB2KopB4OoXwlaeIO3xlFknvEA86jG+De2uXu3o2Q11hIbrkZLQpKeiSU9CmXH4kJaNLuVKuy8ysVNeoWTMJQN3IrV5IlNcNDQ01BJ8AgoKCGDBgAL/99psEoO4yiqIQvvIUB34KB6BZTx/6Tu9x903LmXoWTv0KJ3+FtDNXLVCBV1doOUYfeHIKkpnqxB3p6NGjtGjRosJwC4AuXboAEB4eXuV5ozzZbFUJY83NzTl69Cg6nQ61uvF28x43bhwrVqzg0UcfJScnx1Du5eXF/PnzGTduXAO2Tggh6t+PP/7IG2+8USGVx5o1a+jdu/d161lbW7Njxw5eeOEF3nvvPXQ6HX379mXevHk4O1fsNf/MM89gbGzMJ598wp9//om3tzfz5s1j+vTpdfnUaqwoV39+MzIzuulZwSKzIonKvoiR2og+Xn3roHVVKyrV8sveaBbviqKoVD9j7rD2HjzZrzke1xlGqDHWMPDlXuz4fB8RO6LY+sluCjIKaTs66K4OWtQnjVpDiGtnQlw7U1BawL7EveyI287x1GOcTj/F6fRTLDj2Pzq4dKSXV2+6unXDwtgCbZmOqL0xHP/jDKkX9D3dVGoVAff40n5sa5yaNXwwt64oioKSk3NNUCn5yu/JKfqeTCkpKLm5Nd+wsTEaJyfUri5onJ3R+PjW2XNoMlfUt3ohodPpOH78OI899lilZV26dGHTpk3k5uYaxm+Lpk2n1bH7m4Oc2RgBQPuxrek6uePd020zI1IfcDr1KyQfv1KuMYFmg/QBpxajwPrmusUKUZsKCwvJz8/HwsICC4tbn4UyMTGxyjxH5WUJCQmVlgEEBgaiUqnYs2cPjz76qKH83LlzpKamApCZmVnt8O3i4uIqZ0zKy8u76edwO8aNG8f27dv58ssvGT16NC+88AK9evWSnk9CiLuSmZkZc+bMYc6cOdWus2PHjirLvby8WL58eY328+STT/Lkk0/eShPrXFGOfvjdLfV+itkEQHf3HtX2WKlNiqKw/XQyn286R1KWvt1tve14YVgQrT1ta7QNtUZNv+k9MDY35vT68+z74TA5Sbn0eKIzak3jvYnUFFkYWzDAZyADfAaSXpjGzks72RG3neicKA4lH+RQ8kHMSy3oFt8bm6NOlGXpg40aYzUt+gfQfmxrbN3v7Ot1RatFl5qKNjERbWIS2qQk/e/lPxOT0CUloVyeYbMmVGZm+qCSiytqFxc0bq5oXFz0v7u66H93dUVtZ4eqnm6cNpkA1K1eSGRkZFBcXHzDui1btqyyfmO5kBC3r7SojC1zdxF7MB5U0POJzgSPDLpxxTtdfiqcWArHfoLEw1fK1UYQMBjaTNT3djK3a7AmCqHVavnrr7/YunUrKSlXkt27uLgwYMAARo0addOBk8LCwipnFCpPIF5YWFhlPScnJyZOnMjixYtp1aoVY8eOJT4+nmnTpmFsbExpaWm1dQE+/PBD3nnnnUrl7u7uTJ069aaew+1KS0sDoF+/fvTt27de9y2EEKJxKcrRX9OYWd9cAKpUV8rfl3YAMND3xpM/3a74jALmrD3NPxfSAXCxMePZQYEMbut+072XVGoV90wNxdbdin0Lj3Bq3XlyU/IZ8NI9mFgY10XzxQ04mjsxLnA84wLHE5cby87wv4nemID9GReMyowoQ0uxeRF0KaHTyHZ0DeiEsaZxv1dKURHa5OSrAkpXgkraxER0SUloU1JAq63R9lQ2NpUDSYbfXS8HnVxQWVs3uh59TSYAdasXEuXlt1IXGteFhLh1hTlFrP/3dlIj0tGYaBjwYk/8u/s0dLPqTlkxnF8LxxZDxDrQlenLVRp9EvHg+yBoLFg03S6s4s5RVlbG+++/z+nTp1GpVDg5OWFnZ0dWVhapqan88ssvhIeH83//938YGdX8tGZubl7lDYSiy3eWqhpiV+6bb76hsLCQmTNnGvIOPvTQQwQEBLBq1SqsrKyqrTt79mxefPHFSuXJycksXbq0xu2vDeXBvKunBBdCCHF3MgSgbrIH1LGUcPJK87A3taedc/u6aBoAZVodS/dG8/2OSIrLdBhrVEy+pxkP3eOHucmtX9aqVCrajWmNlYsV2z7dQ+yheH5/eQODX+2NvXfNelOJ2qUoCgknkjn110XyD4Kz4gGAyk3hYpsznPU8gU6jY8vptViet6Srezd6efWmnXN7jNX1G4xSSkv1waX4eLTxCWgvXaIsPuFKYCkxEV1GRs02ptHog0lubmjc3S8/3PQPN/1D7eqK+jrfURu7JhOAutULifLyW70IaUwXEuLW5KcXsPatrWTGZWNqbcLQ1/vh1qoJznSnKPoE4uGL4eQvUHjVgdCjM7R/RB94smyCz13c0dasWcPp06fp1KkTkydPrtBjNSkpiR9//JHDhw+zZs0a7r333hpv193dnfj4+ErliYmJAHh4eFRb19bWlj/++IPY2Fiio6Px9fXF19eXHj164OzsjJ2dXbV1TU1Nq7zpkZ+fX+O21xYJQAkhhChXHoC62RnwdsXvAqCHR080qroZxn08NpOP/jpNZIp+lElnfwdmjWyNj1PtTRDUrLsPlu9ZsOk/O8m6lM3vM9fT5/nuBPSsu3w4oqLivBLOb7/I6Q3nybp0JUelT6gn7Ua3wqOtKwARWefZdelvdsfvIr0onW1xW9kWtxVLI0tC3brQ3aMHnVw6YWp087M5XkuXk2MILpXFx1/+/XKwKT4ebVIS6HQ33pCZKRq38oDS5eCS21XBJXd31M7OqJp4KoQmE4C61QsJBwcHTE1NDevdTF1oXBcS4ublJOex9s0t5CTlYeFgzsh3BmDvY9fQzapdxblwfAkc/gaSwq+UW3tAu4f0gSeX1g3WPCFuZPfu3Xh7e/Pyyy9XSuzt5ubGzJkzmTVrFrt27bqpAFSHDh3Yvn07OTk5FfIH7t+/37D8Rnx8fPDx0feWzMrK4vDhw4wfP77GbWhoEoASQghR7laG4JVqS9mfuA+AXl7XT9h+S20q1bJg2wV+2ReNooCdhTHThwYxtN3ND7erCdeWToyfN5ytc3aTcDKZLR/vImlECl0f6XjTidlFzaVGpnN6fQQX/o6irFg/DM3YzIjAfs1oO7Ildl4Ve6K1sG9JC/uWPBr8OGfST7Mr/m/2JewlsziTHZe2s+PSdkw1poS4dqa7Rw9CXbtgYVw5b6ii06FLSqYs/lKFoFLZpXi0Cfq/lasma6mWiQkaD3c0Hp4YeXqg8fRE4+FhCCxp3N1Q2dk1uuFwDaHJ/Bfd6oWEWq2mbdu2HDp0qNKy/fv306xZM0lA3kRlxmWz9q2t5KcXYO1qxch3B2LjWv2wmTtO4lE49A2cWAIll3OSaUyh1Tjo8Ag0Gwjqph1hF01DUlISQ4cOrXZWObVaTYcOHdiwYcNNbTcsLIy5c+eyYMECwzC64uJiFi5cSNeuXQ0TV8TGxlJQUEBQ0PVzws2ePZuysjJeeOGFm2pHQ9FqtYYcUBKAEkIIcStJyI+kHKagrABHM0eCHFrVantOx2fzzqoTxKTpb+yP6ODB80NaYmthUqv7uZaFnTkj/j2AAz+Hc2zVaU6uPcelY0n0f7EHzgFVTzAibl5ZcRkX98Ryav15Us6nGcrtfWxpM6wFgX39MbnBe61WqWnjFEwbp2Ceavc0ZzPOsi9hL/sS9pBSmMLehD3sTdiDERra4knnTDvaXyjDIiqBstg4tPHxUFJyw7aq7e31QaXy4JKnJ0aXf2o8PfQ9lxrx7MeNSZMJQN3OhURYWBivvvoqhw4donPnzoB+NqNt27YZtiWaltTIdNa9vY2inGLsvW0Z8c4ALB1vfTatRqO0CE4ug0NfQ/yBK+WOLaHzVH1vJ8nrJO4wRkZGhiHR1SkuLr7pJORdu3ZlwoQJzJ49m5SUFJo3b87ixYuJjo7m+++/N6w3efJkdu7ciaIohrL//Oc/nDx5kq5du2JkZMTq1avZtGkT7733HqGhoTf3BBtIRkYGustdxp2cnBq4NUIIIRpaUe7N54DafXn4XU/Pe1CraucCvLRMxw87I/lxdxRanYKjlQmvjQmmZ4v6SxOh1qjp9kgnPNq4svPLfWRdymb1yxsIub8d7ce1QWMkwYZboSgKqRfSObclkgu7oinJLwVAbaTGv7s3bYa1xK218031FNLl56ONi6MsNg6f2Fg8Yi8xJg4uFpVyyDmPo63NSXYz4yixHLWPRRWiEGibTzt1Lu1ywTnLSN9LycvzSg8mL68rwSYPD9SWtTfU827XZAJQt3Mh8cwzz/Dtt98yYsQIZs6cibGxMZ9++imurq689NJLDfF0RB1KjUhnzVtbKMkvxSnAgeFv98fc5vbHBzeovGQ4+LU+8JR/eYYwtbG+t1Pnp8GvD0iXzzuSTqdwPimHvefTCA1wpK23XUM3qd75+vqyf/9+Jk6cWKGHa7mcnBz++ecf/Pz8bnrbP/74I2+88QY//fQTmZmZtGvXjjVr1tC79/WHEbRt25bff/+dP//8E61WS7t27fjtt9+YMGHCTbehoZQPv3NwcLip5O1CCCGapitJyGv2vbhEW8KBJP1ok3s8e9VKG2LT83lj+XHOJeqHPQ1u68ZLw1vVea+n6vh09iTs85Hs+uoAUftiObjkGJG7Y7jn6S64t5bewzVVkFVIxI4ozm2NJDM221Bu5WxJqyGBBA0KwMKu6rzLiqKgS0mhLDpa/4iKRhsTQ1lcHNrYOHTp6VXW87z8GLMSktu4E97NjaPNNcTYlHC+hRXnW1ixIswDLysvurh3pYtbV1o6BNVZHjOh16S+cd7qhYS1tTU7duzghRde4L333kOn09G3b1/mzZuHs7MkZG5KUiPTWfPWVkryS3Fr5czQN/phatkwJ7RakXQc/pmvH2anvdx91MYLQp+Fjo+BlZwY70R5RaUciExnb0Qa+yJSSc/Tv7eZBSV3ZQBqyJAhfPbZZ8yePZvx48fTpk0b7O3tycrK4tSpU6xatYqcnBweffTRm962mZkZc+bMYc6cOdWus2PHjkplI0aMYMSIETe9v8YkNTUVkOF3Qggh9G52FrwTaccpLCvEwcyRlvbXH6ZeExuPJ/DRX6cpKNFia2HMrJGtGdDG7ba3e7vMbcwY9EovInZGse+7w2TEZPHn7E206N+Mbo90wtzuDr+RXUfKisuIPRRPxM4oYg/Fo9PqO4BoTDT4d/Om5cAAPNu6oVKrUHQ6/cxx5UGmq4NN0dEo15mVHkBla4uRjw8ab2+MfLwv//RB4+ONkacnnubmdLq8blJ+IvsT93Mw6QCn0k9yKe8SlyIusSpiJTYmNoS4htLFrQsdXTpVmTdK3J4mFYC61QsJAC8vL5YvX15HLRONQdrFDNa+uZWS/BJcg5wZ9mZ/TCzqd5rOWqEoELkJ9syBqK1Xyj27QLcXoPV40NyBz+supigKUan57D2fyp6IVI7HZqHVXemlaWGiITTAkY5+9g3YyobTo0cPoqOj+eOPP/jmm2+qXGf06NH06NGjnlt2Z5ME5EIIIa52swGog0n6dA+hbqG3lVy5sKSMT9adZc1R/YRSHf3seWd8O1wa0QgFlUpFi77N8OnkyYGfj3Jm4wXOb7tI1N5Y2o1tTbvRre7M64papi3VculYIhf+jiZm/yVKi8oMy1wCHQnsZI+PUxHqxItoV28jY340ZdExlMXEQBWz0huo1Wi8vDDy88XIzw+Nr++VAJO3N2pb2+rrXsPN0p0xze9lTPN7ySvJ40jKYQ4mHeBw8iFySnLYHreV7XFbMVIZEezUli7uXens2hk3S/cbb1zcUJMKQAlRnbSLGax5cwvFeSW4tHRi+Fv97ryThE4HZ3+HXR9A4hF9mUoNrcZD9xfAu3vDtk/clKISLQej0tl7Xt/LKSm7Yo4jXydLegQ60aOFM+197DG5y3MNTJo0ic6dO7Nt2zaio6MpKCjAwsICPz8/+vfvT4sWLRq6iXccCUAJIYQop9PqKMqreQBKURRDAKqLW9db3m90ah6vLAsnJi0ftQoe7RPAY30C0KgbZ+oIMxtTej/TjZYDAtiz4CCpFzI4/MtxTq07R8fxwbQa3Bxj8zvsGuM2aUu1JJxM5uKeWKL2xVKcdyWpt6VJGV7qeDxTDmGx4hj8UkpudRsyMtL3XPL3w8jvykPj54eRtxcqk9oftWJlYkVvrz709uqDVqflTMbpy72j9pOQn0B46lHCU4+yAPCw9KCTawidXEJo69QWU6PGEyC9k0gASjR56dGZrH1zK8W5Jbi0cGL4W/1vOKNCo6IthRO/wO7/QNoZfZmxBYQ8Bd1mgJ1vgzZP1Fxmfgm7z6Xw99kUDlxMp7hUZ1hmaqSmk7+DPugU6Iyng3T5vVaLFi0k0FSLJAAlhBCiXHF+CVzufG1qdeMAVHRONKmFqZioTWjn1O6W9vn32RTeXnWcgmItztamvD2+HSH+d8ZkOa4tnRk7ZxgX98Vy8OdwshNy2ffDYY78doLWw1oQPLJltTmNmoKizDyiN58k+p9Y4qOLKdNeCRialuTgkXkCj4xj2OXHUSGUaGKCka8vRn6++sCSn58h4KTx9ETVgDkpNWoNwU5tCXZqy+Ntn+BS7iUOJu3nYNJBzmScJiE/gYSLCay5+BfGamPaOAbT0aUTIa4heFv73FYvwLuJBKBEk5adkMPat7ZSlFuMS6Ajw9/uf+fkfCorgfBFsPtDyIrWl5naQtdp0PV5sJT8ZHeC2PR8dp3VB52Ox2Vx1fwHuNmZ0TPQmZ4tnOnk54CZiSQ9FPVHAlBCCCHKFefqe60YmxvXaIa3g5eTj7d37nDTPUF0OoXvd0by/Y5IADr62vP+xPY41CDw1Zio1CoCevri19Wb89siCV91mpzEXI4uP8nx1afx7+FDq0HNcQ92vWODE9qMDMoiIiiNuEDayUskRBWQmGNOurE7iiFZtwrTkhxcs8/gkXEcx9wojDzcMeoUgFFAf4wCAjAKaIZRQAAad3dUNzlrcUPxsvbCy9qLsYHjKSgt4HjqMY6kHOZw8iFSC1MNvaMWnvoeJ3MnOrnoe0e1c26PlYlVQze/0ZIAlGiy8tMLWPPWVgqzinD0t2f42wPujOCTTgvHf4Yd70BWlL7M0gW6vwid/wVmlWcBE42HTqdwOiGbXWdT2Hk2hejU/ArLW7rb0DvImd5BLjR3tb5jv5DUpbS0NEA/O5tarTb8XRNOTk511awmRwJQQgghypXk6wNQplY1+658MOkgAKFuXW5qP/lFZby96ji7zuknwpjQ1YfpQ1pipLlzUw1ojNS0GhxIywEBRB+4xLFVp0k5n8aFndFc2BmNjZsVLfo1o1kPH+y8bRvddz9FUdClpVF2PoLSiPOUnTtPaUQEOZFJpGodSbVpTppNACXGnvoKlz8iVsWpeGhS8PJQcGnlhnHAIIwCnsaomT9qi6bVk9/C2IJuHt3p5tEdRVGIz7vE4eTDHEk5zMm0E6QVprEpZiObYjaiRk1z++a0c+5AO6d2tHJsjanmzgqu1iUJQIkmqTCniDVvbiUvJR8bd2t9z6canlAbjE4Hp1fAjrcg7ay+zMoN7pkNIU+CcdPtxnunK9PqCI/JZOupZHadSyEt90oSRY1aRSc/B3oHOdOrpQtuTbg7dm159tlnAZg3bx4eHh6Gv29EpVKxbNmyumxakyIBKCGEEOWKLwegTCxvnL8orySX85nnAAhx7VzjfaRkF/HiksNcSM7DxEjNK6NaM6KD5601uBFSa9Q06+6DfzdvUs6nc3bLBSL/jiYnKY9Dvxzn0C/HsfO0wa+bN94d3XFp6YxRPfZ+VxQFXUoKpecj9L2azp2nLOI8ZecjKMvKIdvCnUxLXzKtfMi06kORj12F+hq1DldnFZ6tHfHr1xL7ds0aXTCtPqhUKrysvfGy9mZM83spLiviZPpJjiQf4UjKYeLzLnE+8zznM8+z4vxvGKuNCXJoRXvn9rRz7kCgXSAa9Z3RC6wuSABKNDklBaWs//d2si5lY+lowch3BjTuMdiKAufXwrb/g+Rj+jJzB7jnVQh9Fkya1h2EpqJMq+NwdAbbTyWz82wKmflXEi5amGro3tyZ3kHO9Ah0xvouS0Z5u3r37o1KpcLi8t2z8r9F7ZIAlBBCiHIl+aUANRotcDztOAoKXlZeOFvULCVERFIOLy45QmpOMY5WJsyZ1InWnjWfuexOolKpcG3phGtLJ3o83pmLe2K4uCeGS8eSyIrPIXzlKcJXnkJjosE1yBn31s44NXPAKcABS0eLWvnOo01NpfTMGX2vpvPnDb2bdFnZlBhZkmvuRo6FGznm3uS4dSHP3wWduuL3VZUanPzt8erkiVcHd1xbOqExvnsDJ9UxNTIjxLWzIRibWpDK8bRjHE89xrHUY2QUpXMi7Tgn0o7DmZ+wMLIg2CmYtk7tae/cAV8b37vqe64EoESTUlaiZeOHO0mNSMfM2pQRb/fH2rURj8FNOAKbXoLoHfq/TW2g+0v65OIy1K7RKdPqOBSVwbZTSew8m0J2Qalhma2FMX2CXOjX2pUQf8e7fta623Ftj6ea9oASN0cCUEIIIcpd6QF14wBUeEo4AB1cOtZo2/9cSOO138IpKNbi72zJpw+F4N6Ybw7XImMzI1oOCKDlgACK80uIOxxPzMF44o8nUZhVRMLxJBKOJxnWN7Mxxc7LFhs3K6xdrbBxscLMzgwzaxPMrE0xtTJFY6xGbaRGpVZBURHF585TfOoMRWciKD5/kYKLlyjK11JsZEmJsSVFxrbkm7akwKM7Bf4OaKsZDmZqbYJrkDOuLZ1xC3LCOdAJYzMJF9wsZwtnBvgMZIDPQMNwvWOpxziWGs6JtOPkl+ZzIOkABy7PImljYkNrxza0cQwm2CkYP1t/NKqmG+iTT5RoMhSdwo7P95JwPAljMyOGvdUP+2u6jjYa2Zdg2+tw7CdAAY0pdJsOPV8Biztj9o+7RWmZjoNR6YaeTjmFV4JOdhbG9G3lSr82roT4OdzR+QvE3aW4uJjs7GxAAlBCCCGuygFVgwDUsdRwQJ+A/EbWH0vgvdUn0eoUQvwd+M99He7anuGmliY07+1P897+KIpC1qUcEk4kkRKRTlpkBplx2RTlFJN0OoWk0yk12qZK0V6VDNxf/7jRqEYV2Lha4ehvj4OfPY6+djj42WPjZnVX9cSpD1cP1xvRbCRaRUtU9kWOpep7SJ1KP0VOSQ7/JO7jn8R9AJgbmdPKoTVtnIJp4xhMoF0gxpqm8z8jASjRZBz4OZzIXTGoNSoGz+6DS2AjTEZcnAd7PoK9n0BZob6s7SQY8AHY+TZs24SBTqdwLDaTTScS2XoquULQyd7ShL6tXOnfxpWOvvYSdKoH9913HxMmTCAsLKzadVatWsVvv/0mOaBqKDVVn/zVyMgIOzu7hm2MEEKIBlfTHFDJ+ckk5iegVqkJdmp73XVXHIhl7tozAAxt587rY4Ixlh7igD4wYe9ti723LW0ul5WVaMmMzSLrYgpZp6LJjkolN7WA4vwyisvUlKjN0GkqBgiVa3rKqFRgZmmEuYMF5nYWmNmaYmFvjo2bNTZuVti4WmHlYlWvuafEFRqVhuZ2gTS3C2R8YBilulIuZEZwOv0Up9JPcjr9NAVlBRxJ0Sc4BzBRm9DSoSVtHINp4xRMC/uWmBvduT0IJQAlmoTT/8/efcfXeL4PHP+cc7J3IhGJFSLDighib9pabZHSomq0dKiWoqVKFdUWRalv66elNWoEHao1WpsGESMSW5AhsudJznp+fxw5lWZIIuMk7vfr1VfPeeZ1iDznuZ7rvu691zi34xIA3SZ1oJ6/WxVH9B+SBBd/gn3TIDNOv6x+Z3j6S6hXutlDhIohSRLX4zPYeyGO/eH3iE/LMaxzsjGj54Okk39DJxRy8XTIGEmSVNUhVBsPD78TTzsFQRCEvB5QjxqCl1f95O3ojbWpdZHb/Xj0JqsPXAP0M91NecYXufj+VIA2IQF1eDjq8Euowy+hDQ/HKioKK8D9vxubmSH38kHu7YvC2xtFE28UjT0xdauNibmpfmieeDBarZjKTWlaqxlNazVjKC+glbREpUUZElKXEsNJU6VxMfEiFxMvwhWQI6ehvQe+Tr74OjbFx8kXN2u3avN9TiSghGrvTmgMx77Rj6Ft85IfPr08qzii/7h/CX5/C24f1r93bAx9v4CmQ/SPKYQqFZOczb6Lcey7GMethCzDcmtzE3o2c+Wplm60aSSSTsYuMzMTMzMjn+nSiIj+T4IgCMLDSjoE71HD7yRJ4tu/r7P+yE0AxnRrzMReTarNzXFFkSQJ7d27DxJN4aguhqO+FI4uvvChdgo3N0yaNcO0qS+mzZpi2rQpJo0aITOtOUOxhIIUMgWeDp54OngyyPNZQw+p8KRwIhL1SakEZQK30m5yK+0mf9zaA4C9mT0+Tj74ODXF19GXJo5eRlslJRJQQrWWeDOZ/V8cRdJJePdqTJvhxZcCV6rcDDj8CfyzHHQaMLGEbh9Cp2lgUnjzP6FypGap2B8ex76L97h4N9Ww3FQho7O3C0/5udHZywVzMdNHlYmIiMj3/v79+wWWAeh0OhITEzl27Bju7gWeFQpFEAkoQRAE4WGqEjQhlySJ8MSLQNEJqDUPJZ/e7OPF6K6NyzfQakDSaNBcv446/BKqvOqmiAikB70X85HJMGncGNMWzTFt0cLwf4WT6Akr5O8h9YxHPwCSlIlcTr7M5eTLXEmJ5HrqddJUafkam8tlchra6aukfBx98XL0oq5NPeSyqq+QEwkoodrKSsrmj/kH0eRoqOtXh25vtjeOpyuSBBHB8Oe7kBGrX+b7PDy9DBw9qjCwJ5tGq+Pk9UR+D4vh2NUENFr9cC2ZDNo0cuIZP3e6+9Z+YhtjGpt58+ble3/48GEOHz5c5PYymYzRo0dXdFg1hkhACYIgCA/LfTAEz7yYHlBxWXGk5KZgIjPBy9G7wPrvD99g3YPk05R+vgzvUPP7m0o6HZqbN1GfO4/qwgXU586jvnQJKSen4MZmZpj6+DxIMjXHtHkLTJs1RW5d9FBGQfivWpbOdK7bhc51uwCg1qq5kXaDK8mRD5JSl0lUJhaokrI0scTTvglNHJvQxMELL0dv6ljVqfT7Z5GAEqoljUrLvkWHyU5W4ljfnr4fdENhDNUq6bHw+5tw5Rf9e0dP6PcVePev2rieYNfjM/g9LIY/L8SR8uDpHoC3my39W7nTp4UbzraiIs3YDB06FJlMhiRJ7Nixg2bNmtGsWbMC28nlcmxtbWnevDl16z5q2hchj0hACYIgCA8rSQVUZJK+32oTRy/MFfm/O208dos1f18H4O2nvGtk8kmSJLR37qA6fwH1+fP6/1+8iJSZWWBbmbU1ps2b/VvV1LwFpt5eyES7AKGcmSpM9f2gnHx57sGyRGUil5MjuZJ8maspV7mRdgOlRkl40kXCky4a9rU2tTY0Rfdy8MLL0QtnS5cKTUqJBJRQ7UiSxNHVIdy/loS5rRlPf9ijRFPGVnBQcPY7fZPx3DSQm0LXmdBlJphaVG1sT6DULBX7Lsbx+7lYrsSlG5Y7WpvxjJ8b/f3r4lXHtgojFB5l2LBhhteHDx+mXbt29O8vErnlRSSgBEEQhIflzYJnblP0d+pLDxJQzWs1z7c8+NQdVu2/CsDEXk0Y2blRBUVZubRxcajOn0d9/gKqBwknKTW1wHYyCwtMW7bE1M8PM/9WmPr5YdK4ETJ51Q93Ep5MzpbOdKnblS51uwKg1Wm5m3GX66nXDP/dTLtJljqL8wnnDL3d4N9+UrPaf1QhQ/ZEAkqodi7+GsnVgzeRyWX0md4Ve7cqTiQkXYffJkDUQf37uoHw7Hfg2qJq43rCaHUSIdcT+fVsdL4hdiYKGV28XRjQui4dmzhjImYHqXa+/vrrqg6hxhEJKEEQBOFhJamAiniQgGr2UALqYEQ8S/dEAvqG42O7G9lkQCWkS0tDde4cqrNh+uqmCxcKbxBuZoZps6aY+flh2soPs1atMPHyQmYibqsF46WQK/Cw98DD3oM+DfsCoNapuZN+m2up17ieco3rqde5nR5FmiqN+9kJFdYvSvxLEaqVu2dj+Wd9GAAdx7WhXiu3qgtGp4NTq+DAB6BR6puM914I7SeD3AiGAz4h7qfl8FtYNL+ejSE+7d/x9r7udgzwd+eplm7YW4lyZ0F4mEhACYIgCHm0ai2aXC1QdA+olJwUYrNikSGjqVNTAM7dTmHujgtIEgxuW5+JvZpUWsyPQ9Jq0Vy9iupsGKrQUFRnw9Bcu1ZwQ4UCE29vzPxb6RNO/q0w9fFBZi5aNwjVn6ncFE+HJng6NIEHDc5ztblEpd0iR1tID7NyIhJQQrWRFpvOgSXHkHQSPn08aTHQpwqDiYZfxsLNA/r3jXrBoP8Dpydvpo+qkNdQ/Ocz0Zy8loBOX+yEnaUp/f3dGdi6Lk1cxRC7muK/DcmLIpPJmDNnTgVHUzOIBJQgCIKQR5WtNrw2LWIylsgk/Uy0DewaYmNmy637mcz46SwqjY6uPi5MG9DUOCYDKoQ2KUlf2XT2rD7pdO5coX2bFB4emAW0xszfH1M/P0xbNEduaZxT2QtCRTBXmOPj5Fuh5xAJKKFaUOdo2LvoMKosFa6+LnR9PbDqLnLhW2H365CTqq96emoJtHtDP52aUKHupSr57WwMv4ZFk5Cea1ge4OHI823r0923NubG0Iy+nKkjIsnashWrwc9h1rp1VYdT6SIiIqo6hBpFkiSRgBIEQRAM8obfmVqaIi+iVUFE8r/9n1KyVEzZFEq6UkOLevbMD2qFQm4c34MltRr15cv6yqbQMFRnz6KNiiqwnczaGjN/f8zaBGAaEIBZQGsUtWpVfsCC8IQRCSjB6EmSxNH/hZByJw0rRwv6vt+1ama8U6bAnklwcbP+vXs7GLIBnKuwEusJoNVJnLyWwM7Tdzl5PRHpQbWTg5UpA/zr8mybejR0rnnT1+pSU8n++Weyt25DfUE/W4WUnfVEJqC2bt1a6PLs7GyuX7/Opk2bcHNzY/LkyZUcWfWUkZFBbq4+gevi4lLF0QiCIAhVzdCAvIjhdwBXkq8A4OXgy6xt57iXmkM9JyuWjAjAwqzqHv5p4+NR5VU2hYaiPn8BKafg8CETLy99dVObNpgFtMbE2xuZouY9tBQEYycSUILRi9x3nWuHbiGTy+g9vSvWTlaVH8Sd4xD8IqRHg0wB3WZDtw9BUfSFWng8adkqdofFsOP0XWJTlIblbRs58VzbenT3dcXMpGY1FJe0WnKPHSN76zaUf+6FB0kCTE2x6NsXy2cHVW2ARsbKygo/Pz8aN27Me++9x2+//cZzzz336B2fcAkJCQBYW1tjZVUFv08FQRAEo6LK0g/BK6oBuVqn5mbaDQCOXzAhLCoFK3MFi19qjUMlzkQt5eaivhTxoG+TPumkjY4usJ3M3l6fbHpQ2WTWujVye/tKi1MQhKKJBJRg1BKuJ3F8zWkAAl/2x725a+UGoNPB8c/h749A0oKTl77qqV77yo3jCXI1Lp3tp+6w70IcuRodAHaWJgxqXY/n2tajQa2aV+2kuX2b7G3byd62HW1srGG5SVNfrF98Ecshg1E4OVVhhMbNxsaG1q1b8/fff4sEVAmI4XeCIAjCw/J6QJlZFf5g9XZ6FGqdGjOZFXvOZCOTyZg31I9GtW0qLCZJktDGxqIKPWtoFK4ODweVKv+GcjkmPj76ZFMbfYWTSePGyOQ16yGlINQUIgElGK3czFz2f34EnUaHR/t6tBrcrHIDyLwPu0bDjb36936jYMD/wLziLrZPKrVGx6HL8QSH3OH8nVTDcq86trwQ2ICnWrpVaXl3RdApleT8voesLVtRnTxpWC6zt8dq8PNYDR+GacuWRtvQ09hYWlqSmJhY1WFUCyIBJQiCUFBqaiozZsxg165dZGdnExgYyNKlSwkICCjR/pGRkUyZMoVjx45hZmbGgAED+PLLL/MNdY6KiqJRo0aF7v/TTz/x4osvlstnKS11jj4BZWJR+K3htRT9DHFZ6S6AjIm9vOjqU77XEJ1SifrCBf1QurP6pJMu/n6B7eROTpi1CXhQ3RSAqX8r5Dbiu7kgVBc1JgFV1ouGTqfjxx9/ZOfOnYSFhZGcnEyjRo148cUXmTZtGhYWFpX0CYSHSZLEweUnyLifha2rDT0md6rcG/GowxD8EmTG6RuN918FrceKRuPlLCkzl12n7/JzaDSJGfrhZgq5jF7NXAlq3wC/+g41LgGjuniRrI2bUf78878zsMhkmHfritXw4Vg+/RQy8XunVFQqFWfPnsXOzq6qQ6kWRAJKEAQhP51Ox4ABAzh//jzTp0/H2dmZ1atX06NHD0JDQ/Hy8ip2/+joaLp164a9vT2ffvopmZmZLFmyhIsXL3Lq1CnMzPIPU3vppZfo379/vmUdO3Ys989VUmqlBgCzImbAi0i8DIAq05VuvrV5pWvhSbSSkiQJ7a2oB8Po9EPp1BERoNXm31ChwLR5swfVTfreTYqGDWvcd0NBeJLUiATU41w0srOzGTt2LB06dOD111+ndu3anDx5krlz5/LXX3/x999/i19yVSB89xVun45BYSqn7/tdMbeppPHlkgTHv4C/ZoGkA+emMGw71G5eOed/Qty8n8lPJ6L480Isaq2+q3gtGzOeb1ufwW3r42xrXsURli9dZibKn38ha9MmQ0NxAEXDBlgNG4bVC0GY1K1bhREat8OHDxe6XKvVkpSUxLFjx7h37x6DBokeWSUhElCCIAj5BQcHc+LECbZv305QUBAAw4YNw9vbm7lz57J58+Zi9//000/JysoiNDSUBg0aABAYGEjfvn1Zv349EyZMyLd9QEAAo0aNqpgPUwZqZdEVUJIk8c/diyAHG1k9Zj/fotT3Rrr0dFTnzumH050NQx0Whi4lpcB2ctfa+kRT69b62en8/JBbWpbtQwmCYJRqRALqcS4aZmZmHD9+nE6dOhmWvfbaa3h4eBiSUH369KnwzyD8K+lWCv+sPwtAh7FtcPGspClRczPhl3EQsV3/vtUrMOBrMKt5PYeqgiRJnLqZxE8novjnepJhefN69rzYoSE9mrpiWoOaikuShPr8ebI2bUb58y9I2dn6FWZmWPZ7BusRIzDr1FH0KCiB1atXF7teJpPRtWvXKhu6UN2IBJQgCEJ+wcHBuLq6MmTIEMMyFxcXhg0bxsaNG8nNzcXcvOiHYzt27GDgwIGG5BNAnz598Pb2Ztu2bQUSUABZWVmYmpoWqI6qCsVVQG0/dZ0c2X1kwAdP98auiCqpPDqlEk1EJKqLF1BfuIjq3Dk0V69hmMY4j7k5Zi1bGpqFmwYEoHB3Ew/+BaGGqzEJqLJeNMzMzPIln/IMHjyYuXPnEhkZKRJQlUidq+HAkmPoNDoatqtL8/7elXPipOuwdTDcDwe5qX7IXduCXxaE0lNpdOy7GMdPJ6O4Ea8fciaXQfemrrzUsSF+DRyrOMLypUtPJ3vXz2Rv2oz60iXDchNPT6xGjsDqhSDRULyU3njjjUKXy+VyrK2t8fT0xMHBoXKDqsZEAkoQBCG/sLAwAgICkP/noVBgYCBr1qzh6tWrtGzZstB9Y2JiuH//Pm3bti2wLjAwkD179hRYPm/ePKZPn45MJqNNmzYsXLiQp556qnw+TBnkVUCZ/ie5dDcpi29PHMO6EVjJHenYyCPfel1mJurIy6gvXtT3b7p4Ec216wWH0qGv+s7r22QW0BrTZs2QGUHyTRCEylUjElCPc9Eoyr179wBwdnYutziFRzv5XSip0WlYOVrSfXLHynkKcu1P2PES5KSCTR0YtgMaFExKCqWTlq1i5+m7BJ+6Q1KmfsYSSzMFg1rXZXiHhtR1qjnTv0uShPpsGFmbNqH89TckpVK/wtwcywEDsB75Embt24unemXUo0ePqg6hRhEJKEEQhPzi4uLo1q1bgeVubm4AxMbGFnkvERcXl2/b/+6fnJxseBgul8t56qmnGDx4MHXr1uXmzZt8+eWX9OvXj19//ZUBAwYUGWNubi65ubkFlmfm9ZMshfQvFoOJCTavT0RuZYU6R18BZWr5762hVicx/+dwJDP95/Mzdydr6zY0V6+ivnoVzZWraGNiCj2+3MUF05YtMfNriWkrP8wCAlCIeypBEKghCajHuWgU5YsvvsDOzo5+/foVu115XgyedLdO3iFy7zWQQc8pnbC0q+BGzHn9ng7MBCSo10GffLJzr9jz1nD303LYfCKKn0OjyVHrn4C52JkzrH1Dnm9TD9tHlG5XJ7qMDLJ37CBr4yY0kZcNy028vbEeOQKroUOQO9asCi+h+hMJKEEQajKdTodKpSrRtubm5shkMpRKZaGjJfImI1LmPVgqRN66R+1vbm5OgwYN2Lt3b75tXn75ZZo1a8Z7771XbAJq0aJFzJs3r8ByNzc3Jk6cWOR+/6W5e5eMr1eDRkPG119j5udHlnkPwAnNgT9JObkeXXo6wYr6XHANxLG+/qG865YDpO77qcDx5K61MW3xINnk1xKzli2R16kjHroJglAoo0tAVfZFozCffvopBw4cYPXq1Y8c1lFeF4MnXWZiFoe//geAVoObUa9VwadI5Uqjgt0T4dx6/fs2E6DfV2BSs5pfV6Y7iVlsOHaLPy7EonnQWNzbzZYRnTzo3axOjervpL58mawffiR7x06krCz9QgtzLAcOwnrUCMzathVfvCrA/fv3OXLkCFFRUWRnZ2NlZYWHhwfdunUTyZRSEAkoQRBqsiNHjtCzZ88SbRsZGYmvry+WlpaFPlDOyckBwLKYRth568q6v5OTE2PHjuWzzz4jOjqaevXqFbrdzJkzmTp1aoHl8fHxj2yS/jBFvXo4rVpJ2mefo42KQnXqNLlezcHeCe2Jo2QnnSXavg4bBz+rj09+iwygYbYVZp06Yerjjam3NyY+3ph4eaNwEg/aBEEouRInoIqahagkunfvXuJtK/ui8V9bt25l9uzZjB8/vsi+Iw8rr4vBk0ySJA59dZLcDBUuTZxoN6JVxZ4wOxm2DYWoQyCT6xNPgW9V7DlrsMux6fx49CYHI+MN/SUDPBx5pWtjAj1r1ZhEjKRSofzjT7J++AFVyCnDchMvL6xHv4zVkMHIRR+iCvPbb7+xZcsWNBpNvuWnT59m586djBgxgoEDB1ZRdNWHVqslMTEREAkoQRAqV2XdS/j6+rJu3boSbZs3WsLNzc0wlO5hecvc3Yuujs87RlH7Ozk5FdvAHKB+/foAJCcnF5mAMjc3L/Q4WXkPwkpIJpNhOWggFgMH6IfTXb4MO1MgFWz79cHWrTffKz1Q55jS1llHtJP+y12bH37F0UL0sBQE4fGUOAH1qFmIimPMF42H7d+/n9GjRzNgwAC++eabEu1TXheDJ1nEn9eIOX8PEzMFvaZ2QWGqqLiTJV2HzQMg6SqY2cIL28DrmYo7Xw0lSRJht1P44chNQm78O6NdFx8XXunamJb1HaouuHKmjY0ja9Mmsjb/hO5B5QgKBRZPP43NmFf0M9nVkCSbsTp27BgbN27E2tqa559/nubNm+Pg4EBqairh4eH88ccfbNiwAScnp0InlRD+lZycjE6nA0SPQ0EQKldl3UvUqVOHMWPGlOr4/v7+HD16FJ1Ol6+nbEhICFZWVnh7Fz0pTt26dXFxceHMmTMF1p06dQp/f/9Hnv/mzZuAfhKlyiKTyTD18cHUxwft37shNRW7F4dyXA7nd17E3FTOS8/W4fMwCXtzB5F8EgShXJQ4AVWSaqDyUNkXjYe3HTx4MG3btmXbtm2YmBjd6MQaKS0ug3/WnwUgcHRrHOraVdzJbh+DLc+DMgns6sPI38G1dL3BnnSSJPHP9US+P3yTi3dTAVDIZfRpUYeXuzSiiatt1QZYTiRJIvfYcbJ+/JGcvfsMs7nIa9fGeuQIrEeOQFFIs1GhYuzevRtra2s+//zzfF/O3d3dadasGT169OD999/nt99+EwmoR8gbflerVi1xnRMEoVJV1r1EWQQFBREcHMzOnTsJCgoCIDExke3btzNo0KB8D5tv3LgBgKenp2HZ0KFD+eGHH7h7966hmumvv/7i6tWrTJkyxbBdQkJCgSRTTEwM33//PX5+foU2Mq8MmgdNyFUyGV/t1fe0HNvNkwzpCgCN7RtXSVyCINQ8Jf72acyzED3uRSMyMpIBAwbg4eHB7t27SzVkTyg7SacfeqfJ0eDewpUWA3wq7mQRO2HHCNDmgntbeOlXsBUJhJLKSzytPXSDS9FpAJiZyBnYui4jO3nUmBntdOnpZAfvIOuHH9Fcv25YbtaxA9ajR2PZ7xlkpjWniXp1ER0dTffu3Yt8Mly7dm06duzIkSNHKjmy6kf0fxIEoaoY+71Ehw4dGDt2LBERETg7O7N69Wq0Wm2BXq+9e/cGICoqyrBs1qxZbN++nZ49e/LOO++QmZnJ4sWLadmyJWPHjjVsN2PGDG7cuEHv3r1xd3cnKiqKb7/9lqysLFasWFEpn7UwKqUagF8vxpGSpaKhszUjO3mw9tIfADSyb1RlsQmCULPUiMefj3PRyMjI4OmnnyYlJYXp06fz+++/59ve09OTjh07VsrneNJc/O0y9yLuY2phQvfJHZHJK2gYU+j/we7XQdKBz3MwdDOY1YyESUWTJImT1xNZe/AGETH6xJO5qZyh7RowopMHzrY1o2m7+sZNsr7/nuxt25GyswGQWVtjFTQU69EvY+rrW8URPtksLS2xtrYudhtra2vx8KAERAJKEAShIIVCwZ49e5g+fTpfffUVSqWSdu3asX79enx8Hv2AtH79+hw+fJipU6fywQcfYGZmxoABA1i6dGm+B+FPPfUU33zzDV9//TUpKSk4ODjQrVs3Zs+eTUBAQEV+xGKplfoKqD8i48FUzrQBTTE1kXMrTT80sJGogBIEoZzUiATU41w0kpKSuHv3LgAffPBBgfWvvPKKSEBVgJS7aZzaEAZAh3FtsHO1Kf+TSBIcWQgHP9K/D3gVBvwPFDXix75CFZd4GtnZg1o21T/xJEkSuUeOkLn2e3L//tuw3MTbG+tXRmMVNBS5TQX8XAql5ufnx/nz5xkxYkSh6yVJ4sKFC7RqVcETGNQAIgElCIJQOEdHR9auXcvatWuL3e7hyqeHNW/enL179xa770svvcRLL71U1hArhE6rQ6vStxrIlUFnbxfaNa6FVtISlRYFiCF4giCUn8e6E8/JyWHfvn2cP3+e5ORk1Gp1gW1kMhkrV658nNOUSFkvGh4eHkh5U3cJlUKn1XFoxQm0ah31WrvR9KkmFXASHfz5DpxapX/f9UPoNR9Es+hiPQmJJ112NsrgHWR+vw7NtWv6hTIZFr17Y/3qeMy7dBZNxY3MqFGjmD17NsuXL2fkyJH5huIlJiayceNGsrKyGDVqVBVGWT2IBJQgCMbEmO4lnlR51U8AWoWMt/rqe+fey7pHjjYHM7kZ7tZ1qyo8QRBqmDInoLKyspgzZw7R0dFYWlqiVCqxsrJCo9GgUqkAfVJIoajAGc2Eain89yvcv5aEmZUp3Sd1KP+bfa0ado2G8C3698+sgA6Ty/ccNdDZqGT+d+Caobl4TUs8aaKjyVr/A1mbf0JK0yfXZDY2WA0fhs3YMZg0Ev0NjMV/h06DfojdyZMnCQkJwdnZ2TALXmJiIjqdjoYNG/LVV18xZ86cKoi4+hAJKEEQjIW4lzAOef2fdED/gLo0rq2v/s4bftfQzgOFXPwdCIJQPsqcgNqxYwfR0dG8/vrr9OjRgxdffJEBAwYwdOhQrl27xvfff4+5uTkffvhhecYrVHMZ9zM5vek8AO3HBGDjXHxfl1LT5ML2YXDlV5CbwPM/gF/hw3YEvcux6Xzz11X+uZ4EgLmJnCHt6jOqS6Nqn3iSJAnV6dNk/t935Pz5p74yDlB4NMRm7Fishg9DblszZu6rSSIiIopcp9PpuH//viGRkuf27dsVHVaNIBJQgiAYC3EvYRwu3NB//1MrZLzay8uw/E66/rra0K5hlcQlCELNVOYEVGhoKE2bNqVnz575lstkMry9vZk5cybTpk1j586dvPjii48dqFD9SZLE0W9OocnRUKdZbZr2Leehd2olbB0K1/8AhTkM3wne/cv3HDXI7cQs1vx9jb8uxQOgkMt4NqAe47o3xsXOooqjezySSoXy19/IXPsd6osXDcvNu3TBevw4LHr3QiaeqBqtrVu3VnUINZZIQAmCYCzEvYRx+OXkbTwBU0tTaj/0/e9Oxh0AGogElCAI5ajMCajExETatGljeC+TyfKN27a3t8ff358TJ06Ii4YAwI2jUdwNjUVuIqfbW+3Ld9Y7VTZseQ5uHgATSxjxGzTuXX7Hr0Hi05SsPXSDPedi0eokZDLo28KNCb2aUM+pes8OqEtPJ2vTZjLXfofu3j39QgtzrIYMwWbcWEybNq3aAAWhiokElCAIxkLcS1S98LupXLubiidgb5e/6v1uhn6Spvq29asgMkEQaqoyJ6DMzc3z9e6xsrIiNTU13zb29vYkJyeXOTih5shJz+X42jMABAxrgWM9+/I7eG4mbB4Itw+DqTWM/B08upff8WuItGwV64/cZMfpu6g0+qFoXXxcmNjLC6861XsYmiYmhqy13+n7O2VmAiCvXRubsWOwGjUShZNTFUcoGKvc3FzmzJnDhg0bSElJwc/PjwULFtC3b99H7nvgwAEWLlzIxYsX0Wg0eHt78/bbb/Pyyy9XQuRlIxJQgiAYC3EvUfU2Hr+FqU4/GZPlQ20XNDoNsZkxADSwbVAlsQmCUDPJy7pjrVq1SEpKMryvV68ekZGR6B70WAG4cuUKDg4OjxWgUDOcXBdKTloujg3s8R/SvPwOnJMOG5/WJ5/M7eDlfSL59B8qjY5Nx6MIWnGUn07eRqXR0drDkTXjA1kyIqBaJ59UFy+SPOlt4jt2JnPN/yFlZmLi7Y3Dl0uo888JbCe/LZJP1VBERAQRERGGJrR570vyX2mNGTOGL7/8kpEjR7JixQoUCgX9+/fn2LFjxe7366+/8tRTT6FSqfj4449ZuHAhlpaWjB49mmXLlpXpc1e03Nxc0tPTAfLNJFidxcfHExQURK1atZDJZCxfvhyAa9eu8dRTT2Fvb49MJuPnn3+u0jgF4xYVFYVMJmP9+vWGZWPGjMHGxqbSYpDJZHz88ceVdj5jIO4lqlZ8mpIjl+9jotUnoEwt/61LiM2MRStpsTSxxNmyZlwvBEEwDmWugGrWrBknT55EkiRkMhmdOnVi3bp1LFq0iDZt2hAREcHVq1d56qmnyjNeoRqKuXCPq3/fBBl0e6sDCtNy6r2jyoLNA+DuCbBw0Cef6rYrn2PXAJIk8deleFYfuEpsihKAJq42vNXXmw5NnMt/9sFKIkkSuQcPkfnNt+QeP25Ybt65MzavT8S8Z49q+9kEvbxZ8JYtW4a7u3uhs+IVpTT9o06dOsWWLVtYvHgx06ZNA2D06NG0aNGCGTNmcOLEiSL3XbVqFW5ubvz999+Ym+ufGk+cOBFfX1/Wr1/PlClTShxHZUlISADAxMTkkTd0CxcuZPbs2TRv3pzw8PBKiK5spkyZwt69e5k7dy516tShbdu2ALzyyivcunWLhQsX4uDgYFhuLDIzM5k9ezbBwcEkJCTQuHFjJk+ezBtvvFFg2/379zNv3jzOnj2Lubk5vXv3ZsmSJXh4eBR7Dp1Ox48//sjOnTsJCwsjOTmZRo0a8eKLLzJt2jQsLP7t9ZKbm8u0adPYsmUL5ubmvP7668yePTvf8aKjo/H19WXv3r107ty5XP4cKsKePXs4deqUUSZzjDm2qiDuJarWrjPR6CTwdLSEOxmYWpga1t190P+pvm198Z1KEIRyVeYEVPfu3dFoNCQlJeHs7Ezfvn0JDw/n9OnTXLhwAQAfHx8xZvsJp1VrOfbtKQCaPeNNHd9yeoqiVsJPz8GdY2BuD6MPgHubR+/3hDh/J4WVe68QHp0GgLOtOa/39qJfK3cU5dl7qxJJublk//wzmd+uQXPlqn6hQoHls4OwmTgBs5YtqzZAodwMHToUmUyGnZ1dvvflLTg4GIVCwYQJEwzLLCwsGD9+PLNmzeLu3bvUr19474v09HQcHR0NySfQJ3acnZ3LPc7y8vDwu+L+PKOjo/n000+xti7nWUorwN9//81zzz1nSCACKJVKTp48yYcffsikSZOqMLrCabVann76ac6cOcNbb72Fl5cXe/fu5c033yQlJYVZs2YZtt29ezfPPfccAQEBfPbZZ6Snp7NixQq6dOlCWFhYsZVs2dnZjB07lg4dOvD6669Tu3ZtTp48ydy5c/nrr7/4+++/DT8Hixcv5scff+TDDz8kIyODTz75BE9PT1566SXD8aZPn86zzz5r1Mkn0Cd5vv7661IleRo2bIhSqcTU1PTRGz+G4mJTKpWYmJT5a3m1JO4lqo5Gq+OX0GgA/N3tSTx/P18F1L8JKDH8ThCE8lXmK13jxo1p3Lix4b1CoWDatGncvHmTe/fu4eLigqenJ3J5mUf5CTXAxd8ukxqdjoW9OYGj/MvnoBoVbAuCW3+BmQ2M+lMknx6ITs7m6/1XORihn9nO0kzBqM4ejOjkgaVZ9fxiq8vIIGvDRjL/by26BzfQMhsbrEeOwHr8OEzq1q3iCIXyNmzYsGLfl5ewsDC8vb0Nia48gYGBAJw7d67IBFSPHj34/PPP+eijj3jllVeQyWRs3ryZM2fOsG3btgqJ93GVtP/TtGnT6NChA1qtlsTExMoIrczu379foJorr9KrPIftZGVlER8fn+97T1nt3LmTEydO8N133zFu3DgA3njjDYKCgpg/fz6vvvqq4e/o/fffp3Hjxhw/fhwzMzMABg0aZEhILV26tMjzmJmZcfz4cTp16mRY9tprr+Hh4WFIQvXp0wfQJ7ree+89ZsyYAcDdu3f59ddfDQmoY8eO8dtvv3H58uXH/vzGRKPRoNPpMDMzy1cRVhWq+vxVQdxLVJ3TN5NIyVLhaG1GA3sLEgET84cTUHkNyEUCShCE8lXuv9EbN25Mp06d8PLyEheMJ1xmYhahWy8C0OGVAMxtzB7/oFo1BL8I1/Y8mO1uN9Tv8PjHreYylGqW/3mZF1cd42BEPHIZPNemHtsnd2V8jybVMvmkTUwk7bPPuRfYgfSFn6K7fx95nTrYffQhdU6HYD/nI5F8ekIEBwdz5MiRcj9uXFwcbm5uBZbnLYuNjS1y348++ohhw4axcOFCvLy8aNKkCZ999hk7duxgyJAhxZ43rxfTf//LfNBAv6KUJAF15MgRgoODDb2USiMkJIT+/fvj6OiItbU1fn5+rFixIt82f//9N127dsXa2hoHBweee+45IiMjCxwrJiaGcePG4erqirm5Oc2bN+f77783rF+/fj0ymQxJkvj666+RyWSGHjoNG+qnDJ8+fToymeyRQ9VKIiEhgSZNmtCrVy82b95MTk5OmY919OhRgAJVHS+++CI5OTn88ssvACQnJxMREcHgwYMNySeAVq1a0bRpU7Zs2VLseczMzPIln/IMHjwYIN+fu1KpxNHR0fDeycmJ7OxsQD+U75133mHGjBnUq1evNB+V1NRUpkyZgoeHB+bm5tSrV4/Ro0fnS2zev3+f8ePH4+rqioWFBa1ateKHH37Id5y8Hk1LlixhzZo1eHp6Ym5uTrt27Th9+rRhuzFjxvD1118DGH4m8qq8Hj7G8uXLDceIiIgotAdUnps3b/L0009jbW2Nu7s7n3zyCZIkGdYfOnQImUzGoUOHCo0575jFxZa37L+VUWFhYfTr1w87OztsbGzo3bs3//zzT75t8v4tHD9+nKlTp+Li4oK1tTWDBw82JGOrG3EvUfH2h+tnCu7d3BWdSt9zy8T83xYZdx4agicIglCeqt9dqVBt/LPuLJocDa4+znj3fPynxui0sOsVuLwLFGbw4s9PfMNxrU7it7PRfPPXNVKz9VMXd2jizKSnvGniWj2bi2uio8n85luyfvoJcnIBMPHywubNN7B6/jlkZuWQyBSqlR07djBgwIByP65Sqcw3hC5PXiWCUqkscl9zc3O8vb0JCgpiyJAhaLVa1qxZw6hRo9i/fz8dOhSdGF+0aFGhfa3c3NyYOHFiGT5JyTwqAaXVann77bd59dVXaVnKIa379+9n4MCBuLm58c4771CnTh0iIyPZvXs377zzDqCfNbBfv340btyYjz/+GKVSycqVK+ncuTNnz541JIri4+Pp0KEDMpmMSZMm4eLiwh9//MH48eNJT0/n3XffpVu3bmzYsIGXX36Zvn37Mnr0aAD8/PxwcHBgypQpvPTSS/Tv379cGkm7ubmxZMkS1q1bx8iRI3FwcGDkyJGMHz+e1q1bl+pYubm5KBSKfEkl0M8ABhAaGsprr71Gbq7+95+lpWWBY1hZWXHp0iXu3btHnTp1SnX+e/f0N54PDxdt164da9asoUePHmRmZvLTTz8Zhi9+9913JCYmMn369FKdJzMzk65duxIZGcm4ceMICAggMTGRX3/9lejoaJydnVEqlfTo0YPr168zadIkGjVqxPbt2xkzZgypqamGn508mzdvJiMjg4kTJyKTyfjiiy8YMmQIN2/exNTUlIkTJxIbG8v+/fvZsGFDoXGtW7eOnJwcJkyYgLm5OU5OTvmaXj9Mq9XyzDPP0KFDB7744gv+/PNP5s6di0aj4ZNPPinVn0dJYnvYpUuX6Nq1K3Z2dsyYMQNTU1O+/fZbevToweHDh2nfvn2+7d9++20cHR2ZO3cuUVFRLF++nEmTJpWqL57wZMhVazkcqb8e9GnhRtbe68C/FVBanZaYTP3wvAa2DasmSEEQaqzHSkBpNBrOnDnD9evXyczMLPQCLpPJCm2qKdRsMRfucePYbWRyGV1eD0T2uH2HJAn+mAzhP4HcBIYFQ5MnuynlhTspLN1zmStx+lmtPFysmfKML+2bGG8PmuKor14lY9VqlD//DFotAKb+rbCd9BYWTz+NTDwFfWI9XI1RniwtLQ03+Q/Lq24p7MY/z6RJk/jnn384e/as4Qn9sGHDaN68Oe+88w4hISFF7jtz5kymTp1aYHl8fDybN28u7ccosUcloL755htu377NgQMHSnVcrVbLxIkTcXNz49y5c/mGvj1cKTJ9+nScnJw4efIkTg9mp3z++edp3bo1c+fONVS9fPjhh2i1Wi5evEitWrUAeP3113nppZf4+OOPmThxomHozssvv4y3tzejRo0ynMfOzo4pU6YQEBCQb/njMDc3Z+rUqUydOpXTp0/z/fffs2nTJr7++mtat27Nq6++yogRI0o07M/HxwetVss///xDly5dDMvzKqNiYvRTn7u6uuLg4MDxhyZbAEhKSjLM+BgTE1PqBNQXX3yBnZ0d/fr1Myz7+OOPeeaZZ/Dz8wOga9euvPPOO6SlpfHhhx+ycuXKYv89FGbx4sWEh4ezc+dOQ9UVwOzZsw0/F2vWrCEyMpKNGzcycuRIQP933b17d2bPns24ceOwtf33YcqdO3e4du2aoVrLx8eH5557jr179zJw4EA6duyIt7c3+/fvL/LvPjo6muvXr+frnxUVFVXotjk5OTzzzDN89dVXALz55psMGjSIzz//nMmTJ5eq51tJYnvY7NmzUavVHDt2zDBMbfTo0fj4+DBjxgwOHz6cb/tatWqxb98+Q1WVTqfjq6++Ii0tDXt7+xLHWdnEvUTlU2t1DO/QgHO3U/Cr78DRXA3wbwIqLisOjU6DucIcFysxA54gCOWrzAmo5ORkFixYYPiiVBxx0Xiy6BuP60vimz3jhXNjp8c/6JEFcHo1IIMhG8Fn0OMfs5pKSM/h6/1X+fNCHAA2Fia81qMJQwPrY6Kofkka1dkwMlatImfvPsMy865dsXnrTcy7dBazrwgEBgZy5swZVCpVgaqRx+Hm5lboNSwuTv9vy93dvdD9VCoV3333HTNmzMg3PMTU1JR+/fqxatWqYmM1NzcvtPIqKyurLB+jxIpLQCUlJTFnzhw++uijYhtbFyYsLIxbt26xbNmyAgmYvH+/cXFxnDt3jhkzZhiST6CvWOrbty979uwB9AmrHTt2MGzYMCRJyjdU6+mnn2bLli2cPXu2Shtht2vXjnbt2rFs2TJ27tzJ999/z6RJk3jvvfcYOnQon376KQ0aFN03ZcSIEXzyySeMGzeOr7/+Gi8vL/bt28fq1auBfyvv5HI5EydO5PPPP2fmzJmMGzeO9PR0ZsyYgUqlyrdtSX366accOHCA1atX5/u7qlevHmFhYVy6dAkzMzN8fX2Ry+VMnToVHx8fhg8fzrFjx3jvvfeIjY1l8ODBLFmypNh/jzt27KBVq1b5kk958n4u9uzZQ506dfI1Ozc1NWXy5Mm89NJLHD58mIEDBxrWDR8+PN9Qwa5duwL6YXIlNXTo0FL9jD/cyD6vKu/333/nwIEDFdYcW6vVsm/fPp5//vl8PZLc3NwYMWIE//d//0d6enq+/nUTJkzId73s2rUry5Yt4/bt24bEorER9xJVw8bClAm9vAzvNSr9Q7+8IXjRmfr+T3Vt6iGXVb/vlYIgGLcyJ6B+/PFHYmJi6Ny5M71796ZWrVooFIpH7yjUeOG7r5AanYaFvTntRrZ6/AOeWQMH5+hf91sBLYY//jGrIZVGx5aTUaw7chOlSotMBoNa1+X13l442RS8mTVmkiSRe/QoGSu/RpU31b1MhkW/Z7B9603M/P2rND7BuAwbNozLly+zePFiXn755WJv7kvD39+fgwcPFriRy6te8i/i5zApKQmNRoP2QaXew9RqNTqdrtB1Va24BNTs2bNxcnLi7bffLvVxb9y4AUCLFi2K3Ob27duAvmLlv5o2bcrevXvJysoiKyuL1NRU1qxZw5o1a4r9HBUhb3haHnt7+yIrfywsLBgxYgTDhg3jf//7H9OmTWPTpk0EBQUV+zNap04dfv31V15++WXD9PJ2dnasXLmSV155Jd+QwU8++YTExES++OILPvvsMwCeeuopxo8fzzfffFOq4YVbt25l9uzZjB8/vtCbeVNT03w/85cvX2b16tWcOHGC5ORkBgwYwAcffEDPnj0ZO3YsCxcuLHQoaZ4bN24wdOjQYmO6fft2oX1+mjZtalj/sP/+ueYlo1JSUoo9z8MaNWpU4m3lcnmBxvPe3t5A0VVT5SEhIYHs7Owi/73odDru3r1L8+bNDcvL48+msol7CeOg+W8FVKa+/2FdG9FnUxCE8lfmBNSFCxdo2rQpkydPLs94hGouO1VpaDzefnQA5o+bGIncBb8/+KLc9UNoX/qbo5rgxNUEvvzjMtHJ+mFILes78F5/X3zdjbesvjCSJJGzfz8Zy1egPq+fYhkTE6yGDMbmzTcw9fIq/gDCE2n69OloNBpu3rzJ9OnTMTMzw87OrkB1nEwmY+XKlSU+blBQkKGp8bRp0wB9f55169bRvn17wwx4d+7cITs7G19fX0CfwHFwcGDXrl188sknhiqQzMxMfvvtN3x9fUs9XKkyFJWAunbtGmvWrGH58uX5Gq/n5OSgVquJiorCzs4uX+VSRckbfjNq1CheeeWVQrepyGqO/zalX7duHWPGjCl028jISNatW8eGDRu4d+8ezZs3Z/z48fTs2fOR5+nWrRs3b97k4sWLZGVl0apVK8OffV6CA/SNxNeuXcvChQu5evUqrq6ueHt7M2LECORyOU2aNCnR59q/fz+jR49mwIABfPPNNyXaZ8qUKYwaNYqAgAA2bNiAk5MTM2fOBGDGjBmPTEBVhKKSEw8P9XyU8v63WVSVbmUnocvjz6ayiXsJ46DJzV8BFZul/13kblN4FbAgCMLjKHMCSq1Wl/iLj/DkOLP5AmqlGpcmTvj0eszG41FHIPglkHTQejz0ml8+QVYj99Ny+PKPSA49aBbpbGvOW329ecbPrVoNTZN0OnL+3KtPPF26BIDMwgKrkSOwmThBzGYnFEuSJBQKRYF+K/+9sSrtjVb79u154YUXmDlzJvfv36dJkyb88MMPREVF8d133xm2Gz16NIcPHzYcP2+q8NmzZ9OhQwdGjx6NVqvlu+++Izo6mo0bN5bxk1asohJQMTEx6HQ6Jk+eXOiNYKNGjXjnnXeKnBnP09MTgPDwcPr06VPoNnkz0125cqXAusuXL+Ps7Iy1tTUWFhbY2tqi1WqLPFZF2r9/f773D1eYAKSlpbF161a+//57QkJCsLGxYfjw4bz66qvFNp4vjEKhyFdxlNd7q7DP7erqiqurK6BPbBw6dIj27duXqAIqJCSEwYMH07ZtW7Zt24aJyaO/+u3evZsTJ05w7do1QD8j5MPJOXd390cOm/L09CQ8PLzYbRo2bMiFCxfQ6XT5qqAuX75sWF9a5Xlt1Ol03Lx5M19S8OrVqwCGpvl5lUapqan59v1v9VZpYnNxccHKyqrIfy9yudyQIK/OxL2EcfhvBVRspv7ftru1+G4mCEL5K3MCqn79+vl6MwhC8u1ULu/Xz6TRcVzbx2s8nhAJPz0L2lzweRYGfgPVKOHyuDRaHdtC7rD24HWyVVoUchkvdmjIuB6eWJtXn8krJa0W5e97yFixAs1l/RdpmbU11mPHYDPhNRQPGgwLQnHypi6vCD/++CMfffQRGzZsICUlBT8/P3bv3k23bt2K3e/DDz+kUaNGrFixgnnz5pGbm4ufnx/BwcGPHHZUFSRJKjIB1aJFC3bt2lVgn9mzZ5ORkcGKFSsMSabCBAQE0KhRI5YvX86YMWMKNCGXyWS4ubnh7+/PDz/8wMyZMw3bhIeHs2/fPkNTZoVCwdChQ9m8eTPh4eEFhvUlJCSUukcVQGJiIomJiTRo0MAw21xhikp6ZWRk8MYbb7Bz506USiUdOnRg7dq1DB8+vFxm2UtISODzzz/Hz8/vkYm3JUuWEBcXV6DaL28o5MN/V5GRkQwYMAAPDw92795douoflUrF1KlTmT17tuFnxdXVlevXr6PRaDAxMSEyMvKRzc+HDh3KJ598wq5duwr0gcr7uejfvz/79u1j69athj5QGo2GlStXYmNjQ/fupZ/p1traGtAnhErSFP5RVq1aZWhCLkkSq1atwtTUlN69ewP6JJlCoeDIkSM8//zzhv3yenqVJTaFQsFTTz3FL7/8QlRUVL4ZIjdv3kyXLl3yDRuursS9hHEomIDSV0C5iQooQRAqQJnvZJ999llWrVpFdHQ09erVK8+YhGpIkiROfh+KpJNo3KkBbs0Ln2WpRLISYNMAyE2D+p0gaAsoqk/S5XGF303l890RXLuXAYBfAwdmDGxGE1fbR+xpPCStFuWvv5KxYiWaB0/QZba22Iwbi/Wrr6JwcnzEEQShclhYWLB48WIWL15c5DaHDh0qdPmIESMYMWJEBUVWvjIyMgwz/v03gePs7JzvxjlPXsVTYeseJpfL+d///segQYPw9/dn7NixuLm5cfnyZS5dusTevXsB/axo/fr1o2PHjowfPx6lUsnKlSuxt7fn448/Nhzvs88+4+DBg7Rv357XXnuNZs2akZyczNmzZzlw4ADJycml/vyrVq1i3rx5HDx4kB49epR6/6SkJPbu3cvrr7/O+PHjC1RGlVb37t3p2LEjTZo04d69e6xZs4bMzEx2796drxJo48aN7Nixg27dumFjY8OBAwfYtm0br776aoFEZ15CJK83UUZGBk8//TQpKSlMnz6d33//Pd/2np6edOzYsUBsK1asAOCdd94xLOvfvz9vvfUWI0aMoFOnTsyfP59XX3212M84ffp0goODeeGFFxg3bhxt2rQhOTmZX3/9lW+++YZWrVoxYcIEvv32W8aMGUNoaCgeHh4EBwdz/Phxli9fnm8GvJJq06YNAJMnT+bpp59GoVCUuVm4hYUFf/75J6+88grt27fnjz/+4Pfff2fWrFmGf0f29va88MILrFy5EplMhqenJ7t37y60V1lpYluwYAH79++nS5cuvPnmm5iYmPDtt9+Sm5vLF198UabPY2zEvYRxeHgIXo4mh6ScJED0gBIEoWKU+a7ezs6ONm3aMHv2bPr370/jxo2LfKrYrFmzMgcoVA93z8YSfS4OuYmcwNGty34gdQ5seR5Sb4FjY3jxZzA1vl4qFSEtW8X/Dlzjl7PRSBLYWZoyqa83A1vXRf441WSVSNJoUO76mYyvVqJ5MCuRzN4em1fHYzNuLPJyeBotPHnmzZtHjx49iq2GOHLkCAcPHmTu3LmVGFn1kXczbGNjU2wFUFk9/fTTHDx4kHnz5rF06VJ0Oh2enp689tprhm369OnDn3/+ydy5c5kzZw6mpqZ0796dzz//PF9jaFdXV06dOsUnn3zCzp07Wb16NbVq1aJ58+Z8/vnn5R57SdStW5eYmJhym4WxTZs2bN++nZiYGOzs7Ojbty/z588vtOF1cnIy8+fPR6lU4uPjwzfffMOECRMeeY6kpCTu3tXPZvXBBx8UWP/KK68USEDFx8czf/58Nm3alO+z1q5dmx07djBlyhT279/Ps88++8h/azY2Nhw9epS5c+eya9cufvjhB2rXrk3v3r0NyQZLS0sOHTrEBx98wA8//EB6ejo+Pj7F9t56lCFDhvD222+zZcsWNm7ciCRJZU5AKRQK/vzzT9544w2mT5+Ora2t4ef3YStXrkStVvPNN99gbm7OsGHDWLx4cYEKvtLE1rx5c44ePcrMmTNZtGgROp2O9u3bs3HjRtq3b1+mz2NsxL2EccirgDI1MyHuQf8nW1NbbM2qz4NPQRCqD5lUxu6Ew4eXfCayrVu3luUU1VpcXBxr1qxhwoQJBZqa1jQ6rY7tk38nNToNv+eb0nFsm7IdSJJgx0gI/wnM7eHVf8DFt3yDNUKSJPHnhTi+2nuFlCz91NoD/N2Z9JQPjtblN+V8RZLUarJ37iTjq5Voo/R9L2QODthOeA3rsWOQ14ChAtVRTfk9NHz4cF544QWCgoKK3Gbnzp1s3bq1Wl9vKvLv68SJE3Tu3JnGjRsbhmoJgiD8V2VeN8S9RPl43L+zH0ZtJycjl2ErBxKhCOfz04vwdvRhSfcvKyBaQRBqotL8HipzBdTQoUOrVRNkoeJE7r1GanQaFnbmBLzQsuwHOvSxPvkkN4HhO56I5FNsipLPfrvEqRv6cudGLtbMGNiM1h4VP9tUeZA0GrKDg8lY/hXaB0/a5U5O2EycgPWYV5CXQ28UQSgJlUolpu8uRlH9nwRBEKqKuJcwDg/3gIpN01dAieF3giBUlDInoIYNG1aecQjVlCpbxZmfLgDQ9iU/zG3KWLFzfiMc/kT/esD/oHHvcorQOGl1EsEhd/jfX9fIUWsxN5EzrrsnIzp5YGoif/QBqpik1aL8+RfSv1yG9kG/EbmzMzZvTMT65ZeRP2i0KggVTZIkEhMTCQsLo5Zoal8kkYASBMHYiHuJqifpJDSqvB5QJv82ILcWDcgFQagYT05nZ6FCnN8VSU56Lg517Wj6tFfZDhIdAr+O17/uPAPaFN/YtLq7dT+Thb+EEx6dBkDrho7MfLY5DZyNP2kj6XTk/L6H9KVfGpqLy52csHnrTaxfGY28BDMsCUJJ/Hdoxvbt29m+fXux+/x3pi3hXyIBJQiCIPyXRq01vDYxVxCbGQOAu5gBTxCEClJjElCpqanMmDGDXbt2kZ2dTWBgIEuXLiUgIKBUx1Gr1bRq1YrIyEgWL17MtGnTKiji6i87VcmFXyMBaPeyP3JFGSp3Mu7B1iGgVYHPs9B7UTlHaTzUGh0/HrvJuiM30WglrMwVvN3Xh+fa1DP6JuOSJJGzbx/pi5eiidT/ncsc7LF9/XWsx40VFU9CuWvatKlhaEZERATOzs6FJk/kcjk2Nja0bNmSXr16VXaY1YZIQAmCIAj/lTf8DkBhpiA2SwzBEwShYpU5ATVv3rxHbiOXy7G0tKRu3boEBgbi6elZ1tMVS6fTMWDAAM6fP8/06dNxdnZm9erV9OjRg9DQULy8Sl6Zs3LlSu7cuVMhcdY0YdvC0eRocPGqRaMO9Ut/AI0KtgVBRiw4+8LgDSA3/uFnZXEpOpVPf7nEjfuZAHT2duH9gc2obW9RxZEVT5Ikcg8dIn3xEtTn9UMtZTY22Ex4DZvXXhXNxYUK8/HHHxteDx8+nJ49exbbhFwonkhACYJgbIzpXuJJpcnVV0ApzBTk6HJIy00FxBA8QRAqTpkTUBERESXe9vTp0/z888/07duXV18t/+FVwcHBnDhxgu3btxtuUIYNG4a3tzdz585l8+bNJTrO/fv3+eSTT3j//fcLTLEr5Jd+L4OIvfohWO1Hty5bE8k/34W7x8HcDl78GSxqXjIjV61lzcHr/HQiCp0EDlamvNe/KX1a1DH6xpu5x0+Q/sViVGfOACCztMR6/DhsJk5E4eRYxdEJT5JVq1ZhLarsHotIQAmCYGyM6V7iSfVvA3IFcVlxANibO2BlalWVYQmCUIOVOQG1adMmli9fTkxMDEOHDsXX1xd7e3vS0tKIjIxk586d1K1bl3HjxhEdHc2mTZvYv38/np6e9OzZszw/A8HBwbi6ujJkyBDDMhcXF4YNG8bGjRvJzc3F3Nz8kcf54IMP8PHxYdSoUSIB9QhnfrqATqOjnr8bdf3qlP4AZ7+DM/8DZDBkEzj7lHuMVe1ybBrzdl7kVkIWAE/7uTHlGV8crMvYqL2S5J4JJf3zL1CdOKFfYGGOzejR2Lz1Jgpn56oNTngiubi4VHUI1Z5IQAmCYGyM6V7iSWVIQJmZEJ99DwBXK9eqDEkQhBquzAmo4OBgbty4wdKlS7Gy+jdL7uzsTNeuXWnTpg3vvfce+/fvZ/jw4TRq1Ih3332Xv//+u9wvGmFhYQQEBCD/z/CtwMBA1qxZw9WrV2nZsmWxxzh16hQ//PADx44dM/rKlKqWFJXCtcO3AAh82b/0B4gOgd/f1L/u+Qn4DCy/4IyARqtj3ZGbrD9yE61OwsnGjA8GNaebr3Hf+KmvXiX9s8/J2btPv8DUFOuRI7B9exKKOmVIMgpCOdJoNJw5c4br16+TmZmJTqcrsI1MJuONN96oguiMn0hACYJgbIzpXuJJlTcEz8RcQXxWPCASUIIgVKwyJ6COHTtG+/bt810wHmZlZUX79u05evQow4cPx9bWFn9/f0JDQ8scbFHi4uLo1q1bgeVubm4AxMbGFpuAkiSJt99+m+HDh9OxY0eiHkwrXxK5ubnk5uYWWJ6ZmVniY1Q3pzacAwkad26IS5NSTnuenQTbXtA3HfcdDF1nVUiMVeVGfAaf7ArnSlw6AL2buzJ9QDOjrnrSxMSQsWQp2cE7QKcDuRyrYS9gO3UKJnVFE0qh6iUnJ7NgwQJiYmIeua1IQBWk1WpJSkoCRDWZIAjGw5juJZ5U/w7BMyE+W9+AvLZIQAmCUIHKnIBKSUlBoVAUu41CoSAlJcXwvlatWqjV6mL30el0qFSqEsVgbm6OTCZDqVQWOsTOwkLf4FmpVBZ7nPXr13Px4kWCg4NLdN6HLVq0qNAmim5ubkycOLHUxzN29yITuHMmBplcRruRrUq3s04Hu0ZD+l1w8oLn19eYpuNancTmE1Gs+fsaaq2EnaUp0wc2pW8Lt6oOrUja5BQyV64k84cf4UES1aLfM9i9PwPTUjTuF4SK9uOPPxITE0Pnzp3p3bs3tWrVeuT1R/hXcnKyoWLMWQyjFQTBSFTUvYRQcv9WQJlwP/tBBZS1SEAJglBxypyAcnJyIjQ0lBEjRhR68cgbLuHk5GRYlp6eXuRTjjxHjhwpcVltZGQkvr6+WFpaFlqFlJOTA4ClpWWRx0hPT2fmzJlMnz6d+vVLP5PbzJkzmTp1aoHl8fHxJW5+Xp2c+ek8AD69PXGoW8qm4ce/gGt7wMQChgXXmKbjd5Oy+GRXOBfvpgL6Ge5mPtscZ9tH9x2rCrrsbDLX/B+Z33yLlJEBgFnHjtjPmolZQOsqjk4QCrpw4QJNmzZl8uTJVR1KtZQ3/K5WrVqYmJT5si8IglCuKupeQii5h5uQx+cloKxE2wVBECpOmb+Jdu3alR07drBgwQKGDx+Ot7c3crkcnU7H1atX2bJlC/fu3WPo0KGGfa5cufLIJI+vry/r1q0rUQx5Q+zc3NyIi4srsD5vmbt70VOJLlmyBJVKxfDhww1D76KjowH9k5moqCjc3d0xMyt8CJW5uXmh1VdZWVkl+gzVSVzEfWLO30OukBHwQovS7Rx1BP6erX/dbyXU8Sv/ACuZJEnsDovhyz8uo1RpsTJXMLVfUwb4uxtlHzFJrSZr02Yylq9Al5AAgGnz5tjNfB/zHj2MMmZBAFCr1TRp0qSqw6i2RP8nQRCMUUXdS5RVamoqM2bMYNeuXWRnZxMYGMjSpUsJCAh45L6nTp1i/fr1hISEcOHCBTQaDZIkFbn9d999x5IlS7h16xb169dn8uTJvP322+X5cUokLwGlMFX8WwElhuAJglCBypyAGjJkCDdv3iQsLIy5c+cil8uxsbHJ1xzW39/fMDNdSkoKDRs2pEOHDsUet06dOowZM6ZUsfj7+3P06FF0Ol2+RuQhISFYWVnh7e1d5L537twhJSWF5s2bF1j36aef8umnnxIWFoa/v3+pYqqJQn+6AIB3b09sXW1KvmPmfQh+ESQt+L0MAeMrKMLKk5at4rPfIjgYob9YB3g48tHglrg5FF1tV1UknQ7lr7+SvngJ2qjbACgaNsBuxnQsn30WWQ0ZBinUXPXr1ycxMbGqw6i2RAJKEARjVFH3EmWh0+kYMGAA58+fZ/r06Tg7O7N69Wp69OhBaGgoXo9oTbBnzx7Wrl2Ln58fjRs35urVq0Vu++233/L6668zdOhQpk6dytGjR5k8eTLZ2dm8//775f3RiqVV6/+cdSY6crW5yJDhYiV6BQqCUHHKnIAyMTHhgw8+4MiRIxw+fJioqCgyMzOxtLSkUaNGdOvWje7duxu2d3R05N133y2PmAsICgoiODiYnTt3EhQUBEBiYiLbt29n0KBB+SqUbty4AYCnpycAkydP5vnnn893vPv37zNx4kTGjBnDc889R6NGjSok7uok7tJ9Yi7cQ24iL131k04LO0dBZhw4N4WB/4NqXmkTeiuJj3deJCE9F4Vcxuu9vRjRyQOF3Pg+V+7Jk6R9Mh/1hYsAyF1csH33HaxHvISsiKo+QTA2zz77LKtWrSI6Opp69epVdTjVjkhACYJgjIzpXiI4OJgTJ06wfft2w73EsGHD8Pb2Zu7cuY9sq/HGG2/w/vvvY2lpyaRJk4pMQCmVSj788EMGDBhg6D372muvodPpmD9/PhMmTMDR0bF8P1wxtCp9Dyi1XN9/t5alM6Zy00o7vyAIT57HbgbRrVu3Qmegq0xBQUF06NCBsWPHEhERYXhqodVqCzQI7927N4BhuF1AQECB0tq8dc2bNy+QnHpSndmir37y6e2Jbe1SVD8dXww394Oplb7vk5l1BUVY8dQaHWsOXmfj8VtIEjSoZcUnQX74uttXdWgFqK/fIH3hQnL27QdAZmODzRuvY/Paq8itq+/fgfBksrOzo02bNsyePZv+/fvTuHHjInuANGvWrJKjM34iASUIgjEzhnuJ4OBgXF1dDdVWoJ81dNiwYWzcuJHc3NxCW27kcXUt2bC1gwcPkpSUxJtvvplv+VtvvcWmTZv4/fffGTVqVNk+RBlo1foEVI5M3zdXDL8TqqvExERCQ0ORJEm0FSknecOIHR0d8ff3L/Z3YGnUiG6kCoWCPXv2MH36dL766iuUSiXt2rVj/fr1+Pj4VHV41V7spXhiH1Q/tS5N9VPMGTj4kf51/1VQu/reGN5JzGLOjgtcjk0H4NmAukzp54ulmXH9E9ImJpLx5TKyNm4CrRYUCqxHjcR26hQUYvYroZp6+EHCjh07it1269atFR1OtSMSUIIgCMULCwsjICAgXysPgMDAQNasWcPVq1dp2bJluZwHoG3btvmWt2nTBrlcTlhYWKUmoDQPKqBy0M8YLhJQQnWUmJhISEgIffr0KbckiaAnSRL37t3jwIEDBAYG4uLy+EN0jevu+TE4Ojqydu1a1q5dW+x2edVNxfHw8Ci2ceCTJq/3k28fT2xdSlg9o8qCHSNAp4FmL4D/mIoLsALlNRpfuucyOWotdpamzHy2OT2bGdcFWlIqyVz7HRmrvkbKzATA4qm+2H04C1PRvLla00k6bqff5nzCOZrVaoa345OXVB86dKh4mvUYRAJKEASheHFxcYVWYeVNeBQbG1suCai4uDgUCkWB38dmZmbUqlWL2NjYIvfNzc0tdNbvzAff+8oirwIqW9JPnuRqLWbAE6qf0NBQkXyqIDKZDDc3N3r06ME///xjGE32OEqcgBo+fDgymYwvv/wSd3d3hg8fXqL9ZDIZW7ZsKXOAQtWKvRRP7MV45CZy/INKUf305xRIvgZ29WDgN9Wy71N2roYvdkfw5wX9bIptGzkxZ0hLattZVHFk/5J0OpS7fib9s8/RPvjSYtqyJfZzPsK8U8cqjk4oq4Ts+5xLOMf5hHOcTzhPWm4qAM95Pv9EJqCGDRtW1SFUayIBJQiCMaisewmdTodKpSrRtubm5shkMpRKZaE3rxYW+u98SqWyxOcvjlKpLHJmbQsLi2LPs2jRogKtRUCfJJs4cWKZ4snrAZUl6ZNYta3EdUKofiRJEsmnCmZtbY1arS6XY5U4AdW0aVNkMpnhLzfvvVCzhW0LB0pZ/RS5C87+HyCDwT+ClVPFBVhBrt3LYPb289xOzEIhlzGhZxNe7tIIuRE1Gs89foK0+QtQX9Q3GFe4u2P3wftYDn5ezGxXzWSqMrmYeOFBwukcMZkx+dZbKCxo4dwCTwdRzSaUnkhACYJgDCrrXuLIkSP07NmzRNtGRkbi6+uLpaVlodVFOTn63kiWluUzy7GlpWWRybGcnJxizzNz5kymTp1aYHl8fPwjm6QXJS8BlSFlAOBqJSqghOpH5CQqR3n9OZc4AfXxxx8X+16oeRKuJxF9Lg6ZXEarIc1LtlN6DPz6qv515xnQqGRfAIyFJEn8EhrNsj8uk6vR4WJnzvygVvg3rLwZSR5FfeMm6fPnk7P/AKBvMG779iRsxo9DVk5fkISKpdaquZwcyfmEc5xLCON6ynV06Azr5TI53o7etHLxp5VLa3ycfMSsNA9cvnyZW7dukZWVhZWVFY0bN8bX17eqwzJqIgElCIIxqKx7CV9fX9atW1eibfOG2Lm5uREXF1dgfd4yd3f3conNzc0NrVbL/fv38/1OVqlUJCUlFXsec3PzQqs8srKyyhyP5sEQvAydvsep6AElCEJFK/ceUBkZGURGRmJmZoafn1+BZn5C9XFuxyUAmnTzwM61BDPf6XTw8xhQJoNbAPT8pGIDLGdZuRo+/y2CfRf1XzY6eTkzZ3BLHKwLL5WubLr0dDJWfEXmd9+DWq1vMP7yKGynvCsajBs5fR+nKM7dD+NcwjkuJV1Cpc3/pLWeTT1aufjjX7s1LZxbYm0qZit82M2bN1m5cmWh/THc3d2ZNGkSnp6eVRCZccvJySE9XX9jIRJQgiBUB497L1GnTh3GjBlTqn38/f05evQoOp0u3/lCQkKwsrLC29u7VMcr7jwAZ86coX///oblZ86cQafTGdZXFq1K//BLI1cjl8lxsqx+oxYEQaheypyA2rdvH4cOHWLWrFnY2OiTEzdv3mThwoWGZnienp7MmTPHMH5aqD5So9O4efIOAP5DS1j9dOYbuHkATCxh6GYwMY7ETUlcu5fOh9vOcycpG4Vcxuu9vRjZycMohtxJWi3ZW7eR/vkX6BITATDv1RP7OR9h6uVVxdEJRUnLTSPs/lnOxocSlhBm6OOUx9HcUV/hVNufVi7+OFuKJGJR7t27xyeffIJSqcTX15fmzZvj6OhISkoKly5d4vLlyyxYsIBPP/3U8DRb0EtISADA1NQUe3v7Ko5GEAThX8Z0LxEUFERwcDA7d+4kKCgI0M+stX37dgYNGpSv8ujGjRuG2EqrV69eODk58b///S9fAup///sfVlZWDBgw4DE/SenkNSHXKnQ4WdRCIVNU6vkFQXjylDkBdeLECWQymeGCAbBhwwaysrLo2bMnqamphIWFsX//fgYNGlQuwQqV59zOCJCgYWA9nBo4PHqH5Juwf7r+dd/Pwbn6NEr+JTSapXsiUWl0uNpbMD/ID78GxjHkLjckhLQ5H6MO1/fiMvH0xH7uHCx696riyIT/0ug0XEm+rE863Q/lRuoNJP6dTVPfx6nlgyonfxrYNhRj1ksoODgYpVLJu+++S8eOBZvr//PPPyxfvpwdO3YwadKkKojQeD08/E78vAmCYEyM6V4iKCiIDh06MHbsWCIiInB2dmb16tVotdoCjb/zZoF6eGbt27dvs2HDBkBfzQSwYMECABo2bMjLL78M6HtAzZ8/n7feeosXXniBp59+mqNHj7Jx40YWLlyIk1PlViDl9YDSKbTiQZggGLnz58/j7+/P5cuX8fHxYdmyZaxYsSLf76LiLFy4kJCQEEJCQrh//z5z586tkrZKZU5AxcXFERAQYHifnp5OREQEvXv3ZsKECQDMmjWLY8eOiQRUNZOZkMW1QzcBaB1UguonnQ5+GQfqbGjYHdq9VcERlo9ctZYleyL57ay+4XNnbxfmDG6BvVXVV25poqNJX7AQ5W+7AZDZ2WE35V2sx7yCrIjZU4TKdz/7PmfvhxIWf5bzCefI1mTnW9/IvjEBtdsQUDsA31pNRR+nMrp48SKBgYGFJp8AOnToQNu2bbn4oCG/8C/R/0kQBGNlTPcSCoWCPXv2MH36dL766iuUSiXt2rVj/fr1+Pg8+qHqrVu3+Oijj/Ity3vfvXt3QwIK4M0338TU1JSlS5fy66+/Ur9+fZYtW8Y777xTvh+qBPIqoHQKLS6WLpV+fkEQSi4kJAQnJyfDkOCTJ0/SoUOHEu8/e/Zs6tSpQ+vWrdm7d29FhflIZU5AZWZm5ivnv3LlCgCBgYGGZb6+vhw+fPgxwhOqwvlfItFpJdxbuOLqU4KL0emv4fZhMLWG576HatD3KzZFyaxt57gcm45cBq/39mJU56qf5U6XnU3m6v+R8b//QU4uyOVYjRiB3YxpKGrVqtLYBMjV5hKeeNEwtC46MzrfelszO1rXbk1A7Ta0rt0aRwvRS6E8ZGRkULdu3WK3qVu3LmfPnq2kiKoPkYASBMFYGdu9hKOjI2vXrmXt2rXFbldYtUGPHj2QJKngxkV47bXXeO2110obYrnTqPKG4IkKKEEwdqdOnSIwMNBQ0X7y5MlCZ8Ysyq1bt/Dw8CAxMREXl6pLOJc5AWVjY2NobAoQERGBXC7P16RPJpMVOdWoYJyU6Tlc3ncNAP+SVD8lXYf97+tf9/0CnBpXYHTlI+R6Ih8FXyBdqcbBypRPgloR6Fm1yR1JklD+8gvpCz5F+2DGFbOOHXGY9zGmzZtVaWxPMkmSiMmMJjT+DGfvn+VSYjgq3b+/0+TI8XHypXXtANq4tqGxg6fon1AB7OzsiI6OLnabmJgYbG1tKymi6kMkoARBMFbiXqLq/VsBpcNZVEAJgtFJSUlBq9X/Ow0JCeGZZ54hMTGR+Ph4oqOj8fLyIjExEQsLi3zDmQvj4eFRCRE/WpkTUHXr1iU0NJSMjAzkcjknTpzA09MTKysrwzYJCQk4ODiUR5xCJQn/7QqaXC3Onk7U839EM1+dVj/rnUYJjXpB29crJcay0ukkfjh6kzUHryNJ0KyuHZ8O86eOg2WVxqWOiCT1ww9RnToNgKJ+few/mo1F/36iZ0sVUGlVhCde5Ez8ac7cO8297Hv51jtbOj+ocAqglUsrbMxE0qOitWjRgmPHjnH8+HE6d+5cYP0///zDmTNn6NKlSxVEZ9xEAkoQBGMl7iWqnugBJQjGrXXr1ty+fdvwPjw8nCVLlhje5w1PfuWVV1i/fn1lh1cmZU5A9e/fn8WLF/P666+jUCjIzc1l5MiR+ba5du2amBa7GlHnaoj44yqgn/nukcmPkJVw9ziY2cCz3xn10LsMpZpPdl3k6BX9jFDPtanH1H6+mJtWXbWKLi2N9KVfkrX+B9BqkVlaYvv2JGwmvIbMsmqTYk+aRGWiIeF0PuEcudpcwzoTuQnNa7WgjWtbAmq3ob5tfZEYrGRBQUGcPn2ar776ir179xpmwUtNTTXMgmdpacnQoUOrOlSjIxJQgiAYK3EvUfW0ap3+/wqtqIASahRJkpCUyqoOw0BmaVmm+4dNmzahVCo5cuQIixYt4rfffsPExIQvv/yShIQEFi1aBIC7u3t5h1xhypyAatu2La+99hoHDhwAoEuXLnTr1s2w/tKlS+Tk5ODv7//YQQqV49rfN8nJyMXW1YZGHeoXv3FKFPz9of71U0vA0aOiwyuzm/czmfFTGNHJ2ZiZyJnWvynPtqlXZfFIkoQyeAdpCxaiS0wEwHLgQOzmfIRJ3erzy6M600pariZfMSSdbqXfyrfeyaIWbV3b0ta1Ha1q+2NpIhKCValOnTp89NFHfP3111y5csXQJySPu7s7b731Fm5uj6jafAKJBJQgCMZK3EtUPY1KA4DORIuLlUhACTWHpFQS52U8s7K7XbuC7KHqzpLKq/zfs2cP7dq145lnngHg3Xff5YUXXqBPnz7lGmdlKHMCCqBPnz5FfujmzZuzbt26xzm8UIkkncSFXyMBaDnIF7mimGomSYLf33ww6103CKj6JopFOXrlPnODL5Ct0lLH3oJFw/1pWtf+0TtWEPWlCFI/nI3qtH64nYmnJ/YL5mPRrWuVxfSkyFBlcPZ+KGfunebs/bNkqP7tOyFDhrejD23rtKOtazsa2zcWVU5GpkmTJixbtowrV65w69YtsrOzsbKywsPDA19f36oOz2iJBJQgCMZM3EtUrbwm5HITOfZmVff9WBCEgtLS0lCr1QD89ddf9OrVi8TERJKTk7l06RILFiwgMTERU1PTfBM6GLvHSkAJNced0BjSYjMwszbFp/cjSp0vbYPrf4DCDAZ+a5RD7yRJ4sejt/jm72tIEgR4OPLpMH8crM2qJB5dWhrpS5bqh9vpdMisrLCd8i42r45HZlY1MdV0kiQRnXmXU3EhnI4/zeWkSHToDOutTa0JqN2Gtq7tCHBtg7159fnF/STz8fEp0ZTYgl5Cgn7YsUhACYIgCP+V14Tc3tpePHgTahSZpSVu1648esNKUpb2Ks8991y+WUAvXLjA8uXLDe8HDx4MQPfu3Tl06NDjhlhpRAJKAODCz/rqp6ZPeWFmZVr0hsoU+GOy/nXXD8HF+CoPclRaFv4Szv5wffPooe3qM6WfLybFVXVVEEmnIzt4B+kLP/13uN2ggdjPmYPCXQwXKm9aScvlpEhO3QshJO4fYrNi861vYNuQtnXa0tY1kKZOTVHIxYx11YFKpSI9PR0HBwdMTApettRqNWlpadjZ2WEmEroGkiQZKqCqcrpdQRAEwfjotDrynss52ThWbTCCUM5kMlmZhrwZk6VLl5KSksLJkyeZN28eu3fvxsTEhJUrVxITE8Nnn30GgKNj9fr3KxJQAgk3kogNj0cml9FiwCMqC/bPgKz74OwLXd6vnABLIT5NyYyfznElLh2FXMZ7/ZsypN0j+llVEFX4JdI+nI3qzBkATJo0wX7+J2K4XTnL0eRw7n4YIff+4fS9U6Q/NLTORG6Cn3Mr2tUJpK1rO1ytXaswUqGsgoOD+f333/n2228LnWI2NzeXd999l0GDBjF8+PAqiNA4ZWRkkJurb6gvElCCIAjCw/JmwANwsnWqwkgEQShMmzZtADh69CgtWrQw9H+aPXt2scOXjZ1IQAlc+EVf/eTZpSE2LtZFbxh1GM6u1b8etAZMzCshupK7eDeV97eEkZypwsHKlE+H+xPgUfkXVF1WFumLl5D13fdiuF0FSclJ4fS9U4TE/cP5hHOodCrDOhtTG9q6tiPQrT0BtdtgZVq9n34IEBYWRsuWLQtNPgHY2NjQsmVLzp49KxJQD8mrfrKxsck3rbkgCIIgaNT/JqBq2ThXYSSCIBTn+PHjdOrUCYCcnBzCwsKYNWtWqY+zYcMGbt++TXZ2NgBHjhxhwYIFALz88ss0bNiw/IIuhkhAPeEyE7O4eew2AH7PNi16Q00u/DZR/7rNBGhoXFU8u8Ni+Py3S6i1Ek1cbfjipQDcHSt/5jLl3r2kzZ6DNlY/9MtiwAAcPp4rhts9prx+TiFx/xASF8LVlCtISIb1rlautHfrQGCd9jSr1RwTufjVVpMkJCTQsmXLYrdxc3Pj8uXLlRRR9SAakAuCIAhFyauA0sm1uFiLKllBMEZarZaQkBDGjBkDQGhoKCqVio4dO5b6WN99912+nlIHDx7k4MGDgH4WUpGAEirFpd+votNKuDWvjYtXraI3PL4Ykq6ATR3o83nlBfgIOp3EN39d48djtwDo3rQ2cwe3xMq8cn+0NTGxpM2ZQ86fewFQ1K+Pw6cLsejVs1LjqEl0ko6rKVc4GXui0H5OXg7etHdrT2CdDjS0ayiaZ9ZgWq32kX+/MpnMMFOIoCcSUIIgCEJRtGp9AyitQoezpaiAEgRjpFAoyMjIMLzv3LkzkiQVs0fRjKVRuUhAPcHUuRoi910DwO+5YqqfUm/D0U/1r5/+EiwdKj64EshRa5m/6yJ/XYoHYGy3xrzWswlyeeUlIiSNhqzv15G+ZClSVhaYmGDz+kRs330HeRlmO3jSaXVawpPCORl7nH/iTpKck2xYZyI3oZWLP+3rdKBdnXbUEl+Wnhi1a9cmIiKi2G0iIiJEn6P/EAkoQRAEoSiGCiiFFmdLcf0UBKFyiATUE+zGkShyM1XYutrQoG3dojf8cwpolNCwO7R4sfICLEZyZi4zfgojPDoNE4WMWc82p79/MZ+hAqjOnSP1/Zmow8MBMGvbFofPF2Hqa3wzAxoztVbNuYQwfaXTvRAyHmoibmViRbs6gXRw60jr2gGin9MTqm3btvz888/88ssvPPfccwXW//zzz9y8ebPQdU8ykYASBEEQiqLMUQL6BJSLSEAJglBJRALqCSVJEuG/XwGgeT9v5Ap54Rte3wuXd4FMAf1XgREMc7qVkMl7m84Sm6LE1sKEz15sTZtGlddsXJeRQfrnX5C1/geQJGT29th/OAurl15EJi/iz1HIJ0eTQ2j8GU7GneD0vVMoNUrDOjszOzq4daSjeyf8XFphKjetwkgFYzBo0CCOHTvG5s2bOXnyJH5+fjg5OZGcnMz58+eJiorC2dmZZ599tqpDNSoiASUIgiAUJTlTX2UuKSSsTYuZhEgQBKEciQTUEyr+cgJJt1JQmCnw6eNZ+EaaXPhjsv51+7fBtUXlBViEMzeT+GDrOTJzNNR1tOTLUW1o6Fw5F01JksjZ8wepc+agu6cf9mc5ZDD2cz5CIYb+PFKmKpPT8ac4GXuCs/Gh+Wauq2VRiw5uHenk3plmtZqjkCuqMFLB2NjY2DB37ly++uorrl27xq1bt/Kt9/b25u233y5ylrwnlUhACYIgCEVJyUoBQGYqE300BUGoNDUmAZWamsqMGTPYtWsX2dnZBAYGsnTpUgICAkq0v06n49tvv+Xbb7/lypUrWFlZ0apVK5YtW0arVq0qOPrKl1f91KSbBxa25oVvdHIZJF0Fa1fo8XHlBVeE3WExLPr1ElqdRMv6DnzxUmscrc0q5dzae/dInfUhOXv3AaDw8MBh0adYdDOu2QCNTXpuGifjTnIi9jgXEs6jlf6d8reOVR06unemk3snvBy9kctE9ZhQtNq1a7NgwQJu3rzJtWvXyMrKwtraGi8vLxo3blzV4RklkYASBEEQipKSmQqAwkx8/xIEofLUiASUTqdjwIABnD9/nunTp+Ps7Mzq1avp0aMHoaGheHl5PfIY48aNY9OmTYwePZpJkyaRlZVFWFiY4Qt8TZKVnM2tE3cAaN7fu/CN0qLhyHz966cWg4V9JUVXkCRJrPn7OuuO3ASgT4s6fPR8C8xNK75KRtLpyN78E2kLFiJlZICpKbZvvoHt5LeRWVhU+PmrowxVBidjT3A89hjnE86hk3SGdQ1sG9LJvRMd3TvhYddIPHETSq1x48blmnDKzc1lzpw5bNiwgZSUFPz8/FiwYAF9+/Ytdj8PDw9u375d6LomTZpw7dq1couxrEQCShAEQShKelYaACYmNeJ2UBCEaqJG/MYJDg7mxIkTbN++naCgIACGDRuGt7c3c+fOZfPmzcXuv23bNn744Qd27tzJ4MGDKyPkKnV533V0WglXXxdcPGsVvtG+aaDOhgZdwG9U5Qb4EI1Wx+e/RfBbWAwAY7o1ZkIlzXSnuXWLlOnvozp5EgDT1v44LlksmowXIlOVQUjcPxyLPca5+2H5Kp087T3pVLcLHd06Uc+2XhVGKQgFjRkzhuDgYN599128vLxYv349/fv35+DBg3Tp0qXI/ZYvX05mZma+Zbdv32b27Nk89dRTFR12iYgElCAIglCUdGUGJthgaiZ6bQqCUHlqTALK1dWVIUOGGJa5uLgwbNgwNm7cSG5uLubmRQwzA7788ksCAwMZPHgwOp0OpVKJtXXNbMan1eiI+FP/ZL7FgCKqn+6cgEtbARn0W1lljceVKg2zt1/g+NUE5DKYMbAZz7etX+HnlTQaMtf8H+lLl0JOLjJLS+xmTMd6/DhkCtGbKE+WOotTcSEcjTnCufthaCSNYV0ju0Z0rtuVLnW74G5TubMTCkJJnTp1ii1btrB48WKmTZsGwOjRo2nRogUzZszgxIkTRe77/PPPF1i2YMECAEaOHFkh8ZaGVqslMTEREAkoQRAEoaAMZQaO2GBmXjntLARBEKCGJKDCwsIICAhA/p8ZyAIDA1mzZg1Xr16lZcuWhe6bnp7OqVOnePPNN5k1axYrV64kMzOTRo0a8dlnnzFs2LDK+AiVJuqfu2SnKLF0sKBRxwYFN9DpYO8U/euA8eDmX6nx5UnNUvHe5rNcik7D3ETO/Bda0c234m+iVOGXSJ02HfXFiwCYd+2Kw+eLMGnYsMLPXR1kq7M5dS+EYzFHOXs/FI3u36RTQzsPutTtSmf3LqLSSagWgoODUSgUTJgwwbDMwsKC8ePHM2vWLO7evUv9+iVPem/evJlGjRrRqVOnigi3VJKSkpAkCZlMRq1aRVS6CoIgCE+srJwsHAELs6If0guCIJS3GpGAiouLo1u3bgWWu7m5ARAbG1tkAurGjRtIksSWLVswMTHhiy++wN7enhUrVvDiiy9iZ2fHM888U+S5c3Nzyc3NLbD8v0MzjEVe8/GmT3uhKKyHUvgWiDkFZjbQc34lR6cXm5LNuxtCuZOUjZ2lKUtGtMavgWOFnlPKySF92XIy//cNaLXI7O2xn/sRVsOGPfF9ipQaJafvneJYzFFC48+g1qkN6+rb1qdL3W50du9CA7tCEpqCYMTCwsLw9vbGzs4u3/LAwEAAzp07V+IEVFhYGJGRkXz44YflHmdZ5A2/q1WrlujvIQiCIBSQlZMFgIWZ6GkqCELlMbpvpTqdDpVK9egNAXNzc2QyGUqlstAhdhYPmkQrlcoij5GXKEpKSuKff/6hffv2ADz77LM0atSIBQsWFJuAWrRoEfPmzSuw3M3NjYkTJ5boc1SW5Dup3Iu4j0wuo9nThTRmVyvhwAf6111mgm2dyg0QuBqXzpSNoSRlqqhjb8Gyl9vQyKVip1bPPXWK1Pemo7mpb3Ju0b8/Dgvno3iCh62odWrO3Q/jcPQhQuL+IVf7b5K1rk1dutTtSte63WhgJyrDhOorLi7O8KDiYQ8/vCipTZs2ASUbflcZDy5E/ydBEAShKFnqLLQafb9OSwvLKo5GEIQnidEloI4cOULPnj1LtG1kZCS+vr5YWloW+mU+JycHAEvLon+x5q1r1KiRIfkEYGNjw6BBg9i4cSMajabIJ8gzZ85k6tSpBZbHx8c/svl5ZYvcdx2AhoH1sK5lVXCDk19C+l2wbwAdp1RydHDmZhIztoSRnavF09WGZaPaUNuu4p7K6LKzSf/sc7K++x4Aee3aOHy6AMt+/SrsnMZMJ+mISIrgSPQhjsccI0OdYVjnZu1O17pd6Vy3Kx52Hk98VZhQMzzOw4uH6XQ6tmzZQuvWrWnatOkjt6+MBxciASUIgiAUJVGZgEyrb11iaiqakAuCUHmMLgHl6+vLunXrSrRt3lNqNzc34uLiCqzPW+bu7l7kMfLWubq6FlhXu3Zt1Go1WVlZ2NvbF7q/ubl5oTcwWVlZj/4AlUiTq+HaQX2FT9PCqp8y7sHRRfrXfT4D08p9GvJ3xD3mBl9ArZVo7eHIFy+2xtay4i6IuadOkTLlPbRRUQBYvTgc+49mI3dwqLBzGiNJkohKv8Whu4c4GnOYRGWiYZ2juSNd63Wje70eNHHwEkknocZ5nIcXDzt8+DAxMTFMmVKyxH1lPLgQCShBEAShKInKROQ6fQJKbiJ/xNaCIBiD8+fP4+/vz+XLl/Hx8WHZsmWsWLGCqAf3s8W5fPky33//Pfv27ePGjRvY2NgQEBDAvHnzaNu2bcUH/xCjS0DVqVOHMWPGlGoff39/jh49ik6ny9eIPCQkBCsrK7y9i5jtDX0Cqk6dOsTExBRYFxsbi4WFBba2tqWKxxjdPHmH3EwVNrWtqdeqkKF1f88GdRbUbQ8tXqzU2HaHxfDpL+HoJOjZzJWPh7TEvLD+VOVAp1SS/vkXZK39DiQJhZsbDos/x6KEVXc1xb2sOI5EH+Zw9GHuZtwxLLcysaKje2d61O9BC+eWKGRi1j+h5nJzcyv0d39JHl48bNOmTcjlcl566aUSbV8ZDy5EAkoQBEEoSoIyAfmDCiiFSEAJQrUQEhKCk5OTIbdx8uRJOnToUKJ9165dy3fffcfQoUN58803SUtL49tvv6VDhw78+eef9OnTpyJDz8foElBlERQURHBwMDt37iQoKAiAxMREtm/fzqBBg/J90b9x4wYAnp6ehmXDhw9nxYoV7N+/n759+xr2/+WXX+jVq1eB2fWqo8i9+uF3Tfs2Qa74z+eJvwhh+mFoPLMMKrHSZevJ2yz78zIAgwLq8sGg5ijkFXP+3NNnSJkyFe2tW8CDqqe5c5D/pwFxTZWSk8LxmKMcjj7MlZTLhuWmclPa1QmkW73utHVth5lCTMcrVC/x8fHMnz8fmUzGypUrS7yfv78/Bw8eJD09PV8j8pCQEMP6R8nNzWXHjh306NGjxAmryiASUIIgCEJR4rPikev0DxnlptX/PkcQngSnTp0iMDDQMCrl5MmThVbUF+all17i448/xsbm397K48aNo2nTpnz88cciAVVaQUFBdOjQgbFjxxIREYGzszOrV69Gq9UW6LPRu3dvgHylajNnzmTbtm0MHTqUqVOnYm9vzzfffINarebTTz+tzI9SIVKi0wzNx316exbc4MBMQIJmL0D9jpUSkyRJfH/4Bv93UJ8QfKljQyY/7VMhw7wkpZL0JUvJ/HYNSBLyOq44fvEFFr17lfu5jE2uJod/7v3DwTt/cy4hDJ2kA0COnJYufnSv14OO7p2wNrWu4kgFoey0Wi0JCQml3i8oKIglS5awZs0apk2bBugTSuvWraN9+/aGGfDu3LlDdnY2vr6+BY6xZ88eUlNTS9R8vDKJBJQgCIJQlJjMaDEETxCqgZSUFLRa/YQBISEhPPPMMyQmJhIfH090dDReXl4kJiZiYWGRL7n0X23atCmwrFatWnTt2pVDhw5VVPiFqhEJKIVCwZ49e5g+fTpfffUVSqWSdu3asX79enx8fB65v6urK8eOHWPatGksW7YMtVpNx44d2bhxI61ataqET1CxLj9oPt6gbd2CzcdvH4Vrv4NMAb0WVEo8kiSxYu8Vtpy8DcCEnk0Y271xhSSfVKFnSZkyFc2DyjerF4Kw/3huje71pG8mfom/7/zF8dhjKDX/NlL2dvSmW70edKnbFScLpyqMUhDKj6urK6tWrSr1fu3bt+eFF15g5syZ3L9/nyZNmvDDDz8QFRXFd999Z9hu9OjRHD58GEmSChxj06ZNmJubM3To0Mf6DOUtLyEnElCCIAjCf8VkxmCv018fFBXU9kIQhMfXunVrbt++bXgfHh7OkiVLDO8HDRoEwCuvvML69etLffx79+7h7Oz82HGWRo1IQAE4Ojqydu1a1q5dW+x2RTXpaty4MTt37qyAyKqWRqXl6t95zceb5F8pSXDgA/3rgFfBueheWeVFq5P47NdL/Bam77sypZ8vwzs0LPfzSDk5pC/9ksxvvgWdDrlrbRw+/xzLvpVXXljZYjNjOHj3bw7ePcj97HjD8tpWrvSq34se9XviblO3CiMUhIqhUChwcXEp074//vgjH330ERs2bCAlJQU/Pz92795Nt27dHrlveno6v//+OwMGDChyooqqklcBVdY/F0EQBKFm0uq0xGXG4qDV94QVPaCEmkiSJHLU2qoOw8DCVFGmYotNmzahVCo5cuQIixYt4rfffsPExIQvv/yShIQEFi3STyJWljYQR48e5eTJk8yePbvU+z6OGpOAEgoX9c8dcjJysa5lRf3W//nBvLob7p4AEwvoPqfCY1FrdHy88wJ/XYpHLoMPn2/BAP/yT4ioLlwgZfK7aK5dA8By6FAcPvm4RlY9ZagyOBZzlIN3/+Jy8r99nSxNLOlStyu96vemaa1myGXiy4UgFMbCwoLFixezePHiIrcpqjTZzs4OpVJZ6LqqJobgCYIgCEX5sMNHhJ+/Tg4aMQRPqJFy1Fp6LvyrqsMwOPhhbyzNSp966dy5M6Bv+dCuXTueeeYZAN59911eeOGFMvduun//PiNGjKBRo0bMmDGjTMcoK5GAquHymo/79vXM33xcp33Q+wlo/w7YVWzz3Fy1lplbz3HiWiImChnzg1rRs5lruZ5D0mjI/Ho16V8uA40GuYsLDl98huVTT5XreaqaRqfhbHwof9/9i1P3QtDoNIC+r1Nr1wB61u9Fe7cOmCsKzrIlCELNl5OTQ3p6OiASUIIgCEJ+CrmCNq5tSbFUcoPbogJKEIxUWloaarUagL/++otevXqRmJhIcnIyly5dYsGCBSQmJmJqalqqSvysrCwGDhxIRkYGx44dK7Z3VEUQCagaLC02ndjweH3z8T7/GX53YRMkXAILB+jyfoXGkaPSMmNLGKduJGFuKueLF1vTvkn5jjXV3LpFyjtTUIWGAmAxYAAOny1C4eRYruepSjdSr/P3nb84HH2IdFW6YbmHXSN6NehNt3rdRV8noUaYNGlSmfYr7Sx4NVVe/6fSfiERBEF4kqWmpjJjxgx27dpFdnY2gYGBLF26lICAgEfue+rUKdavX09ISAgXLlxAo9EU2jcQKHIYzqJFi/jggw8e6zOUhlbzYGIakYASaiALUwUHP+xd1WEYWJSh19pzzz3H4cOHDe8vXLjA8uXLDe8HDx4MQPfu3UvcSFylUjFkyBAuXLjA3r17adGiRanjelwiAVWDXflL3/upXms3bF0emuVMkwsHHwy56/IBWFZckkap0jBtcxiht5KxNFOwdGQAAR7llySRJInsTZtJm/cJUnY2MltbHBYuwHLI4Appal7Z0lXpHLl7iP139nMr7aZhuYO5A93r9aRXg140sm9cdQEKQgUo6kt7Re1X0zw8/K4m/B4UBEGoaDqdjgEDBnD+/HmmT59umFG7R48ehIaG4uXlVez+e/bsYe3atfj5+dG4cWOuXr1a7PZ9+/Zl9OjR+Za1bt36sT9HaegMCSjRhFyoeWQyWZmGvBmTpUuXkpKSwsmTJ5k3bx67d+/GxMSElStXEhMTw2effQboe2GXhE6nY/To0fz1119s27aN7t27V2T4RarefytCkXRaHVcP6hMWPr0986888w2k3QZbdwh8u8JiyMrVMG3TWcJup2BlpuDLUW3wb1h+yS7t/fukTJtB7l/68b1mHTviuGIZJnWrd6NtraTlQsJ59t/exz9xJw1D7EzkJnR060SvBr3xd2mNQi6+MAg109dff13VIVRrov+TIAhC6QQHB3PixAm2b99OUFAQAMOGDcPb25u5c+eyefPmYvd/4403eP/997G0tGTSpEmPTEB5e3szatSocou/LLQPGjSLIXiCYJzatGkD6JuFt2jRwtD/afbs2fTp06fU/Z/efvtttm7dyrfffsuQIUPKPd6SEgmoGir2YjxZSdmY25jRsF29f1eosuGovls+3eeAmVWFnD8rR8O7G0O5eDcVa3MTVrzchhb1Hcrt+Mo//iB1+vvoUlLA3Bz7D97H+tXxyOTV9yJ6LyuOv+4c4K87f5GoTDAsb2zvSZ+Gfelerwe2ZrZVGKEgCNWBSEAJgiCUTnBwMK6urvluylxcXBg2bBgbN24kNzcXc/Oie2u6upa+r6lSqUQmk2FhYVGmmB+XoQLKtPp+dxaEJ8Hx48fp1KkToO/zGRYWxqxZs0p1jOXLl7N69Wo6duyIlZUVGzduzLd+8ODBWFtbF7F3+RIJqBrqyl83APDs6oGJ2UOVMmf+B1nx4OABrcdVyLkzlGre3RjKpeg0bC1MWDG6Lc3qlk8fEl1GBmlz5pK9bTsAps2a4bhyBaa+vuVy/MqWq83lZOwJDtzez4XE84blNqY2dK/Xgz4Nn8LTwbOYIwjCkyczM5OcnBycncu3l1xNIRJQgiAIpRMWFkZAQADy/zzIDAwMZM2aNVy9epWWLVuW2/nWr1/P6tWrkSSJpk2bMnv2bEaMGFFuxy+JvB5QogJKEIyXVqslJCSEMWPGABAaGopKpaJjx46lOs65c+cAOHnyJCdPniyw/tatWyIBJZRdbpaKW//cBcCn90P9gVRZcOxz/etus0FhWu7nTstW8c6GUC7HpmNnacpXo9vi625XLsfODQkhZfK7aKOjQSbD5q03sZs6BVkxT6SMkSRJXE+9zv7b+zgafZgsTRYAMmS0cvGnT8O+dHDriJnCrIojFQTjkZOTw7Zt2zh69Cjp6enIZDK2bNkCwLVr1wgODmb48OE0bix6ookElCAIQunExcXRrVu3Asvd3NwAiI2NLbcEVKdOnRg2bBiNGjUiNjaWr7/+mpEjR5KWlsYbb7xR5H65ubnk5uYWWJ6ZmVmmOHSiCbkgGD2FQkFGRobhfefOncvU83T9+vWsX7++HCMrO5GAqoFuHr+NVqXFsb49Lk1q/bvi9GrITgDHxtBqdNEHKKO0bBVv/3iGq3EZOFiZsvKVtnjVefzkk6RWk7FsORkrV4FOh6JBAxxXLMM8MLAcoq48maoMDt49yL7be7mdHmVYXmvl/VEAAFDjSURBVNvKlT4N+tCrQR9qW4kbRkH4r+zsbD766COio6Px8PDAzs6O6Ohow/oGDRoQGRnJ8ePHRQIKkYASBOHJptPpUKlUJdrW3NwcmUyGUqksdIhd3vA4pVJZbvEdP3483/tx48bRpk0bZs2axZgxY7C0tCx0v0WLFjFv3rwCy93c3Jg4cWKp48hLQCnKMDuXIAhCWYkEVA2UN/udd6/G/86AlJsJx7/Qv66A6qcMpZp3N4RyNS4DR2szVr3SFk/Xx+9XpLl9m+RJk1GfPQuA1bAXsJ//CXIbm8c+dmWQJInLyZH8GfUnx2OOotLpvxCZyk3p5N6ZPg370tLZD7lMPH0ShKLs3LmT6Oho3nzzTbp378727dsJDg42rDc3N6dZs2aEh4dXYZTGQySgBEF4kh05coSePXuWaNvIyEh8fX2xtLQstLooJycHoMikUHkwMzNj0qRJvP7664SGhtKlS5dCt5s5cyZTp04tsDw+Pv6RTdILk9eEXFRACYJQmUQCqoZJjUkn/nICMrkMrx6N/l1x+mvITgRHT/B7uVzPmZWjYcrGUCJj07G3Mi235FP2rl2kfjALKTMTmZ0dDp8twuq5Z8sh4oqXqcrg0N2D7L39J7fTbxuWN7Tz4GmPZ+hRrwc2oqG4IJRISEgIrVq1Kna6WGdnZ27cuFGJURkvkYASBOFJ5uvry7p160q0bd4QOzc3N+Li4gqsz1vm7u5efgEWon79+gAkJycXuY25uXmhVVpZWVllOqdO9IASBKEKiARUDXP1b331U/3Wblg7PZjhLjcDji/Wv+7+ESjK7689O1fD1E2hhEenYWdpwsrRj5980mVkkPrhRyh37ADArF07HFd9hUm9eo/Ys2rlVTvtjfqTYw9VO5kpzOlatytPe/TDx9Hn36o0QRBKJDk5mfbt2xe7jYWFBdnZ2ZUUkXETCShBEJ5kderUMTTsLSl/f3+OHj2KTqfL14g8JCQEKysrvL29yznK/G7e1H9/d3FxqdDzPEwrekAJglAFRAKqBtFpdVw9+GD4Xe+HZk47tQqUSeDkBS1Hltv5clRapm0+y/k7qdhYmPDV6LZ4uz1ezydVWBjJb01Ce/sOyOXYTp2C7duTkJkY749qpiqTQ3f/LqTaqSFPe/SjR72e2JhVjyGDgmCMLCwsSE9PL3ab+/fvY2srqgolSRIJKEEQhFIKCgoiODiYnTt3EhQUBEBiYiLbt29n0KBB+SqP8qptPT1LP0txQkJCgSRTRkYGy5cvx9nZmTZt2jzGpygdUQElCEJVMN67eqHUYi/Gk5WUjbmNGQ3bPagWys2AE0v0r7vPKbfqp1y1luk/hXE2KgUrcwXLX26Dr7t9mY8nabVkrv4f6UuWgkaDol49HFd9hXm7duUSb3mTJIkrKZfZG/UnR2OOotLq+wb8W+30DD6OvqLaSRDKQZMmTQgNDUWpVBbahyMlJYWwsLBK/eJurNLT0w3NdyvzSbogCEJ1FhQURIcOHRg7diwRERE4OzuzevVqtFptgcbfvXv3BiAqKsqw7Pbt22zYsAGAM2fOALBgwQIAGjZsyMsv69tffP311/z8888MGjSIBg0aEBcXx/fff8+dO3fYsGEDZmaVNwOyVv2gAko0IRcEoRKJBFQNcu3QLQA8u3pgYvbgYhK6BpTJD6qfXiqX86g0Oj7Yeo7TN5OwNFOwbFQbWtRzKPPxtLFxJE9+B9XJkwBYPjsIh88WIbcve0Kroig1Sg7dPcieW7/nm8lOVDsJQsXp168fixYtYtGiRUyYMCHfuujoaL799lvUajX9+vWrogiNR171k62tbYU2zRUEQahJFAoFe/bsYfr06Xz11VcolUratWvH+vXr8fHxeeT+t27d4qOPPsq3LO999+7dDQmozp07c+LECdauXUtSUhLW1tYEBgby/fff06tXr/L/YMXQaUQTckEQKp9IQNUQ6lwNt07eAcCru8eDhTlwYqn+dZcPQP74Tzg0Wh0fbjvHyWuJmJvKWToygFYNHMt8POXevaRMfQ8pNQ2ZlRX2Cxdg9UKQ0VUORWfcZc+t3/n7zl9ka/R9ZszkZnSp25VnGvUT1U6CUIH8/f0NwyPee+89TB4MyR0/fjyZmZkAjBw5skQ3CTWdGH4nCIJQNo6Ojqxdu5a1a9cWu93DlU95evTogSRJjzxH37596du3b1lDLDeSJBl6QIkheIIgVCaRgKoh7pyOQZ2jwba2Na6+D4ZdnP8BMuPArh74jXrsc2h1EvN2XuTolQTMTeQsGRFAgIdTmY4l5eaStnARWd99B4BpKz+cVq3CpHGjR+xZebQ6LafuhbDn1m7OJ5w3LHezdqd/o/70btBHzGQnCJXkhRdeoGnTpvzxxx9cu3aNjIwMAFq3bs3AgQNp0aJFFUdoHEQCShAEQXgUSSfBg3yZqIASBKEyiQRUDXHtsH74XZNujfSVOFoNHPtcv7LTdDB5vDHlkiSx5PcI9offQyGXsWi4P+0a1yrTsTS3b5P8+huoL1wEwGbiBOw+eB9ZJY57L05KTgr7bu9lb9QfJCoTAZAjp22ddgxoPJBWLv7IZeJiLQiVJSIiAisrK1q0aCESTY8gElCCIAjCo+RVPwEoRA8oQRAqkUhA1QA5GbncPRsLQJO84XeXtkLqLbByhoBXH/sc/ztwjV1nopHJ4OOhLenkXbbmtsrdv5MybTpSRgYyBwccly/Dsm+fx47vcUmSRGRyJHtu7eZEzHE0kgYAOzM7+jZ8mn6N+lPbStzQCUJVmDdvHn379uXVVx//d1lNJxJQgiAIwqPo1P8moEQFlCAIlUkkoGqAmyfuoNPoqNXIEacGDqDTwdFF+pUdpoCZ1WMd/8ejN/nxmL7C6v2Bzejbwq3Ux5Byckj7ZD5ZP/wIgFm7djh+vQqTuu6PFdvjytHkcDj6EHtu7uZW+i3Dch9HX/o3HkAX966YKkyrMEJBEOzs7Cp1ZqDqTCSgBEEQhEfRPVQBJVeIHqaCIFQekYCqAa4fyRt+56FfcHU3JFwCczto9+ZjHXvX6busPnANgEl9vXm+bf1SH0Nz85Z+yN2lSwDYTHoLu2nvITOtusROfFY8v9/6jf2395GlzgL0TcW71evOgMYD8XRoUmWxCYKQX7Nmzbhy5UpVh1EtiASUIAiC8Cjah2bAE5PoCEL1cP78efz9/bl8+TI+Pj4sW7aMFStWFDoxwn/FxsYyY8YMTp8+TWxsLAqFAm9vb9566y1Gjx5dqb8HRAKqmstMyCIu/D7IoElXD5AkOLpQv7Ldm2DpUOZj77sYxxe/RwDwStdGjOpS+gbh2b/8Qur095GyspA7OeH41XIsevYsc0yPQ5IkLiWF8+uNXzgVF4IO/dOfOtZu9G80gN4N+mArmooLgtF58cUXmTVrFlu2bCEoKMgwC55QUEJCAiASUIIgCELRdGIGPEGodkJCQnBycsLb2xuAkydP0qFDhxLtm5iYSHR0NEFBQTRo0AC1Ws3+/fsZM2YMV65c4dNPP63I0PMR3+KruetHowBwa14bGxdruPk3xJwCEwvo8G6Zj3v8agLzdl5EkmBIu/q83turVPtLSiWpc+eRvWkTAGYd2uO0aiUKt9IP33tcKq2Ko9GH+fXmr9xKu2lY7u/Smmc9nyPAtY1oKi4IRmzXrl00aNCAXbt2cfDgQRo2bIiDg0OB7WQyGW+88UblB2hE8iqgXFzK1qdPEARBqPnympDLTcX3X0GoLk6dOkVgYKChWunkyZNMnTq1RPv6+flx6NChfMsmTZrEoEGD+Oqrr5g/fz4KReVMSFBjElCpqanMmDGDXbt2kZ2dTWBgIEuXLiUgIKBE+2/bto0vv/ySy5cvo1AoaNGiBTNmzGDAgAEVHPnjuX4kCtDPfgfA8S/0/289Hmxcy3TMc7dTmLX1HFqdxFMt3ZjWv2mpyvI0N2+RNGEimshIkMmwnfw2tlOnIKvkqoXknGT+uPU7f976gzRVGgBmCnN61e/FwMbP0sCuQaXGIwhC2Rw+fNjwOjU1ldTU1CK3FQkoMQRPEARBKF5eE3JRASUIxi0lJQWtVj9kNiQkhGeeeYbExETi4+OJjo7Gy8uLxMRELCwssLGxKfXxPTw8yM7ORqVSYWlpWd7hF6pGJKB0Oh0DBgzg/PnzTJ8+HWdnZ1avXk2PHj0IDQ3Fy6v46p2VK1cyefJkBgwYwGeffUZOTg7r169n4MCB7NixgyFDhlTSJymd5DupJN1KQW4ip3GnBhAfDjf2gkwOHUuWDf2vG/EZTN98llyNjs7eLswZ/P/t3XlcVGX7x/HPsIMCiqDivgIK7uKWpZalZqYpLu27lVa291j6M8uystK0x57U0nrKnpTMLct9wQ3RUMslFZWUUNlEdmRmfn8Qk8SgAwID+n2/Xr6S+2zXOU5zuK9z39cJwcHB9uRT1qqfSHnhRcxpaTj4+lJz1kzcbrqxVLGU1tGUo6yIWcbWuAjL2+x83X0Z2PQObmvSX9PsRKqYTz75xN4hVAlGo5HExERACSgRESne3zWgKmbEg4iUTocOHYiNjbX8/Ntvv/HBBx9Yfh40aBAADz74IAsWLLji/rKyssjIyCA9PZ3Nmzczf/58unfvXmHJJ7hGElDh4eFs376dxYsXExYWBsCIESMICAhg0qRJLFy48LLbz5o1i9DQUFasWGEZ6fPII49Qv359vvzyy0qbgDq2+SQADTvWw83TFdZ/lL+g1VDwaVbi/Z1NzeK5r/eQlp1Hm4Y1eHtEO5wcbXsyYs7L48LUd0n/z2cAuHTtgs+ns3GsU7pRWCVlNBnZEb+d5THLOJx8yNIe5NOKO5sPprt/DxwddJMVqYo0ncw2SUlJmM1mDAYDtWrVsnc4IiJSSRXUgHLQCCi5RpnNZnKMOfYOw8LV0bVUhb6/+eYbsrKy2LJlC1OnTmXFihU4OTnx0UcfkZCQwNSpUwGoV8+2N8t//PHHjB8/3vLzLbfcwvz580sc19W4ZhJQderUKZQo8vPzY8SIEXz99dfk5OTg6upa7PYXLlwgICCg0IfCy8uL6tWrV2g2sCTMZjMxW08CfxUfT4uH/V/nL+z+Yon3l5qZy3P/3UPChRya+FXjg3s64OZsW8LGePYsyWPGkrszEoDqTz6B179erZC33GVezGRN7GqWxywjMSu/+K6TwYme9W9kUPPBtKxZstpVIiJVVcH0u1q1aqlQu4iIFMuoKXhyjcsx5jBi5TB7h2Gx6I7vcXNyK/F2N9xwAwCrVq0iNDSU/v37A/Dcc88xfPhw+vbtW6L93X333XTu3JmEhARWrlzJ2bNnycrKKnFcV+Oa+A01Ojqajh074uBQ+Eu0S5cuzJkzhyNHjtCmTZtit+/duzfh4eHMmjWLQYMGkZ2dzaxZs0hNTWXcuHHlHX6pJJ1I4cKZdBxdHGkcWh+2vwGmi9CwBzS0rRp+geyLRl75NpoTCRn4eboy475OeHu42LRtzs6dJD85BlNCAobq1an50Ye4D7y9FGdUMgmZCaw8vpzVJ38mMy8TAG8Xb/o3HcCApgPxcfMp9xhERCoT1X8SERFbmE1mQCOgRCqz1NRULl68CMD69eu5+eabSUxMJDk5mQMHDjBlyhQSExNxdnbG29vbpn02btyYxo0bA/nJqNGjR9O3b19+//131YAqifj4eG666aYi7f5/vXHtzz//vGwCaubMmSQmJvLss8/y7LPPAuDr68v69evp3r37ZY+dk5NDTk7R4X3p6eklOYUSi9mWPxe0Uaf6ODvmQtSn+Qt6vFSi/RhNZiaF72ffH+ep7ubE9Ps7UbfGlT98ZrOZ9M8+48I774LRiFNQID5z5uDcvORT/0ri+PkYlh77gYi4LRjN+fPXG1RvwJAWQ+ndsA8ujrYlzkRErjVKQImIiC0KpuAZSlDnVaQqcXV0ZdEd39s7DAtXx+JnYxVn8ODBhV7Es3//fmbMmGH5+a677gKgV69eRd5wZ6uwsDDmzp3Lli1b6NevX6n2UVKVLgFlMpnIzc21aV1X1/y5lFlZWVan2Lm55Q9zu9KwMg8PDwIDA2nQoAF33HEHaWlpTJ8+naFDhxIREUGLFi2K3Xbq1KlMnjy5SLu/vz9PPPGETedRUmazmeNb8xNQzW5oBNHzITsFajaHwDtLtJ8PfjzE5sPncHY08P7dHWhR58oFuk0XLpDywotk//QzAO5Dh1Ljvak4eHiU7oRsiPOXc3tYeuwH9iXstbS38W3DkBZD6VSnMw4GPcERkeubElAiImILk/GvGlA21noVqWoMBkOpprxVJh9++CEpKSns2LGDyZMns3LlSpycnJg1axZxcXG8++67ANSsWbPUxyjIk6SmppZJzLaodAmoLVu20KdPH5vWPXToEEFBQbi7u1sdhZSdnQ1wxeFkw4cPx8nJiRUrVljaBg8eTMuWLXn99df57rvvit12/PjxvPBC0TfOnT179orFz0ur0PS7jnVh3vT8Bd2fhxIU2p6/5Tg/7D6FwQCTh7WlY5MrT1u7ePAQSY+PxnjyJLi44P3GJKo9cH+piqpd8VjGi2w5vYmlMT8QeyE/4eZgcOCGej0Z0mKo6juJiFxCCSgREbGFyVgwBU8joEQqq06dOgEQERFBSEiIpf7ThAkT6Nu3b4nqPyUkJFh9qc/nn3+OwWCgY8eOZRO0DSpdAiooKMjmSuwFU+z8/f2Jj48vsryg7XJV4Y8fP87PP//MnDlzCrX7+PjQs2dPtm3bdtkYXF1drY6+ysjIuGL8pRWz9ZLpd7GrIOU4uNWE9g/ZvI+V0XHM2XAMgBcGBHFzcN0rbpO55AfOv/wK5uxsHOvXx+ezT3Hp0KFU53A56blp/HzyJ1YeX0FydjIA7k7u3Na4H4OaD6a2hzpXIiL/pASUiIjYwjICykEjoEQqu23bttGjRw8gf4BNdHQ0r732Won28fbbb7Nt2zb69+9Po0aNSE5O5vvvvycqKopnnnnmsjO+ylqlS0DVrVuXhx56qETbtG/fnoiICEwmU6Ev0sjISDw8PAgICCh227NnzwJgNBqLLLt48SJ5eXkliqW8mc1mjm+7ZPrdjr9eoxg6Blyq2bSP3ceTmLr8AAAP9GzK8K6NL3/MvDxS35pCxrzPAXDt3Yuas2bi6FO2hb4TMs+x9NhS1sauJtuYP3qtllst7mh+J/0a96e6S/UyPZ6IyLVECSgREbGFJQGlIuQilZrRaCQyMtKSH9mzZw+5ublXrFP9TwMHDiQmJoYvvviChIQE3NzcaNu2LfPnz+fBBx8sh8iLV+kSUKURFhZGeHg4S5YsISwsDIDExEQWL17MoEGDCo1QiomJAaB58+YAtGjRAgcHB7777jueeOIJy1Sy06dPExERQc+ePSv4bC7v0ul3TeqfgfXbwcEZuoy1afsT59L513d7MZrM3BpSlydvufw0NmNSEslPPEXujh0AeI57Fs8XX8DgaPtUvys5lfYHS45+z6ZTGy2FxZt4NeWuFkPp2eBGnB2cy+xYIiLXKiWgRETEFua/puAZHDUFT6Qyc3R0JC0tzfLzDTfcgNlsLvF+br31Vm699dayDK3UrpkEVLdu3Xj44Yc5ePAgvr6+zJ49G6PRWKRA+C233ALAyZMnAfDz8+ORRx5h3rx53HLLLQwdOpS0tDRmz55NVlYW48ePr+jTuaxLp9857fvrzXfBI8DT/4rbJqXn8MI3v5CenUfbRjWYMCQEh8u8/SL3119JfvRxjHFxGKpVo+aM6bjfPqBMzgPgSMrvhB9ZTGT8Tszk/4/U1rcdwwLCaO/XoVzqSomIXKuUgBIREVuoCLmI2Ms1kYBydHRk1apVvPzyy8ycOZOsrCxCQ0NZsGABgYGBV9z+008/pV27dnz++eeWhFNoaChfffUVN910U3mHb7NLp9+1DPWA7f/LX9D1mStum51r5OWF0cSfz6KBjzvvj+qAq3Pxo5gyw78n5dVXITsHx6ZNqfXFPJwvM5WxJOewN2Ev3x9ZzP7EfZb2bv7dGdYyjECfoKs+hojI9UgJKBERsYWlCLlGQIlIBbsmElCQ//rBefPmMW/evMuuVzDy6VJOTk48/fTTPP300+UUXdlIPJ5smX7XiFVgzIV6odCg62W3M5nMTP7hVw7GpeLl7sxH93aiRjUXq+uaL14k9a23yfj8r3pPt9yCz6yPcfD2vqrYjWYjO//cwfdHF3PsfH7xc0eDI70b9mFoy2E09Gx0VfsXEbmeZWVlWYZoKwElIiKXY/5rBJRBRchFpIJdMwmo68HxbX8A0LhjHRz3vpzfaMPop3+vO8LGg2dxdjTw/t0daORrvVh5kXpPz43Lr/d0FTeni8aLbDy1gR+OfU9cehwAro6u3Na4P0NaDMFPb7QTEblqCQkJALi4uODl5WXnaEREpDL7uwi5RkCJSMVSAqqKMJvNHN+en4AKaXkIfouDarXz6z9dxg9Rp/hm20kAXh8SQvvGNa2ul7t/f369pz//zK/39PF03AeUvt5TVl4Wq0/+zLJjP5CUnQRAdefq3NFsEHc0G4SX69WNqBIRkb9dOv1O9fNERORy/p6CpxFQIlKxlICqIlL+SOVCfBqOzg7UOf9X7adOo8HJtdhtIo8l8sGqQwA83qc5/dvWs7pe5vdLSHnlFcjOwalZM3w+n1vqek+ZFzNZeXwFy2KWkpZ7AQAft1oMaXEXtzXuh4ezR6n2KyIixVP9JxERsZUpT0XIRcQ+lICqIk7szB/9FNQuE4fTW8HBCTo/Wez6sYkZvL54H0aTmdvb1eORXs2LrGM2Grnw7nukz85/m55b377UnPUxDqWYvpGem8aK4ytYHrOUjIsZANSt5k9Yy+H0aXgzzo7OJd6niIjYRgkoERGxlcmkIuQiYh9KQFURJyNPAxBSaw2cA1oNBa/6Vte9kHWRlxf+Qnp2Hm0a1uBfdwYXmZJhSksjeewz5KxfD4Dns8/g+fJLJa73dCEnlWUxS1l5fAVZeVkANKjegOGBI7mpfi8cHYp/056IiJQNJaBERMRWGgElIvaiBFQVkHYuncSYZNycM/BOWpHf2MV68fE8o4mJi/fxR1ImdbzdeHdUe1ycCt9c8mJjSXroEfKOHAE3V2p++AEeQ4aUKKaU7BSWHlvCTydWkW3MBqCxVxNGBo6ie70eOBqUeBIRqShKQImIiK3Mf9WAMmgElIhUMCWgqoCC0U+dgvZgMGZD3fbQ6Aar636y5giRMUm4OTsy7e4O1KpeuEZUzvYdJI9+AlNKCg51alPri89xad/e5liSshJZcnQJq0/+RK4pF4Dm3s0ZGXg3Xfy74mDQkxQRkYpW8BY8JaBERORK/n4Lnn5vF5GKpW+dKuDkzlOAmZbV1uY3dH4KrLzlaPme0/xvZywA/zc0hAD/wrWcMr7+hsS778GUkoJzu7bU/nGlzcmnc5nn+HTfv3l87aOsOL6MXFMuATUDmdhtEh/1/phu9bor+SQiVU5OTg6vvvoq9erVw93dna5du7J27Vqbt//uu+/o3r071apVo0aNGvTo0YMNGzaUY8TWaQSUiIjYypKAKmHpDRGRq6URUJVc1oVs4g+eo171Q7jmnASX6tDm7iLr7Y1N4f0fDwL5b7y7uXVdyzJzXh6pb0wmY/4CANwH30nNDz/A4O5+xeMnZJ5j0ZHvWBe7FqPZCEDrWsGMDLyb9n7t9bpvEanSHnroIcLDw3nuuedo2bIlCxYs4Pbbb2fjxo307Nnzstu+8cYbvPnmm4SFhfHQQw9x8eJFfvvtN+Li4ioo+r8VJKD8/Pwq/NgiIlK1mDQFT0TsRAmoSu6PqDjMJjPtG2/Nb2hzL7h6Flon/nwW47/bS57RzC3BdQq98c50/jzJT44hJyICAK9XX6H6M09fMXGUmJVI+JFFrDm5mjxzHgDt/NoxMvBuQnzblOEZiojYx65du/jf//7HtGnTeOmllwB44IEHCAkJ4ZVXXmH79u3Fbrtz507efPNNPvzwQ55//vmKCrlYGgElIiK2KhgB5agpeCJSwfStU8md2HkKN6dU6rvsyG/o/ESh5Zk5eby88BdSMnIJ9Pdi4pA2luTSxWPHOHfHneRERGDw8MBn3hw8n33mssmn5Oxk5u7/jCfWPsaqEz+SZ86jrW873r3xfd664R0ln0TkmhEeHo6joyOjR4+2tLm5ufHoo4+yY8cOTp06Vey2M2bMoG7duowbNw6z2Ux6enpFhGyV2WxWAkpERGxmKULuoBFQIlXFvn37MBgM/P777wBMnz6dJk2alGpf33zzDQaDgerVq5dhhLZRAqoSu5idx+m98QT6ROBAHtQLBf8OluVms5kpS3/j2Nl0fKq78P7d7XFzyX/7XPaWCBIGDcZ44gSO9evjt/QH3AcMKPZYKdkpfP7rPEaveZQVx5dz0XSR4FohvNPzXab0fIfWtYLL/XxFRCpSdHQ0AQEBeHkVrpfXpUsXAPbu3VvstuvXryc0NJSZM2fi5+eHp6cn/v7+fPLJJ+UZslUXLlwgNzf/pRCagiciUjrnz59n9OjR+Pn5Ua1aNfr06cMvv/xyxe1MJhMLFizgzjvvpGHDhlSrVo2QkBCmTJlCdna21W0+//xzWrVqhZubGy1btmTWrFllfTqXj1lFyEWqnMjISHx8fAgICABgx44ddOvWrcT7SU9P55VXXqFatWplHaJNNAWvEjsV/SfG3IsE19mc3/CP0U/fbDvJhoNncXI08O7I9tTxzq/plLHwW86Pfw3y8nAJDcVn3hwcfX2tHuNCTipLjn3Pj8dXkmPMASDIpxX3trqPtr7tVONJRK5Z8fHx+Pv7F2kvaPvzzz+tbpeSkkJiYiLbtm1jw4YNTJo0iUaNGjF//nyeeeYZnJ2deeKJJ6xuC/mFz3Nycoq0l3YUVcHoJ09PT9xtqO0nIiKFmUwmBg4cyL59+3j55Zfx9fVl9uzZ9O7dmz179tCyZctit83MzOThhx+mW7duPPnkk9SuXZsdO3YwadIk1q9fz4YNGwr9Pv3ZZ5/x5JNPMmzYMF544QUiIiJ49tlnyczM5NVXX62I0/07AeWoBJRIVbFr1y66dOli+T7ZsWMHL7zwQon3M2XKFDw9PenTpw9Lly4t4yivTAmoSuzkzlPU9zyIp9MZcPWCkFGWZbtikpi97ggALwxoRdtGNTGbTFyY+i7psz8FwP2uIfnFxl1di+w7LTeNpceWsPL4CrLysgAIqBnAPUH30aF2RyWeROSal5WVhauV70c3NzfLcmsKEkVJSUn873//Y+TIkQCEhYXRpk0bpkyZctkE1NSpU5k8eXKRdn9//8tuVxxNvxMRuTrh4eFs376dxYsXExYWBsCIESMICAhg0qRJLFy4sNhtXVxc2LZtGz169LC0Pf744zRp0sSShOrbty+Qf195/fXXGThwIOHh4ZZ1TSYTb731FqNHj6ZmzZrleKb5THn5U/AcVIRcpFJLSUnBaMx/EVhkZCT9+/cnMTGRs2fPcvr0aVq2bEliYiJubm42Tac7evQo06dP54cffmDRokXlHb5VSntXUsY8E7FRcbSq9dfrvNveBy75w+T+TMliYvg+TGYY1KE+d3VugCkri+QnnrIknzxfeJ6as2YWST6l56az8NDXPLbmYRYfWURWXhbNvZszsdskpt30ER3rdFLySUSuC+7u7lZHIhVMmShuNFFBu7Ozs6WjAvmvsx45ciSnT5/mjz/+KPa448ePJzU1tcifzZs3l+o8lIASEbk64eHh1KlTh6FDh1ra/Pz8GDFiBMuWLbN6ryjg4uJSKPlU4K677gLg0KFDlraNGzeSlJTEmDFjCq07duxYMjIy+PHHH6/2VGxiNuWPgDJoBJRIpdahQwf8/Pzw8/Pjt99+44MPPsDPz4+QkBAABg0ahJ+fH08//bRN+3vuuefo06cPt99+e3mGfVkaAVVJnT10DsecczSt8dfc8075T8WzLxoZ/91eUjMv0qqeFy8NbIUpIYGkhx/h4t594OJCzQ+m4TFsaKH95eRls/L4Cr4/Gk76xfyn9028mnJPq3vpWrebkk4ict3x9/cnLi6uSHt8fDwA9erVs7qdj48Pbm5u1KhRA0dHx0LLCpJAKSkpNGrUyOr2rq6uVkdeZWRklCj+AkpAiYhcnejoaDp27IiDQ+GETJcuXZgzZw5HjhyhTZuSvYjnzJkzAPheUgYjOjoagM6dOxdat1OnTjg4OBAdHc19991XmlMoEVOepuDJtc1sNpOXY7R3GBZOro6l6m9/8803ZGVlsWXLFqZOncqKFStwcnLio48+IiEhgalTpwLF/856qR9//JE1a9awb9++EsdRlpSAqqRid8cRWGsLDgYjNOgGddtiNpt5f+VBfo+/QA0PZ6aObI9DzFESHngIY1wchho1qPXFPFy7drXs56LpImtj1/Dd4W9JyUkBoKFnI+4Nuo9u9brjYNCNR0SuT+3bt2fjxo1cuHChUCHyyMhIy3JrHBwcaN++PVFRUeTm5uLi4mJZVlA3qiKLgSsBJSJydeLj47npppuKtF9aE7CkCaj3338fLy8vBlzyEqD4+HgcHR2LfF+7uLhQq1atYmsPQtnWDzQZNQVPrm15OUa+GPk/e4dh8ch3o3B2K3nq5YYbbgBg1apVhIaG0r9/fyB/JNPw4cMt03uvJDc3l+eff54nn3yS1q1blziOsqTsQyX1R9Qpgmr9NR3jr9FP3+86xaq9f+JggLdHtKPGvl0kDBmKMS4Ox6ZNqb1iuSX5ZDQb2XhqA2PXPcl/9s0mJSeF2h51eK7jC8y8+RN61L9ByScRua6FhYVhNBqZM2eOpS0nJ4f58+fTtWtXGjZsCMAff/zB4cOHC207cuRIjEYjX375paUtOzubb775htatW9v0JKqsKAElIvI3k8lEdna2TX/M5vxETGlrAhbnnXfeYd26dbz77rvUqFHD0p6VlVXoocU/j3W540ydOhVvb+8if3r16lWi2ODSIuRKQIlUVqmpqSQmJpKYmMj69evp2rUriYmJHDlyhAMHDtCuXTsSExNJTU294r6mT59OYmKi1RqkFU0joCqh1Pg03FOj8K59DrOLJ4bg4eyNTWH6z/kdoLG3BhK09SeSXp8ARiMu3briM3cujj41MZvNRJ3ZxX8PfUnshVgAarjWYETgKPo16Y+zg7M9T01EpNLo2rUrw4cPZ/z48Zw7d44WLVrw5ZdfcvLkST7//HPLeg888ACbN2+2dFQAnnjiCebNm8fYsWM5cuQIjRo14r///S+xsbGsWLGiQs9DCSgRkb9t2bKFPn362LTuoUOHCAoKKnVNQGu+++47JkyYwKOPPspTTz1VaJm7uzu5ublWt8vOzr7sccaPH2/1jVdnz569bJF0a/4eAaWH0XJtcnJ15JHvRl15xQri5Op45ZX+YfDgwYXqg+7fv58ZM2ZYfi6oM9erVy82bdpU7H5SU1OZMmUKY8aM4cKFC1y4cAHIHz1pNps5efIkHh4eFfZ7pBJQldAfu+MI9NkCgCFkJAnZjry+aC9Gk5m+wXUYuO6/nP/rib37sGHUnPYeBldXfkv8la8OLuBwcn6iqppTNe5qOYw7mw/GzcnNbucjIlJZffXVV0ycOJH//ve/pKSk0LZtW1auXGl1Ksal3N3d2bBhA6+88gpffPEFGRkZtG/fnh9//JF+/fpVUPT5lIASEflbUFAQ8+fPt2ndgil2/v7+lvp/l7pSTcB/Wrt2LQ888AADBw7kP//5j9XjGY1Gzp07V+g7Ozc3l6SkpMsepyzrBxaMgFIRcrlWGQyGUk15q0w+/PBDUlJS2LFjB5MnT2blypU4OTkxa9Ys4uLiePfddwGu+ObMlJQU0tPTef/993n//feLLG/atCmDBw9m6dKl5XEaRVTtf5Vr1OmoI/StsQuAvLYPMjF8P0npuTTzq8ZT6+eSsXI5AJ4vvYjnc+M4nhrDV3u+JPpcfsFyF0dXBjUbxNCWYXi6eNrtPEREKjs3NzemTZvGtGnTil2nuKdKtWvXZsGCBeUTWAkoASUi8re6devy0EMPlWib9u3bExERgclkKlSIPDIyEg8PDwICAq64j8jISO666y46d+7MokWLcHIq2s0qqC24e/fuQm+h2r17NyaTqdjag2XNXDAFz0lT8EQqq06dOgEQERFBSEiIpf7ThAkT6Nu3r831n2rXrs0PP/xQpH3mzJns2LGDb7/91pKMrwhKQFUyuZm5VPtzJc4NcjF6t+SzI37sjT2Jh4sDr279HCLWgbMzNT/6kJTbuvBp1Lts+3MrAI4GR25r0o+RgXfj4+Zj5zMREZGKoASUiMjVCQsLIzw8nCVLlhAWFgZAYmIiixcvZtCgQYVGHsXExADQvHlzS9uhQ4cYOHAgTZo0YeXKlcVOpbv55pvx8fHh008/LZSA+vTTT/Hw8GDgwIHlcXpFWKbgOWgElEhlt23bNnr06AHkT9WNjo7mtddes3l7Dw8PhgwZUqR96dKl7Nq1y+qy8qQEVCVzeu8ZAmpsAuCPJiP577aTADwdvQTfHesweHriOHcGX3kd4+f1T2IymzBg4KYGvbin1X34V6u47KWIiNhXXl4eSUlJgBJQIiKlFRYWRrdu3Xj44Yc5ePAgvr6+zJ49G6PRWKRo7y233ALAyZMnAUhLS6Nfv36kpKTw8ssv8+OPPxZav3nz5nTv3h3In7791ltvMXbsWIYPH06/fv2IiIjg66+/5u2338bHp2IeIFuKkDspASVSmRmNRiIjIy2jOvfs2UNubq7lO6UqUgKqkjm3cxvdqh/FjAPjD4cAMPD4drruWMnFhnXZPu1+lqXOISsp/y0ZneuE8kDrh2ji3cSOUYuIiD0kJSVhNpsxGAzUqlXL3uGIiFRJjo6OrFq1ipdffpmZM2eSlZVFaGgoCxYsIDAw8LLbJiUlcerUKQD+9a9/FVn+4IMPFuosjhkzBmdnZz788EOWL19Ow4YNmT59OuPGjSvbk7oMU15BDShNwROpzBwdHUlLS7P8fMMNNxR6Kc7VWLBggV1KSVwTCaj4+Hg+/vhjIiMj2b17N+np6WzcuJHevXvbvI+4uDief/551qxZg8lkok+fPkyfPp1mzZqVX+D/YDaZqRa7CGrCQUMoJ7Nr0DLxJPds+ZLtw1qxsp8vKUmrAWhRoyUPBz9CG7+2FRafiIhUHkaj0fKk3cvLy87RiIhUbTVr1mTevHnMmzfvsusVjHwq0KRJkxJ3CB9//HEef/zxkoZYZswmvQVPROzjmkhA/f7777z33nu0bNmSNm3asGPHjhJtn56eTp8+fUhNTeW1117D2dmZ6dOn06tXL/bu3VthT5XP/X6WZtU3AfC1sS/Vc9MZGPcF708OIb6GGS6mUsejDg+0fogb6vfEwaCbhojI9WjJkiWMGzeO06dPA/mv2G3SpAkff/wxQ4cOtXN0IiJSmVlqQGkElIhUsGsiAdWpUyeSkpLw8fEhPDyc4cOHl2j72bNnc/ToUXbt2kVoaCgAAwYMICQkhA8//JB33nmnPMIuIjViMXWcz5Nh9GRHtaYE+H7Owm6+gBlPZ09GBt3NgCa34+zoXCHxiIhI5VNQJPefT9zj4uIshXSVhBIRkeIUTMHTCCgRqWjXxLeOp6fnVRXtCw8PJzQ01JJ8AggKCuKWW25h0aJFZRGiTdxO/A+A7Y7BeAUt4UwjA84OzgxrGcZnt87jzuaDlXwSEbmOGY1Gxo0bZ3W6R0Hbc889h9ForOjQRESkijCZlIASEfu47r91TCYT+/fvp3PnzkWWdenShZiYmEKFv8pL7P4o6jtHAvBTE3cMZri54S38p+8cHgx+mOou1cs9BhERqdwiIiIs0+6sMZvNnDp1ioiIiAqMSkREqhJTXv4DCxUhF5GKdk1MwbsaycnJ5OTk4O/vX2RZQduff/5Z7BswcnJyyMnJKdKenp5eojgOLplOYwcj8bkNcKkRyIw+L9PUu+IKoIuISOUXHx9fpuuJiMj1x2zUCCgRsY9Kl4AymUzk5ubatK6rqysGw9Vl7rOysiz7+ic3N7dC61gzdepUJk+eXKTd39+fJ554wuY4+r4+nw9m5dHWvSXvDnnb5u1EROT6Ye1hydWsJyIi15/2w4IxXjTi5uli71BErlpJ30IppVNW17nSJaC2bNlCnz59bFr30KFDBAUFXdXx3N3dAayOYsrOzi60jjXjx4/nhRdeKNJ+9uxZFi5caHMczs6uvPRCxdWbEhGRqufGG2+kQYMGxMXFWf1FwGAw0KBBA2688UY7RCciIlVBxxFt7B2CSJkxGAzk5ORYHVAiZSMjIwNn57KpRV3pElBBQUHMnz/fpnXL4gmvj48Prq6uVqcrFLTVq1ev2O1dXV2tftgzMjKuOjYREZFLOTo68vHHHxMWFobBYCiUhCoYETxjxgwcHR3tFaKIiIhIhenUqRPr1q2jb9++SkKVMbPZzJkzZ/jll1/o0qVLmeyz0iWg6taty0MPPVRhx3NwcKBNmzbs3r27yLLIyEiaNWuGp6dnhcUjIiJyOUOHDiU8PJxx48YVKkjeoEEDZsyYwdChQ+0YnYiIiEjF8fX1pWvXrmzevBmTyXTVJXokn9lsxmAwUKNGjTJN7lW6BFR5++OPP8jMzCw0dS8sLIx//etf7N692/I2vN9//50NGzbw0ksv2StUERERq4YOHcrgwYOJiIggPj4ef39/brzxRo18EhERkeuOr68vt912m73DEBtcMwmoKVOmAHDgwAEA/vvf/7J161YAJkyYYFnvgQceYPPmzYWmLYwZM4a5c+cycOBAXnrpJZydnfnoo4+oU6cOL774YgWehYiIiG0cHR3p3bu3vcMQEREREbHJNZOAmjhxYqGfv/jiC8vfL01AWePp6cmmTZt4/vnnmTJlCiaTid69ezN9+nT8/PzKJV4RERERERERkevFNZOAsvW1gJs2bbLa3qBBAxYvXlyGEYmIiIiIiIiICICDvQMQEREREREREZFrmxJQIiIiIiIiIiJSrpSAEhERERERERGRcnXN1ICqbPLy8gBITEy0cyQicr0q+P4p+D6Syk33DRGxN903qh7dO0TE3kpy71ACqpycP38egCVLltg3EBG57p0/f56GDRvaOwy5At03RKSy0H2j6tC9Q0QqC1vuHQazra+PkxLJzMwkJiaGGjVq4ORkW54vPT2dXr16sXnzZqpXr17OEV47dN1KTtesdKradcvLy+P8+fM0b94cDw8Pe4cjV6D7hn3pWpYNXceyY49rqftG1aN7R8XRdSsdXbeSq2rXrCT3DiWgKpELFy7g7e1NamoqXl5e9g6nytB1Kzlds9LRdZPKRp/JsqNrWTZ0HcuOrqWUF322SkfXrXR03UruWr5mKkIuIiIiIiIiIiLlSgkoEREREREREREpV0pAiYiIiIiIiIhIuVICSkREREREREREypUSUJWIq6srkyZNwtXV1d6hVCm6biWna1Y6um5S2egzWXZ0LcuGrmPZ0bWU8qLPVunoupWOrlvJXcvXTG/BExERERERERGRcqURUCIiIiIiIiIiUq6UgBIRERERERERkXKlBJSIiIiIiIiIiJQrJaAqgZycHF599VXq1auHu7s7Xbt2Ze3atfYOq1KLiori6aefJjg4mGrVqtGoUSNGjBjBkSNH7B1alfL2229jMBgICQmxdyiV3i+//MKdd96Jj48PHh4ehISEMHPmTHuHJdcp3TfKxqZNmzAYDFb/7Ny5097hVVrp6elMmjSJ/v374+Pjg8FgYMGCBVbXPXToEP3796d69er4+Phw//33k5CQULEBV1K2XseHHnrI6mc0KCio4oOWKk33jpJTn6NsqM9hu2u9z+Fk7wAk/xeL8PBwnnvuOVq2bMmCBQu4/fbb2bhxIz179rR3eJXSe++9x7Zt2xg+fDht27blzJkzfPLJJ3Ts2JGdO3fqy80Gp0+f5p133qFatWr2DqXSW7NmDYMGDaJDhw5MnDiR6tWrExMTw+nTp+0dmlyndN8oW88++yyhoaGF2lq0aGGnaCq/xMRE3nzzTRo1akS7du3YtGmT1fVOnz7NTTfdhLe3N++88w7p6el88MEH/Prrr+zatQsXF5eKDbySsfU6Qv4bkebNm1eozdvbu5wjlGuN7h0lpz7H1VOfw3bXRZ/DLHYVGRlpBszTpk2ztGVlZZmbN29u7t69ux0jq9y2bdtmzsnJKdR25MgRs6urq/nee++1U1RVy8iRI80333yzuVevXubg4GB7h1NppaammuvUqWO+6667zEaj0d7hiOi+UYY2btxoBsyLFy+2dyhVSnZ2tjk+Pt5sNpvNUVFRZsA8f/78Ius99dRTZnd3d3NsbKylbe3atWbA/Nlnn1VUuJWWrdfxwQcfNFerVq2Co5Nrje4dpaM+x9VTn8M210ufQ1Pw7Cw8PBxHR0dGjx5taXNzc+PRRx9lx44dnDp1yo7RVV49evQo8uS0ZcuWBAcHc+jQITtFVXVs2bKF8PBwZsyYYe9QKr2FCxdy9uxZ3n77bRwcHMjIyMBkMtk7LLmO6b5RPtLS0sjLy7N3GFWCq6srdevWveJ633//PXfccQeNGjWytPXt25eAgAAWLVpUniFWCbZexwJGo5ELFy6UY0RyLdO9o3TU57g66nPY7nrpcygBZWfR0dEEBATg5eVVqL1Lly4A7N271w5RVU1ms5mzZ8/i6+tr71AqNaPRyDPPPMNjjz1GmzZt7B1Opbdu3Tq8vLyIi4sjMDCQ6tWr4+XlxVNPPUV2dra9w5PrkO4bZe/hhx/Gy8sLNzc3+vTpw+7du+0dUpUXFxfHuXPn6Ny5c5FlXbp0ITo62g5RVV2ZmZl4eXnh7e2Nj48PY8eOJT093d5hSRWie0fZUZ/DNupzlMz10udQDSg7i4+Px9/fv0h7Qduff/5Z0SFVWd988w1xcXG8+eab9g6lUvvPf/5DbGws69ats3coVcLRo0fJy8tj8ODBPProo0ydOpVNmzYxa9Yszp8/z7fffmvvEOU6o/tG2XFxcWHYsGHcfvvt+Pr6cvDgQT744ANuvPFGtm/fTocOHewdYpUVHx8PUOxnNTk5mZycHFxdXSs6tCrH39+fV155hY4dO2Iymfj555+ZPXs2+/btY9OmTTg56dd5uTLdO8qO+hy2UZ+jZK6XPofuWHaWlZVl9ZcvNzc3y3K5ssOHDzN27Fi6d+/Ogw8+aO9wKq2kpCT+7//+j4kTJ+Ln52fvcKqE9PR0MjMzefLJJy1voBg6dCi5ubl89tlnvPnmm7Rs2dLOUcr1RPeNstOjRw969Ohh+fnOO+8kLCyMtm3bMn78eH7++Wc7Rle1FXwOr/RZVQLqyqZOnVro51GjRhEQEMDrr79OeHg4o0aNslNkUpXo3lE21OewjfocJXe99Dk0Bc/O3N3dycnJKdJeMMzO3d29okOqcs6cOcPAgQPx9va2zG8X6yZMmICPjw/PPPOMvUOpMgr+H7z77rsLtd9zzz0A7Nixo8Jjkuub7hvlq0WLFgwePJiNGzdiNBrtHU6VVfA51Ge1fDz//PM4ODhoZIHYTPeOq6c+h+3U5yi566XPoRFQdubv709cXFyR9oKh6/Xq1avokKqU1NRUBgwYwPnz54mIiND1uoyjR48yZ84cZsyYUWiYdXZ2NhcvXuTkyZN4eXnh4+Njxygrn3r16nHgwAHq1KlTqL127doApKSk2CMsuY7pvlH+GjZsSG5uLhkZGUXqpYhtCqb1FHwuLxUfH4+Pj49GP10Fd3d3atWqRXJysr1DkSpC946roz6H7dTnKJ3rpc+hEVB21r59e44cOVLkrSaRkZGW5WJddnY2gwYN4siRI6xcuZLWrVvbO6RKLS4uDpPJxLPPPkvTpk0tfyIjIzly5AhNmzbVXHYrOnXqBFDkl7aCG6qGFUtF032j/B0/fhw3NzeqV69u71CqrPr16+Pn52e1oPuuXbv0Ob1KaWlpJCYm6h4kNtO9o/TU5ygZ9TlK53rpcygBZWdhYWEYjUbmzJljacvJyWH+/Pl07dqVhg0b2jG6ystoNDJy5Eh27NjB4sWL6d69u71DqvRCQkL44YcfivwJDg6mUaNG/PDDDzz66KP2DrPSGTFiBACff/55ofZ58+bh5ORE79697RCVXM903yg7CQkJRdr27dvH8uXLue2223Bw0K9JV2PYsGGsXLmy0Ovd169fz5EjRxg+fLgdI6s6srOzSUtLK9L+1ltvYTab6d+/vx2ikqpI947SUZ+j5NTnKJ3rpc+hKXh21rVrV4YPH8748eM5d+4cLVq04Msvv+TkyZNFPnzytxdffJHly5czaNAgkpOT+frrrwstv+++++wUWeXl6+vLkCFDirTPmDEDwOoygQ4dOvDII4/wxRdfkJeXR69evdi0aROLFy9m/PjxGoItFU73jbIzcuRI3N3d6dGjB7Vr1+bgwYPMmTMHDw8P3n33XXuHV6l98sknnD9/3vJkdsWKFZw+fRqAZ555Bm9vb1577TUWL15Mnz59GDduHOnp6UybNo02bdrw8MMP2zP8SuNK1zElJYUOHTpw9913ExQUBMDq1atZtWoV/fv3Z/DgwXaLXaoW3TtKR32OklOfo3Sumz6HWewuKyvL/NJLL5nr1q1rdnV1NYeGhpp//vlne4dVqfXq1csMFPtHbNerVy9zcHCwvcOo1HJzc81vvPGGuXHjxmZnZ2dzixYtzNOnT7d3WHId032jbHz88cfmLl26mH18fMxOTk5mf39/83333Wc+evSovUOr9Bo3blzsPfjEiROW9X777TfzbbfdZvbw8DDXqFHDfO+995rPnDljv8ArmStdx5SUFPN9991nbtGihdnDw8Ps6upqDg4ONr/zzjvm3Nxce4cvVYzuHSWnPkfZUZ/jyq6HPofBbDabKyrZJSIiIiIiIiIi1x8VNxARERERERERkXKlBJSIiIiIiIiIiJQrJaBERERERERERKRcKQElIiIiIiIiIiLlSgkoEREREREREREpV0pAiYiIiIiIiIhIuVICSkREREREREREypUSUCIiIiIiIiIiUq6UgBIRERERERERkXLlZO8ARKqCAwcOMHnyZMLCwhgxYoS9w7miRYsWER4ebvm5b9++jB49usT7iYmJYfz48Zaf/fz8+Pe//10mMYqIWDNixAhat27NG2+8UWHHfOONNzh48CCLFi2qsGMCnDt3jqeffppevXoxduzYCj22iIhUPupz5FOf49qlEVAi5HcCRowYcc190fXq1YuwsDA6depUqu1r1qxJWFgYYWFheHh4lHF0IiIi155FixYxYsQIDhw4YO9QRKSSUZ/DOvU5rh8aASVigxYtWjB9+nQ8PT3tHUqJ9O7dm+Dg4FJv7+PjY3n6snnz5rIKS0SkWNOnT8fV1bVCj/n000+Tk5NToccUERH5J/U51Oe41ikBJWIDV1dX6tevb+8wRESuefb4rvX19a3wY4qIiPyT+hxyrVMCSq57l85d3rx5c6Gs+5gxY+jdu3ex87EL6oYsXLiQpUuXsnnzZpKTk/H19WXQoEH07dsXgDVr1rB69WrOnDmDp6cnN998M2FhYTg4FJ0Fe/ToUZYvX87hw4dJT0+nRo0adOjQgbCwMHx8fMrknM+fP8/y5cvZs2cPycnJODo64u3tTUBAAGFhYdSpU6dMjiMi165L6xcNGTKEb775hkOHDpGXl0eTJk0ICwujXbt2hbbZtGkTs2fPZsyYMdSoUYOlS5dy4sQJsrKyLPWXrNWAKvienjRpEmlpaSxbtoxTp07h7OxMu3bteOCBB6x+P6anp7NixQp2797N2bNncXR0pHbt2rRv355hw4bh5uYGWK8Bden3fvv27fnuu+84duwYZrOZwMBARo0aRfPmzQsdLzk5mQ0bNrBv3z7OnDlDeno6Xl5etG7dmmHDhtGgQYMyufb79u3jp59+4tixY2RmZuLt7U3Tpk3p378/bdu2taxnMplYt24dGzdu5PTp0wA0aNCAPn360Ldv3yL3oIJr/9xzz7Fw4UKio6PJzs6mcePG3HvvvbRq1Yrs7GwWL17Mjh07OH/+PHXr1mX48OF079690L4u/bf28vJiyZIlxMbG4uTkREhICPfccw/+/v5Fzi0lJYXvv/+e6OhokpOT8fDwoFWrVgwdOpRmzZoVewxfX1/Cw8M5fvw4BoOBoKAg7r//fqvXPCcnh1WrVrF9+3bOnDkDQKNGjRgwYAA9e/YstO6ln4MuXbrw7bff8vvvv5OXl0fz5s255557CAwMtKw/duxYEhISAJg8eXKhfVV0jTERqVzU51CfQ5SAEiE4OJjMzExWrVpF48aNCQ0NtSxr0qSJTfuYMWMGx44do0OHDjg6OhIZGcmcOXNwcnIiNjaWzZs307FjR9q0acPu3bsJDw/HxcWFIUOGFNrPhg0bmDNnDs7OznTq1AlfX1/i4+NZv349e/bs4e23377qJ/U5OTlMnDiRs2fP0rZtW8tc7YSEBHbv3k23bt10MxARm507d44JEybQqFEjbr31VlJSUti+fTvvvPMO48aNo0ePHkW22blzJ3v37qV9+/bceuutJCYm2nSs1atXs2fPHjp16kTr1q05duwY27dvJzY2lvfffx9nZ+dCcU2ePJmEhASaNWvGbbfdhslkIj4+nh9//JFbb73VkoC6nGPHjrF06VLatGlDv379OHPmDLt27eLgwYNMmDCBVq1aWdY9dOgQS5cuJTg4mK5du+Lm5saZM2fYuXMnu3fv5q233rL5vlKcgg6Mm5sboaGh1KpVi5SUFI4cOUJEREShBNQnn3zC1q1bqVWrFrfccgsAUVFRzJs3j8OHD/Pss88W2X9GRgYTJ07E3d2dG264gfT0dLZt28bbb7/NlClTmDt3Lunp6XTs2BGj0ci2bduYMWMGtWrVIiAgoMj+IiMj2bt3L6GhobRu3ZrY2FgiIyM5cOAAU6ZMoV69epZ1z507x8SJE0lJSSEkJIQbbriBxMREdu7cyS+//MKLL75otb7Inj172L17t+XzdPr0aaKjo4mJieGjjz7Cy8ur0Pm9+eabnDhxgqZNm9KnTx9MJhP79u1j5syZnD59mlGjRhU5xvHjx1m+fDkBAQHcfPPNJCYmEhkZyZtvvsm0adMs53H77bcTFRXFwYMH6dWrF35+fiX41xWRa5n6HOpziBJQIgQHB+Pn58eqVato0qRJqd44kZSUxIcffki1atUAGDRoEM899xxffvklHh4efPDBB5YnCcOHD+fZZ59lxYoVDBo0CEdHRwD+/PNP5s6di5+fH5MnTy705OHXX39lypQpzJ8/n5dffvmqzvfXX3/l7Nmz3H777Tz00EOFluXl5XHx4sWr2r+IXF8OHTrEoEGDuP/++y1t/fv3Z8KECcydO5f27dsXKSgaHR3N+PHjad++fYmOtW/fPqZOnUqjRo0sbR9//DHbtm0jKiqqULJr5syZJCQkcPfdd3PXXXcV2s+FCxdsSj4B7N27l0ceeYT+/ftb2qKiopg2bRqffvopM2bMsDxZDgkJYe7cubi7uxfax8mTJ5k4cSILFy7ktddeK9E5X2rfvn2Eh4dTu3Zt3nzzzSJPqJOSkix/37p1K1u3bqVp06ZMnjzZcr6jRo3ijTfeYOvWrXTs2LHIiJ/Y2Fj69u3LY489Zjmvtm3b8sknnzB58mQCAwOZNGkSLi4uANx0001MmjSJZcuWWb0/7dmzh1dffbVQ4mjVqlUsWLCAefPm8X//93+W9rlz55KSksKoUaMYOnSopb1fv35MmjSJf//738yePbvIv11UVBSvv/46bdq0sbQVjBLYuHEjgwcPtrQvWLCAEydOcO+99xZqz83NZdq0afzwww9069atSGfwl19+sYxQKLB27Vrmzp3LqlWreOyxxwAYOHAgGRkZHDx48KproojItUV9jr+pz3H90lvwRMrAPffcY7kRANSpU4egoCAyMjIYNmxYoS/2atWq0alTJ9LS0khOTra0r1mzBqPRyMMPP1ykU9GmTRs6d+7Mnj17yMrKKpOYCzoPl3JycirScRIRuRwPDw/CwsIKtTVv3pyePXuSkZHBrl27imzTuXPnEiefAAYMGFAo+QRYRvYcO3bM0nb8+HGOHDlCkyZNCiUZCnh5eVn9DrSmbt263HbbbYXaCkbznDlzhsOHD1vavb29rX6HNmnShJCQEA4cOEBeXp5Nx7Xmp59+Aih2ymGtWrUsf9+4cSOQf3+6NGHj5ubGvffeC8D69euL7MPV1ZX777+/0HSNnj174ujoSEZGBg8//HCha9eqVSv8/Pw4efKk1ZhDQkKKjFrq378/derU4bfffrNMV0tKSmLfvn34+vpy5513Flo/MDDQMhorMjKyyDF69OhRKPkEWKajXPq5SEtLIyIigubNmxf5XLi4uHDvvfdiNpvZunVrkWMEBgYWSj4B9OnTB0dHx0LHEBEpT+pzSFWnEVAiZeCfdUAg/3WiQJGaFYDlyz4pKckyPP/o0aMAHDx40OovsxcuXLBMH7G2T1u1bt0aHx8fli1bxokTJ+jQoQNBQUE0adLE6vxwEZHLadq0qdVfIoODg9m8ebPVxESLFi1KdSxr330FUwQyMjIsbUeOHAGgXbt2V/29FhQUZHUfrVu35uDBg5w4cYLWrVtb2n/55RfWrFnD8ePHSUtLw2g0FtouLS3Ncn8oqaNHj2IwGGxK3p04cQKDwWB1BE7r1q1xcHCw+m/j7+9f5N/TwcEBb29vcnJyrE6X8PHxKTYJc+m1uXR/QUFBnD17lhMnTuDn58eJEyeA/Ovt5FT019OQkBAiIiI4ceIEvXr1KrTM2j24IBl36eciJiYGk8kEWK/HVPBvVVAv60rHcHJywtvbu9AxRETKk/ocUtUpASVSBv45vQSwDHO1tqzgS/fSjklaWhoAy5cvv+yxsrOzSx1nQTxvv/02ixYtYvfu3ezbtw8AT09P+vXrx9ChQ63+8i8iYo23t7fV9ho1agCQmZlZ7LKSuvSpb4GC79OCxMKlxyyLIqrFxWrt/AqmllWrVo22bdvi6+uLq6srkD9NLDY29qqmHGRmZlKtWjWbRm9lZmZSvXp1q9/njo6OeHp6cuHChSLLrN2zCra53LJ/JtoK2Pr5KPhvccm5gnZrnydrn4uCe/Cln4uC+2xMTAwxMTFWjwP5dUv+6XLnfukxRETKk/ocUtXpX1ykkii4aSxYsKDYX3TLSq1atXjqqacwm82cPn2a3377jdWrVxMeHo7JZLJagFVExJrU1FSr7efPnwes/0JsMBjKMyTLMS+dclBaBedRXHvBsYxGI4sXL6ZGjRq89957RRIpR48eJTY29qpi8fDwID09ndzc3CsmoQrWzcvLK/ILvtFoJC0trUKmP9j6+Sj4b3HXOyUlpdB6pVGw7cCBA3nwwQdLvR8RkapMfQ6xJ419E8H6E/SK1rJlS4BC9UTKm8FgoGHDhgwYMIAJEyYA+U/pRURsdeLECat1Ig4cOADY/mafslTwNrZ9+/Zd9ff677//bnUfBw8eBPKnIEL+E+WMjAwCAgKKJJ+ys7M5fvz4VcUB+fcJs9nM3r17r7hu06ZNMZvNHDp0qMiyQ4cOYTKZLLGXp4LrdCmTyWS51xXEUPDfw4cPWx1NVfB5upqYW7RogcFgKPf7bGX4nUJEKqfK8P2gPofYkxJQIkD16tUxGAw2vwq8PPTv3x9HR0e+/PJL/vzzzyLL8/LyrHYkSurUqVNWnzAXPKUumC4iImKLzMxMwsPDC7XFxMSwdetWPDw86NKlS4XH1KxZMwIDAzl58iTLli0rsjwtLY3c3Fyb9hUfH8+aNWsKtUVFRXHw4EHq1q1LUFAQkF/Y3NXVlRMnThSatpCXl8f8+fMtUx6uxoABAwD46quvrI7uurStT58+QP7b4C6dUpaTk8M333wDwM0333zVMV3Jb7/9xp49ewq1/fzzz5w9e9byRijIf0retm1bEhIS+PHHHwutf/ToUbZu3Uq1atWu6vPk7e3NjTfeSExMjOXp+z+dOXOGc+fOlfoYkD+9BLDr7xQiUjmpz6E+x/VOU/BEyH8rUIsWLTh8+DAzZ87E398fBwcHOnfuTOPGjSskhvr16/PUU0/x6aef8uKLL9KuXTvq1atHXl4eiYmJHD58GC8vL2bMmHFVx9m/fz9ff/01AQEB+Pv74+XlRXJyMlFRURgMhiJvHxIRuZxWrVqxYcMGjh07RmBgICkpKWzfvh2TycTo0aPLfXh/cZ555hneeOMNvv32WyIjIy3FsOPj49m/fz/Tp0+ndu3aV9xP+/bt+eqrr4iOjqZx48acOXOGXbt24ezszFNPPWV5mu3g4MCAAQNYunQpL774IqGhoeTl5XHgwAHS09MJDg62jOIprXbt2jF06FCWLFnC888/T2hoKLVq1SI1NZXDhw/TsmVLxo4dC+S/uS4qKoodO3bwwgsvEBoaisFgICoqinPnztGjRw9uvPHGq4rHFp06deKDDz4gNDSUunXrEhsbS3R0NNWrV+exxx4rtO7jjz/OxIkT+frrr9m/fz/NmjUjKSmJnTt3YjAYGDNmzFVPG3zkkUeIj49n0aJFREREEBgYSI0aNUhOTiYuLo6YmBjGjRtn02ejOMHBwRgMBhYuXMipU6csNaqGDRt2VbGLSNWnPof6HNc7JaBE/vLMM8+wYMEC9u7dy7Zt2zCbzdSqVavCbgYAN910E02aNGHFihUcOHCA/fv34+rqio+PD926daNHjx5XfYx27dqRmJjIoUOHiIqKIisri5o1a9K2bVvuuOMOAgMDy+BMROR6Ubt2bR5//HEWLlzI2rVruXjxIs2aNWPYsGE2va2tPON67733WLZsGVFRUaxevRpnZ2f8/Py44447ii2O/U8tWrQgLCyM7777jtWrV2M2mwkJCWHUqFFF3uY3cuRIvLy8WL9+PWvXrsXDw4O2bdsyatQoq29dK41Ro0YREBDATz/9xJ49e8jJycHb25tmzZoVeTvcuHHjaN26NRs3bmTdunVAfsfjkUce4bbbbiuTeK6ka9eu9O3blyVLlhAdHY2joyNdunThnnvuoV69eoXWrVOnDu+++y7ff/890dHRHDhwAA8PD0virbRvT7yUh4cHkydPZt26dWzdupXIyEguXryIt7c3/v7+PPjgg7Rt2/aqjtGgQQPGjh3LihUrWL16taXwvBJQIgLqc6jPcX0zmM1ms72DEJGytWjRIsLDw5k0aZLVV3CXRsFT9X//+99lsj8RqdrOnTvH008/Ta9evSzfD9eSAwcOMHnyZMLCwhgxYoS9w6lyNm3axOzZsxkzZgy9e/e2dzgiIlIO1OeQktIIKJFr2OTJkwHo27cvo0ePLvH2MTExjB8/3vJzQa0OERERERERUJ9DbKcElMg16J9PIJo3b16q/dSsWZOwsDDLzwV1LERERERE5PqmPoeUlBJQIteg4ODgMhkG6+Pjo6knIiIiIiJShPocUlKqASUiIiIiIiIiIuXKwd4BiIiIiIiIiIjItU0JKBERERERERERKVdKQImIiIiIiIiISLlSAkpERERERERERMqVElAiIiIiIiIiIlKulIASEREREREREZFypQSUiIiIiIiIiIiUKyWgRERERERERESkXCkBJSIiIiIiIiIi5er/ATLww6ou6SryAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ], + "source": [ + "ps.plotSubspace()" + ] + }, + { + "cell_type": "markdown", + "id": "366196ff", + "metadata": { + "id": "366196ff" + }, + "source": [ + "### Estimate Coil Sensitivities Using Subspace\n", + "We realized, that 4 PCA coefficients contribute to more than 99% of the observed signal. Hence, we can reduce our basis to only contain the first 4 eigenvectors. We create a subspace basis spanned by those 4 eigenvectors." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "34d0599a", + "metadata": { + "id": "34d0599a" + }, + "outputs": [], + "source": [ + "nCoe = 4 ## use 4 coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "86725660", + "metadata": { + "id": "86725660" + }, + "outputs": [], + "source": [ + "%%pybash\n", + "\n", + "# create the temporal basis\n", + "bart extract 1 0 {nCoe} U subbasis\n", + "# transpose the basis to have time on the 6th dimension and coefficients on the 5th dimension\n", + "bart transpose 1 6 subbasis - | bart transpose 0 5 - subbasis" + ] + }, + { + "cell_type": "markdown", + "id": "df31a4c0", + "metadata": { + "id": "df31a4c0" + }, + "source": [ + "For consistency, check dimensions of subbasis, input data and trajectory:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "dbc79fd8", + "metadata": { + "id": "dbc79fd8", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "976ddc0e-4f8e-4e79-aadf-1651570d2621" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "# Dimensions\n", + "1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 \n", + "# Dimensions\n", + "3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 \n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "head -n2 subbasis.hdr\n", + "head -n2 tmp_ksp.hdr\n", + "head -n2 traj.hdr\n" + ] + }, + { + "cell_type": "markdown", + "id": "cf545179", + "metadata": { + "id": "cf545179" + }, + "source": [ + "\n", + " Now, we estimate coil sensitivities using `bart ncalib` and reduced subspace basis in one go." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "09aa77bc", + "metadata": { + "id": "09aa77bc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ac48a44e-b7b7-4fc1-f04e-35c24cee1832" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Est. image size: 256 256 1\n", + "ksp : [ 1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [ 48 48 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: low-mem mode\n", + "NUFFT: Toeplitz mode\n", + "\n", + "Model created (non Cartesian, nufft-based):\n", + "kspace: [ 1 512 1 18 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "images: [ 48 48 1 1 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "coils: [ 16 16 1 18 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "trajectory: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "pattern: [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "basis: [ 1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "mask: [ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "coilimg: [ 48 48 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "\n", + "NUFFT: Toeplitz mode\n", + "ksp : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [ 48 48 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: low-mem mode\n", + "Scaling: 254.087387\n", + "Step: 0, Res: 100.000002\n", + "\t cg: 1\n", + "Step: 1, Res: 99.999773\n", + "\t cg: 0\n", + "Step: 2, Res: 99.999471\n", + "\t cg: 0\n", + "Step: 3, Res: 99.994801\n", + "\t cg: 0\n", + "Step: 4, Res: 99.627939\n", + "\t cg: 1\n", + "Step: 5, Res: 84.743537\n", + "\t cg: 1\n", + "Step: 6, Res: 16.248221\n", + "\t cg: 7\n", + "Step: 7, Res: 14.348478\n", + "\t cg: 1\n", + "Step: 8, Res: 2.042189\n", + "\t cg: 16\n", + "Step: 9, Res: 2.472199\n", + "\t cg: 1\n", + "Step: 10, Res: 0.627561\n", + "\t cg: 24\n", + "Step: 11, Res: 0.641095\n", + "\t cg: 2\n", + "Step: 12, Res: 0.365611\n", + "\t cg: 47\n", + "Step: 13, Res: 0.288282\n", + "\t cg: 19\n", + "Step: 14, Res: 0.239600\n", + "\t cg: 100\n", + "Step: 15, Res: 0.198678\n", + "\t cg: 100\n", + "Total time: 9.16 s\n", + "Freed 690473860 bytes.\n" + ] + } + ], + "source": [ + "%%bash\n", + "\n", + "DEBUG_LEVEL=4 bart ncalib -g -N -i16 -t traj -B subbasis tmp_ksp sens_ncalib" + ] + }, + { + "cell_type": "markdown", + "id": "d7a097cd", + "metadata": { + "id": "d7a097cd" + }, + "source": [ + "### Perform reconstruction\n", + "\n", + "Using estimated coil sensitvities, we can now perform parrallel imaging reconstruction with `bart pics`. We use the following parameter for iterations and regularization." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7122e0f6", + "metadata": { + "id": "7122e0f6" + }, + "outputs": [], + "source": [ + "ITER=100\n", + "REG=0.0005\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "3a3d91b5", + "metadata": { + "id": "3a3d91b5", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "cc81615d-1477-41f6-f709-f3d626709fc3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Basis: [256 256 1 18 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "Max: [256 256 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "GPU reconstruction\n", + "[ 1 512 1 18 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "[256 256 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 512 1 18 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [256 256 1 18 1 1 4 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 4 1 1 1 1 1 1 1 1 1 ]\n", + "NUFFT: Toeplitz mode\n", + "psf_dims: [256 256 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 ]\n", + "ksp : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "cim : [512 512 1 1 1 1 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "traj: [ 3 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "wgh : [ 1 512 1 1 1 1131 1 1 1 1 1 1 1 1 1 1 1 ]\n", + "bas : [ 1 1 1 1 1 1131 16 1 1 1 1 1 1 1 1 1 1 ]\n", + "Scaling: 0.001372 (max = 0.001967/p90 = 0.001372/median = 0.000241)\n", + "Inverse scaling of the data: 0.001372\n", + "Maximum eigenvalue: 1.291646e+00\n", + "Maximum eigenvalue: 1.29e+00\n", + "l1-wavelet regularization: 0.000500\n", + "Regularization terms: 1, Supporting variables: 0\n", + "FISTA\n", + "lsqr: add GPU wrapper\n", + "#It 000: 1.000000 \n", + "#It 001: 0.252686 \n", + "#It 002: 0.080538 \n", + "#It 003: 0.037267 \n", + "#It 004: 0.026370 \n", + "#It 005: 0.022633 \n", + "#It 006: 0.018049 \n", + "#It 007: 0.013382 \n", + "#It 008: 0.010236 \n", + "#It 009: 0.008546 \n", + "#It 010: 0.007322 \n", + "#It 011: 0.006117 \n", + "#It 012: 0.005053 \n", + "#It 013: 0.004290 \n", + "#It 014: 0.003777 \n", + "#It 015: 0.003374 \n", + "#It 016: 0.003010 \n", + "#It 017: 0.002693 \n", + "#It 018: 0.002441 \n", + "#It 019: 0.002245 \n", + "#It 020: 0.002083 \n", + "#It 021: 0.001933 \n", + "#It 022: 0.001789 \n", + "#It 023: 0.001651 \n", + "#It 024: 0.001521 \n", + "#It 025: 0.001402 \n", + "#It 026: 0.001296 \n", + "#It 027: 0.001203 \n", + "#It 028: 0.001119 \n", + "#It 029: 0.001043 \n", + "#It 030: 0.000974 \n", + "#It 031: 0.000912 \n", + "#It 032: 0.000857 \n", + "#It 033: 0.000811 \n", + "#It 034: 0.000774 \n", + "#It 035: 0.000744 \n", + "#It 036: 0.000718 \n", + "#It 037: 0.000694 \n", + "#It 038: 0.000672 \n", + "#It 039: 0.000650 \n", + "#It 040: 0.000629 \n", + "#It 041: 0.000609 \n", + "#It 042: 0.000589 \n", + "#It 043: 0.000571 \n", + "#It 044: 0.000555 \n", + "#It 045: 0.000540 \n", + "#It 046: 0.000526 \n", + "#It 047: 0.000514 \n", + "#It 048: 0.000504 \n", + "#It 049: 0.000495 \n", + "#It 050: 0.000488 \n", + "#It 051: 0.000482 \n", + "#It 052: 0.000477 \n", + "#It 053: 0.000472 \n", + "#It 054: 0.000469 \n", + "#It 055: 0.000465 \n", + "#It 056: 0.000463 \n", + "#It 057: 0.000460 \n", + "#It 058: 0.000458 \n", + "#It 059: 0.000456 \n", + "#It 060: 0.000454 \n", + "#It 061: 0.000453 \n", + "#It 062: 0.000452 \n", + "#It 063: 0.000450 \n", + "#It 064: 0.000449 \n", + "#It 065: 0.000448 \n", + "#It 066: 0.000447 \n", + "#It 067: 0.000446 \n", + "#It 068: 0.000445 \n", + "#It 069: 0.000444 \n", + "#It 070: 0.000443 \n", + "#It 071: 0.000442 \n", + "#It 072: 0.000441 \n", + "#It 073: 0.000441 \n", + "#It 074: 0.000440 \n", + "#It 075: 0.000440 \n", + "#It 076: 0.000439 \n", + "#It 077: 0.000439 \n", + "#It 078: 0.000438 \n", + "#It 079: 0.000437 \n", + "#It 080: 0.000436 \n", + "#It 081: 0.000435 \n", + "#It 082: 0.000435 \n", + "#It 083: 0.000434 \n", + "#It 084: 0.000433 \n", + "#It 085: 0.000432 \n", + "#It 086: 0.000432 \n", + "#It 087: 0.000431 \n", + "#It 088: 0.000430 \n", + "#It 089: 0.000429 \n", + "#It 090: 0.000429 \n", + "#It 091: 0.000428 \n", + "#It 092: 0.000427 \n", + "#It 093: 0.000426 \n", + "#It 094: 0.000426 \n", + "#It 095: 0.000425 \n", + "#It 096: 0.000425 \n", + "#It 097: 0.000425 \n", + "#It 098: 0.000425 \n", + "#It 099: 0.000424 \n", + "\n", + "\t\tFISTA iterations: 100\n", + "Total Time: 123.877349\n", + "Enter BART loop_step: start=0 idx=0, idx_p=0, final_ret=0.\n", + "BART loop_step finish: idx >= total: 1 OR 0 != final_ret: 0.\n", + "Freeing 8 bytes.\n", + "Freeing 8 bytes.\n", + "Freeing 8 bytes.\n", + "Freeing 16 bytes.\n", + "Freeing 16 bytes.\n", + "Freeing 4096 bytes.\n", + "Freeing 12800 bytes.\n", + "Freeing 12800 bytes.\n", + "Freeing 12800 bytes.\n", + "Freeing 41472 bytes.\n", + "Freeing 41472 bytes.\n", + "Freeing 147968 bytes.\n", + "Freeing 147968 bytes.\n", + "Freeing 147968 bytes.\n", + "Freeing 557568 bytes.\n", + "Freeing 557568 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2097152 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2130048 bytes.\n", + "Freeing 2170592 bytes.\n", + "Freeing 9437184 bytes.\n", + "Freeing 33554432 bytes.\n", + "Freeing 37748736 bytes.\n", + "Freeing 37748736 bytes.\n", + "Freeing 150994944 bytes.\n", + "Freeing 150994944 bytes.\n", + "Freed 441242904 bytes.\n" + ] + } + ], + "source": [ + "%%pybash\n", + "# # reconstruction with subspace constraint\n", + "bart pics -g -e -d5 -i {ITER} -R W:$(bart bitmask 0 1):$(bart bitmask 6):{REG} -B subbasis -t traj tmp_ksp sens_ncalib subspace_reco" + ] + }, + { + "cell_type": "markdown", + "id": "7d0461f8", + "metadata": { + "id": "7d0461f8" + }, + "source": [ + "We can visualize the first 4 coefficients projected onto our data set" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "53cca807", + "metadata": { + "id": "53cca807", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 280 + }, + "outputId": "917a110b-d051-4d48-ae57-581297b66017" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "ps.plotCoefficientMaps()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "649fe1a6", + "metadata": { + "id": "649fe1a6" + }, + "outputs": [], + "source": [ + "%%bash\n", + "## by chance, 2nd coefficient map also suitable for mask\n", + "bart slice 6 1 subspace_reco - | bart threshold -B 0.3 - mask\n", + "bart fmac mask subspace_reco subspace_reco" + ] + }, + { + "cell_type": "markdown", + "id": "498cd337", + "metadata": { + "id": "498cd337" + }, + "source": [ + "### Temporal Signal Evolution\n", + "\n", + "We can also project our subbasis onto all spokes, resulting in temporal signal evolution." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "337338b7", + "metadata": { + "id": "337338b7" + }, + "outputs": [], + "source": [ + "%%bash\n", + "bart fmac -s $(bart bitmask 6) subbasis subspace_reco imgs" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "6e62143e", + "metadata": { + "id": "6e62143e", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 356 + }, + "outputId": "815f932f-9f37-4602-c552-a12b45d88583" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "ps.plotTemporalEvolution()\n" + ] + }, + { + "cell_type": "markdown", + "id": "6662df65", + "metadata": { + "id": "6662df65" + }, + "source": [ + "### T1 Map from Reconstructed Images\n", + "Using `bart mobafit` we obtain T1 parameter map via pixel-wise fitting." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4d5e4eaa", + "metadata": { + "id": "4d5e4eaa", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1531ed03-2d2e-463d-99b3-19ce66cf5913" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Temp file for pipe: bart-5IlUgI\n", + "Step: 0, Res: 5747.415077\n", + "\t cg: 11\n", + "Step: 1, Res: 143.756656\n", + "\t cg: 10\n", + "Step: 2, Res: 20975142421.382660\n", + "\t cg: 50\n", + "Step: 3, Res: nan\n", + "\t cg: 50\n", + "Step: 4, Res: nan\n", + "\t cg: 50\n", + "Step: 5, Res: nan\n", + "\t cg: 50\n", + "Step: 6, Res: nan\n", + "\t cg: 50\n", + "Step: 7, Res: nan\n", + "\t cg: 50\n", + "Step: 8, Res: nan\n", + "\t cg: 50\n", + "Step: 9, Res: nan\n", + "\t cg: 50\n", + "Step: 10, Res: nan\n", + "\t cg: 50\n", + "Step: 11, Res: nan\n", + "\t cg: 50\n", + "Step: 12, Res: nan\n", + "\t cg: 50\n", + "Step: 13, Res: nan\n", + "\t cg: 50\n", + "Step: 14, Res: nan\n", + "\t cg: 50\n", + "Step: 15, Res: nan\n", + "\t cg: 50\n", + "Step: 16, Res: nan\n", + "\t cg: 50\n", + "Step: 17, Res: nan\n", + "\t cg: 50\n", + "Step: 18, Res: nan\n", + "\t cg: 50\n", + "Step: 19, Res: nan\n", + "\t cg: 50\n", + "Total Time: 4.59 s\n", + "Freed 3611607760 bytes.\n" + ] + } + ], + "source": [ + "%%pybash\n", + "### create vector with inversion times nREP*TR\n", + "bart index 5 {REP} - | bart scale {TR} - TI\n", + "\n", + "DEBUG_LEVEL=4 bart mobafit -g -i20 --init 1:1:1 -B subbasis -L TI subspace_reco - | bart looklocker -t0 -D15.3e-3 - t1map" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "a6cfbe43", + "metadata": { + "id": "a6cfbe43", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 268 + }, + "outputId": "3c844363-4d71-4b29-927a-f9635b9a45d6" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "\n", + "ps.plotT1Map()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.11.2" + }, + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 7bf803db04eda6cbc0d9fd103549e820ff98e68d Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 9 Sep 2025 10:51:46 +0200 Subject: [PATCH 13/17] prep dir for mrirecon-tutorials --- .gitignore => dach_ismrm2025/subspace/.gitignore | 0 README.md => dach_ismrm2025/subspace/README.md | 0 .../subspace/requirements.txt | 0 {src => dach_ismrm2025/subspace/src}/__init__.py | 0 .../src}/__pycache__/__init__.cpython-311.pyc | Bin .../subspace/src}/customStyle.mplstyle | 0 .../subspace/src}/plotSubspace.py | 0 .../subspace/tutorial.ipynb | 0 .../subspace/tutorial_colab.ipynb | 0 9 files changed, 0 insertions(+), 0 deletions(-) rename .gitignore => dach_ismrm2025/subspace/.gitignore (100%) rename README.md => dach_ismrm2025/subspace/README.md (100%) rename requirements.txt => dach_ismrm2025/subspace/requirements.txt (100%) rename {src => dach_ismrm2025/subspace/src}/__init__.py (100%) rename {src => dach_ismrm2025/subspace/src}/__pycache__/__init__.cpython-311.pyc (100%) rename {src => dach_ismrm2025/subspace/src}/customStyle.mplstyle (100%) rename {src => dach_ismrm2025/subspace/src}/plotSubspace.py (100%) rename tutorial.ipynb => dach_ismrm2025/subspace/tutorial.ipynb (100%) rename tutorial_colab.ipynb => dach_ismrm2025/subspace/tutorial_colab.ipynb (100%) diff --git a/.gitignore b/dach_ismrm2025/subspace/.gitignore similarity index 100% rename from .gitignore rename to dach_ismrm2025/subspace/.gitignore diff --git a/README.md b/dach_ismrm2025/subspace/README.md similarity index 100% rename from README.md rename to dach_ismrm2025/subspace/README.md diff --git a/requirements.txt b/dach_ismrm2025/subspace/requirements.txt similarity index 100% rename from requirements.txt rename to dach_ismrm2025/subspace/requirements.txt diff --git a/src/__init__.py b/dach_ismrm2025/subspace/src/__init__.py similarity index 100% rename from src/__init__.py rename to dach_ismrm2025/subspace/src/__init__.py diff --git a/src/__pycache__/__init__.cpython-311.pyc b/dach_ismrm2025/subspace/src/__pycache__/__init__.cpython-311.pyc similarity index 100% rename from src/__pycache__/__init__.cpython-311.pyc rename to dach_ismrm2025/subspace/src/__pycache__/__init__.cpython-311.pyc diff --git a/src/customStyle.mplstyle b/dach_ismrm2025/subspace/src/customStyle.mplstyle similarity index 100% rename from src/customStyle.mplstyle rename to dach_ismrm2025/subspace/src/customStyle.mplstyle diff --git a/src/plotSubspace.py b/dach_ismrm2025/subspace/src/plotSubspace.py similarity index 100% rename from src/plotSubspace.py rename to dach_ismrm2025/subspace/src/plotSubspace.py diff --git a/tutorial.ipynb b/dach_ismrm2025/subspace/tutorial.ipynb similarity index 100% rename from tutorial.ipynb rename to dach_ismrm2025/subspace/tutorial.ipynb diff --git a/tutorial_colab.ipynb b/dach_ismrm2025/subspace/tutorial_colab.ipynb similarity index 100% rename from tutorial_colab.ipynb rename to dach_ismrm2025/subspace/tutorial_colab.ipynb From 5ba3a70b30af91a7477c32e9ff1e36ff13247962 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 9 Sep 2025 10:56:48 +0200 Subject: [PATCH 14/17] remove falsely tracked file --- .../src/__pycache__/__init__.cpython-311.pyc | Bin 190 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 dach_ismrm2025/subspace/src/__pycache__/__init__.cpython-311.pyc diff --git a/dach_ismrm2025/subspace/src/__pycache__/__init__.cpython-311.pyc b/dach_ismrm2025/subspace/src/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 86e6ef6bd5fe5a8a98284d224a7a80fcaddbffa1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 190 zcmZ3^%ge<81ZQm5WPs?$AOZ#$p^VRLK*n^26oz01O-8?!3`I;p{%4TnuR#5b{M=Oi zvXa!C)T-=E{h-u>{9=9gqWsc=Vtq&V_|Vkk?9?Lt;?ktzg2d$15JUa){G#mQjQj%c z%+wqs10z%Y;-X~z`1s7c%#!$cy@JYL95%W6DWy57c15f}8$fO-<_8iVm>C%vKQO?E IB4(f%0N4R9_5c6? From c6f27f44c9f577161d6910fb68d22710944c15fe Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 9 Sep 2025 11:02:47 +0200 Subject: [PATCH 15/17] Add dach_ismrm info to readme --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 4db912c..3f9f07b 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,12 @@ The most up-to-date information can be found at the official BART website: http: **Quick Installation** See the [Quick-Install guide](doc/quick-install.md) for quick installation instructions for BART. +## DACH_NORDIC ISMRM 2025 +**Title**: Non-Cartesian T1 | Subspace-Constrained Reconstruction +**Meeting**: [2025 DACH-Nordic ISMRM 2025, Kiel, Germany](https://ismrm-dach-2025.moincc.de/) +**Material**: [./dach_ismrm2025/subspace/](./dach_ismrm2025/subspace) +**Date**: September 14, 2025 + ## DS-ISMRM PhD Training 2025 **Title**: Translational cardiovascular MR Imaging **Meeting**: [2025 DS-ISMRM PhD Training, Ulm, Germany](https://www.uni-ulm.de/einrichtungen/moman/forschungsbereiche/academy/phd-training-2025) From 85f98ce2e3ead1754a270a57d09e3dca11339965 Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 9 Sep 2025 11:04:56 +0200 Subject: [PATCH 16/17] FIX: style --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3f9f07b..0f2d3e3 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ See the [Quick-Install guide](doc/quick-install.md) for quick installation instr ## DACH_NORDIC ISMRM 2025 **Title**: Non-Cartesian T1 | Subspace-Constrained Reconstruction **Meeting**: [2025 DACH-Nordic ISMRM 2025, Kiel, Germany](https://ismrm-dach-2025.moincc.de/) -**Material**: [./dach_ismrm2025/subspace/](./dach_ismrm2025/subspace) +**Material**: [`./dach_ismrm2025/subspace/`](./dach_ismrm2025/subspace) **Date**: September 14, 2025 ## DS-ISMRM PhD Training 2025 From b1f0378825f01c50e3ef2842d2227e4059395e0c Mon Sep 17 00:00:00 2001 From: Vitali Telezki Date: Tue, 9 Sep 2025 11:24:06 +0200 Subject: [PATCH 17/17] FIX: url colab --- dach_ismrm2025/subspace/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dach_ismrm2025/subspace/README.md b/dach_ismrm2025/subspace/README.md index 4c6ca3b..b04026d 100644 --- a/dach_ismrm2025/subspace/README.md +++ b/dach_ismrm2025/subspace/README.md @@ -2,7 +2,7 @@ Demonstrate subspace reconstruction for inversion recovery FLASH acquisition both on numerical phantom and data acquired with pulseq sequence generated with `bart seq`. - [Jupyter Notebook](./tutorial.ipynb) -- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mrirecon/bart-workshop/blob/master/dach-ismrm_2025/subspace/tutorial_colab.ipynb) +- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mrirecon/bart-workshop/blob/master/dach_ismrm2025/subspace/tutorial_colab.ipynb)