From 0aa9b67c5daec100ecc351eaf0b81f8dadd1976f Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Thu, 6 Jun 2024 13:55:34 +0100 Subject: [PATCH 01/13] first commuit --- requirements.txt | 1 + src/qp/__init__.py | 2 + src/qp/projectors/__init__.py | 3 + src/qp/projectors/projector_base.py | 60 ++++++++++++++++++ src/qp/projectors/projector_moments.py | 57 +++++++++++++++++ src/qp/projectors/projector_shifts.py | 44 +++++++++++++ src/qp/projectors/tests/__init__.py | 0 src/qp/projectors/tests/dummy.npz | Bin 0 -> 36856 bytes .../projectors/tests/test_projector_base.py | 35 ++++++++++ .../tests/test_projector_moments.py | 39 ++++++++++++ .../projectors/tests/test_projector_shifts.py | 39 ++++++++++++ 11 files changed, 280 insertions(+) create mode 100644 src/qp/projectors/__init__.py create mode 100644 src/qp/projectors/projector_base.py create mode 100644 src/qp/projectors/projector_moments.py create mode 100644 src/qp/projectors/projector_shifts.py create mode 100644 src/qp/projectors/tests/__init__.py create mode 100644 src/qp/projectors/tests/dummy.npz create mode 100644 src/qp/projectors/tests/test_projector_base.py create mode 100644 src/qp/projectors/tests/test_projector_moments.py create mode 100644 src/qp/projectors/tests/test_projector_shifts.py diff --git a/requirements.txt b/requirements.txt index 25bd9b93..ee5280c7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -5,3 +5,4 @@ scikit-learn setuptools_scm tables-io[full] deprecated +multipledispatch diff --git a/src/qp/__init__.py b/src/qp/__init__.py index f23f038f..09bb8f35 100644 --- a/src/qp/__init__.py +++ b/src/qp/__init__.py @@ -34,3 +34,5 @@ from . import packing_utils from . import test_funcs + +from . import projectors diff --git a/src/qp/projectors/__init__.py b/src/qp/projectors/__init__.py new file mode 100644 index 00000000..17d9ce79 --- /dev/null +++ b/src/qp/projectors/__init__.py @@ -0,0 +1,3 @@ +from .projector_base import ProjectorBase +from .projector_shifts import ProjectorShifts +from .projector_moments import ProjectorMoments diff --git a/src/qp/projectors/projector_base.py b/src/qp/projectors/projector_base.py new file mode 100644 index 00000000..cb5fe001 --- /dev/null +++ b/src/qp/projectors/projector_base.py @@ -0,0 +1,60 @@ +from ..ensemble import Ensemble +import numpy as np +from multipledispatch import dispatch + + +class ProjectorBase(object): + @dispatch() + def __init__(self): + self._project_base() + self._project() + + @dispatch(np.ndarray, np.ndarray) + def __init__(self, zs, pzs): + self._project_base(zs, pzs) + + @dispatch(Ensemble) + def __init__(self, ens): + self._project_base(ens) + + @dispatch() + def _project_base(self): + raise NotImplementedError + + @dispatch(np.ndarray, np.ndarray) + def _project_base(self, zs, pzs): + self.pzs = self._normalize(pzs) + self.z = zs + self.pz_mean = np.mean(self.pzs, axis=0) + self.prior = None + + @dispatch(qp.ensemble.Ensemble) + def _project_base(self, ens, z=None): + if z is None: + z = np.linspace(0, 1.5, 45) + self.z = z + pzs = ens.pdf(z) + pzs = ens.objdata()['pdfs'] + self.pzs = self._normalize(pzs) + self.pz_mean = np.mean(self.pzs, axis=0) + self.prior = None + + def _normalize(self, pzs): + norms = np.sum(pzs, axis=1) + pzs /= norms[:, None] + return pzs + + def evaluate_model(self, *args): + raise NotImplementedError + + def get_prior(self): + if self.prior is None: + self.prior = self._get_prior() + return self.prior + + def sample_prior(self): + prior = self.get_prior() + return prior.rvs() + + def save_prior(self): + raise NotImplementedError diff --git a/src/qp/projectors/projector_moments.py b/src/qp/projectors/projector_moments.py new file mode 100644 index 00000000..391b1705 --- /dev/null +++ b/src/qp/projectors/projector_moments.py @@ -0,0 +1,57 @@ +import numpy as np +from ..ensemble import Ensemble +from multipledispatch import dispatch +from .projector_base import ProjectorBase +from numpy.linalg import eig, cholesky +from scipy.stats import multivariate_normal as mvn + + +class ProjectorMoments(ProjectorBase): + @dispatch() + def __init__(self): + self._project_base() + self._project() + + @dispatch(np.ndarray, np.ndarray) + def __init__(self, zs, pzs): + self._project_base(zs, pzs) + self._project() + + @dispatch(Ensemble) + def __init__(self, ens): + self._project_base(ens) + self._project() + + def _project(self): + self.pz_cov = self._get_cov() + self.pz_chol = cholesky(self.pz_cov) + + def _get_cov(self): + cov = np.cov(self.pzs, rowvar=False) + if not self._is_pos_def(cov): + print('Warning: Covariance matrix is not positive definite') + print('The covariance matrix will be regularized') + jitter = 1e-15 * np.eye(cov.shape[0]) + w, v = eig(cov+jitter) + w = np.real(np.abs(w)) + v = np.real(v) + cov = v @ np.diag(np.abs(w)) @ v.T + cov = np.tril(cov) + np.triu(cov.T, 1) + if not self._is_pos_def(cov): + print('Warning: regularization failed') + print('The covariance matrix will be diagonalized') + cov = np.diag(np.diag(cov)) + return cov + + def _is_pos_def(self, A): + return np.all(np.linalg.eigvals(A) > 0) + + def evaluate_model(self, pz, alpha): + z = pz[0] + pz = pz[1] + return [z, pz + self.pz_chol @ alpha] + + def _get_prior(self): + return mvn(np.zeros_like(self.pz_mean), + np.ones_like(self.pz_mean)) + diff --git a/src/qp/projectors/projector_shifts.py b/src/qp/projectors/projector_shifts.py new file mode 100644 index 00000000..11be278e --- /dev/null +++ b/src/qp/projectors/projector_shifts.py @@ -0,0 +1,44 @@ +import numpy as np +from ..ensemble import Ensemble +from multipledispatch import dispatch +from .projector_base import ProjectorBase +from scipy.interpolate import interp1d +from scipy.stats import multivariate_normal + + +class ProjectorShifts(ProjectorBase): + @dispatch() + def __init__(self): + self._project_base() + self._project() + + @dispatch(np.ndarray, np.ndarray) + def __init__(self, zs, pzs): + self._project_base(zs, pzs) + self._project() + + @dispatch(Ensemble) + def __init__(self, ens): + self._project_base(ens) + self._project() + + def _project(self): + self.shift = self._find_shift() + + def evaluate_model(self, pz, shift): + z = pz[0] + pz = pz[1] + z_shift = z + shift + pz_shift = interp1d(z_shift, pz, + kind='linear', + fill_value='extrapolate')(z) + return [z, pz_shift] + + def _find_shift(self): + stds = np.std(self.pzs, axis=1) # std of each pz + s_stds = np.std(stds) # std of the z-std + m_stds = np.mean(stds) # mean of the z-std + return s_stds / m_stds + + def _get_prior(self): + return multivariate_normal([0], [self.shift**2]) diff --git a/src/qp/projectors/tests/__init__.py b/src/qp/projectors/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/qp/projectors/tests/dummy.npz b/src/qp/projectors/tests/dummy.npz new file mode 100644 index 0000000000000000000000000000000000000000..b0f54d8da5ce6b502de8ed000638658f6e7e8a3d GIT binary patch literal 36856 zcmbrlWmJ{l7sp8nB1(g_bl0VGZ$dGMp9m@_A_xj7U7~=bL8*X%B1(&ZA_fi84N7-Q z2}nv9;N1Vrnl)?Q&YZQL^{jjD^X8ss-+lJ}e81NF_{@`%ko@nW zBw;4G?IG>#dW)2V{{Ni$-&6nl=6@sB=&a#sb5as-5?>M9s~$G)B5J%M8rM`rBzZ-y zxww0}TRUHNaksttzj-}tM~|z-c@KMQ*Q>9si{+A%}i_|z5J4m_p8@l)x1C$1g)_JSs* z3!j?2IX*GpjbQDy_KDDoGtTfl>~E9J43!0hyae zpWzf<2s_)PwLXQ?^lIF>@!yavfybRieHweX$r}U4r}1^h9OpvF4Ejm5xtfa3qS1%^ z`p<2%$gdj5A?7xRTa~w5Vp-;~Nzbxww`3lZ+I86NEx)6ysfcqI*#hbe)6{BYEgILh`?hiWncR|4)GYZ|Z;J|GxkK z3J`*Ex0=8wT(F=DULq@tbOKD~=JgBh@a?zZJ zNqsZw#%pV^v^4dHlw}U&Ld9Dai~GP~7H^Z3SHmE^mgFy=DtPQ2SpMzCXE^@O>e_w2 zbzo&)<*3r8!1$TGI(IH0P98U)7n#AzK=e;BPt za#|bx`uGA{y%A|IJX=gSq>2@0$~Qd3W$}pR*<5vQZftFTHLFg=fJp~KHbYWLa69Ee zo{sncC~?@_8qZmPowcfVqm-X;w#D#*m(x$sa(wwnp>!TH?(6jamFonT$o%)e^BZ9x zwpsVkObeL)*5vWeYJ>bG=ZN&@)sW>IFeQRHkZ`-oykAHVCK!GP7w53TnT-R!OG6b9 zHT|0Zk7EHm&W(D)w3iLP6(-W;DRTf0^xt6Q$b%V*eD4SU>X*1M!)O zu+Wqfb|GsW*m7^ud8^am_|8G6n7|8iQ~V znmgJC$Kl?f=VQLY2^eF#TWk?935Uu&EtsYT!J^RCBY~m~7~-V}jD6X_<}7t0@K`EP zL|*tj;t&lvM?cIy%DDrx+lO8_Y6n44=bIqwA5)VaY`OY)s!A2j=ZOrYhQ1OaosmaMVw0M8xo@EWgyHq(>x6yG)Y_u&6By$@NM?G3_{zVvgPoKtX(jD;sRbqQ=ZnU3GkWkbzYLfq+F!bmmuV3*lk8Xv!7 z40>5Ci!T#f9JB2Xb=5+m(Zm{e zLo+A}aK&6aR15a$a}}34KS1ZYF!hZuS`a-ry-=W~1OEXm|1z6eMI_T=0AeJd!WT_nm(XpGIdb8itl&U@Pj46A3B0 zf1h%gdO?HMfgwT^>pZxx;Xp*h0a0vg4!^jpCV`a60@1@ZVwh*+_ApCN z3eBsBu51d(;ZTR)UVMfkmSxD;JbI^$9n&ji_g|}G;hzC}?PfKUUJ)0ky{n2jQ+|s> zS}M4?Mq{|&LdpL6kjjUP;uKVo85!{Sk*}@AXf!--l`u*tuCx1tdyh~1_rM(O zJEmd9QD71*en)n&3*4qDWU?QW0mBt~nu$DbSjuwGcfT71UkTP}jh@}0kpHhN*Juf< zZS1;lxorcRceFxM-WtFubM=hW38*P3t!a?81Y=~lTRwXaHezSk^2y`i_ufH0{YxK# zcGYx3p{oi0%kQL}`rQo%mHgKenma&F=yF&tXDxhx{#5DQvrgFMRI6S zC9zXWt?f{U9CEOq@6cG0Lz^{^o*T6C*tQWl`s)S(7f;!LrpcB<&Ah^Df!m@;kQF~? zHm``?^a(T$ELuos_I8}Gr-Nkq0jxpFh`--uIK6aNK?Q}n5Q#K7l&a((SUoI(%&Zl! z!xwpxLhU_`v4~s{A9=^BhhHwtE3J zy_FFSdZ7@>bKW=CHWip3u1QRXZi9WVlvhyiDtN2*_-PtU1BIp=^N{{148P_*#QdQb z+Uvk?xu_l1o(7)k|I-T0PBm;**aA2IkbN|`-VR++2jd!ZyJ7xCLWh0Y07R0vg^E=7 zgX*!)YPGx`@E9&Mab+5VoIKUS;Tkq<-+nHy)g^*D-Y$ofy<~9IuPQ~kR0h357!*|g z$>2lbEduvl0%ED+N%}TxaAf*lAVte*Zzg zlu`}dyw)}2%hj;*mK4X^&q{cIRdt;0yfg+36PVvw^Ptpt_0ZR9W)yk)U&SlMgGlqN z^O3DE2|i1Hck!&-1~@CMTHZT91j{+~E}Cm!pvf>_HYs5au0Jgb_AJ?e|Bf=gvfx~X zcj7OkXaYyTG}pm9Ik+51zIy*hYPkW`LA54Jx5#kBoa6zpQy{0}=P90yEx4fiWlYz} z4&v`g)Sb2TfIF)zPpK(=0ip!oTGZA8tLcfkKe4?KqQ1w*Nj3qLe3_4rNMrZ zY7fVMjVQA?t4k*p<^b_rL4~1_jDQ zQc7Ah^brzZe#3=l@p*p`tuV4>v3FVr%Ag~a!3^&$1r)YX+tbokz~)!3ViINq?CUYi z79W#Dchgoa)%^;%@20{v{R3*mIwpKia8nZn^+$QP*442jUq-iaRTZ6N0_MlBDkCGm zb9<}10#-3!`cM==K-nQ%|9Ah1AkEP~%oA}e_)w2EpgF4>*3K6gRug|$QsnsXi}qP? z`Sn%${l7UNjj)r?)XGv|Bm)%0HghD zz5B1zAjq_+InuEeT6P=jJa3M|Po2DrMcE4wZK;0b;b|tcz8#pop2>#>Um6rV+{N+C z#hTRn+Pu@)@hx~y(?h^ z+_rnG&7&!gj)Qr*t6s|3eJY=&HcuTx>gQ7XIo0uVNhREGD&In#C5KNJk5pDZ*E(UVGcFIsX$ANm*?O4XUPeF1dXX$xX9oW>o-r&5@ z2eeDW!Ydwg@XnK_fNqQfmkVChbX*fdw!Jk=={5q&&_*5Sky6CtJfgC+4^{Af{5c2b ze~L&?Z$8$jAd3X1qE|XSg6LSn!4tVlK!(3y+o7n2fdv9>e*_UvR}4QCtW!hD`dDK_ z8zn4wJvV=9RSr+<$SeiO$>Ma;k1>bu;`n_a=Bdp^eiT>W33*=3h)3qRLhi2q09V2@ zm1xOtaA#9|M76U6Dg-EN1@=BbX4A+^i}?(2GrC?8m3{}DxUVGBUax{H7f$gT`gMUM zU+w0N{2}0!WaB*+R61cWcQU6Y*3%FltsoI!!ge3WjK`NyLD3~?;cGvzr zgak@N^2ac}v(Vz}_;51BL!L27o7Xm0lpNVx3yvmo>r%r8C-@E2gm&C4{^ zv+F|0@+jT$qM8)C1?T?JQjtY7&3)RY-2{AlBk)=DUjjZp_Gsw11pz&dyyV;~lf}S& z$A3PElgG;ZEYr1TN?6uc=9G6*6<3(v{d1;PM=s;EXqjdWyfSjOD#}|8-N8)%4YeW) zXcxSRQZ#z?RA^+LNP3xar-Js%nLLB zEi8Svl1EjlEW>Fl1suH@%N`)4fWh+tGwciUXhq7nBDSN5^?OmvPW&pUT)w>b-c1ev z1n8FcifLk@?$cYpCJ}eOu;nyWspB^zue~&4KI(mup81=LA3u%$%uqIC!PMYsvZbr! zXvuW(g{)!*(EjfD<*AYix2vPxxZg~IT-~Ry9`-ze`;-L3zccq>jn=s3OSZjXI zP4R1RNc5_J80`gUlxMyDf*m1WLYVfEW;*;Wog%n-7l73O-?G4q&u}Sl`M6Bw2e^^C zbZ;T_IZS;l=6k+v0rV`QLuNic@MLe*>*`=ASk>(e3zk$tVi1Q|+-Mh!k({JH^6nda zXA-Hkf60PFAu(OvHiG!cmR&TAMFtb8CwiiY>o;Wek>&g~4GewQq;C|UigvP^HnG73 zjLxvx%%>5+DkEdEH-BWYOU$?WpNuMw=8nCWUIHw%J1zC%wI)6hsCi9uRRe`8XV2^2 zQbvAL$)DN}WKdi@LS>hm7im`0>12TkJ#DDXhf+!Lr&F)$!-{%vs`T@-QXu9v2AzUD zzn>6gUaEAr{wLfGO_T9CG!NzHwHp(N_0@2zv{3Qqe6W19N44}Z8SZ?7oy$kVHFuuw z1q=y?Xny+bN0-CsqiJJfrA+h84!lnpjvu-h3XdhO5!??90?YmxK4zA6ICj^yC}M6G z{tJnHs`+FKGXKd+Jv}=EpC{QIIM|;9N&0L5o3EQ;iurK=%vL{4-?V*wjrjgbIL)P& znZLs6M_o)jI-lUiKriKOrZV`-Y(K!p)&h42 z*EBj8FCRfN)%mEWwTEyy{94+r+r2O)b&x4EvJ2j%+E8(8egzuKq$5HBqd=&1xt0*T z40%}(c)sv&!%NeJ4^hEu5MH`Q`?hHUxE7NhHP$`=(xN20pGQL=XP;_-PNXli_@&$P zp7R2}#h}(aT5sSFGUyik)CPrObA6llW+3L7zlPiD8muJSMnthK!p_49!pVq1_!Yc= z%|6Qket%lsWfi&$&oaJ_i>*dOmDl7s%XDJC5jvD@IXMapO{PrucjjSVtVa4x?p1hG zG!yQtx&fLKJG~9xci?khZ{I664lFEX{p<8c7$*YEIzLcLqqr8m{=U01s7hixB@rl# zRBvM2JIV?8(1h|q7RV#(A0M4NRSMWqUSP{NLhSQ$KM(tyu_S8IE`oxd@CY!7q~Jr{QCn z?dKASZZKg}c8zt31gYilFpY?62vwwBuFUEHdYuQC_4vAA)G1e3=VcwxeQK+bb$JhF zzxRqtUo^wncK!Ry+PyH?-K3PYzXLubzGC_)@ENMj9te@$%mUXll61G~Mqsk7duhMn zBE%p2VJCI#2hgpa8e8s~0HNz?XR1F`0f#e-cH~ks99<3>IQL})Qlr(Jp190I&U0Z% zEu=!PlL7g8ubGjz>)mzcMn1HPcO3QRmBIhsGQVEZP(nc=s=%QVMXb=Q*48s1?u&1> zC~Ygm(7bjyus~h`HzkwUtJpPg_4l@pp_>-sM*ZK}ehtiBeeNMoupWW;~Qk4u5Gb#b5Ll#g*DzxlP)A$kn@$rSS~wZfF+HiOib3I-hNp>jBC~ISzc-}>S~!!B>3|64TN?wNw*X$As6P|F$d0X@ zZcAy$_Tz;j-(?|>W_VkB^a+=26_9Bu&l`Nog^vb1>0d*NA=EkY%`?vq7-{Bk#ik*! zwQarC@v0XR^R8569&Cm(y88(mZ}Z^{!vKe*VJ6U19z8VW7X$Y;%4t=T++f)79*wZK z2WVYs<6zfng<13I;eO2#IIm5J>vWodL*!o+>Q|>g4vf8a6i49dL0284)h;NhxZAWB z*$iju&#~3GmqHJ9-8=u>2H+%UWb-qP!)s}MOElMaxO= zsE-XWb%3ImlzKld{xfj6YH}F2bn|>;EcozRM8eltArb8B3KWQ2mPB9ar%7w{1U#%r zfAnjRJbqMvu=r+O5%oKsY}wKg^R`ftPAQQ?+dYvrVfahrq0JAn3NNc7*T0EB7i(2< zx?(k{T1ge%b(M~>Z73sov+ob*cS@Mb)mheBBaOO#dY2S>xbQ+uQw=%oILy=OoFZN6 zfq9Ob>AT7G(0{n3T{OE0*4`^^m64UgL4!{`|5=m+J;Qj$ebEMZHEJ&`IrA0#f7RYR z`=}efuqQ8Z(l^0Opkp^X`3LBDcCcgg?n#(#%{X+z#1LriZ~Z>Q6b@PEENwnTq(j5q zf8?i5=0iPMdGpVPIta4;%`eo`37_qUD_MPsd3xIAz?SVK#Ime^vN|{m172#yx_+CW zn>|_Y6t@rCX}bF@l<3judCSS9L2B%*xYo1m^9xQNFRjvY?19(^<)y0!1<*UWqzKF8 zP$0;?AZJ_|X;l{CtdJu9TDEEWcU=xcUyU&=OUPoZXZQ@Ql_VZXI-jL&FN$X09@7Pz z6R>uNXT76O3DtA1iqVIwA+N-A!f$a^-2dhZLEG~yFJf+l0fUUu4833+vEFD2dz6&|1}AjV-^ygc zzDsBMxEgc8QrnFzTsakH;}sr`Cx=7V$9XamF+)h1Na~Y5t_=l>N3*@-gy8+co_W*R zY3TB$tScAZfwO1ZsgH({V=GJBPO>~RE(X3|dXdJ1DcgM{l81${!`jO=ctQqAW~p75 zdK56E)ywxxvLa3q1&!-c3aDLpr8=1SUaaS?nSZEILNZD9I(~9>R7(G;JJh3z9uLI@ zHXmrL0to>K>%4$OySJ&JWM1(!*Lpe3rwm1c>b1vsjyK zgMa>wfmI=u&@N5Ee~UH_KD>xK=k@j&q;TFJ8zM9{^XQDeRuRM{31CSbN8b) zq^;;bE>zr4?1LA_sM$F&`!{!ewwVC(b28JfRUXFapaBW)7o@l(6US`BpA64GDcb&g z5Dl&^?_Wy!xj>Y2L<6(zC`{N1S1FpVfoZSp%+8g+V7{}xdt8nIFPFvFbn0{BYkR4L zdN)2KU1`vj=-|f-URJA*r3JBz=UQ85oG>2EnYFzdC5DBHcDp;FlBj1k?bmo*0q^H3 zoTnt}DM^$&V|JE+*1vX&Lfq7mu=MM3a;ORt_Sx3G%22|%YZtD^MJwW;#?$nncNFle z?%Q^uSqWr}bth=v;=nm2-w87FDM*nxxJ}2_2Mw9`KiTh8z|b7iJ|Djl_?x$sam%h7 zNaaptEGSO^!}3*bofDJLu_W=ccx3|a)!XkAxiA5K_jcF9jfP<;NNliiz8B7Nj64u( z{0gI0`@3b9t3i!2BKlN0C0_gV_tuTJ9XRI}rArmm0ryfz?&Zuy!^bV_+`jiO;3J*# zmvDo0IF%U0>$mw7u851DtWUoOeyu+r-bnid%xA>^`@7TuC*2ZCFTEcDM(W!ob+^`F zbmebjQTQI**6wfm>_&-kdJj)TZy!b_Z?kwlBF}*@pZ(65ieT^RffL^o#L$81JX7GX z1UhEYc-T!4_rp)r%vs7(7+yt%``}=N>%x^ivx%e2g|J zcmQ+xBL-85T$)*daD-Gr0eO9X)iD$K$aSBP-qZV~FrnY*j8A|7_DSyJr0!xwlQhxV z&Xbd{zs)1`vQHoMy^`FgTv`V-H?zM{zR8Dkbw6%BE6j&f2041k>U>xYdGqb|Y7-1A zC0ZnW>w}x7=EELAlklS5`G7Ug3U~|DaAjTEf*EGhqwPfQy#BaY<7j!k}d=*8TfZaF5eQKJ>w`78?(;X)v>`Gc|=DVMe=RRdTzMl*~>3@i` zPUgqUyI#4+EM@WBF;e*$O$C&teil!%PC%wa>z|_rGWg>Mohk}T;z7Fc0+%K+6qn7D zOSvwB=4ScQ17O_8ej(CYjxMkhdznNdF5Z4JD9-L|D5NF7537*6yP`)-fm z>^t6m1e~i0xh}CMj2XU<2vMfoxJ4KG-w_WQtV%sLtM2p#o|a#K8R7jEiWiUP{=g2{ zElbgSUOxcMoDRAsgVRL)k92yF*3 zw!-)mDupQDkEHy9BM*N1)F0i0>03t(g91pgy4LU-IoCdXdB`u|Zt;FpdmMJ<50L|B zMxV5gniIu%sjNp|l;n|DQq@F!hscwrx4)%$5HLf<>AUop6b4Xm*cm*RN9O})-bkP&iRZxiCA+Nf6}?;sD!^*jh6B>WYNU7g!9x3 zA&jk|$!%L>!7Xd%561>qLFvb(y4x1hKy|?&<~4g8sB{t*g5-n1_S!`{<@IoA^4H<; zHj9C8ZDpLN(%-^I$>;yttjl03ZBcRfc?~43Ws)q86vAUQB7CJth1}0ICkmz0fQR!E zrQZ2UAQcETrispngiHQ@cLtkaz?AE?dO;76{ID)7=jnj*tP^(IGgV;58+AxgGZ|>p z-qG(1`T+a>{uwQotAMFO>e&fm9e-DGs^|3aNl1KDsYEbcfU4q{<6kOgK-WID>@mjx zxRz&MtrM;Tg>>0|y$@t)e3twZJp&_F+^^qbVJGJ2!J^2s#5zuJ`5*^xi!y#?`@S^zeh2EwaSiLs# z#YSfdYCE0zeqCCF$fh&jFXJj~ORv{ian8WIXa3IQuHEqT^UOPu$6w)$e;Z9YQSTsK zVdM)+=>j?}<74#keIOqF$RRmm2=-qSm-CJp03E5)se!+(aE0)#zsFk-sLA{Hcm}PY zRJEY-0kb1qpE7@=b^I9!k$ygGwv`Q=2D-0)J@^bfSA*66W)SrqD-E4NpC9lpvanP( zdlkA48n5{_&jYbnbBfoRfWv1823_X5c@i2SQcG^ z)w6c>WpGuM@nuAx5FYJwdc0T0iV>1rvR%7B!TI6(y;<%>2)%E9(Kv7bQkK2Fe+$*X zjzQZo@3YlloXf|u9$E$Oj%tnkQ2h#dZgKvczXqWGTVMVOjR{be6{0cs?1yNAs)P1K z8*n-nRC5!mpjJiKk7$Ab+SoOv+=d#cpem+2bFvtUy4Y==A9w}-;-f`9th-^Zg5t1} z?KF(H&mPKsy#x%oXG-lCCxM#pcjB|+Hn?w66PMdk3%>nKBB`?@kf@Wcy|pn%)VV&D z4V{^VZG(sc|nqCPcVon%0g?&-_ZKX{Qo_(M>&nk1@P7JW_JQNruK zabrE*i2QSAb@$I};?Crb68&2Rd|E;`R|4G+7yf4hIL#Q#Q*?JAK3CaQ*qf+>6Q~mBTsL9CQhu?}2C zS{;-R*FY@VGIS$*3H~mK1%0NQ07v1R75z75u*3X2VE0!wn9^KNereDPpG$PeS)9JX zVNRw%zgB7-tIZi7ymT0Euzo#CL&lG_r8SS9x`|_y%*7uut^{07)4#oZkwao%DPWljmwF_?lJbBv>Ca0(ci9eyhpO!V9IHYc5qorYP9@1@}%hhT;0j?a8x z6Tmtp?`B9TynNGpS##?(VD#~@-0DvdliJjjNaPoOq6+kZTsxp;^dschQ*yMu%GP!- z=MWzK%y+p~v{AZSOq3lA~TWtNpIqDilAV5UH_d#^_4Y+rcLMNTBa` zd6FrClWMLL8AQD`=f}?n0j{bzzSh`v$ygZ;>LPD3PROFWRJzu~Q9%q^`O7a#FOB1N ziQz2sZuXd$I7dB)Z7XIu_<}l9M$juKm9RP4x(Rdg*5(3&tc>( zYVG|?MS}r5)ffLL?!gefe#-{6lZ2aC?1eo%L?5o!ja{_L(X(5_JfTdy}V+rJKj zYvi;{qShSHj&VMgAe#b{hY1?Ie>=gQ`=U1;b22nJP~2#|^acXboT6%yraP}(*LAg>|q$sBgfwLyTVz z6^1)IK;2b*{mZvMz@lV);e#GG_Hh1=RA~{zJD9)rUV(rwV~*u>G05ZRnIY%TsJp28Ti#kz!2NfV?{{RYp}j7{PkLj((|!$hIb0g3 zRp2|UJFkidlH*p=Efw*Sgj&-Ar!=;*oqQj4n-2*Vo?i-MVQ0lmSU{rY_1;%Cb>KBxqSKAnHL?(4t*tpmsW;P2kY zh${Iw5GAZh9?4AwEgv%NI<@Ce@AB~Zqf~iN zrd!yo<*5`3#m91Z661LO=1HRB#dpULgsu6yr}&$z9hYb4GHeYc@HblqpeV|LToApwze&tUM*OI4R-RN z#rhst?$8(Tr0IlCIGLyRFF#ruy`tn}Qu+#PR z5FQ@@=d?42=k11Ij?jMaV0k;Z%fCG!I@SZf2->1C1r1<4kAtb+FTkPgx_+R`K3H9M z)Urw>fzT)7F8#Z|G|e1eSBY$r5%=e^W}C(RAa2CznZLCk)b_^Kl?F&4#^Ttw+a7D0 zE687SNuhJh+;kS)(uz9%sxzWgu#HAhA1{`{iHI-XMe&K<_r;A~ zS!{hL9Ydn5h&x;l+hPLbG3~+I?-`4dc%~oJ1PAzW=B4O{`vFB#eXKY?tBZ!N26Qr~v@wYG=8jDqQSZK$lhG~7hhwf)b02t^uy5Z? z>lZUJY_v~NQ@PLq1q|C`tJz;+#Q5zAH=@tbzb5_6Yu^@_`zG~hi?tTg54a|T*%pCP zLr%u*z#CZ0TIze*`y3i;i{iew8Nuo|N>i<$I?zC8cGALG5<0E+QH@h{Xt;0~_=`wJ;EEY59ES5OdS zC`Z(5;5q$csR2-JzH&q9KtHhfDXS+fw!pXe%sbLF?|@S2y4+@JGAIkmn&f0=!TF*) z=M_@Fz<=JPwXsaB=FJHa#q>QUx-6Hf+#WTJQI zWel+|@T2g!bEX7bT}!R*{7VDIKpnA4M_nNQE^<@D_#|=NzKd0#NP??!QoMzYpWw}( zmESL*8Z--gMqZPD0rw-W!iDU8z#gBK79mFL3$sII)Fg&rtlYYMUUC4Q5X@J-^15O9 z`Kj8STaD0qCL)2=A`jkW(}{g?dk>*EUwz3X?kj|acAuwQ#Gqs(FKYK>#rZUijrlSm zjOZ|0>l2Yiu5>GD)ni0`Wt4sTp0_+c5-*j#W-fPufU3gE8K7qy;8`M{P`Wfs5p3c_}8 zi+pN-24OVaUduk-aQFuM2xY)a$lGT6`jp5!lIIUy6VUw($u<4ao#{Q0vX52BX_&~H z^pu%-jHclEqYydq&jXOm@$aR8Sq%hflw3R^Jq*KMzdZ2iER1!Ek32lN0fX=QS4X-2 zLgu}HZq!Poc!1&6;XUR}P&84H%G@4-R?L z+{@r~XY2F|Z9TYrRTLw=-Uq5CRZqnF=&>ThJ7SQZ7tdBHZ;pQZV;oBK!93kN-Q_~Sy(~F{%tBG*>=}#weSv_-^Es~kAaee{i%AD0RMl}H zJ=%N4PXqHW-kbVZrHK~SR*P|bYUmJhOz%Ro93Iv`tD`w3j2aB0%#l;vxX{RXF>Q(t zuklzqj!mut*B-(2pvg4k?7jq-uvS<`!ne%rOi0zy{!gs33XUrl3OSIpL6U1s^eFit zsL0pEQWZ`??A%Qyqsw!^PxUBjs9*$|{VgmA7wW;-tUvD2f)8kN1UoCa#zB;>?C#Xu z2RPVLDb;721zYS;)3y-}%?wc-270wnE!e+amfQoEo?ZPzBRc`YP0Vf|4}K^5M6EsE z{#=EqjgTY%?ySPOf1w#ZPo_Y}a=&O>ZWRo?qkYe4`UKi%!{7{QI>(!?NgS zsP9tbBZ;e0+-x;{ayZ^SAKqQ1j7HJHUA!*pn0@GV@{O13NEP1hSlF(PxouqmiL$E5 zBCD^F>ZX94BKOz+yDEd_&KkcLt_or~#mOiYOJd*Ok=W=J&;t71`qstqn}EVy6xGY* zSZjUUa!sBBCr^>_F`8__pA-Eol)pM4rg74HMxYj$sdz`aH@ZMYO!Vq{-ubj)4 z>44CeNx55$#XwU2^?bEZ3xwWiR~C3k^fA4@rIcst4|ldtC)u73g+h+2-0oXpK-tc( z-xM$geDu*RRvoK=zIP;y!+yb>Ujg%h7kh9Lx9(UE5Pc?(9rrrVk|48TbEAOoI{coP zIrUJy6HXAZ>1bUGlxEy4zkO#ErX0LFyi4X`rSV-SnG+>`;7Hx>KFfr5o3XuPM!a~M zCsHnQO#)vC)HHIn$YX+ibxbhv{xW{yV05x9>W7KYA`#ID+E`hr`Kh46c4V*@yAHNY z4(nW1I);{Uv5Pk%wU8txUUa5T8ErCsti%^(ad#y+!{WOL=8B8aH}7!b+htvSK_v!s z&CFXg+W!w^<0&b*LlPmCOSR;EaSg!7f%yRXPWZl`(mQl?6}t7aW5>=?;In2CZ+{+o zqQ36aD($%+Jp+T?szkTpZ1%0sJ8mX$bAfJk;rnqAp)hY~8Yh5)B{;m#^MaXui;krq zVqkvSE4+@b9#SkGGf%G+f{AZd>JI5c*ximg|9UhRf>xv0jtf_UN6DB@VMHSgiYT7t z3U2}J_z1h;2kkJOQGl6OTVOFOK7=o+0+iYIADR023}WjpWgRljhn%FH`f8I}cuwK9 z;p{U2!He?@ztyyeUQx;%cNRp!gM3Q$;p`|OHzn6oM1_gl98R=1>%jYwh*{dd zYDhJ*zvoC_32dWe_vJi$q3Bp}o2%V-aD7-UZhPP-Fr@CMF|%2Q2Z>yBlg%T*kizu+ z#?VnvoI4(@(5wnlT%ET3Wdd-lahdbZ*)|X-BM+N!od<`o`&a6lW8sHIxZ5@I$1q{V zK}vV~0n|xstcBbu2S(kG$Fq)nf#)j&{v$UAK`zcQ=bYIh95>$zzf9yWmsLKm*y?Wr zxyo7+=g=H5?SvQ@w*8%&h#j4D`oF3Z~Qr3&_!s8vW1^;qq*{714t3HNbHMDf0p#ZUEi z#Hw5vSpwhgq^x!N{h-1=oe)qbD-?S5E)>28Ub4R-a}%64)mg;%On@Qu zK+8th8ayJ>;L#qUuf2OYau%i<^J@y z+PI@II#idSjy+O&nYuml__X2ZEL(vT8s0GExlSsIEcEBjl^OEmYm;^@|B1u+tTjyb z%J+SEUbXvYm_;F2T0dD67s>^$6pD=y{#Zyf|2ygJY6*8P{?5KJe*@T$`K}oncmh?C z>O)Zq7ua4li>SPK8II&n`<9tX!PUcZOVd^Yz_q(q%r(RahIDuAzO;XY;dHj=8qA%r z_!|Bey!lK>P`49awa#IDjP05rwu%B zH3I!U=Jg|A7a$Wuci6Pnz-OZR$V~nk7zX{*d(XEH=lnj@+Nx|o`S=~MiTVlo^ZDjM ztUFLQGrnz+!-{X4vfCoF1TfyjaQgmFG34kqI2UnV5|hsvG(9YpM(R`31m!dtG^^hi zELtXmSz01p>^(Br&it_OAc-8BROT{E$|#@@cjoCHUS+IG?7cdns)4&SA)4OVT4->D zgNdU6@aySuhr3EjI6`qUXwrq~o4F9$!+VeD7t!EkdZNvM@4r<_B{NRLk{_A-)q4Z5 zVtasr{cAO(9jJWYb~zGMrY?}mKm>G@Y@Lqg3Wre}NtU9-Xt?T;6_<7^0nX(7Fs~1* zfp4Mim&>Yt!o{3!>LWzn6F?#0q@ukKr>V4-kIrwyrcr4dw{a?5eMHH!QS=IWzn;0& z#PbG3>-IThd9*^N??^zH$`DMw@elThoPvE8vc@?%lORmZ#Qsa%mml_5Rmb+U{pi%CqUz6e6AvqKdSM z7kmmvEjrP4zi&cT#~1U|C+5)aGL9?a=`=QTK6BC-J+F$aLIWKA! z+vzqB76roPgKtZ`+LIvXLp;$M)C;Yyw;or}55j`9g`#iI2oy=K%&K(vK#?fZ;{cL6 z;C3TDaBIv54*vJ9Jv-AGT5lH7)^eQ(I@n6yi%SQ(FoPA}`&IBX__>mgSQ|X_^CjaK z>4z~BQ*E`939xy8e_TFn5jIJq9vwTxj^p>97=Iw@uax4J8qF_dkxNCH$B5`_k<+6m z>26iQ*l(W}_-`wrA=RBTc{#F3ckZF5N1+go7RBl?J4m6@FB6_$6!KV}@E8qei2L24 zsd~RlfL7J)!hP3uaPDp?`9n!9Gt;~654`~S{lD;IHK>Y~=M=vW%e@xCXtd;b^M z`86G0rLBa2qYG@i_xiy7%Nom(%qfs{DRwCz{swnV&i1bob^F{V)vxwBUC?aH;-P+_ z5q3W{Yq{GMLPgRxsiR*2RDL+ntN7v_aH}pdyJS|trw2?-CCpWzouhNQLF)sYBMFm^;AWbf3d!^ALP{b)a}miO79^npfogtAQfZLcK2~_u-_RPIN9q1^jL6 zdqW%F3jJ~Y!(I*T;KNK%8v9)ZP6pyS92F@*F19t~J(2?ft_+|?@)>+-=~8yo`(R@} zE6f;KFu*md&Mit1b05$)$9qWQ{VPXSZW8_E#eqe)1Q}Fu;8oA#p^M5mUv57#MlFXc znZN#PAjbWW_Fs=#G6K#%SQETir-&tP+;n3Gsz~XfdM5pnDw=qnjk9-F#j;mP&MZX! z!TpBm#ZBV>gvEv>;bW#W?gl1{)C>sX*Ttj7*CJTZc~QpHUVj7XSUq_CZuyIo;+aj?O7~K!wKlqLTP4vE`s`B$;MrBEo+^`sC zJ&Ls+`9wfpZ1Fter-TxQOK)#h5YMYjU6s1an>$C*HGCq&-8y#be@4+cWoRedqf$T$=-X<>!2hh?lK}p85v0`E0It} z$lhdA_FmbUq3l&g_9leP=l8tj4S&ZO-|@NZfWww^FNfm^@G0MV&20Y^m`Llru1?rP z{YSjSM_h40PDx(TKVAZZiI<~B#lL_IO=gViX+O9pk6T=dodUeL17jxfQAlo0*0`Y9 z4r7BnRu#!uKfa9M&)MWZ5arY?MVy0!3YaGR6qaz2P7JYD%()$4o73T&m+uArB*K^w zp8-&;Hh$P}54%6wvqU)>?gGipvAQxl7Iggj0=aLR0P0P7-ZhTpMhlpw)R=L^P;m5K z?OiMnR}!a$Pr@yXeZ2~%$pujEN6D98wt3JIg$lp@KM{16|HcE(D_EYiiJgt6P!<`| zB${}6E1|<;GHn+D736o-;gTWtyrTF|C+eJ<6f!R{XAF_xLDIamY4eKAh`~bukCluR zsdbR(=zeQ}g%jh#fvHjm7}9mby_<~bN4L)2+Hi#Uq;YAz%T|zj)l`!$SryF6KKY1@ zBd9N5)M>Q(4~li`DvR0dp^cKyM1nXG4AjmOALHdf*8tb$-{pf49Ig&Q^qT+*<#8&P zet~VLPLJdJB}h=rw9fF_0$*yPH`IPBkVfl%c#d=o-o_J%Ch@gG>s@7|o39VxEUvOu z2@?sLrtDL(Gb2NFr{2CvFL2P~x?#!7l=CngC7WGQj`a%tE8VX(EP#6L589HrZP*z) zv46VBim)Pyhu;$sB$&CAObb$IocY$bZ_j1Whw!{@k1RP;L!#)+7LmPuh6H+V`2J8fRT_~slKbK&$)TjA1NIqn z8FWQoBQRA=4E<#gUHN*%h0?j!UXUj;p~CregFEZQ=;pHlfpPV8IL(5}jK{4o$k0rc zJ>3tfsp>3!tNrjkrnt4fvjtp?3w*}b6Tvtt;+dLy7IfTuHu74s8g}fy;%Z{=1K!E9 zxq_4mc-hbq9Ne1<1D~#xMiVB(6Z`M@_hhTEI%czF32}y!wGy8)aZtUInxyQbpVz-B zWr$U%QM_;c&Av8yCfHQNk%@<$qVrd-N+ttf+Zr?jeqePvLu(2mcCMNBs> z*=&rzE{g`g%}5&C$|9}UlFqqd8Ps9vZTjT03_2IKg-85B3VB?tZ*e;kM?0SaeE-;p zqH%_H0ZV!wlvnwt5#NjfRopzj7i)3~O~F6{bR5c~mU{Kuad zDhD7}V5^#9Y!oifWfN=<55azNS2fX>UeIf+p?Ptw1M5}i^@L#O>DaBW8&33D@RLUM zd)rli_$(Ge-rt=83$1UZ@z1@3TjU>b8@HXnOFyEpOF;{mml)KUS@?kBd4$<)mOMB# zzj`y!pbAl&aWxc&4L*d0FX=sYf=9%$RTP_HKppkyD2+WCSec0Iw)F;} zSKPszH(?%j{VCflrMF>2Bc4!ymG zXJhPwoj*9r(M)C~UIiVcbfKFmuVL|Dalvz$AaIef%kypt1_5oIs#_DDF!(QNp_Mod zM)EI>zt*Y&i$WQWn}Kbh$r&i*)9@XbC2pHaR`h{-9tXSM&jFxaDO~lr-U*6(lKh8X zs(@Dim85fR7bvmia2{j#<5%TOpmk;o>&vQhC*0Y9g7txj#~w5ANyuL3F4nhLqIYZ29pRmXE0n`xfI7D~cjkCnPwD#E{Q`hR500*uE^sz}`5`imts% zrS88-g05ZtXZmrSACU)p{zwauMcyyRqi^{tqm$&M|A0#cxwJnd5%{Wts7T(sY8xYz z&vHX?no$PxP3Vu7@`X^OsEgjrPj+Ohg>UIpb{<70WEQa!4nVX*|9GTxCy=-m7Y?-4 zf-rI3cD_#`5Ph)YwAIm8n%@PB!h%d+Izx6>Ie~ZvT#Xt$`pGSs>u!Hiix0w5vw*EtoI#n_9-@n zQx4&c&vsg+C?SQr>D?>t%4kDPUy4IO75z0;Z!6GHM$c{x%@$+(G+(NM6S=J*qD&0= zwX)2HcETE-^ISNO92RYEd8lIVEXjKJiOLbEc|)D8Br*j0rjK8EaP&eDK~)F)N)y;i zjG0ThCP39gv4}<$Q}_`grFl*B792TW*dFqlRvKO?|GW8?241{*=kxU*2M{tcSUlHH z1`kg5kCx|apzH3HOR_!lAU$QME4}j@lshM=tVPFQ(D!WaJBnWTuzhezl&t~Of|*G# zy55D3M^C5l^{il5burPs{24H)<9{&Q^@YD7+TpsS2_WL}z2FOZCirRX@{(CkK-G}J zUI6|dczIj$teyE0w8zo7+~1)?uIKE^e^_!NYUusYo*;zj4Fb{gSWbX%e|_Ex<7m*D z%4o6=V!2Pjo}L$@l89#4O0Q*H6b(f@@ha|>L`xReyWDx?kk88vQ3F>6G=%r~VFm-1 z$NexLx`p*x?7y+RIFl`gI<;%*YKw(XJE@X}<9S{bFRHR%ILC^bvVOVRVtvsxs^@_? z4ga9UhnD#0bR9nQ1g)=~4gk@ON4E&PT7awz=Z5^FDbOSMq_X{Z1vVS6vzz+N!S#Q` z+=O03K;+Z5a+$9HXv4?{n>f#;+vU)Mft!JSA@WEursp4}p#nNE;Bs+0qkzgO z$U=;J<&b0ZW|lIRdwk!$)^{^R6jd3WxZ+T-Akz`?5^mc{DE0WyB-t_#)DxWw=hwoa ziP!$Q%kW3I@-BUm*Q){q-{_CYWqk!<&KvjLPiw(#^3G_EMJ~9AE9_4+OeytoMZ9Fc zZ~;1=pL*$nRvV~6$BJ(N*h`<+Tn(@PWEwU?b z-{bYb#dpay@;_Q&{bsDokM0)GBi)!tHd}(osh=D3pLe0utNCoI_C6%~;o98zyNdBZ zcI-2v`oN*@d-u@MFdU7?vT@NZfYOZeom{0YIN$am{O)gZr23)Ged88AO7k7+%OK=H zH1?(}{7FLSvf!TNFq0%gsf^QqEhLa-K5f#keqp3dzx%TLCpS9#Nw0|Jq9n5ZFU;n( zl@eM`urS7JQ$cweXSegsl+nVfHDwtNpun${8E!;!NI`~#Bni{AkM&AMyqtNEpUs?% z$0!TB{n^s0;OaS)OT-eFC%y?9hNHi)yqST;z%iw2+i!4*T+r-#!v#1oQ52LN;e@5C zY3>{U34@);k%;G3E-bqn4N+?~Kwn1u@KQ}1{0ayqI*0j4Ni!5rZN*D~E+9wS=~*gV z&!;Lp#}x^#O5)x(nB9SX;4b+i{YbD0+=>5HoC5!z3u}z!d;ydB89Ju z1Dg@AI>Id4uwIZ-)AD!~IM+B^f8VOc^ewOIL9uRl%f!jb?l=U#H+fo>p8N*=A>QhR zmy7UkTT`Vn2;p(qWD4l_So@ZIkR+nx7pm^PD2PbnFaB3}h6BALx!2RWN`s0*es8I- z{)3SWi+d}VHsNR`lTJZv6c##jKdqBZg36-1{~)HbH)~my-eJZ?elqp`XU-o0iEYn+ zD_$4gArsWv0$(qVO!`ulD_I=*^L8H(hM|5fR<2X?4$XS?+4nh9Lm;&+UFHkrO zHvYnYL9L+4)Gq`V2{HN<8Tg(!2o&yT3y;q4LH6t7;me*x1iypxKIupGh7nqxV} z1$IQl72rwC!Hc-&oBp$~5k`c^0uD=r5{Tw%*tdliS#&OVpLPB%V7e%KAcdL&LQ&uy z%rAzNq->W|l$nwEtp9H|+H;7)VZw}i{uIj-eVz{4?T4AK8O?%N-pwIs%l9dFG4PCX zZB+(%fM@;WNRH48u!??k;)+qg=F)VuMc!(|?Bq6|v4|!d*d`I{!!@wM50K1nQ-Z7a z^9vquaf7Rvzw&U{SEbIX-UOxTDJ7$#XE_0UfiS7Mc=q|{*FYawN-c4!17RNC5c6RJ z_N>+F$Z~Me-hm{S>|7Oj@i4g~-GQ`;QXRg3>zuNf%OwTx|Gs_Y?t$+@LjY685 z2#_#dO_I*9faKH<2EXXKKv{RHb?C!52%ahBQYJWuXioo4go&}BVezt|yz@Lr{UCm} z|A8oCGa4W7k(EO7`dQ}pxv=$YbH^>kOdLfXQt)3&Z=@&KW*dY#dTj%BdMKgLd zdV4$MA~hkx4S2A?pcMx^{iL@1Qt_b0RJJM4oB#pZ`wIB8@leKnd?NTd4yKNAoAl^o zL5->Fw(&UjeVjB2siS0A^usk`y!Z)jl18_e?=*r>@sk7Y>29d{67;Um;0LgZ5L+Cj zVEq)slC2D*KTx$2Q$>1r2G)2C?KJ1>LG4dzbx&*+IGQk5uzqX872=h~%U`kZnvh<~z90rhLIwtp9u0K>}+ z4Z^a1FtMRhJ<6p+7^#9%my!obWZd#@8WKi)e+`z^wnb1Vd*P>9Ur|J=Cn0q$SqwS+ z${O6nlR&@Bn4MxRCD9u0lx?;f_ILR5Rd6dv8cnf0KO@E^i?GHe0k^CI(lk*eX1W1r z&YoE5q)Q&TD1B%-yeW<}Xm}I05;>3`<$cWy226;ReZcc+3Kf!wSv%bDAV5KaJ-o~B z55V%)`;tY0S>QE-%ek{B7HALzwXr+h926?T{})C&=7<^)!pV14NF=d*xhX zFw`;w^hHYHcHtusS-i2h<=hK?N4{;uB5hFq;KDoBtncv5^fp@pWk1kRSwD_D8h{&9 zH@^&Tbcv76lpshTfX*{!meynb3qCi$_1zm7 zzfNxb{;|0d`nI}AN>`bP0X-!cQu(Bu5-MEcsb&!C<6l=_btP4QkT${DaHZz)^ZzmF7RpDj?@K zzSepRSZwQa0xIu=g8rX}Inr4$4Mtk?5mhicp?n=bx(T#ZbGFZve1V?Uf!oJ2#Sr>H z^hu5LXL$5LS84V_Hso@Klw7)(BnG>J4VWhf1B`+0QkYb?f;jX1@ye1+x0yUYLZo7iFzc;$^_Xra@zL zcp1cM4P4F6=wtm7yiM0&3&=0bGUR3U0_8_qd(Q?wKwL?6xytnrC?9g&(t7L#vx#(3 zk&GR{Q}L3#_4XIQ|8}m#yD=1KpE8%e5dH?Cx4N=_YL7$XB%Q}T>l_GGlV0RW8i$F} zIfeTe$II2WJSe=s5$=Z+dw0LDfv@WOD=+NIz~`-l!6S|V2ppZXG7p^v&mS&y1U-Ks zv2*86S?UFpTSQP+YQ>4h2<|u%EDNFYW%EsH%#uiEfvwZ;vK+dAchK*4Q5MY-D#hsf zVVpl&oGOEPA#`VeKlOK{B)WLBMIf$R9!1_IC$*nYLWaqNUWwQ`7MaI6_#KAqB}I&RS-at%x?e9@pGUQeTkpHGilJz2V2jdQ0@Wg&+xPpDU9E@ z_^#g4qIflvz<6wtBRYOlX91fEftnLZ>!=scn7rh~8u=;NFU*P^H zP$_cv_Sv0+xxNF|CgDxE@c!mrHun2+xMw=3T%QB6ve!67SkL7@?`t}L?Kgoq_ZGLM z?k*6$c^kMPd{>xb16S2AwTJMe1%ms919fx zr_PoFoWx)H#Xn>ML+nOZBgRY0>#2Gv`)C1tj(SyHT(^Nd`(g4Ert@fLfI?Ks;36W8 zHhs0fz==jwaHB`=2_W5FZNp!SqKLp<^XdC%Vkl6Eo9DilDB`X;tu^7s@*Up^v~)`) zkUJeY&k8k`3A^Mg++VW)|k z&g^FuIJBs2o89{iOgi0!X0@46`dNgTQ6(GWZqz$iXyrooefzRq(-dHk^d7l1;SX6) zc?Fjsf$E8{O)(Y<)H_~-u=K#CY8JWBOr4VWJUG+Wd z6twu7@GfFpM;-G0NV~E_2rJ5r+RPzF?)kibBI?egLBIQP&NVDZEb>Mbi$E~uKW$)rbL zRQ%T4qs}3v`>KOi4)D;qUp-QjOe-K?TSM_9%NWew3|3J%8A9OYb#tvNx{y91G4dFv z0t^%>C^R}c;BN$Nw?=#)y#2@6TB6YgbD^}eSyjcbQ28q93&tlU3-F(&4jO`)$;&aD zYbQ`jtt=#R`wy@wPM^0c>4uoSYU4-e(1Gms= z6Hv$O{r5T};^-RZ)EosbGm4?wY#FDfK>o3djI^4Eps`H5)v=cdXLQ|7bExvbZgg+1 zGNKHE6pss|Tr1(3ee2K?K?Ufg2OlYhmO-xZpH-QQzv1Yw_1BwOe;|{emh$W5KCIHT zq?0VKL;9zBeMY_!@C%gD5*#goiGZXP38oIfVv{>wcZXqnqktjqaR)q1$>gu{O9oNr z#ec1?vgTyG3}@fH(b;Ez0K{(&3ZpRn+WhJJOc~W^7?%7>dLuC&_O`m_{^&%* zg`%N`7}9Vss<(%yK8nlX2C zZ*<^9;vWMqwf&$$aleg>YJ4~0u%b#d@5uuA8anHJjs6J@y6hE)dELOa{;)oBq!Gwi zd|2wqKf$wZRXMk{7&wWarwUSvfRoO(;>-7f!L`}ONBFfLOxG+JG9-J#%mdzFgP?lI z7P)ITDl`U`oBfx3$%o-C=g=JsjXw~tS+Vfx#}U-{-RY_R{THad=2Kamn}bIRAv?OG z2|#r3#Yu8@D16#7WGmfx2@!vKE*Qr&Kxah2(|4r5;E}=b(v#T*IM1Mv%H%W)+)cm3 zq^L%K-?esf>%tg_Y6Wtb)w3aWgR=%icf?S9F-dUNp%hA#>SJA%#d=khamAueqDYF{ z>1@}WAaZZ=j2tcCLrum(7Z)&&@w>1}B9dUNPhY=w&MW}qQ7zC`))`5mlwUb#wW{UO zpT*=NJ91_8^?GSYsUV;?dflR8#nLFdp)1AcsW5t}YtFqF#(`8-qua9LsL->uR}{q| zW6-K#!lsYg1CM!0dl%cvfIfOV%wJv&7A{9Ja~NHR@=fW?npfJO-;l5Mlgtr5(g>yU zNxcIK6{*LU3WK1AqtrI&qZhC+bXBfN*g;Ekx?R6QEEM&n4w7QLwBI*l&*QwQfQtJ* zWAr>FaPjB-RkMUV;3oL_P%5ebjE~=o2vQcq+lp#OoPcsDlfPHtAlM51ff&}&zX!6( zR9I!Oe2D^K{sdh?6L=3;ZWCB01HlE~mL%*PxjHcYERkUtnzqk{{VH03^px+F7bxhF zRaoA}ei%0rmzfc)pch7rH&b|ozltEwB9YL(a#6Hs_F`LPLsBK%xpaf;h-H1@PWCOfb$;-ZIS_+8#_O?n{GBoK` zDcV6e94{;uTrx@rIxa^QV!8tGC^gXqB#$8$N3W=6FN0rv~NF5jADbdp#RU z{|1_rR>ih=p@*J~8zxkQF4Z;GY39MYrnok9a1V;qQ-YpMKf zmoV}~eO=uXlIXmnCGIGu*L_l}K*rYukzh)a8)*yne-Lomm*F6R-0mfO`P%^~eni8v zQt>i6o6xOByrhEOncU(uh*U;D4z9U0V*Ef7u~}P5EZ6%w@%UY$I1|#i7A?A(dJZKr z=QLAU<0IF#SuZ1}EkNwCI$odVfvUepHNL$E7TrdB4|%7cZ+2UQ+iwqI-?{58xZ|N2 zk!`V!>SIteN4sM}tH7bvCzP7}0O$`&ssf#Kf!O4%iEaTv!{ERJ8>>dZYxLRXBAx&j zry*H?<5X}FaU%a2RgLM>%5}1*EzlC8r68O>1(NKv7tPk!fR&Q(ziJ#TAG$!9{F=z}x=80E6Mr$PQv@Ux+k zKhT+w?9uV$62dFAE7HPv4;@sg1?~M3=!UWVgCrVh)b$z8JL$=yMRm3SnqFztrxX0V z7UQZp*B_L08Hk{!yUf1BPoz*R{cmaQR0UMXnpr-y1jyY<=Udpk95U*{nb4Y%MEf7E zUi*dJ2YZQ+X8$Pip^j}EIROVYR3`bv>FMR^hh_-@oXw?}}6#(yFoKKj6QI`Rva z5AOpEep?B}Yk{VRi60w$hoM9I>b=KZQ{e0;xBN3~0NjJ(p1zf+16EQ=1Hs!<5N+d2 zu@-&^lvb|$4?T#GSd!sb1`io3e8D-b^qw4%@FyK!-k?CT$|OsXjF(WEBinMbF~*(J z=(*mWBY?c`-2cAE%ZEfPmT&Q7a-*wL85AnLJZQXO_DSL~KXOjt=>EqijGjpPe7uM& zjT}n0ZOBBFP)duUgjtd@iuuo7=YoqOI-&JcepDob%E`nRMX~p)3(ciT1_f zZfG2zL7YNw?z(#}f%M*_!{GBlxVd)pVenHksD9014~5m_$I zJ>aBjp3M5gX zFYo|}!tw0hrpV_e@+*U-y1`=5z-OA`*+O1(mGDTDqrTBp6l{E5^8EJdN zhTTWH7nb|6NgL1ZK%gc86XGB`c+%!}4&~e^yQ*Gv3=XLxcQ(`3l+uXlH_=a0(5Dff zYviT_!^3Ctb)%BNI}l725Ooc1>1}&6Joe~WfB|fseqrvfNj~o?6 zGCq3s4HwM8ZRKjDayAsrc}sD~u->=gS@pz)o#E`7bOFQ%k!sb@THd z;Jh`k{W)z1;293#+VC!1*7wOLY}y0idmjwdCDtIHjy3m8%OI$_C^dW_{0a%d*6QTH zCm=xVZnV{uoBP`}KD2SwydXCcCn6U)H`x7CVh23Kq z>C^ZS2RG{9);#)fK#j(a?+Cwtng(RjLQkBqbN!=jvleMbHxxB!6a13+0hz0TBKZU@ zAR`u0f>Tfik5YRWC2y8N5!Z*-a@uO(HOOma3vI>baol>rv#bJ&Y>*3X)Izst4Ij_XpiF_#Q$iZK2V61wT`GW-CkSbp@h+eiSA9AidQoJY|NhSPSOsJfv+BW-s)CNv8!7jR zl#zlN=AHjkL@$Ff=>;#zAU&ryr{hb)=v$g)d>j8IjOm!DiF&C}q+FMmh{PGx?;No2 zS3Uwbf!~}SajpYtewJ+W?jGRtM1NrM+{1Wit3w7amNB0wU$rl^4c_WR5h+fk!a7F< zl{RS@P&uT%%cCm=t)Bz$Ld91=EZsHl!k>R&p7xMy%j5_qRh%4gpKijxme-2T=d5AE zKIMAl1usw%U)tbkr~)`~I+ATOAsi>yp)3^kGq@&i2QT=P>ptFUi`{7ak0` zH#?SK`LEdtvcs#pVDVP^>6RiXDyEpeO+HV9^hZdQ-zKwResjA1neV(v>a!MpRXEYQ%C{_chL~sxn>vi2bWppbti&O!O^o^?0sT*JlDMYu?Ysc;$&|0%?&Y;T*GQfQ{cEGw)9>uV$vvL+&;mSExpF}7=!=8i(o@-r ze%S(r{K*%ZSI2YO93z#cMPcYCG?9C++}4Fmijj_EB)8}Vz1>$yW*{?`JAi%po*F7$)w+bXpH zw>fyd>o(hsy8)hrPsXW*6LTZa7mU9clG{Kny}42Xv$#w9We0GCYaM~M(a;Fo&E z%tfLPA`-fB7rbsm+Wq54l23Z!rBraQqst5sJXW&RCtd{uW$N9lFJ{0{pzqYKW)Qv+ zq%D>leTC|LA@-w{a&TAI>r%n|GjrRgLsCwuuzx#VcT%MkeoyPk7~kuFLwv%NttIST zrFWx%@)9*NqY*W~Y0QB#n-&?zuzW53t19oH1SMqeMY?xbOD-MXG5$vS)hqunpY^}zI5#WIr2yLy99bTxtrMf@Qb{#0=RCCpd&jnAG(hFUfk3EfGN>ko6jTcWt= zCu_mQ^}9R3TK6_+`*%nL%0}w1SvZ(pA4(dMHbfyp_L-{(9(Ee!^_*@aH z4nApts#Q9(O~GxDml#ZT$i+v#&4a(WYAI3hqbJ=GOc*zQdE@iI9Y$n>r&&*Tg$NqkNSRzG=&}tg0e*zO|SAJd#HX0k8LMjAaq&QH~oA=mjo! zd-X7-ei*u%ymJ-f`08&_`Y~WX=Q4HV?T+IEklKYWffUUhn0K#r&eg5c0eKVSJbBIqmQCjr=I%ihYMO73P~pRSKA4^Eqxidx_xx zltVYl#qI=jNh1H{#$!%55pF$LjRQ&Y@TQ&iT3+S1MV> zc00A~6ijnP6ZT_?P|!4ey&o|V%9XL%f8cTmZn|o759)tIx>so+cXk&D61}lJsrUj0 z0xMdHOwXW64KF+ThXoi~Kd@c;aT~JI8@Q;|?m^eRH`2*J9btFeudUw17991weTQQ^WY^;@I=Pq|&p9N{5u;mE;-3BkKFwuy+~O8gc#+ zcV&QKQ>Y*{P9sR`&Mcw6!ha2 zl(4x|0Th}gn~g83eaF$f8vxQMJdr7nDq5=z6Tk`x`bwsIvKp#HWQ1 ziEeiIH?VS}!m$j4Yx)<_n!lN&Svo0VZZ_wC^YRlk$BkTca!!P#yFa>z_q<^W;rG3u zOoXaScAYIeSg$Ht=+^MNCMXsj2LXpV@O1k@F``ur|2e5iD2085tmdbk+cN1O^ru37F2Vf(5>Fi5`1h9{~ zIrQJBeE4}yWd1XDPpeetT5WlF1aZbD1wERih%L%&dXa@3QGPkB_wzUfTb{<%6a1gR zmXYm{eXbNvJbbQ**jsvh{~uN=Ps55t@izMB4&c+bK@1` zHrb_7+ks`Pwt^JeH4NX%*O5epbqiZRv3$Z(*gs|gOy}peBvW?{#CUAYnPlttxzTXR zhbz2WG>Ev6PE&4a5Cl)p+hs3(gGj|C-)7uW*uG4kNAcJnGBlKPl4?WX*0Y_{ik1k# z#X^8{pNm1-e?%xguMsw$HGG!Q!2A)xu?RtfZ!k2!?ZIZ*3D;LTn?5pjLcLh7*u|lC zcutC|bT#t_bjPbbwtm?Nvevh{%+2G#;n}QovuZo+Pz3~b_l|*e#%-z|ni&W&;j5Wy)F4ND>^h7Wjk#tng4`oQyDQ z7!mr_bg0=Y%YY<*JyFrn#dxalvVRQIk1BXhk*t~!()3du`c^24q~+XA|6p?-U%Q@U z$yte_Am`IDyl4>=FnCx*;Vg}qn)Vm0-IS22TMWxayfUg?n?6IFqJUbaBihACrBSr1 zi;SGTIC?Pb#&BeaM!4U4z;?;Ss`TOy z*v`7j@Cciai5s$?wZ=UI&UYe8mPB^JSt3e9_z^BDG9;UENIL*_>eR3#nPmvNcCnC? zpb*CH%im+;t%T$%0sLUD2H@Mu3{P^a2f<>reYLCzN@wdD9?7)8MVnBKHuD-tq`l7J zRhA1nmfDxe1qe}7ILp&Bv6wE;gRi@ifceEEGHUC$=n#DU-b^+?h`e&NFVp1yf#JCs zcgwa-xTCyj@7S_|?L#hkl6kw};_)hqTL=ez-K`#VY$8A@p2CYyb?MRO*ZOCDGwf*S zc(kZ8pAWfn{WtpIrYJh6Sz_4uRRVPy_Q#TEV!U&CpV_z6!YIGNB64$#8#Pf{5^knq zeJt;`Hhwi}RE*+|hOoI|dSy3A&XLQa6aHgb4IXL4qgfZHnU38z2G$0?Vm(^VN_iHi zy8=kb&f5MBGY4u*wit1v#rUF3dZdAY2Y?^4)nw!R2iS>O_rjW|z}icJ{atK32$LwE zCC26~vP*Ls(3!`8Y<2hZZFXz|MsuNq5n(0BU9RV^_|OQe!M+FC z{^g+_{|~r0=-c??&lDI?IQ1u3&Vnxg$kTa=A*iWmYmIHr#W-z>;)$3)Ms@sCu_|#2 zB9n;}PChR}2;S||&e{bCdXyj(+dB^x-d;!6)7W`eH@9vYJqR!Q8N%DL%CO!Ln}<>N zA5i*l_X+VoeDqmcg)iLW9Ex74vySPfMQ?o-vlDrk5T%E7sje9Z%C)m+>b@?5xJ2|C z*<+>9rk|t{GmjKH(R6Rhlodma?14I_5&XzUZKEvki#Rf&3=sCl^2~l}PZXc3DWd20 zJh@5!*j$_V-%LH-(n!=(O+~TPbmXD9?~Qu zmRfj1cUf77{wv(bs%Ra~?u6p;4&m@K(@@eo_t>6s4Ww~z3=dsihrJzMH+zELVC(MY z5PTs3M7tWqcdsFh6_pTT{0w%%}nAe>W1DRXXTgXO^{Rj zjfl%67x06UDvz1G;CJc=*~5MpaJo}-`ghU>O7As4_@)0D1Zb-@wra6CJS=A?{=EGL zCpXXZI$=2?g>2=>ksp8H79aWfjgBple!$%0tUm{iuPJs+^GYCYy5pm#XE&Uxw*Kag z8UZQ`Y&Ql3XES*3!ZxEW~VGj!gLj_3t=XL^Te9BF&>Nz2Oj2dEUzSryzYNYUzle}1A5^@S>|9_KJUxvu78-4ZP(NOkM;5=~ zN^ds5C(Rmcv=WRHI=(UB_?{|%9BZlvZmV=%H_`yct2??5d@#E_y|1kImy_ug{V!v$g{ zll`(D7*v{a$?CwkRir7CA;iR}iICcAmkHymr8^Uy8(>GfoA*`>r$taLOUlA67p!l2 z5>izsD~nPGEga^IWsqE+ya@R_X%uI3kCO%KS>HoRh}K34hKM>#R%J!m^Rs?LM%ldbd3?$e+VNAq14 z8DH2^p;UCanGJF!s`n!vRY28Zh7Uhw8%R0$Y~6h|0Oxk9Qdpmk!{hUDkK4`;fvn1L z(mXcj@nItMzQ!XpNKsLbp{B3}`tMf^uRnYVo(jFS?cXXP@$MCRdENm)beWyU&!V96 z;pPqZL5z>Cw8#01q6X%f2})wzYT>5~zMMi>4cw74vtV6lg$qmlrXsORuZa*mffM1OD7OtK(cde*} z)4xo@D`7LR`9VwNkJBO8hqgINhY_OF|C)L3GUK7}vsJXqoBI%#vGMng=@JZm+Y9j) z#{8nm(>un0M}Z*Bpe1Lx7x?7HJ?ODHD>1u5RbN}@0C(GOB}HQtRA+|6{#>Ymf{-V| zH4l5hUNi3Uh|m=Hn*CadyEzYD4n~*yYktDt%SYW)H7%g(NRxc=BQ`fV-#H+X%@Y<< zAODn!Fa^c^`nc!UmccGk^;kjj6yuzxIhqU;WBaH3)Bzq1vIycOyqds-lx!ytFR`(s znhK_0@RA3~;ThE2?-fMhpXxd*qlAzmET~+Z5J2<&l$D-b{HW7LnsF9;-*v9kk;!8B zY?Hsb8tOiP#$-ZfNJe*W`Y z+~`-*yTOl7Xwk=k>F_I9t{6SOpRjtf6Fl!Ovn5}xf~r4@Ws1>hFe$Lzwos9R@%s-- zxQdeCzoe)BUxp(=T}$PA*uYy5dFC&CA?gZ*RexIVl68WQ91Q`FH{L=!n`ld(Tnw0u z?r1YwVe?m#nAz&&OF=hW@~$vmCJ3u|gyQ+SK@)$x`{l?6u-^Q=oE6#!{CLzYUH)T$ zuj=($>s1fD!fTyWE~$bVlEDJQ3+WK{cNsTdy#_c+{zlTNwt>gjZz*B2KcW0LtD2_k z0+?EH)G#q@1J_4Eoh$S*1n?m798HJkbHUP z1aVDbZ*0O+VV;1{ity?POe~#gm}Fjn7?ZQAX-iA+ZSeHkqp>M?xRtT*sF?x!jp4t; zsEgp0|3K?9mYYe<{ucPipa}5eheWR#B!lgz_|j1lZx|8Y#qm5U2W^L3iy6#s-zBQp zUgzosZqK5)_9ZNLbUet~t3L$=$wLOZ*u0hSXT08cQC>_K zMbq1!4ZSXf!dH2hx|S3WUgVg|J1obDr>DA8BczOo_;n{2PZ3Hhh`u;<7waMKKJ)i} zCV>uIW0oJD<3W<-(|oJ$%qU;f&&jBk1R1drCrgHh!|aVCHP0{M@Wg3zr5o$HUcVoh zz*18QcYw1H$b7> z&=F2>Hv~U-ZNK~R2Ymlya7VVi5o~Tg^Ql*=2WjCu$8NnvfUCIEvlI~ubd=OZI8WSQ zOv<7#VEq-)^IA!DbbEnLd{&QUUJ_gnz3DynFB^beBy3%v6XGRExDO70!>5lvS^I)( z@T%;wwld*5oN4mA^WbmHuFgFg%C!ySle0Yz#Uw;d zDQCklGsyjr$|0qM3L&9Ukw`U4NJ$|?wnULb$YJA4DN;_6LnDVAaz2GkQEXv`WlX04g$zTf-0epgA%)K)}u^l^zvQ9*Cf%Eh5RC1j}(9<9A)J6i5u zk=Yl8=d>9@_Tw9|pVM15KIox5`Z1aOKCVa|6>S1iHlD|hN=j}FJE@QPnfg%xun&^IhdWLlF0{hAvxZB ztTineE~wwj7L4+RyMwi-iOM5T&=so}e0~8W^_M@`r2m9W^^Tt+P4m!ly{2?mTQ3-2 zZF#3(kqen=CZ!@>HPF{;e(ZE`D`@m&7-X z=LJq~5x9RfQk-3+_Q9U)4hNMxBOrLet97hkGrG0;4^_?!Du_QJtBBm>o?c7p%hyH$p7~lNJ#A$5CYrUaO$!-0Ix`M` z*G4sMYd=lh>4>^F^&b6`Arf@8ImyJ|yU&vAvwK)C(c7TLxp_&&JE1%g@^& zy(WAj^DE9-zZ^?Wep*EVV#XY*-Xc#amw0IE=ZBNY6n4>tdc#EH8%O{PUPF6PK};sG8~)~|A`4d;hkSwo@)rrqzKiphERHX-4f>6c$2(YH zPT;wW$Id151RbP7j9jGL-iCH}+L^l&q|p6qM`il6h)A=Cr*2pCAm(|_cc_|wf}z_5 zDEVsxFdsdAQfE_!=N;c-8KJm8{Hkm%?0*ZE$UEzcblqW#p;GX2xg8j>4x+1VkAdOJ z;^uPghVb3Ja!op4fU)7@jZXZ3Nf&D8J%#nsJ;S5ZJtgxnQ`>fpB`^kY;uoLiy{m#v zPo}goe`H|Y?u&}Fpi~fyS~Q6l%7(So*KSDA0%5!Q!CNO@qQiBDPLc1&GOM77MXyyG$H*UnqKkXGzCW;c2TFz6s zeKV`wtjhJh0Hi^(!$DEZbaCB^3euS`-3 z((Ze}w@2gLjZ$a8*O3rbd(;OCt$e12K3)Vraf43g{y2ygnn{$lNrkBVh)EZ67I1tH z%@^p;h4i{4U721Uc+Xr(m*!gsLr2TE(oZcK?km1NSGqkCRy938KMQ^YGL{F7^m(6x z^<7g@cdR!s52A!7FzRq!>7;NM&&7P_KVK}y{i-QtE}i3e0{q3Jb57?D8*D2V+{LRI)jUEQPrngLYCB%HLY3=XjzweN`9DODeNZ1mZrhz3fKxDiyhhN_RBB zq@eajYH(KUP+%ck|!Aki9 znq7KmKts;uc zxMa$j`Oxgrr7(8$H&C17mtXy81;XJcA1<79gDLZE?0a55P_!2QW7@t1-aE3xm6dCO z6`SLC(y|3YniQSMkE?(x6|OQi@D$FHZXMAv05DY+O*qR#hxcOs9Y46%p*W*Wx0P

G65P5+O8X<+ktzd*pAVC zg}}R`)J|_(76{hm4NI-w2ey`JieXwk1YNj(jK{ART*lIo_m>HXwQ#z8!GMUynmtPx zAdaL&ZRRR}ZbjWwo9ZuMzq>-yjo+h8^w9!irZRmGuG_diJ=eqgqVS_Pg&#g(ov5Yl z6*=5r50cCRcKFdzO0Varu>s~GwW$~O(da0nagNE@lr+4 z8IX!wtJx#PfTx0D9_Irc;5L)I*snMRsn!1Ha{N9+<^h$SL*B)ZYSmC*W7PzMYVM97 zN(Lb4c-4@9^EgPQJM#S{FaSG3b@p)tv0&uuaJ&Gq3WQD^q6Mec0j;yT`@3!JW@DRVcDzl)Lsyaq4$9kat;^r}Zc_g&w4`)9uH8jBd^r>~L4k}}H zu1%8l(PSh4bYUJHMLZ)a+woJ7J#21SYE(f=P4F8p&Y{qZEtd25Hb6J?R(yjx5!x}C zQT>>JxtEIjNOdZ7)D?L%a1L{g?XS^pFLP=j*=c8q^}btC1nE_`oaSbf!oPA{{kj0U z>+Mu}#(Nr^EGQGd?3*spLZXM9i2dw4W_xvb-K zBdmpK2yCip07JuV9w~0`z?Y#XW@c3Zr}8Y{oqVWdL1b=JZ-aHSp&>|Mt} z;v^CNd&m(~IqfffSw|rJI(h#2^w&!;eor6-_-T0iF#rFWzfWghl8qt|ex1C(mi==C cuao5<5Pbf35%+)Y$3fsAc;W@j=wGY;4Si85`2YX_ literal 0 HcmV?d00001 diff --git a/src/qp/projectors/tests/test_projector_base.py b/src/qp/projectors/tests/test_projector_base.py new file mode 100644 index 00000000..f93229a0 --- /dev/null +++ b/src/qp/projectors/tests/test_projector_base.py @@ -0,0 +1,35 @@ +import qp +import numpy as np +import rail_projector.projectors as rp + + +def make_qp_ens(file): + zs = file['zs'] + pzs = file['pzs'] + dz = np.mean(np.diff(zs)) + zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":pzs}) + return q + +def test_base_from_qp(): + file = np.load('rail_projector/tests/dummy.npz') + ens = make_qp_ens(file) + projector = rp.ProjectorBase(ens) + m, n = projector.pzs.shape + k, = projector.z.shape + pzs = file['pzs'] + pzs /= np.sum(pzs, axis=1)[:, None] + assert n == k + assert np.allclose(projector.pz_mean, np.mean(pzs, axis=0)) + +def test_base_from_arrs(): + file = np.load('rail_projector/tests/dummy.npz') + zs = file['zs'] + pzs = file['pzs'] + projector = rp.ProjectorBase(zs, pzs) + m, n = projector.pzs.shape + k, = projector.z.shape + pzs = file['pzs'] + pzs /= np.sum(pzs, axis=1)[:, None] + assert n == k + assert np.allclose(projector.pz_mean, np.mean(pzs, axis=0)) \ No newline at end of file diff --git a/src/qp/projectors/tests/test_projector_moments.py b/src/qp/projectors/tests/test_projector_moments.py new file mode 100644 index 00000000..d9030748 --- /dev/null +++ b/src/qp/projectors/tests/test_projector_moments.py @@ -0,0 +1,39 @@ +import qp +import numpy as np +import rail_projector.projectors as rp + + +def make_qp_ens(file): + zs = file['zs'] + pzs = file['pzs'] + dz = np.mean(np.diff(zs)) + zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":pzs}) + return q + + +def make_projector(): + file = np.load('rail_projector/tests/dummy.npz') + ens = make_qp_ens(file) + return rp.ProjectorMoments(ens) + + +def test_prior(): + projector = make_projector() + prior = projector.get_prior() + assert prior is not None + + +def test_sample_prior(): + projector = make_projector() + pz = projector.sample_prior() + assert len(pz) == len(projector.pz_mean) + + +def test_model(): + projector = make_projector() + shift = projector.sample_prior() + input = np.array([projector.z, projector.pz_mean]) + output = projector.evaluate_model(input, shift) + assert (projector.z == output[0]).all() + assert len(output[1]) == len(projector.pz_mean) diff --git a/src/qp/projectors/tests/test_projector_shifts.py b/src/qp/projectors/tests/test_projector_shifts.py new file mode 100644 index 00000000..1cc5f253 --- /dev/null +++ b/src/qp/projectors/tests/test_projector_shifts.py @@ -0,0 +1,39 @@ +import qp +import numpy as np +import rail_projector.projectors as rp + + +def make_qp_ens(file): + zs = file['zs'] + pzs = file['pzs'] + dz = np.mean(np.diff(zs)) + zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":pzs}) + return q + + +def make_projector(): + file = np.load('rail_projector/tests/dummy.npz') + ens = make_qp_ens(file) + return rp.ProjectorShifts(ens) + + +def test_prior(): + projector = make_projector() + prior = projector.get_prior() + assert prior is not None + + +def test_sample_prior(): + projector = make_projector() + shift = projector.sample_prior() + assert len([shift]) == len([projector.shift]) + + +def test_model(): + projector = make_projector() + shift = projector.sample_prior() + input = np.array([projector.z, projector.pz_mean]) + output = projector.evaluate_model(input, shift) + assert (projector.z == output[0]).all() + assert len(output[1]) == len(projector.pz_mean) From db3836a2317c913a0fcaba67344d1dcd0f168cfc Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Tue, 11 Jun 2024 10:49:57 +0100 Subject: [PATCH 02/13] working notebooks --- nb/demo.ipynb | 1928 ++++++++++++++++- nb/priors_example.ipynb | 267 +++ src/qp/projectors/projector_base.py | 2 +- src/qp/projectors/tests/__init__.py | 0 .../projectors/tests => tests/qp}/dummy.npz | Bin .../tests => tests/qp}/test_projector_base.py | 10 +- .../qp}/test_projector_moments.py | 6 +- .../qp}/test_projector_shifts.py | 6 +- 8 files changed, 2107 insertions(+), 112 deletions(-) create mode 100644 nb/priors_example.ipynb delete mode 100644 src/qp/projectors/tests/__init__.py rename {src/qp/projectors/tests => tests/qp}/dummy.npz (100%) rename {src/qp/projectors/tests => tests/qp}/test_projector_base.py (77%) rename {src/qp/projectors/tests => tests/qp}/test_projector_moments.py (86%) rename {src/qp/projectors/tests => tests/qp}/test_projector_shifts.py (87%) diff --git a/nb/demo.ipynb b/nb/demo.ipynb index a510cfca..e9f9e178 100644 --- a/nb/demo.ipynb +++ b/nb/demo.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -39,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -70,9 +70,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PDF at one point for one distribution: 0.3520653267642995\n", + "PDF at three points for one distribution: [0.35206533 0.24197072 0.1295176 ]\n", + "PDF at one point for three distributions: [0.35206533 0.35206533 0.1295176 ]\n", + "PDF at one different point for three distributions: [0.35206533 0.39894228 0.35206533]\n", + "PDF at four different points for three distributions:\n", + " [[0.35206533 0.35206533 0.1295176 ]\n", + " [0.24197072 0.39894228 0.24197072]\n", + " [0.1295176 0.35206533 0.35206533]\n", + " [0.05399097 0.24197072 0.39894228]]\n", + "PDF at four different points for three distributions: broadcast reversed\n", + " [[0.35206533 0.24197072 0.1295176 0.05399097]\n", + " [0.35206533 0.39894228 0.35206533 0.24197072]\n", + " [0.1295176 0.24197072 0.35206533 0.39894228]]\n" + ] + } + ], "source": [ "# evaluate a single distribution's PDF at one value\n", "print(\"PDF at one point for one distribution:\", \n", @@ -113,9 +133,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is the generic normal distribution class: \n", + "This is an instance of the generic normal distribution class \n", + "This is a frozen normal distribution, with specific paramters {'loc': 0, 'scale': 1}\n", + "The frozen object know what generic distribution it comes from \n" + ] + } + ], "source": [ "print(\"This is the generic normal distribution class: \", \n", " sps._continuous_distns.norm_gen)\n", @@ -150,9 +181,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PDF = 0.3520653267642995\n", + "CDF = 0.6914624612740131\n", + "PPF = 0.2533471031357997\n", + "SF = 0.2742531177500736\n", + "ISF = 0.0\n", + "RVS = -0.1331918386344051\n", + "stats = (0.0, 1.0)\n", + "M2 = 1.0\n" + ] + } + ], "source": [ "print(\"PDF = \", norm_sp.pdf(0.5)) \n", "print(\"CDF = \", norm_sp.cdf(0.5))\n", @@ -184,29 +230,849 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "odict_keys(['alpha', 'anglit', 'arcsine', 'argus', 'beta', 'betaprime', 'bradford', 'burr', 'burr12', 'cauchy', 'chi', 'chi2', 'cosine', 'crystalball', 'dgamma', 'dweibull', 'erlang', 'expon', 'exponnorm', 'exponpow', 'exponweib', 'f', 'fatiguelife', 'fisk', 'foldcauchy', 'foldnorm', 'gamma', 'gausshyper', 'genexpon', 'genextreme', 'gengamma', 'genhalflogistic', 'genhyperbolic', 'geninvgauss', 'genlogistic', 'gennorm', 'genpareto', 'gibrat', 'gompertz', 'gumbel_l', 'gumbel_r', 'halfcauchy', 'halfgennorm', 'halflogistic', 'halfnorm', 'hypsecant', 'invgamma', 'invgauss', 'invweibull', 'johnsonsb', 'johnsonsu', 'kappa3', 'kappa4', 'ksone', 'kstwo', 'kstwobign', 'laplace', 'laplace_asymmetric', 'levy', 'levy_l', 'levy_stable', 'loggamma', 'logistic', 'loglaplace', 'lognorm', 'loguniform', 'lomax', 'maxwell', 'mielke', 'moyal', 'nakagami', 'ncf', 'nct', 'ncx2', 'norm', 'norminvgauss', 'pareto', 'pearson3', 'powerlaw', 'powerlognorm', 'powernorm', 'rayleigh', 'rdist', 'recipinvgauss', 'reciprocal', 'rel_breitwigner', 'rice', 'semicircular', 'skewcauchy', 'skewnorm', 'studentized_range', 't', 'trapezoid', 'trapz', 'triang', 'truncexpon', 'truncnorm', 'truncpareto', 'truncweibull_min', 'tukeylambda', 'uniform', 'vonmises', 'vonmises_line', 'wald', 'weibull_max', 'weibull_min', 'wrapcauchy', 'spline', 'hist', 'interp', 'interp_irregular', 'quant', 'mixmod', 'sparse', 'packed_interp'])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "qp.stats.keys()" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on class lognorm in module qp.factory:\n", + "\n", + "class lognorm(qp.pdf_gen.Pdf_gen_wrap, scipy.stats._continuous_distns.lognorm_gen)\n", + " | lognorm(*args, **kwargs)\n", + " | \n", + " | Method resolution order:\n", + " | lognorm\n", + " | qp.pdf_gen.Pdf_gen_wrap\n", + " | qp.pdf_gen.Pdf_gen\n", + " | scipy.stats._continuous_distns.lognorm_gen\n", + " | scipy.stats._distn_infrastructure.rv_continuous\n", + " | scipy.stats._distn_infrastructure.rv_generic\n", + " | builtins.object\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | freeze = _my_freeze(self, *args, **kwds)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " | \n", + " | name = 'lognorm'\n", + " | \n", + " | version = 0\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from qp.pdf_gen.Pdf_gen_wrap:\n", + " | \n", + " | __init__(self, *args, **kwargs)\n", + " | C'tor\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods inherited from qp.pdf_gen.Pdf_gen_wrap:\n", + " | \n", + " | add_mappings() from builtins.type\n", + " | Add this classes mappings to the conversion dictionary\n", + " | \n", + " | get_allocation_kwds(npdf, **kwargs) from builtins.type\n", + " | Return kwds necessary to create 'empty' hdf5 file with npdf entries\n", + " | for iterative writeout\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods inherited from qp.pdf_gen.Pdf_gen:\n", + " | \n", + " | add_method_dicts() from builtins.type\n", + " | Add empty method dicts\n", + " | \n", + " | create(**kwds) from builtins.type\n", + " | Create and return a `scipy.stats.rv_frozen` object using the\n", + " | keyword arguemntets provided\n", + " | \n", + " | create_gen(**kwds) from builtins.type\n", + " | Create and return a `scipy.stats.rv_continuous` object using the\n", + " | keyword arguemntets provided\n", + " | \n", + " | creation_method(method=None) from builtins.type\n", + " | Return the method used to create a PDF of this type\n", + " | \n", + " | extraction_method(method=None) from builtins.type\n", + " | Return the method used to extract data to create a PDF of this type\n", + " | \n", + " | plot(pdf, **kwargs) from builtins.type\n", + " | Plot the pdf as a curve\n", + " | \n", + " | plot_native(pdf, **kwargs) from builtins.type\n", + " | Plot the PDF in a way that is particular to this type of distibution\n", + " | \n", + " | This defaults to plotting it as a curve, but this can be overwritten\n", + " | \n", + " | print_method_maps(stream=) from builtins.type\n", + " | Print the maps showing the methods\n", + " | \n", + " | reader_method(version=None) from builtins.type\n", + " | Return the method used to convert data read from a file PDF of this type\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Readonly properties inherited from qp.pdf_gen.Pdf_gen:\n", + " | \n", + " | metadata\n", + " | Return the metadata for this set of PDFs\n", + " | \n", + " | objdata\n", + " | Return the object data for this set of PDFs\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from qp.pdf_gen.Pdf_gen:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from scipy.stats._continuous_distns.lognorm_gen:\n", + " | \n", + " | fit(self, data, *args, **kwds)\n", + " | Return estimates of shape (if applicable), location, and scale\n", + " | parameters from data. The default estimation method is Maximum\n", + " | Likelihood Estimation (MLE), but Method of Moments (MM)\n", + " | is also available.\n", + " | \n", + " | Starting estimates for the fit are given by input arguments;\n", + " | for any arguments not provided with starting estimates,\n", + " | ``self._fitstart(data)`` is called to generate such.\n", + " | \n", + " | One can hold some parameters fixed to specific values by passing in\n", + " | keyword arguments ``f0``, ``f1``, ..., ``fn`` (for shape parameters)\n", + " | and ``floc`` and ``fscale`` (for location and scale parameters,\n", + " | respectively).\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | data : array_like or `CensoredData` instance\n", + " | Data to use in estimating the distribution parameters.\n", + " | arg1, arg2, arg3,... : floats, optional\n", + " | Starting value(s) for any shape-characterizing arguments (those not\n", + " | provided will be determined by a call to ``_fitstart(data)``).\n", + " | No default value.\n", + " | **kwds : floats, optional\n", + " | - `loc`: initial guess of the distribution's location parameter.\n", + " | - `scale`: initial guess of the distribution's scale parameter.\n", + " | \n", + " | Special keyword arguments are recognized as holding certain\n", + " | parameters fixed:\n", + " | \n", + " | - f0...fn : hold respective shape parameters fixed.\n", + " | Alternatively, shape parameters to fix can be specified by name.\n", + " | For example, if ``self.shapes == \"a, b\"``, ``fa`` and ``fix_a``\n", + " | are equivalent to ``f0``, and ``fb`` and ``fix_b`` are\n", + " | equivalent to ``f1``.\n", + " | \n", + " | - floc : hold location parameter fixed to specified value.\n", + " | \n", + " | - fscale : hold scale parameter fixed to specified value.\n", + " | \n", + " | - optimizer : The optimizer to use. The optimizer must take\n", + " | ``func`` and starting position as the first two arguments,\n", + " | plus ``args`` (for extra arguments to pass to the\n", + " | function to be optimized) and ``disp=0`` to suppress\n", + " | output as keyword arguments.\n", + " | \n", + " | - method : The method to use. The default is \"MLE\" (Maximum\n", + " | Likelihood Estimate); \"MM\" (Method of Moments)\n", + " | is also available.\n", + " | \n", + " | Raises\n", + " | ------\n", + " | TypeError, ValueError\n", + " | If an input is invalid\n", + " | `~scipy.stats.FitError`\n", + " | If fitting fails or the fit produced would be invalid\n", + " | \n", + " | Returns\n", + " | -------\n", + " | parameter_tuple : tuple of floats\n", + " | Estimates for any shape parameters (if applicable), followed by\n", + " | those for location and scale. For most random variables, shape\n", + " | statistics will be returned, but there are exceptions (e.g.\n", + " | ``norm``).\n", + " | \n", + " | Notes\n", + " | -----\n", + " | With ``method=\"MLE\"`` (default), the fit is computed by minimizing\n", + " | the negative log-likelihood function. A large, finite penalty\n", + " | (rather than infinite negative log-likelihood) is applied for\n", + " | observations beyond the support of the distribution.\n", + " | \n", + " | With ``method=\"MM\"``, the fit is computed by minimizing the L2 norm\n", + " | of the relative errors between the first *k* raw (about zero) data\n", + " | moments and the corresponding distribution moments, where *k* is the\n", + " | number of non-fixed parameters.\n", + " | More precisely, the objective function is::\n", + " | \n", + " | (((data_moments - dist_moments)\n", + " | / np.maximum(np.abs(data_moments), 1e-8))**2).sum()\n", + " | \n", + " | where the constant ``1e-8`` avoids division by zero in case of\n", + " | vanishing data moments. Typically, this error norm can be reduced to\n", + " | zero.\n", + " | Note that the standard method of moments can produce parameters for\n", + " | which some data are outside the support of the fitted distribution;\n", + " | this implementation does nothing to prevent this.\n", + " | \n", + " | For either method,\n", + " | the returned answer is not guaranteed to be globally optimal; it\n", + " | may only be locally optimal, or the optimization may fail altogether.\n", + " | If the data contain any of ``np.nan``, ``np.inf``, or ``-np.inf``,\n", + " | the `fit` method will raise a ``RuntimeError``.\n", + " | \n", + " | When `method='MLE'` and\n", + " | the location parameter is fixed by using the `floc` argument,\n", + " | this function uses explicit formulas for the maximum likelihood\n", + " | estimation of the log-normal shape and scale parameters, so the\n", + " | `optimizer`, `loc` and `scale` keyword arguments are ignored.\n", + " | If the location is free, a likelihood maximum is found by\n", + " | setting its partial derivative wrt to location to 0, and\n", + " | solving by substituting the analytical expressions of shape\n", + " | and scale (or provided parameters).\n", + " | See, e.g., equation 3.1 in\n", + " | A. Clifford Cohen & Betty Jones Whitten (1980)\n", + " | Estimation in the Three-Parameter Lognormal Distribution,\n", + " | Journal of the American Statistical Association, 75:370, 399-404\n", + " | https://doi.org/10.2307/2287466\n", + " | \n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | Generate some data to fit: draw random variates from the `beta`\n", + " | distribution\n", + " | \n", + " | >>> from scipy.stats import beta\n", + " | >>> a, b = 1., 2.\n", + " | >>> x = beta.rvs(a, b, size=1000)\n", + " | \n", + " | Now we can fit all four parameters (``a``, ``b``, ``loc`` and\n", + " | ``scale``):\n", + " | \n", + " | >>> a1, b1, loc1, scale1 = beta.fit(x)\n", + " | \n", + " | We can also use some prior knowledge about the dataset: let's keep\n", + " | ``loc`` and ``scale`` fixed:\n", + " | \n", + " | >>> a1, b1, loc1, scale1 = beta.fit(x, floc=0, fscale=1)\n", + " | >>> loc1, scale1\n", + " | (0, 1)\n", + " | \n", + " | We can also keep shape parameters fixed by using ``f``-keywords. To\n", + " | keep the zero-th shape parameter ``a`` equal 1, use ``f0=1`` or,\n", + " | equivalently, ``fa=1``:\n", + " | \n", + " | >>> a1, b1, loc1, scale1 = beta.fit(x, fa=1, floc=0, fscale=1)\n", + " | >>> a1\n", + " | 1\n", + " | \n", + " | Not all distributions return estimates for the shape parameters.\n", + " | ``norm`` for example just returns estimates for location and scale:\n", + " | \n", + " | >>> from scipy.stats import norm\n", + " | >>> x = norm.rvs(a, b, size=1000, random_state=123)\n", + " | >>> loc1, scale1 = norm.fit(x)\n", + " | >>> loc1, scale1\n", + " | (0.92087172783841631, 2.0015750750324668)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from scipy.stats._distn_infrastructure.rv_continuous:\n", + " | \n", + " | __getstate__(self)\n", + " | \n", + " | cdf(self, x, *args, **kwds)\n", + " | Cumulative distribution function of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | x : array_like\n", + " | quantiles\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | cdf : ndarray\n", + " | Cumulative distribution function evaluated at `x`\n", + " | \n", + " | expect(self, func=None, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds)\n", + " | Calculate expected value of a function with respect to the\n", + " | distribution by numerical integration.\n", + " | \n", + " | The expected value of a function ``f(x)`` with respect to a\n", + " | distribution ``dist`` is defined as::\n", + " | \n", + " | ub\n", + " | E[f(x)] = Integral(f(x) * dist.pdf(x)),\n", + " | lb\n", + " | \n", + " | where ``ub`` and ``lb`` are arguments and ``x`` has the ``dist.pdf(x)``\n", + " | distribution. If the bounds ``lb`` and ``ub`` correspond to the\n", + " | support of the distribution, e.g. ``[-inf, inf]`` in the default\n", + " | case, then the integral is the unrestricted expectation of ``f(x)``.\n", + " | Also, the function ``f(x)`` may be defined such that ``f(x)`` is ``0``\n", + " | outside a finite interval in which case the expectation is\n", + " | calculated within the finite range ``[lb, ub]``.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | func : callable, optional\n", + " | Function for which integral is calculated. Takes only one argument.\n", + " | The default is the identity mapping f(x) = x.\n", + " | args : tuple, optional\n", + " | Shape parameters of the distribution.\n", + " | loc : float, optional\n", + " | Location parameter (default=0).\n", + " | scale : float, optional\n", + " | Scale parameter (default=1).\n", + " | lb, ub : scalar, optional\n", + " | Lower and upper bound for integration. Default is set to the\n", + " | support of the distribution.\n", + " | conditional : bool, optional\n", + " | If True, the integral is corrected by the conditional probability\n", + " | of the integration interval. The return value is the expectation\n", + " | of the function, conditional on being in the given interval.\n", + " | Default is False.\n", + " | \n", + " | Additional keyword arguments are passed to the integration routine.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | expect : float\n", + " | The calculated expected value.\n", + " | \n", + " | Notes\n", + " | -----\n", + " | The integration behavior of this function is inherited from\n", + " | `scipy.integrate.quad`. Neither this function nor\n", + " | `scipy.integrate.quad` can verify whether the integral exists or is\n", + " | finite. For example ``cauchy(0).mean()`` returns ``np.nan`` and\n", + " | ``cauchy(0).expect()`` returns ``0.0``.\n", + " | \n", + " | Likewise, the accuracy of results is not verified by the function.\n", + " | `scipy.integrate.quad` is typically reliable for integrals that are\n", + " | numerically favorable, but it is not guaranteed to converge\n", + " | to a correct value for all possible intervals and integrands. This\n", + " | function is provided for convenience; for critical applications,\n", + " | check results against other integration methods.\n", + " | \n", + " | The function is not vectorized.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | To understand the effect of the bounds of integration consider\n", + " | \n", + " | >>> from scipy.stats import expon\n", + " | >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0)\n", + " | 0.6321205588285578\n", + " | \n", + " | This is close to\n", + " | \n", + " | >>> expon(1).cdf(2.0) - expon(1).cdf(0.0)\n", + " | 0.6321205588285577\n", + " | \n", + " | If ``conditional=True``\n", + " | \n", + " | >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0, conditional=True)\n", + " | 1.0000000000000002\n", + " | \n", + " | The slight deviation from 1 is due to numerical integration.\n", + " | \n", + " | The integrand can be treated as a complex-valued function\n", + " | by passing ``complex_func=True`` to `scipy.integrate.quad` .\n", + " | \n", + " | >>> import numpy as np\n", + " | >>> from scipy.stats import vonmises\n", + " | >>> res = vonmises(loc=2, kappa=1).expect(lambda x: np.exp(1j*x),\n", + " | ... complex_func=True)\n", + " | >>> res\n", + " | (-0.18576377217422957+0.40590124735052263j)\n", + " | \n", + " | >>> np.angle(res) # location of the (circular) distribution\n", + " | 2.0\n", + " | \n", + " | fit_loc_scale(self, data, *args)\n", + " | Estimate loc and scale parameters from data using 1st and 2nd moments.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | data : array_like\n", + " | Data to fit.\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information).\n", + " | \n", + " | Returns\n", + " | -------\n", + " | Lhat : float\n", + " | Estimated location parameter for the data.\n", + " | Shat : float\n", + " | Estimated scale parameter for the data.\n", + " | \n", + " | isf(self, q, *args, **kwds)\n", + " | Inverse survival function (inverse of `sf`) at q of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | q : array_like\n", + " | upper tail probability\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | x : ndarray or scalar\n", + " | Quantile corresponding to the upper tail probability q.\n", + " | \n", + " | logcdf(self, x, *args, **kwds)\n", + " | Log of the cumulative distribution function at x of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | x : array_like\n", + " | quantiles\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | logcdf : array_like\n", + " | Log of the cumulative distribution function evaluated at x\n", + " | \n", + " | logpdf(self, x, *args, **kwds)\n", + " | Log of the probability density function at x of the given RV.\n", + " | \n", + " | This uses a more numerically accurate calculation if available.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | x : array_like\n", + " | quantiles\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | logpdf : array_like\n", + " | Log of the probability density function evaluated at x\n", + " | \n", + " | logsf(self, x, *args, **kwds)\n", + " | Log of the survival function of the given RV.\n", + " | \n", + " | Returns the log of the \"survival function,\" defined as (1 - `cdf`),\n", + " | evaluated at `x`.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | x : array_like\n", + " | quantiles\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | logsf : ndarray\n", + " | Log of the survival function evaluated at `x`.\n", + " | \n", + " | pdf(self, x, *args, **kwds)\n", + " | Probability density function at x of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | x : array_like\n", + " | quantiles\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | pdf : ndarray\n", + " | Probability density function evaluated at x\n", + " | \n", + " | ppf(self, q, *args, **kwds)\n", + " | Percent point function (inverse of `cdf`) at q of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | q : array_like\n", + " | lower tail probability\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | x : array_like\n", + " | quantile corresponding to the lower tail probability q.\n", + " | \n", + " | sf(self, x, *args, **kwds)\n", + " | Survival function (1 - `cdf`) at x of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | x : array_like\n", + " | quantiles\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | sf : array_like\n", + " | Survival function evaluated at x\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from scipy.stats._distn_infrastructure.rv_generic:\n", + " | \n", + " | __call__(self, *args, **kwds)\n", + " | Freeze the distribution for the given arguments.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution. Should include all\n", + " | the non-optional arguments, may include ``loc`` and ``scale``.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | rv_frozen : rv_frozen instance\n", + " | The frozen distribution.\n", + " | \n", + " | __setstate__(self, state)\n", + " | \n", + " | entropy(self, *args, **kwds)\n", + " | Differential entropy of the RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information).\n", + " | loc : array_like, optional\n", + " | Location parameter (default=0).\n", + " | scale : array_like, optional (continuous distributions only).\n", + " | Scale parameter (default=1).\n", + " | \n", + " | Notes\n", + " | -----\n", + " | Entropy is defined base `e`:\n", + " | \n", + " | >>> import numpy as np\n", + " | >>> drv = rv_discrete(values=((0, 1), (0.5, 0.5)))\n", + " | >>> np.allclose(drv.entropy(), np.log(2.0))\n", + " | True\n", + " | \n", + " | interval(self, confidence, *args, **kwds)\n", + " | Confidence interval with equal areas around the median.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | confidence : array_like of float\n", + " | Probability that an rv will be drawn from the returned range.\n", + " | Each value should be in the range [0, 1].\n", + " | arg1, arg2, ... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information).\n", + " | loc : array_like, optional\n", + " | location parameter, Default is 0.\n", + " | scale : array_like, optional\n", + " | scale parameter, Default is 1.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | a, b : ndarray of float\n", + " | end-points of range that contain ``100 * alpha %`` of the rv's\n", + " | possible values.\n", + " | \n", + " | Notes\n", + " | -----\n", + " | This is implemented as ``ppf([p_tail, 1-p_tail])``, where\n", + " | ``ppf`` is the inverse cumulative distribution function and\n", + " | ``p_tail = (1-confidence)/2``. Suppose ``[c, d]`` is the support of a\n", + " | discrete distribution; then ``ppf([0, 1]) == (c-1, d)``. Therefore,\n", + " | when ``confidence=1`` and the distribution is discrete, the left end\n", + " | of the interval will be beyond the support of the distribution.\n", + " | For discrete distributions, the interval will limit the probability\n", + " | in each tail to be less than or equal to ``p_tail`` (usually\n", + " | strictly less).\n", + " | \n", + " | mean(self, *args, **kwds)\n", + " | Mean of the distribution.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | mean : float\n", + " | the mean of the distribution\n", + " | \n", + " | median(self, *args, **kwds)\n", + " | Median of the distribution.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | Location parameter, Default is 0.\n", + " | scale : array_like, optional\n", + " | Scale parameter, Default is 1.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | median : float\n", + " | The median of the distribution.\n", + " | \n", + " | See Also\n", + " | --------\n", + " | rv_discrete.ppf\n", + " | Inverse of the CDF\n", + " | \n", + " | moment(self, order, *args, **kwds)\n", + " | non-central moment of distribution of specified order.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | order : int, order >= 1\n", + " | Order of moment.\n", + " | arg1, arg2, arg3,... : float\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information).\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | nnlf(self, theta, x)\n", + " | Negative loglikelihood function.\n", + " | Notes\n", + " | -----\n", + " | This is ``-sum(log pdf(x, theta), axis=0)`` where `theta` are the\n", + " | parameters (including loc and scale).\n", + " | \n", + " | rvs(self, *args, **kwds)\n", + " | Random variates of given type.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information).\n", + " | loc : array_like, optional\n", + " | Location parameter (default=0).\n", + " | scale : array_like, optional\n", + " | Scale parameter (default=1).\n", + " | size : int or tuple of ints, optional\n", + " | Defining number of random variates (default is 1).\n", + " | random_state : {None, int, `numpy.random.Generator`,\n", + " | `numpy.random.RandomState`}, optional\n", + " | \n", + " | If `random_state` is None (or `np.random`), the\n", + " | `numpy.random.RandomState` singleton is used.\n", + " | If `random_state` is an int, a new ``RandomState`` instance is\n", + " | used, seeded with `random_state`.\n", + " | If `random_state` is already a ``Generator`` or ``RandomState``\n", + " | instance, that instance is used.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | rvs : ndarray or scalar\n", + " | Random variates of given `size`.\n", + " | \n", + " | stats(self, *args, **kwds)\n", + " | Some statistics of the given RV.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional (continuous RVs only)\n", + " | scale parameter (default=1)\n", + " | moments : str, optional\n", + " | composed of letters ['mvsk'] defining which moments to compute:\n", + " | 'm' = mean,\n", + " | 'v' = variance,\n", + " | 's' = (Fisher's) skew,\n", + " | 'k' = (Fisher's) kurtosis.\n", + " | (default is 'mv')\n", + " | \n", + " | Returns\n", + " | -------\n", + " | stats : sequence\n", + " | of requested moments.\n", + " | \n", + " | std(self, *args, **kwds)\n", + " | Standard deviation of the distribution.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | std : float\n", + " | standard deviation of the distribution\n", + " | \n", + " | support(self, *args, **kwargs)\n", + " | Support of the distribution.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, ... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information).\n", + " | loc : array_like, optional\n", + " | location parameter, Default is 0.\n", + " | scale : array_like, optional\n", + " | scale parameter, Default is 1.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | a, b : array_like\n", + " | end-points of the distribution's support.\n", + " | \n", + " | var(self, *args, **kwds)\n", + " | Variance of the distribution.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | arg1, arg2, arg3,... : array_like\n", + " | The shape parameter(s) for the distribution (see docstring of the\n", + " | instance object for more information)\n", + " | loc : array_like, optional\n", + " | location parameter (default=0)\n", + " | scale : array_like, optional\n", + " | scale parameter (default=1)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | var : float\n", + " | the variance of the distribution\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from scipy.stats._distn_infrastructure.rv_generic:\n", + " | \n", + " | random_state\n", + " | Get or set the generator object for generating random variates.\n", + " | \n", + " | If `random_state` is None (or `np.random`), the\n", + " | `numpy.random.RandomState` singleton is used.\n", + " | If `random_state` is an int, a new ``RandomState`` instance is used,\n", + " | seeded with `random_state`.\n", + " | If `random_state` is already a ``Generator`` or ``RandomState``\n", + " | instance, that instance is used.\n", + "\n" + ] + } + ], "source": [ "help(qp.stats.lognorm_gen)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on method create in module qp.pdf_gen:\n", + "\n", + "create(**kwds) method of builtins.type instance\n", + " Create and return a `scipy.stats.rv_frozen` object using the\n", + " keyword arguemntets provided\n", + "\n" + ] + } + ], "source": [ "help(qp.stats.lognorm)" ] @@ -222,9 +1088,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "loc1 = np.array([[0]])\n", "scale1 = np.array([[1]])\n", @@ -234,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -255,9 +1132,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Convert to a histogram by computing the bin values by taking the intergral of the CDF\n", "xvals = np.linspace(-5, 5, 11)\n", @@ -281,9 +1169,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For an input vector of shape (2, 1) the output shape is (2, 1)\n" + ] + } + ], "source": [ "xvals_x = np.array([[-1.], [1.]])\n", "yvals_x = hist_dist.pdf(xvals_x)\n", @@ -304,9 +1200,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The input and output shapes are: (11,) (1, 11)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAHsCAYAAABG5syiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjRElEQVR4nO3deVxU9f4/8NeZYRbWUUHBhc0dJFPQEAiXruJSqbcNbzes708rb6t527xaqbeudcvEyrWN9N6Ubqal2VXq5hZoSdCmmamIyiBiys6s5/fHxDgjIDvnzMzr+XjM4wFnzvnM+zDMOe/5rIIoiiKIiIiIyOMopA6AiIiIiKTBRJCIiIjIQzERJCIiIvJQTASJiIiIPJSX1AEQERGRvFmtVhiNRqnDoFZQq9VQKBqv92MiSERERI0yGo04efIkrFar1KFQKygUCkRGRkKtVjf4vMDpY4iIiKghoiiisLAQJpMJvXr1umrNEsmP1WpFUVERVCoVwsLCIAhCvX1YI0hEREQNMpvNqK6uRq9eveDj4yN1ONQK3bt3R1FREcxmM1QqVb3nmdoTERFRgywWCwA02qxI8lf33tW9l1diIkhERERX1VCTIrmGpt47JoJEREREHoqJIBEREXUos0HEpv8rwab/K4HZwDGqu3fvhiAIuHTpEgAgIyMDXbp0kSQWJoJEREREHWTs2LGYO3eu07bExETo9XrodDppgnLAUcNEREREnUitViMkJETqMACwRpCIiIjcUFVVFWbOnAk/Pz/07NkTy5Ytc6qdEwQBW7dudTqmS5cuyMjIsP/+1FNPYeDAgfDx8UHfvn3xzDPPwGQy2Z9ftGgRhg0bhg0bNiAiIgI6nQ4zZsxARUUFAOCee+7Bnj17sGLFCgiCAEEQUFBQUK9puCHbtm1DXFwctFot+vbti8WLF8NsNju9dlhYGDQaDXr16oVHHnmkVX8nJoJERETkdp544gl8+eWX2LJlC3bt2oXdu3cjNze3RWX4+/sjIyMDhw8fxooVK/Dmm29i+fLlTvscP34cW7duxfbt27F9+3bs2bMHL774IgBgxYoVSEhIwL333gu9Xg+9Xo/Q0NAmX3fnzp2466678Mgjj+Dw4cNYu3YtMjIy8MILLwAAPvzwQyxfvhxr167FsWPHsHXrVlxzzTUtOrc6bBomIiIit1JZWYm3334b69evx4QJEwAA7733Hvr06dOichYuXGj/OSIiAn/961+RmZmJJ5980r7darUiIyMD/v7+AIC0tDR88cUXeOGFF6DT6aBWq+Hj49OipuAXXngBTz/9NO6++24AQN++ffH3v/8dTz75JJ577jkUFhYiJCQE48ePt68act1117Xo3OowESQiIiK3cvz4cRiNRiQkJNi3devWDYMGDWpROR9++CHS09Px66+/orKyEmazGQEBAU77RERE2JNAAOjZsydKSkraFH9ubi6++eYbew0gYJsQura2FtXV1bj99tuRnp6Ovn37YtKkSZgyZQpuvvlmeHm1PK1j0zARERG5FVFseooaQRDq7efY/+/AgQOYMWMGJk+ejO3btyMvLw8LFiyA0Wh0OubKZdsEQYDVam1D9LZaxsWLFyM/P9/++OGHH3Ds2DFotVqEhobi6NGjWLlyJby9vfHAAw9g9OjRTvE3F2sEiYiIyK30798fKpUKBw4cQFhYGADg4sWL+OWXXzBmzBgAtjV49Xq9/Zhjx46hurra/vtXX32F8PBwLFiwwL7t1KlTLY5FrVY3urxbY2JjY3H06FH079+/0X28vb0xdepUTJ06FQ8++CAGDx6MH374AbGxsS16LSaCRERE5Fb8/Pwwa9YsPPHEEwgMDERwcDAWLFgAheJyQ+gNN9yAN954A6NGjYLVasVTTz3lVLvXv39/FBYWYtOmTRg5ciQ+/fRTbNmypcWxRERE4ODBgygoKICfnx+6devW5DHPPvssbrrpJoSGhuL222+HQqHA999/jx9++AHPP/88MjIyYLFYEB8fDx8fH2zYsAHe3t4IDw9vcXxsGiYiIiK38/LLL2P06NGYOnUqxo8fj+uvvx5xcXH255ctW4bQ0FCMHj0ad955Jx5//HH4+PjYn582bRoee+wxPPTQQxg2bBiys7PxzDPPtDiOxx9/HEqlEtHR0ejevTsKCwubPGbixInYvn07srKyMHLkSIwaNQqvvvqqPdHr0qUL3nzzTSQlJWHo0KH44osvsG3bNgQGBrY4PkFsTkM6EREReZza2lqcPHkSkZGR0Gq1rS7HbBDx4ZzzAIDb1nSHl0ZorxBbZOzYsRg2bBjS09MleX0pNPUeskaQiIiIyEMxESQiIiLyUBwsQkRERB3KSyNgxrs9pA4Du3fvljoE2WGNIBEREZGHYiJIRERE5KGYCBIRERF5KCaCRERERB6KiSARERGRh2IiSEREROShmAgSERERdaLdu3dDEARcunQJAJCRkYEuXbpIEgsTQSIiIqIOMnbsWMydO9dpW2JiIvR6PXQ6nTRBOeCE0kRERESdSK1WIyQkROowALBGkIiIiNxQVVUVZs6cCT8/P/Ts2RPLli1zqp0TBAFbt251OqZLly7IyMiw//7UU09h4MCB8PHxQd++ffHMM8/AZDLZn1+0aBGGDRuGDRs2ICIiAjqdDjNmzEBFRQUA4J577sGePXuwYsUKCIIAQRBQUFBQr2m4Idu2bUNcXBy0Wi369u2LxYsXw2w2O712WFgYNBoNevXqhUceeaRVfycmgkREROR2nnjiCXz55ZfYsmULdu3ahd27dyM3N7dFZfj7+yMjIwOHDx/GihUr8Oabb2L58uVO+xw/fhxbt27F9u3bsX37duzZswcvvvgiAGDFihVISEjAvffeC71eD71ej9DQ0CZfd+fOnbjrrrvwyCOP4PDhw1i7di0yMjLwwgsvAAA+/PBDLF++HGvXrsWxY8ewdetWXHPNNS06tzpsGiYiIqIW+ea9ChxaX9HkfsFRKtzyRnenbR89dB7njpgaOeKyETP9MfJu/1bFV1lZibfffhvr16/HhAkTAADvvfce+vTp06JyFi5caP85IiICf/3rX5GZmYknn3zSvt1qtSIjIwP+/rZY09LS8MUXX+CFF16ATqeDWq2Gj49Pi5qCX3jhBTz99NO4++67AQB9+/bF3//+dzz55JN47rnnUFhYiJCQEIwfPx4qlQphYWG47rrrWnRudZgIEhERUYsYK62oPGdpcj//EGW9bdUXm3essdLaqtgAWy2d0WhEQkKCfVu3bt0waNCgFpXz4YcfIj09Hb/++isqKythNpsREBDgtE9ERIQ9CQSAnj17oqSkpNWxA0Bubi6++eYbew0gAFgsFtTW1qK6uhq333470tPT0bdvX0yaNAlTpkzBzTffDC+vlqd1TASJiIioRdR+CvgF10/yruTTtX4PNJ+uzTtW7df63muiKDa5jyAI9fZz7P934MABzJgxA4sXL8bEiROh0+mwadMmLFu2zOkYlUpVr1yrtfVJLGCrZVy8eDFuueWWes9ptVqEhobi6NGjyMrKwueff44HHngAL7/8Mvbs2VMvnqYwESQiIqIWGXl365ttr2wq7gj9+/eHSqXCgQMHEBYWBgC4ePEifvnlF4wZMwYA0L17d+j1evsxx44dQ3V1tf33r776CuHh4ViwYIF926lTp1oci1qthsXSdA2oo9jYWBw9ehT9+/dvdB9vb29MnToVU6dOxYMPPojBgwfjhx9+QGxsbItei4kgERERuRU/Pz/MmjULTzzxBAIDAxEcHIwFCxZAobhcy3jDDTfgjTfewKhRo2C1WvHUU0851ab1798fhYWF2LRpE0aOHIlPP/0UW7ZsaXEsEREROHjwIAoKCuDn54du3bo1ecyzzz6Lm266CaGhobj99tuhUCjw/fff44cffsDzzz+PjIwMWCwWxMfHw8fHBxs2bIC3tzfCw8NbHB9HDRMREZHbefnllzF69GhMnToV48ePx/XXX4+4uDj788uWLUNoaChGjx6NO++8E48//jh8fHzsz0+bNg2PPfYYHnroIQwbNgzZ2dl45plnWhzH448/DqVSiejoaHTv3h2FhYVNHjNx4kRs374dWVlZGDlyJEaNGoVXX33Vnuh16dIFb775JpKSkjB06FB88cUX2LZtGwIDA1scnyA2pyGdiIiIPE5tbS1OnjyJyMhIaLVaqcNps7Fjx2LYsGFIT0+XOpRO09R7yBpBIiIiIg/FRJCIiIjIQ3GwCBEREXmE3bt3Sx2C7LBGkIiIiMhDMREkIiIi8lBMBImIiOiqOMGI62rqvWMfQSIiImqQSqWCIAg4f/48unfvDkEQpA6JWkAURZw/fx6CIDS69BznESQiIqJGVVZW4syZM6wVdFGCIKBPnz7w8/Nr+HkmgkRERHQ1FosFJpNJ6jCoFVQqFZRKZaPPMxEkIiIi8lAcLEJERETkoZgIEhEREXkoJoJEREREHoqJIBEREZGH4jyCrWS1WlFUVAR/f3/Oq0REROQiRFFERUUFevXqBYWC9WFMBFupqKgIoaGhUodBRERErXD69Gn06dNH6jAkx0Swlfz9/QHY/pECAgIkjoaIiIiao7y8HKGhofb7uKdziURw1apVePnll6HX6zFkyBCkp6cjOTm5yeO++uorjBkzBjExMcjPz3d6bvPmzXjmmWdw/Phx9OvXDy+88AL++Mc/NjumuubggIAAJoJEREQuht26bGTfOJ6ZmYm5c+diwYIFyMvLQ3JyMiZPnozCwsKrHldWVoaZM2fiD3/4Q73ncnJykJqairS0NHz33XdIS0vDHXfcgYMHD3bUaRARERHJjuxXFomPj0dsbCxWr15t3xYVFYXp06dj6dKljR43Y8YMDBgwAEqlElu3bnWqEUxNTUV5eTk+++wz+7ZJkyaha9eu2LhxY7PiKi8vh06nQ1lZGWsEiYiIXATv385kXSNoNBqRm5uLlJQUp+0pKSnIzs5u9Lh3330Xx48fx3PPPdfg8zk5OfXKnDhx4lXLNBgMKC8vd3oQERERuTJZJ4KlpaWwWCwIDg522h4cHIzi4uIGjzl27Biefvpp/Pvf/4aXV8NdIIuLi1tUJgAsXboUOp3O/uCIYSIiInJ1sk4E61zZoVMUxQY7eVosFtx5551YvHgxBg4c2C5l1pk/fz7Kysrsj9OnT7fgDIiIiIjkR9ajhoOCgqBUKuvV1JWUlNSr0QOAiooKHDp0CHl5eXjooYcA2CZ+FkURXl5e2LVrF2644QaEhIQ0u8w6Go0GGo2mHc6KiIiISB5kXSOoVqsRFxeHrKwsp+1ZWVlITEyst39AQAB++OEH5Ofn2x9z5szBoEGDkJ+fj/j4eABAQkJCvTJ37drVYJlERERE7krWNYIAMG/ePKSlpWHEiBFISEjAunXrUFhYiDlz5gCwNdmePXsW69evh0KhQExMjNPxPXr0gFarddr+6KOPYvTo0XjppZcwbdo0fPzxx/j888+xf//+Tj03IiIiIinJPhFMTU3FhQsXsGTJEuj1esTExGDHjh0IDw8HAOj1+ibnFLxSYmIiNm3ahIULF+KZZ55Bv379kJmZaa8xJCIiIvIEsp9HUK44DxEREZHr4f3bmaz7CBIRERFRx2EiSEREROShZN9HkIiovVw8ZcKvX9bAarm8beTd/lB4XZ5DtPDrWuh/MDZZln+IEtE3+nZEmEREnYaJIBF5BFONFRvvLkFVqdVpe1yav1PTyMmvavH12xVNlhc6QsNEkIhcHpuGicgjHNlRXS8JJCLydKwRJCK3J4oi8jMr7b+PX9gFft2VAACF0nnfITf7otdQdZNlendVNrkPEZHcMREkIrdX/KMR5w6bAAAhQ1QYPsO/0X2D+qsQ1F/V7LJNNVb8/N9q6L83IuW5bm2OlYioMzERJCK3l7fpcm3gsBl+7Vr2f+4/j7PfGu1l9xjUdG0iEZFcsI8gEbm1mksW/PxZNQBAEyBg8CSfdi0/asrl8hybn4mIXAETQSJyaxdPmeHTzdafL2a6L1Te7XvZi77JFypv2/Qzh7dVw1DJASlE5DqYCBKRW+t1rQb3/bcn/vh6EGLvbLxvYGtp/BSIvtlWK2iqEfHTtqp2fw0ioo7CRJCI3J7CS0D/cd7o0qdjukUPS73c7/C7zEpwCXcichVMBImI2qjHIDV6x9oGiZT+asaZXIPEERERNQ8TQSJyS1UXLLhYaO6013OsFczfxEEjROQamAgSkVv69t+VeOtGPT6ccx4XTpg6/PUGTvCBTzfbJfWXz2tQWWpp4ggiIukxESQit2Mxifh+cyUgAqcO1ELj3/GXOi+1gGtusa09bLUAp3JqO/w1iYjaihNKE5HbKciuRfUF2zQu/cd525eT62jX3uEHjZ8CUTf6IKAnL69EJH+8UhGR2/npk8tTuMRM8+2019X18kL87IBOez0iorZi0zARuZXaMit+/bIGAODTTYGIJK3EERERyRcTQSJyK0d3VcNiW/oXUTf6QKkSJIvFahFhNXNOQSKSLyaCRORWfvz4crPwkKmd1yzsqOysGXuWX8LaFL29dpKISI6YCBKR27hYaEJRvq06MGiACj0GqySJ47cCM75+uwKV5yz4aVu1JDEQETUHE0Eichs/fXI56Roy1QeCIE2zcPgoDfx62EYqn9hbg+rfOKcgEckTE0Eichs9BqkQOkIDQQlE3yhNszAAKJQCom/yAQBYzcDPn7FWkIjkiYkgEbmNgRN8MCOjB/7yv172GjmpOPZPdJzOhohITpgIEpHb8Q2UNgkEgKD+KgRH2/ooFv9kQunxjl/mjoiopZgIEhF1ENYKEpHcMREkIpdX9J0BhV/XQrTKa86+qCk+UPy+ftPhbdWwWuQVHxERE0EicnnZq8uR+f/OY91EPcr1ZqnDsfPppkTfZNvKJpUlFpw6YJA4IiIiZ0wEicilVZZYUJBdCwAQFIB/sPT9Ax1F/948rNUpUFXKaWSISF68pA6AiKgtDn9aBdFq+zn6Jl8ICumWlGtIvzHemJYeiL6jveGllldsRERMBInIZYmiWG8SabnxUgsYOF5+cRERAS7SNLxq1SpERkZCq9UiLi4O+/bta3Tf/fv3IykpCYGBgfD29sbgwYOxfPlyp30yMjIgCEK9R21tbUefChG1o5KfTSg9ZpuWpdcwNbqGS7OkHBGRq5J9jWBmZibmzp2LVatWISkpCWvXrsXkyZNx+PBhhIWF1dvf19cXDz30EIYOHQpfX1/s378f999/P3x9fXHffffZ9wsICMDRo0edjtVqtR1+PkTUfhynZHGcqkXOai5ZAAHw1smrLyMReSZBFEVZz2cQHx+P2NhYrF692r4tKioK06dPx9KlS5tVxi233AJfX19s2LABgK1GcO7cubh06VKr4yovL4dOp0NZWRkCAgJaXQ4RtY7FJGLNH4pQ/ZsVSjXwwJe9odXJt5HjwnET9q4ow4m9NUj8iw4J9/O6QSQF3r+dyfeqCcBoNCI3NxcpKSlO21NSUpCdnd2sMvLy8pCdnY0xY8Y4ba+srER4eDj69OmDm266CXl5eVctx2AwoLy83OlBRNIp+KoW1b/ZRon0H+ct6yQQALy8Bfz6vxpYzcBP26og8+/gROQhZH3lLC0thcViQXBwsNP24OBgFBcXX/XYPn36QKPRYMSIEXjwwQcxe/Zs+3ODBw9GRkYGPvnkE2zcuBFarRZJSUk4duxYo+UtXboUOp3O/ggNDW3byRFRm/y0zaFZ+Gb5NwvrenkhdKQGAHCxwAz990aJIyIiknkiWEcQnKdcEEWx3rYr7du3D4cOHcKaNWuQnp6OjRs32p8bNWoU7rrrLlx77bVITk7GBx98gIEDB+L1119vtLz58+ejrKzM/jh9+nTbToqI2iQuzR9Db/dF1wgvRCS5Rv/emGlcco6I5EXWg0WCgoKgVCrr1f6VlJTUqyW8UmRkJADgmmuuwblz57Bo0SL86U9/anBfhUKBkSNHXrVGUKPRQKPRtPAMiKij9B6mQe9hGohWUXZzBzZm4ARvZD0vwFwr4ufPajDuKZFzCxKRpGRdI6hWqxEXF4esrCyn7VlZWUhMTGx2OaIowmBofGknURSRn5+Pnj17tjpWIpKGqySBAKD2VWDAH7wBALXlVhzfUyNxRETk6WRdIwgA8+bNQ1paGkaMGIGEhASsW7cOhYWFmDNnDgBbk+3Zs2exfv16AMDKlSsRFhaGwYMHA7DNK/jKK6/g4Ycftpe5ePFijBo1CgMGDEB5eTlee+015OfnY+XKlZ1/gkTkUWKm+eLIp7ZJsA9/UoVBEzjZNBFJR/aJYGpqKi5cuIAlS5ZAr9cjJiYGO3bsQHh4OABAr9ejsLDQvr/VasX8+fNx8uRJeHl5oV+/fnjxxRdx//332/e5dOkS7rvvPhQXF0On02H48OHYu3cvrrvuuk4/PyJqmR8+qoTFBAye5CP7kcINCYvXwK+HEpUlFpzYV4vq3yzw6cY5BYlIGrKfR1CuOA8RUecTrSLenKxH2VkLVN4C/vK/XtD4u14yuOfVS/j6nQoAwB/md0Hsn/0ljojIc/D+7cz1rqBE5LHOfGtA2VkLAKB3rMYlk0Dg8iooIUNU8A1ibSARSUf2TcNERHV++rja/nPMNNftWxfUX4XZO0LQNYxrIxORtFzz6zQReRxTjRVHd9kSQbWvgP7jvCWOqG2YBBKRHDARJCKX8OuXNTBW2bo0D0rxgcqbly8iorbilZSIXMKPDs3CQ1y4WfhKoiii+EcjSn81SR0KEXkgJoJEJHuVJRacyqkFAOh6K9En1j1W+fmtwIR3pxVjw4xzOPBmudThEJEHYiJIRLJ3+NMqiFbbz9E3+7rUaiJXE9DLC1WlthM79kUNjFVWiSMiIk/DRJCIZK9uJQ4AGDLVfZqFvdQCBk+2DXox14r4JYtLzhFR52IiSESyd+ua7hj3ZBdc80dftxttWzenIAD8+HGVhJEQkSfiPIJEJHt+QUqMmOmeq2/0HKpG13AvXDxlxulvDCgrMkPXi5dmIuocrBEkIpKQIAhOtYKHt1VfZW8iovbFRJCISGLRN1/u9/jTtipwCXgi6ixMBIlItrKev4j/vXQR5342Sh1Kh9L18kLYdbYpcS4WmKH/3r3Pl4jkg4kgEcmSocKKHz6qRO6GSnx433lYze5dS+bUPPwpm4eJqHMwESQiWTr2vxpYfq8YGzTJBwov95g7sDEDxnvDu4sCUTf6YMANrr2OMhG5Dg5NIyJZOrLjcq1Y1GT3mTuwMRo/Bf7yZS8oVe6d8BKRvLBGkIhkp/o3C04dsC0pF9BLiV7D1BJH1DmYBBJRZ2MiSESyc3RXDUSL7efBk30gCEyQiIg6AhNBIpKdnz/zrGbhKxmrrTj8aRWKvjNIHQoRuTn2ESQiWSnXm3Em15YAdYv0QvdB7rWkXFPO/WzExrQSmGpEDJ7kjV7XaqQOiYjcGGsEiUhWfv6vQ23gFM9rFg7qp4KXxnbOv+6uhbHaKnFEROTOmAgSkayc3F9r/zlqiuc1CytVAgam2KaPMdeK+PXLGokjIiJ3xkSQiGTltjXdceuqIIy6LwBdwz2rWbiOYwL88w5OLk1EHYd9BIlIVpQqAX1He6PvaM+dVLlPrAZ+wUpUnrPg5Fe1qCmzwFunlDosInJDrBEkIpIZQSFg8CRbImw1A8ey2DxMRB2DiSARkQxFTb689vCRz9g8TEQdg4kgEcnC/tfLsPmB8zi8vQqmWo6UDR6iQpcwW++dwq8NqDxvkTgiInJHTASJSBaO7KjGib21+GzhbzDViFKHIzlBEC4PGhGBY1+weZiI2h8HixCR5C4WmnHptBkA0Hu4Bj5dOTACAAb8wRsFX9UiIkmL0BGcWJqI2h8TQSKSXEH25dquyCSthJHIS3CUGndtDJY6DCJyY2waJiLJFXx1eRLpCCaCRESdhokgEUnKYhJx6qBtbWGfbgr08LC1hYmIpMREkIgkVZRvgKnaNjgkIlELQeFZaws3hyiKuHDchJ+2VUkdChG5GZdIBFetWoXIyEhotVrExcVh3759je67f/9+JCUlITAwEN7e3hg8eDCWL19eb7/NmzcjOjoaGo0G0dHR2LJlS0eeAhE14qRjs3Aim4UbsvmBUrwzrRg7/vYbqn/jNDJE1H5knwhmZmZi7ty5WLBgAfLy8pCcnIzJkyejsLCwwf19fX3x0EMPYe/evThy5AgWLlyIhQsXYt26dfZ9cnJykJqairS0NHz33XdIS0vDHXfcgYMHD3bWaRHR7wqymQg2pfuA35vLRaAgp/bqOxMRtYAgiqKsJ+yKj49HbGwsVq9ebd8WFRWF6dOnY+nSpc0q45ZbboGvry82bNgAAEhNTUV5eTk+++wz+z6TJk1C165dsXHjxmaVWV5eDp1Oh7KyMgQEBLTgjIioTvVvFqwcXQQA6DFYhbs/DJE4Ink6dbAWH8w6DwAYMtUHU/4RKHFERK6L929nsq4RNBqNyM3NRUpKitP2lJQUZGdnN6uMvLw8ZGdnY8yYMfZtOTk59cqcOHHiVcs0GAwoLy93ehBR23h3VeD/Pg7BuCe7IO4uf6nDka3ewzVQedv6ThZk10Lm39+JyIXIOhEsLS2FxWJBcLDzPFrBwcEoLi6+6rF9+vSBRqPBiBEj8OCDD2L27Nn254qLi1tc5tKlS6HT6eyP0NDQVpwRETkSBAFB/VQYMdMfMdN9mz7AQ3mpBYSOtE0oXVVqxfmjJokjIiJ3IetEsI4gOI8iFEWx3rYr7du3D4cOHcKaNWuQnp5er8m3pWXOnz8fZWVl9sfp06dbeBZERK3nONH2yWz2EySi9iHrlUWCgoKgVCrr1dSVlJTUq9G7UmRkJADgmmuuwblz57Bo0SL86U9/AgCEhIS0uEyNRgONhks8EZE0HCfaLviqFvH/j32biKjtZF0jqFarERcXh6ysLKftWVlZSExMbHY5oijCYDDYf09ISKhX5q5du1pUJhG1zeFPq7D/jTKc+dYAq5l93prSNdwLut62NZjPfmuAsdoqcURE5A5kXSMIAPPmzUNaWhpGjBiBhIQErFu3DoWFhZgzZw4AW5Pt2bNnsX79egDAypUrERYWhsGDBwOwzSv4yiuv4OGHH7aX+eijj2L06NF46aWXMG3aNHz88cf4/PPPsX///s4/QSIP9cPmKhR+bUDOmnLM/jQEXcO5osjVCIKAiEQtvvtPFSwm4PQ3BvQb4y11WETk4mSfCKampuLChQtYsmQJ9Ho9YmJisGPHDoSHhwMA9Hq905yCVqsV8+fPx8mTJ+Hl5YV+/frhxRdfxP3332/fJzExEZs2bcLChQvxzDPPoF+/fsjMzER8fHynnx+RJzJWW3HmW1stva6PEl3CZH8pkoWIJC1+/m81wuK10PjLukGHiFyE7OcRlCvOQ0TUesd31+Cjh0oBANfe4YuUZ7tJHJFrsJhECAKg8OIyfEStxfu3M34NJ6JO5zjq1XE0LF2dUsUEkIjaF9sWiKjTFfy+vrCgBMLimQgSEUmFiSARdapLZ8y4eMoMAOg9TAONHy9DrWE2iCj52Sh1GETk4tg0TESdqq42EAAiElkb2BqfPn0Bv3xeA4UX8NC+3mwyJqJW41dxIupUJ79i/8C2sloAc60IY6UI/Q+sFSSi1mMiSESdxmISUfi1LRH07qpAcDTnDmyNyCtWGSEiai0mgkTUqSYt7oZrbvFF9M0+EBRs0mwNxyb1k0wEiagN2EeQiDqNUiVg0EQfDJroI3UoLs2vhxJBA1QoPWZC8U9GVF+0wKerUuqwiMgFsUaQiMgF2ZuHReBUjuHqOxMRNYKJIBGRC4pw7CeYXSNhJETkypgIElGnKPregJ//W42aMovUobiFPrEaeGltfSwLsg3gaqFE1BpMBImoU3z3QSW2PX4BK5OLUPQ9mzLbyksjIHSkBgBQWWJB6TGTxBERkStiIkhEHU4URRRk25I/L42AHoPVEkfkHiJ/Hz3cLdIL1RetEkdDRK6Io4aJqMOVHjOhssTWJBw6QgMvNaeNaQ/RN/ug/x+8oevFSzkRtQ6vHkTU4U5yWbkO4d1FCe8uUkdBRK6MTcNE1OGc1hfmsnJERLLBRJCIOpSpxooz39r6Bwb0VKJbJBsiOoqphv0EiahleEUmog51+pABFqPt54gkLQSB/QPbkyiK2JtehhN7ayFaRPy/T3pKHRIRuRAmgkTUodgs3LEEQcCZXIN9+phyvRkBPXlpJ6LmYdMwEXWouoEiggIIj2ci2BEcB+A4DswhImoKE0Ei6jBWi4jBk33Q61o1esdqoA3gJacjRDouN8dEkIhagO0HRNRhFEoBSQ/okPSADlYzl0DrKCExamgDFKgtt+LUgVpYzSIUXuyLSURN49dzIuoUTEw6jkIpIDzBttycoUKE/gejxBERkatgIkhE5AbYT5CIWoOJIBF1iIpiM0p/NUEU2STcGZz6CeYwESSi5mEiSEQd4rsPq/Du9GKsHa/HmVyD1OG4Pf8QLwT2s3X7Lv7BiNoyTi5NRE1jIkhEHaIg21YrVXHOAl1vpcTReIa6eRoVSqDkKPsJElHTOGqYiNpdTZkFxT/aEpHAfl7wD+GlpjMMvdUPEaO06DNCA7UPv+cTUdN4dSaidncqxwDx95ZJribSeYL6qRDUTyV1GETkQviVkYjaneOkxpFMBImIZIuJIBG1K1EUcfL3/oFeGgF94jQSR0RERI1h0zARtasLx82oPGcBAPSJ00Cl5ffNzmQ1izi8vRonv6qFoABueilQ6pCISMZc4gq9atUqREZGQqvVIi4uDvv27Wt0348++ggTJkxA9+7dERAQgISEBOzcudNpn4yMDAiCUO9RW8u5t4jaynEyY/YP7HyCEtj3ehl+/qwaxz6vgamW08gQUeNknwhmZmZi7ty5WLBgAfLy8pCcnIzJkyejsLCwwf337t2LCRMmYMeOHcjNzcW4ceNw8803Iy8vz2m/gIAA6PV6p4dWy5sWUVuxf6C0BEFARILt7242iDiTy2lkiKhxsk8EX331VcyaNQuzZ89GVFQU0tPTERoaitWrVze4f3p6Op588kmMHDkSAwYMwD/+8Q8MGDAA27Ztc9pPEASEhIQ4PYiobURRhE+gApoAAX7BSvsEx9S5nFYZyWZLBxE1TtZXaaPRiNzcXDz99NNO21NSUpCdnd2sMqxWKyoqKtCtWzen7ZWVlQgPD4fFYsGwYcPw97//HcOHD2+0HIPBAIPh8uoI5eXlLTgTIs8gCAJuXBoIq1lEebEFgiBIHZJHCk/QAAIAkYkgEV2drGsES0tLYbFYEBwc7LQ9ODgYxcXFzSpj2bJlqKqqwh133GHfNnjwYGRkZOCTTz7Bxo0bodVqkZSUhGPHjjVaztKlS6HT6eyP0NDQ1p0UkQdQeAno0kfW3zPdmncXJXrGqAEApcdMqDhnljgiIpIrWSeCda6sVRBFsVk1DRs3bsSiRYuQmZmJHj162LePGjUKd911F6699lokJyfjgw8+wMCBA/H66683Wtb8+fNRVlZmf5w+fbr1J0RE1MEi2DxMRM0g60QwKCgISqWyXu1fSUlJvVrCK2VmZmLWrFn44IMPMH78+Kvuq1AoMHLkyKvWCGo0GgQEBDg9iOgyU42VI1RlJCLRIRH8iokgETVM1omgWq1GXFwcsrKynLZnZWUhMTGx0eM2btyIe+65B++//z5uvPHGJl9HFEXk5+ejZ8+ebY6ZyFP9/Fk13kgqwn/uO4+zeYamD6AO1WuoGhp/W8tJQY4BVosocUREJEeyTgQBYN68eXjrrbfwzjvv4MiRI3jsscdQWFiIOXPmALA12c6cOdO+/8aNGzFz5kwsW7YMo0aNQnFxMYqLi1FWVmbfZ/Hixdi5cydOnDiB/Px8zJo1C/n5+fYyiajlTn5VC7NBZDOkTCi8BITF22oFa8usOHeY08gQUX2y782dmpqKCxcuYMmSJdDr9YiJicGOHTsQHh4OANDr9U5zCq5duxZmsxkPPvggHnzwQfv2u+++GxkZGQCAS5cu4b777kNxcTF0Oh2GDx+OvXv34rrrruvUcyNyF1aLiFM5tlpAjb+AnteoJY6IAGDoLb7oNVSNiCQtug9USR0OEcmQIIoi2wtaoby8HDqdDmVlZewvSB6v6HsD/n1nCQBg4ARvTFseJHFEREQN4/3bmeybholI/gq4rBwRkUtiIkhEbXaSy8oREbkk2fcRJCJ5qy23Qv+DbSBCt0gvBPTkZUVORKuI4p+MKMiuhZdWgZF3+0sdEhHJCK/YRNQmpw7WQrTYfmZtoPyYakVsnFkCiwkI6KXEiJl+XPqPiOzYNExEbcL+gfKm9lGgd5wGAFBeZMHFAi43R0SXMREkojYp19uqA5VqIHSERuJoqCGRDquMnOQqI0TkgIkgEbXJ7Wu74/6snpi2PAgqb15S5Mhp3WEmgkTkgH0EiajNAnpykIicdR+ogm93BarOW3H6kAFmowgvNfsJEhFrBImI3J4gCIj4vXnYVCPi7LdcC5qIbJgIEhF5AMcR3ewnSER1mAgSUaucOlCLd6bp8b9/XkTJUaPU4VATwhO0wO+twewnSER1mAgSUauc3F+LC8fNyF1fiQvHOSWJ3Pl0VSIkWgUAOP+LCZXnLRJHRERywN7dRNQq9uZFAQhP4LQxrmDwFF8E9jMiIkkLtS8HixARE0EiaoXKEgtKj5kAACFD1PDpqpQ4ImoOLi9HRFdi0zARtVhB9uU+ZlxWjojIdTERJKIWO8ll5YiI3AKbhomoRawWEadybImg2k9Az2vUEkdELWWosOLUwVp4aQT0TfaWOhwikhATQSJqkXOHjai5ZAUAhMdroVRx0IErqTxvwZrxRRAtQJ84DRNBIg/HpmEiapGC7MurUrBZ2PX4dVeiSx9bHUDRdwYYKq0SR0REUmIiSEQtUvg1B4q4uroE3moGCg9ycmkiT8ZEkIha5JY3gnDbmiAkPRQAXW/2LnFFkYlcbo6IbHgVJ6IWUXkrEHm9NyKvZ98yVxV6nQYKL1uNYEF2LURRhCCwryeRJ2KNIBGRh1H7KNAn1rYaTNkZCy4VcolAIk/FRJCIyAM5DvQ5mc3mYSJPxUSQiJrlYqEZn/y1FN9vrkTleYvU4VAbOSaCBewnSOSx2q2PoCiKKC0txfnz51FTU4OgoCB0794dPj4+7fUSRCShk/trcHSn7TH6MSviZwVIHRK1QY+BKvgEKlB9wYrCrw2wmETOCUnkgdqUCB47dgyZmZnYu3cvcnJyUF1dXW+fAQMGIDk5GSkpKZg+fTpUKlVbXpKIJFLAZeXciqAQEHm9FqXHTIhM0sJcy0SQyBMJoiiKLT3oP//5D9544w3s378fgK02EAAUCgV0Oh28vb3x22+/obb28o1DEAR069YNM2fOxLx589C7d+92OgVplJeXQ6fToaysDAEBrBkh92YxiXg98SxMNSJ8AhV44MteEBRMGlyd1SJCoeT7SJ6F929nLeoj+MUXX2DkyJGYMWMG9u3bh6FDh+Jvf/sbPv74YxQVFcFkMuHChQs4c+YMqqurUVNTg0OHDmHVqlX405/+BKPRiOXLl2PgwIGYP38+ysrKOuq8iKgdnc0zwFRj+8IXkahlEugmmAQSUYuahidMmACdToennnoKd999NwYNGnTV/TUaDWJjYxEbG4s5c+bAYDBg27ZteP311/HSSy/B29sbzz77bJtOgIg6nuOkw1xNhIjIfbQoEVy8eDEeeeQR6HS6Vr2YRqPBbbfdhttuuw379u3DpUuXWlUOEXUux/6B4QlMBN2NKIq4WGCGKAKBfdmPm8iTtCgRfOaZZ9rthZOTk9utLCLqOFWlFpT8bAIABEer4BuolDgiak8XC034YPZ5lBdZEH2TD258MVDqkIioE3EeQSK6qgKHyYYjElkb6G4Cenqh5pIVwO/LzVlbPH6QiFxYmxPBJUuWYMmSJTh27FiT+2ZkZGDJkiUtfo1Vq1YhMjISWq0WcXFx2LdvX6P7fvTRR5gwYQK6d++OgIAAJCQkYOfOnfX227x5M6Kjo6HRaBAdHY0tW7a0OC4iT8D+ge5NqRIQHm9bbq76NytKjpokjoiIOlObE8FFixZh8eLFiI+Px65du66679tvv43Fixe3qPzMzEzMnTsXCxYsQF5eHpKTkzF58mQUFhY2uP/evXsxYcIE7NixA7m5uRg3bhxuvvlm5OXl2ffJyclBamoq0tLS8N133yEtLQ133HEHDh482KLYiDxBwn0BGPu4Dv3GaNFrmEbqcKgDhCdylREiT9WqeQQdKRQKeHt7o6amBkqlEi+++CL++te/NrhvcnIysrOzYbE0f3mq+Ph4xMbGYvXq1fZtUVFRmD59OpYuXdqsMoYMGYLU1FT7COXU1FSUl5fjs88+s+8zadIkdO3aFRs3bmywDIPBAIPBYP+9vLwcoaGhnIeIiFzexUIT3ppSDAAIHanBjHd7SBwRUcfhPILO2qWPYFxcHN5//32oVCo8+eSTSEtLc0qaWstoNCI3NxcpKSlO21NSUpCdnd2sMqxWKyoqKtCtWzf7tpycnHplTpw48aplLl26FDqdzv4IDQ1twZkQEclX1zAVdH1sg4DO5hlgrLZKHBERdZZ2GywyY8YM7N+/H71798b777+P0aNHo6ioqE1llpaWwmKxIDg42Gl7cHAwiouLm1XGsmXLUFVVhTvuuMO+rbi4uMVl1k2AXfc4ffp0C86EiEje6vp/Ws1A4ddt/yJPRK6hXUcNx8bGIjc3F0lJSfjmm28wcuRIHDhwoM3lCoLz7PeiKNbb1pCNGzdi0aJFyMzMRI8ezk0dLS1To9EgICDA6UHkzoxVVmSvLkPR9wZYLRxJ6u4ikrztP7OfIJHnaPfpY7p3747//e9/uO+++6DX6zFu3Di88847rSorKCgISqWyXk1dSUlJvRq9K2VmZmLWrFn44IMPMH78eKfnQkJCWlUmkScp/NqAr1aW4993lmD3K5ekDoc6WNh1Gih+n1n2JBNBIo/RIfMIenl5Yc2aNVi5ciWsVivuvfdePPLIIzCbzS0qR61WIy4uDllZWU7bs7KykJiY2OhxGzduxD333IP3338fN954Y73nExIS6pW5a9euq5ZJ5Gkck4HQkZw2xt1p/BToNUwDta+AoP4qmGrYT5DIE7RoZZGW+stf/oKYmBjcdtttWLlyZavKmDdvHtLS0jBixAgkJCRg3bp1KCwsxJw5cwDY+u6dPXsW69evB2BLAmfOnIkVK1Zg1KhR9po/b29v+9J4jz76KEaPHo2XXnoJ06ZNw8cff4zPP/8c+/fvb4ezJnIPdc2DCi9bbRG5v5te6gafbkooVU13vSEi99DhK4skJyfjm2++wbXXXovWzFSTmpqK9PR0LFmyBMOGDcPevXuxY8cOhIeHAwD0er3TnIJr166F2WzGgw8+iJ49e9ofjz76qH2fxMREbNq0Ce+++y6GDh2KjIwMZGZmIj4+vu0nTOQGLhaacem0rQa/1zANNH5chMgT+Ad7MQkk8jBtnkewuWpra+0TNo8ZM6YzXrJDcR4icmd5myrx+fMXAQDJj+gw6j7+jxORe+D921mHNg070mq1bpEAEnkCp/WFuaycRzIbRZhrRWgDWBtM5M74CSciJxaTiMKDtkTQp5sCwVEqiSOiznThhAmb/3IebySdxTfvlksdDhF1sBYlglOmTGmX9Xirqqrw4osvYtWqVW0ui4jaV9F3BhirbD1GwhO0EBTsM+ZJNP4KnNhXC1ONyGlkiDxAixLBffv2ITExEePHj8eGDRtQUVHRohfLy8vD448/jvDwcCxYsKBdlqEjovblOJlwRCKbhT2NX3clug+01QKfO2xC9W/NXxueiFxPi/oInjhxAosWLcJbb72FL7/8EhqNBtdffz2uu+46xMXFoWfPnujWrRs0Gg0uXbqE3377DUeOHMGhQ4ewf/9+HD9+HKIoIioqCu+88w6mTp3aUedFRK0UOlKLyvMWFOQY2D/QQ0UkaXH+FxMAoCCnFtE3+kocERF1lFaNGj558iTWrFmD9957DyUlJbaCrrI8W93ybTfccAPuu+8+3HrrrVAoXLt7Ikcdkbtr7lKO5H5OHajFB7PPAwCGTPXBlH8EShwRUfvh/dtZm6aPMZvN+PLLL7F3715kZ2fj1KlTKC0tRW1tLbp164YePXpg2LBhuP766zFhwgT73H/ugP9IROSuzEYRbySdhalGhG+QAn/5she/FJDb4P3bWZumj/Hy8sKECRMwYcKE9oqHiIgk5qUWEDpCgxP7alFVasX5X0zoMUgtdVhE1AFcu32WiNqNKIo49kU1asu5xiw5zx9ZwNHDRG6LiSARAQDOHzVh66MX8EbyWexedknqcEhikQ6J4MlsJoJE7qrdVhYxGAzYtGkTdu7ciV9++QUVFRXw9/fHwIEDkZKSghkzZkCr5QhEIrmqu9mLFiAgRClxNCS1rhFeCOilRHmRBdUXrLBaRCiU7CdI5G7aZa3h7Oxs3HXXXTh16hQaKk4QBISFheFf//oXkpKS2vpyssDOpuRuMmeVoPCgbW7PWdtD0C2CK4p4utPf1MI/xAtdQjttNVKiDsf7t7M2f7p/+uknTJgwATU1NQgJCcHs2bMRFRWF4OBglJSU4MiRI3j77bdx6tQppKSk4ODBg4iJiWmP2ImonRirrTj7rS0J1PVWoms4b/xkm1OSiNxbm6/2CxcuRE1NDe666y68/fbbUKnq1yIsXLgQs2fPxoYNG/Dss8/io48+auvLElE7Ov2NARbb/MGISNRyqhAiIg/R5sEie/fuRUBAANatW9dgEggAKpUKa9euRUBAAHbv3t3WlySidua0rBxXE6FGtENPIiKSmTYngkajEYMGDWpyIIhWq8WgQYNgMpna+pJE1M7qBooISiA8nokgXXbptBl7Xr2EjFuK8f3mKqnDIaJ21uZEMCoqCmfOnGnWvqdPn8aQIUPa+pJE1I7KzppxscAMAOh1rRoaf84qRZfVXLLg63cqcP4XE07u5zQyRO6mzVf8uXPnQq/XY8WKFVfd77XXXkNxcTHmzp3b1pckonZ00qFZOJLNwnSF4Gg1tDrbraLwYC2sZjYPE7mTNg8WufPOO3H27Fk89dRT2LNnDx544AFERUWhR48eOH/+PI4cOYJVq1bh008/xT//+U/MmDGjPeImonai8VMgJEaN4p+MiEhkIkjOFEoBEQka/PzfGhgqRBR9b0SfWI3UYRFRO2nzPIJKZdsnnhUEAWazuc3ldCbOQ0TupvqiBdoABScNpnp+2FKJ/z5zEQCQMCcA1z+kkzgiotbj/dtZm5uGRVFs88Nq5dqmRFLz6apkEkgNcqwp5rrDRO6lzU3DTOKIiNybf7AXggaoUHrMBP2PRtRcssC7C5chJHIHHB5I5MHKzpo5Nxw1i71WUARO5RikDYaI2g0TQSIPVXPJgnWT9FiXokfO2nKpwyGZcxxRfpLNw0Rug4kgkYc6lWMARKBcb4Ghgl086Or6xGngpbX1IT39DRNBInfBleWJPNRJLitHLeClETDmrzoE9PRC2EhOH0PkLpgIEnkgURRR8Puycl5agfPCUbPE/slf6hCIqJ2xaZjIA5X+akJliQUAEDpSAy8Np40hIvJETASJPJDjXHCRXE2EiMhjsWmYyAOxfyC1VvVFC07srUVBdi2G3uqLsOv4/0PkypgIEnkYU40VZ3Jt88AF9FSiWyQvA9R8p78x4LMFvwEAfLopmAgSuTg2DRN5mDO5BliMtp8jkrQQBPYPpOYLj9dC+P3OUTfgiIhcl0skgqtWrUJkZCS0Wi3i4uKwb9++RvfV6/W48847MWjQICgUCsydO7fePhkZGRAEod6jtpYXNXJ/lSUWqP1syR+bhamltDoFel6jBgBcOG5Gud4scURE1BayTwQzMzMxd+5cLFiwAHl5eUhOTsbkyZNRWFjY4P4GgwHdu3fHggULcO211zZabkBAAPR6vdNDq+VNkdzfNbf44aF9vfGn9T04UIRaxfELBGsFiVyb7BPBV199FbNmzcLs2bMRFRWF9PR0hIaGYvXq1Q3uHxERgRUrVmDmzJnQ6XSNlisIAkJCQpweRJ5CqbLNHaj2lf0lgGQokokgkduQ9V3AaDQiNzcXKSkpTttTUlKQnZ3dprIrKysRHh6OPn364KabbkJeXt5V9zcYDCgvL3d6EBF5opAYNbQBttvHqRwDrBZR4oiIqLVknQiWlpbCYrEgODjYaXtwcDCKi4tbXe7gwYORkZGBTz75BBs3boRWq0VSUhKOHTvW6DFLly6FTqezP0JDQ1v9+kRS4Q2b2oNCKSA8wbYaTW25FcU/GiWOiIhaS9aJYJ0rRzWKotimkY6jRo3CXXfdhWuvvRbJycn44IMPMHDgQLz++uuNHjN//nyUlZXZH6dPn2716xNJwWoWsXaCHh/OOY/vN1dKHQ65uAiH/qWO81ISkWuRdSIYFBQEpVJZr/avpKSkXi1hWygUCowcOfKqNYIajQYBAQFODyJXov/RiMoSC07ur2W/Lmozp36CTASJXJasE0G1Wo24uDhkZWU5bc/KykJiYmK7vY4oisjPz0fPnj3brUwiuXG8WUdwtDC1kX+IF4ZM80HyozqMX9hV6nCIqJVkv6TAvHnzkJaWhhEjRiAhIQHr1q1DYWEh5syZA8DWZHv27FmsX7/efkx+fj4A24CQ8+fPIz8/H2q1GtHR0QCAxYsXY9SoURgwYADKy8vx2muvIT8/HytXruz08yPqLCcdagEjOX8gtYMpLwRKHQIRtZHsE8HU1FRcuHABS5YsgV6vR0xMDHbs2IHw8HAAtgmkr5xTcPjw4fafc3Nz8f777yM8PBwFBQUAgEuXLuG+++5DcXExdDodhg8fjr179+K6667rtPMi6ky1ZVYU/2Dr0B/Yzwv+IbL/6BMRUScQRFHkMMJWKC8vh06nQ1lZGfsLkuwd3VmNT/56AQAQN9MPNzzJpjwi8ky8fzuTdR9BImofjqM62SxM7Um0iij+yYgD68px6TSXmyNyNWwfInJzoijaB4p4aQT0idNIHBG5k2/fr8T/XrwEAPDyFjAizV/agIioRVgjSOTmLpwwo+KcBQDQJ04DlZYfe2o/YfGXv1hwGhki18M7ApGbK8oz2H+OYLMwtbOg/ir4BSsBAKcPGWA2sNs5kSthIkjk5obe5od7/9sTE57tigF/8JY6HHIzgiAgIsH2BcNcK+JMrqGJI4hITpgIEnmALn28MOwOP3Tpw27B1P4cByBxuTki18JEkIiI2iQ8QQP8vvw7ly8kci1MBImIqE28uyjRM0YNACg9ZkLFOU4jQ+QqmAgSubGPHyvF7lcu4dRB1tJQx3IciMRaQSLXwUSQyE1VFJvxS1YNvsmowL4VZVKHQ24uItEhEWQ/QSKXwZ7jRG7KsVbG8SZN1BF6XqNG13AvhMSoMWA8R6cTuQomgkRuisvKUWdSqgTM2h4CQRCkDoWIWoBNw0RuyGoRcSrHNp+bxl9Az2vUEkdEnoBJIJHrYSJI5IaKfzKittwKAAiL10LhxRs0dS5R5AojRK6AiSCRm7GYROx59fLgEDYLU2czVFqx9ZFSHN1ZLXUoRNQE9hEkciOiKOLzf1zEmUO2ZmHfIAUGpfhIHBV5ktoyKzbefQ6lv5pRkGNAlzAvBEexawKRXLFGkMiNHN5eje//UwUAUKqB6a8FQavjx5w6jyZAQHC0LfEz14rY8nApqkotEkdFRI3hHYLIjfQf541+Y21NwRMXdUOvoRqJIyJPIwgCUp7rhp5DbclgRbEFW+eWwmxkn0EiOWIiSORGNH4KTF8RhFtXB2HIVF+pwyEP5aURMH1FEPyClQCAonwjspZc5AASIhkSRH4yW6W8vBw6nQ5lZWUICAiQOhySsW/fr8Dx3U2vtNBzqBrXP6Rz2vbZwguoLLE2eezwP/mh/zhO4kvyUvyjERvvLoHZYLvN9I5VQ6VV4LpZ/giPvzyI6eIpEz5/4VKzypy6LBAa/8t1GEd2VOHHrY0PSvHuqkDinAB0i1S17iTI7fD+7YyDRYjaianGisoSC1Q+Cmj8Bai0tpvVhRPmZq29qmygP/2ZXCMunTY3eWy/cRwZTPITEqPGpL93xfYnfwMAnP3WCAAYMtV5AJOhUmz2+sQWs3PdRdkZS5PHWkwipr0a1NywiTwKm4aJ2sm5Iya8dWMxVo8rwv7Xy6UOh0gWoqb4IvkRHQQJ7zblRRysQtQYNg23EquW6Uon9tVg819KAQCJfwlA0oO2Zl5TrRVWU9PHC0pA7eN8tzRWWSE23TIMpUaAl5qTRpN8mQ0iLL8PGPHSClCqLv+/Wi0iTNXNuxWpfQUIisvHOpZ7pdV/KIKpWkRgXy/8v096tiF6cie8fztj0zBRO3G8kal9L9+oVFoF0MqWW7UvK+3JPXhpBHhpGv6yolAK0Pi37ovM1cq9+8NgeGkEaPz4OSJqDBNBonZirLpcdafy4Y2HSGpdwzhAhKgpvFsRtRNjIzWCREREcsVEkKidGKscEkHWCBIRkQtg0zBROzFVOzYNs0aQSGon99eg9LgZxiorRt7jzy9oRA1gIkjUTow1jjWCTASJpPbj1ir8/N8aAEDMNF8mgkQN4KeCqJ04DhbhDYdIeo6j7h0/n0R0Ge9WRO3EcfoYNg0TSc/xc2hs5jyFRJ6GTcNE7STlua4YPVcHY5UI3yCl1OEQeTzHmnnHwVxEdJlL1AiuWrUKkZGR0Gq1iIuLw759+xrdV6/X484778SgQYOgUCgwd+7cBvfbvHkzoqOjodFoEB0djS1btnRQ9OQpvLso0TVcheBotdOqCUQkDZXDNE6Og7mI6DLZJ4KZmZmYO3cuFixYgLy8PCQnJ2Py5MkoLCxscH+DwYDu3btjwYIFuPbaaxvcJycnB6mpqUhLS8N3332HtLQ03HHHHTh48GBHngoREXUiNZuGiZok+7WG4+PjERsbi9WrV9u3RUVFYfr06Vi6dOlVjx07diyGDRuG9PR0p+2pqakoLy/HZ599Zt82adIkdO3aFRs3bmxWXFyrkIhI3n76pAo7/vYbAOAPC7og9k/+EkdEcsD7tzNZ1wgajUbk5uYiJSXFaXtKSgqys7NbXW5OTk69MidOnHjVMg0GA8rLy50eRI6+3ViB/MxK/PpljdShEBGcB4uY2EeQqEGyHixSWloKi8WC4OBgp+3BwcEoLi5udbnFxcUtLnPp0qVYvHhxq1+T3N+eV8pgNojoPlCF/uO8pQ6HyOM5DRZh0zBRg2RdI1hHEJw73ouiWG9bR5c5f/58lJWV2R+nT59u0+uTe7GaRZgNthsNp44hkgfvLgp0i/RCcLQKvoEucbsj6nSyrhEMCgqCUqmsV1NXUlJSr0avJUJCQlpcpkajgUajafVrknsz1XCdYSK5CY5WY9a2nlKHQSRrsr5jqdVqxMXFISsry2l7VlYWEhMTW11uQkJCvTJ37drVpjLJszmtKuLLGkEiInINsq4RBIB58+YhLS0NI0aMQEJCAtatW4fCwkLMmTMHgK3J9uzZs1i/fr39mPz8fABAZWUlzp8/j/z8fKjVakRHRwMAHn30UYwePRovvfQSpk2bho8//hiff/459u/f3+nnR+7ByFVFiIjIBck+EUxNTcWFCxewZMkS6PV6xMTEYMeOHQgPDwdgm0D6yjkFhw8fbv85NzcX77//PsLDw1FQUAAASExMxKZNm7Bw4UI888wz6NevHzIzMxEfH99p50XuxblGUNYV7URERHayn0dQrjgPETkq/LoWmf/vPAAgfpY/Rj/WRdqAiAgAsOWRUtSWWeHXQ4mbXw6UOhySAd6/ncm+RpDIFTg3DbNGkEguzhwyoLbcii5hvN0RNYR3LKJ2wMEiRPJU12eXaw0TNYxfkYjagZdGQGBfLxirRHh34fcrIrmo+2Jm5MoiRA1iIkjUDgaO98HA8T5Sh0FEV6ib19NUI0K0ihAUrLEncsSqCyIiclsqh64aplrWChJdiYkgERG5Laf1htk8TFQPE0EiInJbaocJ3jlghKg+9hEkagfZa8pQlG+EykfA+AVd4RuolDokIoLzSj+sESSqjzWCRO3g3E9GnNxfi1921YBTtBPJh+NKP0bWCBLVwxpBonbgOKG0mmsNE8lG2EgNBMFWM+gfwlse0ZX4qSBqB6a6RFAAVN5MBInkou9ob/Qd7S11GESyxaZhonZQt7KI2keAIDARJCIi18BEkKgd1DUNq9gsTERELoRNw0TtoK4TumPHdCKSB6tZhLFahELJzyjRlfiJIGojURTtfQQ5UIRIXk5/U4tlw87g9cSzyFlXLnU4RLLDRJCojSxGwGq2/ey4igERSU/FlUWIrop3LaI2cpybjH0EieSFK4sQXR37CBK1kdJLQPwsfxirRQT2U0kdDhE5cJpQmjWCRPUwESRqI42/AqMf6yJ1GETUAKcl5lgjSFQPm4aJiMhtOU7w7rgCEBHZMBEkIiK3pVAK9mTQxESQqB4mgkRtZDGJsJh4gyGSq7pEsG4FICK6jIkgURsd2VGNV4efwbJhp/H95kqpwyGiK9QNGGGNIFF9TASJ2qiuA7rVDChVnD6GSG7qBoywRpCoPo4aJmojk8OUFJxHkEh+Ji7qCqvZ9vkURRGCwM8pUR0mgkRt5DgSkeuYEslPz2s0UodAJFu8axG1kWNzE9caJiIiV8JEkKiNHDugs2mYiIhcCZuGidrIcbUCNg0Tyc+F4yaUHjfBVC0i4not/IKUUodEJBtMBInayKmPIGsEiWTn8PYqHHizAgBwx1vdmQgSOWD1BVEbmThYhEjWVD6XP5dcZo7IGe9aRG1UN1hE4cV5BInkSO3rsN4w5xIkcsKmYaI2mvR8N9T8ZoXZyJoGIjlSO9QIcnURImcuUSO4atUqREZGQqvVIi4uDvv27bvq/nv27EFcXBy0Wi369u2LNWvWOD2fkZEBQRDqPWprazvyNMhNBQ9WIyJRi/5jvaUOhYga4Dia33FwFxG5QCKYmZmJuXPnYsGCBcjLy0NycjImT56MwsLCBvc/efIkpkyZguTkZOTl5eFvf/sbHnnkEWzevNlpv4CAAOj1eqeHVqvtjFMiIqJO5Nw0zBpBIkeybxp+9dVXMWvWLMyePRsAkJ6ejp07d2L16tVYunRpvf3XrFmDsLAwpKenAwCioqJw6NAhvPLKK7j11lvt+wmCgJCQkE45ByIiko7K26FpuIY1gkSOZF0jaDQakZubi5SUFKftKSkpyM7ObvCYnJycevtPnDgRhw4dgslksm+rrKxEeHg4+vTpg5tuugl5eXlXjcVgMKC8vNzpQWQxiTi6sxon9tXg/C9GqcMhogaonZqGWSNI5EjWiWBpaSksFguCg4OdtgcHB6O4uLjBY4qLixvc32w2o7S0FAAwePBgZGRk4JNPPsHGjRuh1WqRlJSEY8eONRrL0qVLodPp7I/Q0NA2nh25g5pLVnzy1wvY/JdS7H+DXw6I5MhxWicTm4aJnMg6EawjCM5TcoiiWG9bU/s7bh81ahTuuusuXHvttUhOTsYHH3yAgQMH4vXXX2+0zPnz56OsrMz+OH36dGtPh9wI1xkmkj+VjwAvjQDvrgp4afk5JXIk6z6CQUFBUCqV9Wr/SkpK6tX61QkJCWlwfy8vLwQGBjZ4jEKhwMiRI69aI6jRaKDRaFp4BuTuuM4wkfz5BirxWG4fqcMgkiVZ1wiq1WrExcUhKyvLaXtWVhYSExMbPCYhIaHe/rt27cKIESOgUqkaPEYUReTn56Nnz57tEzh5DK4zTERErkz2d6558+bhrbfewjvvvIMjR47gscceQ2FhIebMmQPA1mQ7c+ZM+/5z5szBqVOnMG/ePBw5cgTvvPMO3n77bTz++OP2fRYvXoydO3fixIkTyM/Px6xZs5Cfn28vk6i5HKeiYNMwERG5Glk3DQNAamoqLly4gCVLlkCv1yMmJgY7duxAeHg4AECv1zvNKRgZGYkdO3bgsccew8qVK9GrVy+89tprTlPHXLp0Cffddx+Ki4uh0+kwfPhw7N27F9ddd12nnx+5Nq4zTERErkwQ60ZSUIuUl5dDp9OhrKwMAQEBUodDEvl+cyV2PncRAJCyqCuuvc1P4oiIqCHZq8tw8ZQZohW46Z8N9xcnz8D7tzNWYRC1geOcZI7rmRKRvBzfXYPD26vx83+rwfoPost45yJqA1M1p48hcgWq37+oiVbAXMtEkKgOE0GiNhBF2Ocl4/QxRPLltN4wVxchspP9YBEiOUuco0PiHB2sFt5YiOTMseuGsUqEL7sJEgFgIkjULhRK1gYSyZljjb1jlw4iT8emYSIicntsGiZqGBNBIiJyeyrvy7c71ggSXcamYaI2+GplGapKLVD7KjDmrzoIApuIieSINYJEDWMiSNQGv3xeg9JjJqi8BYx9vIvU4RBRI5wHi7BGkKgOE0GiNqi7oai8WRNIJGfdIr0weJI3VD4KdA1TSR0OkWwwESRqg7q1hrnOMJG8hV2nRdh1WqnDIJId3r2I2sBeI8jJpImIyAUxESRqJYtJhMVk+5nLyxERkStiIkjUSiaHkYdsGiYiIlfEPoJErWR0mIuMTcNE8lZ53oINqedgrLIi8notpi4LkjokIllgIkjUSo5zkbFpmEjevNQCKkssAGxrDRORDduziFrJcS4yxznKiEh+HGvtOY8g0WWsESRqJY2fAlFTfGCssqL7QM5LRiRnSpUApRqwGLmyCJEjJoJErRTYV4Wb/hkodRhE1ExqHwVqjFbWCBI5YHsWERF5hLr1hk2sESSyYyJIREQeQfV7X142DRNdxkSQiIg8Qt2AEXOtCKuFySARwESQqNUOvFmOVWPP4q0b9TibZ5A6HCJqguM0T2weJrJhIkjUStUXLagqteLiKbPUoRBRMzhO8+Q4ITyRJ+OoYaJWcqxR4MoiRPIX+2c/DJroDZWPAtoA1oMQAUwEiVrNaa1hTihNJHth12mlDoFIdnj3Imolp5VFfFkjSEREroeJIFErGdk0TERELo5Nw0StZPq9s7mgALw0TASJ5K6mzIKy0xYYq63oGu4F/2DeAon4KSBqBbNBROlx22hhtY8AixH4cE4JAOC2Nd2ZGML2N/pwznkAHfc36YjXcJUypXwdV+L4Nxk00QefP38RANA1wgv3bA7h34g8HpuGiVpJ/H1CWhUHihC5BMe+vCInlCYCwESQqNWsv48VUbN/IJFLUHlf/qxaLRIGQiQjLpEIrlq1CpGRkdBqtYiLi8O+ffuuuv+ePXsQFxcHrVaLvn37Ys2aNfX22bx5M6Kjo6HRaBAdHY0tW7Z0VPjkprpFeKFrhBfiZwdIHQoRNYPa9/ItT+R80kQAXCARzMzMxNy5c7FgwQLk5eUhOTkZkydPRmFhYYP7nzx5ElOmTEFycjLy8vLwt7/9DY888gg2b95s3ycnJwepqalIS0vDd999h7S0NNxxxx04ePBgZ50WuQGfbkr4dVdi8GQfqUMhomZwrhFk0zAR4AKDRV599VXMmjULs2fPBgCkp6dj586dWL16NZYuXVpv/zVr1iAsLAzp6ekAgKioKBw6dAivvPIKbr31VnsZEyZMwPz58wEA8+fPx549e5Ceno6NGze2KL5D68vh6331fUKGqBE+ynki04Nvlzer/EEpPugSevltunTajKO7qpt1bPws55qqUwdqUfyTscnjdL29MHiSc3Lz/YeVqClr+it02HUa9LxGY//dUGlFfmZls+K95hZf+HRV2n8v+dmIk1/VNnmc2lfA8Bn+TtuOfVGN3wqaXvqt+0AV+iY7v4GH1lfAYrr6TcJqFmGqsULlLfvvUkT0O8c+gsYqEd9klCMiUesR1ywA6D/OG4F9VfbfK86ZcXh78+4ncWn+8FJf/vud+dbQrDXW/borMWSqr9O2nz6pQuX5ptvmew/XoE/s5ffGbBSRu6GiWfFG3+TjNCr8wgkTfv2yBgBQVdO8+6+nkHUiaDQakZubi6efftppe0pKCrKzsxs8JicnBykpKU7bJk6ciLfffhsmkwkqlQo5OTl47LHH6u1Tlzw2xGAwwGC4/E9fXm77R/pqZTm0yqt/AONm+tVLBPcuL7vqMXV6DFY5JYIXC03NPvbKRPD43hrkrm/6AheRqK2XCB7aUIELx5u+SI19oovTRdVYaW12vP3GeDtdVIt/NDbrWL9gZb2L6uFPq/HLrpomj73mFt96F9WvVpbBWNX0RTWwnxdUTXwJICL5cPziZqoWsf/1cqi8Fc6JYEULrlljna9Z+mZes/wbumZtr8YvWU1fs4beWv+atf+NMqeVjhrTJdTLKREsL7I0+1yHz/ADHBLBguxa5KxpOqHqda26XiKYt6kS+u+brpRIfCDAKRG0GMRmxxs6QuOUCJ7/5fK9s9bSvGTSU8i6OqO0tBQWiwXBwcFO24ODg1FcXNzgMcXFxQ3ubzabUVpaetV9GisTAJYuXQqdTmd/hIaGtuaUiIhIIr6BCgT2k3X9B1Gnc4lPhCA4j8oURbHetqb2v3J7S8ucP38+5s2bZ/+9vLwcoaGhuOmlbvDzvfpgAccavTrTVwRe9Zg6PQap6/3e3GOvdM10X4TGaZrcz6ebst62P8zv6rSkWmOCBqicftd2UTQ7Xv8Q59cNT9A269iG5gG77v/8EX1j0333AnrVf29ueimwyf5DFpOtlpSIXIegEPCn93pg0/+VQBSBxDk6BEc7X7O8W3LNCna+ZkU095qlbeCa9f/8EX1T665ZN/+z6WsWAITEON9PukV6NftclWrnmKMm+yA4StXI3pdpdfXrm8Y8pkNtedP3k26RzuV7aYVmx9s1wvnv1Hv45XtnZZUKz05rVjEeQdaJYFBQEJRKZb2aupKSkno1enVCQkIa3N/LywuBgYFX3aexMgFAo9FAo6mfRPUb64OAgJYPFhjwh9YNMPANUrb62O4D1eg+UN30jg24smm7uVRaRavj1fX2gq536/5FHZt6Wqrf2Kbbe80Gsdn9iIhIPlTeCnh3sSVw/cd51/siqfJ2z2tWQ7y7tP5+EthPhcB+TSeCDQkd2br7iVIltDpe/+DLK8mUlzfdzcmTyLppWK1WIy4uDllZWU7bs7KykJiY2OAxCQkJ9fbftWsXRowYAZVKddV9GiuTiIiIyB3JukYQAObNm4e0tDSMGDECCQkJWLduHQoLCzFnzhwAtibbs2fPYv369QCAOXPm4I033sC8efNw7733IicnB2+//bbTaOBHH30Uo0ePxksvvYRp06bh448/xueff479+/dLco5EREREUpB9IpiamooLFy5gyZIl0Ov1iImJwY4dOxAeHg4A0Ov1TnMKRkZGYseOHXjsscewcuVK9OrVC6+99pp96hgASExMxKZNm7Bw4UI888wz6NevHzIzMxEfH9/p50dEREQkFdknggDwwAMP4IEHHmjwuYyMjHrbxowZg2+//faqZd5222247bbb2iM8IiIiIpckiHVDaqlFysvLodPpUFZWhoAALjFGRETkCnj/dibrwSJERERE1HGYCBIRERF5KCaCRERERB6KiSARERGRh2IiSEREROShmAgSEREReSgmgkREREQeiokgERERkYdyiZVF5KhuHu7y8nKJIyEiIqLmqrtvcz0NGyaCrVRRUQEACA0NlTgSIiIiaqmKigrodDqpw5Acl5hrJavViqKiIvj7+0MQBKnDabXy8nKEhobi9OnTXGpHYnwv5IPvhXzwvZAXd3g/RFFERUUFevXqBYWCPeRYI9hKCoUCffr0kTqMdhMQEOCyH2p3w/dCPvheyAffC3lx9feDNYGXMRUmIiIi8lBMBImIiIg8FBNBD6fRaPDcc89Bo9FIHYrH43shH3wv5IPvhbzw/XA/HCxCRERE5KFYI0hERETkoZgIEhEREXkoJoJEREREHoqJIBEREZGHYiJI9RgMBgwbNgyCICA/P1/qcDxOQUEBZs2ahcjISHh7e6Nfv3547rnnYDQapQ7NY6xatQqRkZHQarWIi4vDvn37pA7J4yxduhQjR46Ev78/evTogenTp+Po0aNSh0WwvTeCIGDu3LlSh0LtgIkg1fPkk0+iV69eUofhsX7++WdYrVasXbsWP/30E5YvX441a9bgb3/7m9SheYTMzEzMnTsXCxYsQF5eHpKTkzF58mQUFhZKHZpH2bNnDx588EEcOHAAWVlZMJvNSElJQVVVldShebRvvvkG69atw9ChQ6UOhdoJp48hJ5999hnmzZuHzZs3Y8iQIcjLy8OwYcOkDsvjvfzyy1i9ejVOnDghdShuLz4+HrGxsVi9erV9W1RUFKZPn46lS5dKGJlnO3/+PHr06IE9e/Zg9OjRUofjkSorKxEbG4tVq1bh+eefx7Bhw5Ceni51WNRGrBEku3PnzuHee+/Fhg0b4OPjI3U45KCsrAzdunWTOgy3ZzQakZubi5SUFKftKSkpyM7OligqAmyfAQD8HEjowQcfxI033ojx48dLHQq1Iy+pAyB5EEUR99xzD+bMmYMRI0agoKBA6pDod8ePH8frr7+OZcuWSR2K2ystLYXFYkFwcLDT9uDgYBQXF0sUFYmiiHnz5uH6669HTEyM1OF4pE2bNuHbb7/FN998I3Uo1M5YI+jmFi1aBEEQrvo4dOgQXn/9dZSXl2P+/PlSh+y2mvteOCoqKsKkSZNw++23Y/bs2RJF7nkEQXD6XRTFetuo8zz00EP4/vvvsXHjRqlD8UinT5/Go48+in/961/QarVSh0PtjH0E3VxpaSlKS0uvuk9ERARmzJiBbdu2Od3sLBYLlEol/vznP+O9997r6FDdXnPfi7oLbVFREcaNG4f4+HhkZGRAoeD3to5mNBrh4+OD//znP/jjH/9o3/7oo48iPz8fe/bskTA6z/Twww9j69at2Lt3LyIjI6UOxyNt3boVf/zjH6FUKu3bLBYLBEGAQqGAwWBweo5cCxNBAgAUFhaivLzc/ntRUREmTpyIDz/8EPHx8ejTp4+E0Xmes2fPYty4cYiLi8O//vUvXmQ7UXx8POLi4rBq1Sr7tujoaEybNo2DRTqRKIp4+OGHsWXLFuzevRsDBgyQOiSPVVFRgVOnTjlt+7//+z8MHjwYTz31FJvrXRz7CBIAICwszOl3Pz8/AEC/fv2YBHayoqIijB07FmFhYXjllVdw/vx5+3MhISESRuYZ5s2bh7S0NIwYMQIJCQlYt24dCgsLMWfOHKlD8ygPPvgg3n//fXz88cfw9/e399HU6XTw9vaWODrP4u/vXy/Z8/X1RWBgIJNAN8BEkEhmdu3ahV9//RW//vprvSScFfgdLzU1FRcuXMCSJUug1+sRExODHTt2IDw8XOrQPErd9D1jx4512v7uu+/innvu6fyAiNwUm4aJiIiIPBR7nxMRERF5KCaCRERERB6KiSARERGRh2IiSEREROShmAgSEREReSgmgkREREQeiokgERERkYdiIkhERETkoZgIEpFHWbRoEQRBwKJFi9pUTkREBARBQEFBQYuOGzt2LARBwO7du+s9V11djccffxyRkZFQqVQQBIGraBBRh+ISc0REMnHvvffi/fffh4+PD4YNGwaNRoOBAwcCgD1xbWsCS0TkiIkgEVEnCgsLw6BBg+Dj4+O0/eLFi9i0aRN8fHzw888/IzQ01On5xYsXA2AiSETti4kgEVEnWr9+fYPbjx07BqvVipiYmHpJIBFRR2EfQSIiGaipqQEAeHt7SxwJEXkSJoJEJAlBECAIAgBg8+bNGD16NLp06VJvAMZvv/2GBQsWICYmBr6+vvD398eoUaPw5ptvwmq1Nli22WzGP//5TwwePBharRa9e/fGvffei3PnzjUajyiKWL9+vT0OtVqNkJAQxMXF4cknn8SZM2caPfbAgQOYPHkyunbtCl9fXyQnJ+N///tfg/teOVikoKAAgiBg7NixAIA9e/bY/zZ1g0Xq/k6Of7e6R0sHqxAROWLTMBFJ6qWXXsLTTz+N4OBgDBw40Cmx+emnnzBx4kScPXsWarUa/fv3h8FgwNdff42DBw9i165d+OCDD5wSJYvFgltuuQXbtm0DAAwcOBDe3t549913sWvXLkydOrXBOJ544gksW7YMgK0f38CBA1FaWooff/wR3377LRITE9GnT596x23fvh3z5s1DQEAA+vXrh19//RX79+/HxIkTkZWVZU/wGqPVapGUlISysjL8+OOPCAgIwDXXXGN/fuDAgUhKSsJXX30FAEhKSqp3PBFRq4lERBIAIAIQ1Wq1uG7dOtFqtYqiKIomk0k0mUxiZWWl2K9fPxGA+Mgjj4hlZWX2Y3/66SdxyJAhIgDxjTfecCp3xYoVIgCxa9eu4r59++zbT548KcbExIgqlUoEID733HP250pKSkSFQiHqdDpx//79TuXV1NSIGzduFL/77jun7eHh4SIAUaVSiUuXLhXNZrMoiqJoNBrFP//5zyIAMT4+vt55jxkzRgQgfvnll07bv/zySxGAOGbMmKv+vYiI2hObholIUvfffz/uvfdee62el5cXvLy88M477+D48eP44x//iBUrViAgIMB+THR0NN5//30IgoBXX33Vvl0URXut3vPPP4/rr7/e/lxERATee+89mEymejEcP34cVqsVN9xwQ4M1bjNmzMDQoUMbjH/SpEl4+umnoVQqAQAqlQrp6enQaDQ4ePAgLl682Mq/DBFRx2MiSESSmjlzZoPbP/roIwDA7NmzG3x+6NChiIiIwIkTJ+z9944cOYLCwkJotdoGJ2KOjY3FqFGj6m2vG6V78OBBFBYWtij+huILCgpCREQEAODEiRMtKo+IqDOxjyARSSoqKqrB7T/88AMA4Nlnn8U//vGPBvcpLS0FAJw9exZ9+vTBL7/8AgAIDw+vN0+f4+sdOHDAaVvv3r1x++234z//+Q/69++PcePGYezYsUhOTsaoUaPg5dX4pbJfv34Nbu/RoweOHj2KysrKRo8lIpIaE0EikpSvr2+D28vKygAAubm5TZZRN/VKXdLVvXv3RvcNDg5ucPv69esRHR2Nt956C7t27cKuXbvsZT355JOYN28eFIr6jSiNxV+3ryiKTcZPRCQVNg0TkSz5+fkBsE20LIriVR91I3Prjjl//nyj5ZaUlDS4XavVYtGiRThz5gyOHDmCtWvX4uabb8aFCxfwxBNPOPVFJCJyF0wEiUiWoqOjAQA//vhjs4+pW5e3sLAQ1dXVDe5z5MiRJssZPHgw7rvvPnzyySdYtWoVAODNN99sdhxERK6CiSARydItt9wCAHjttdea3bw6ePBghIaGoqampsGl3PLz85GTk9OiOOoGlxQVFbXouPZWt+JIXTM4EVF7YCJIRLJ0//33o2/fvvjyyy/x5z//GXq93un5yspKfPDBB5g3b559m0KhsP++YMECZGdn2587deoU7r77bqhUqnqv9cUXX+CJJ57A4cOH673Gyy+/DMA24lhKffv2BWBbeYSIqL0wESQiWfLz88Onn36KyMhIbNy4EX369EF0dDRGjRqFQYMGoUuXLkhNTXVK9gDg4YcfxpQpU/Dbb78hKSkJUVFRGD58OPr3749Lly7h/vvvr/daFRUVeOWVVzBkyBD06NEDI0eOxLBhwxAcHIx///vf0Ol0WL58eWedeoNSU1MBADfddBNiY2MxduxYjB07FsXFxZLGRUSujaOGiUi2Bg8ejO+++w6rVq3Cli1bcOTIEZw4cQI9e/bEmDFjMGXKFNx6661OxyiVSmzduhXLli3Du+++ixMnTiAwMBB33303XnjhBaxevbre6yQnJ+O1115DVlYWfvzxRxw+fBgqlQr9+/fHpEmT8NhjjyEkJKSzTrtBTz/9NCwWCzZt2oTDhw/DYDAAAGprayWNi4hcmyBybgMiIiIij8SmYSIiIiIPxUSQiIiIyEMxESQiIiLyUEwEiYiIiDwUE0EiIiIiD8VEkIiIiMhDMREkIiIi8lBMBImIiIg8FBNBIiIiIg/FRJCIiIjIQzERJCIiIvJQTASJiIiIPBQTQSIiIiIP9f8BmpW/PLPyHr4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Define the quantile values to compute the locations for\n", "quants = np.linspace(0.01, 0.99, 7)\n", @@ -324,9 +1238,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.01 0.17333333 0.33666667 0.5 0.66333333 0.82666667\n", + " 0.99 ]\n", + "[0. 0.01 0.17333333 0.33666667 0.5 0.66333333\n", + " 0.82666667 0.99 1. ]\n" + ] + } + ], "source": [ "print(quants)\n", "print(quant_dist.dist.quants)" @@ -346,9 +1271,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The input and output shapes are: (11,) (1, 11)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Define the x-grid locations\n", "xvals = np.linspace(-5, 5, 11)\n", @@ -379,9 +1322,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The input and output shapes are: (11,) (2, 51)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAHsCAYAAABG5syiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjCElEQVR4nO3deVxU9f4/8NeZGWaGbUbZURBwBdxFRUBcuonapt0WrJvWLTW/LVfjV93M6qp3MbstZqXmLTXringzs252k8oUBDcEc98RZJFFYVhkgJnz+2NgcgQV2c4sr+fjcR7KmTNn3kdw5sX5bIIoiiKIiIiIyOHIpC6AiIiIiKTBIEhERETkoBgEiYiIiBwUgyARERGRg1JIXQARERFRaxkMBtTV1UldhtVSKpWQyW58349BkIiIiGyOKIooLCxEWVmZ1KVYNZlMhpCQECiVymYfFzh9DBEREdmagoIClJWVwcfHBy4uLhAEQeqSrI7RaER+fj6cnJzQo0ePZv+NeEeQiIiIbIrBYDCHQE9PT6nLsWre3t7Iz89HfX09nJycmjzOwSJERERkUxr7BLq4uEhcifVrbBI2GAzNPs4gSERERDaJzcG3dqt/IwZBIiIiIgfFIEhERETkoBgEiYiIiDrJuHHjMG/evBYf/8QTT2Dq1KkdVg+DIBEREZGDYhAkIiIiclAMgkRERGTTRFFEdW29JFtb1+X43//+B61Wi/Xr18NgMCAhIQFdunSBp6cnXn755SbnF0URb731Fnr27AlnZ2cMHjwYX375ZatfnxNKExERkU27WmdA+Bs/SPLaxxZPhIuydXFq48aNmD17Nj7//HNMmTIFb731FtasWYNPP/0U4eHheOedd7Blyxbccccd5ue89tpr+Oqrr7By5Ur06dMHu3btwmOPPQZvb2+MHTv2tmtgECQiIiLqZCtWrMCrr76KrVu3Yvz48QCAZcuWYf78+XjggQcAAKtWrcIPP/wWcKuqqvDuu+/i559/RlRUFACgZ8+eSE1Nxccff8wgSERERI7H2UmOY4snSvbat2vz5s24dOkSUlNTMXLkSABAeXk5CgoKzAEPABQKBYYPH25uHj527BhqamowYcIEi/PV1tZi6NChraqfQZCIiIhsmiAIrW6elcKQIUNw8OBBrF27FiNGjGjxCilGoxEA8N1336F79+4Wj6lUqlbVwsEiRERERJ2oV69e2LFjB7Zu3Yrnn38eAKDVauHv7489e/aYj6uvr0dGRob56/DwcKhUKuTk5KB3794WW2BgYKtqsZ34TERERGQn+vbtix07dmDcuHFQKBRYtmwZ5s6dizfffBN9+vRBWFgY3n33XZSVlZmf4+7ujhdffBEvvPACjEYjRo8eDZ1Oh7S0NLi5ueHxxx+/7ToYBImIiIgk0K9fP/z8888YN24c5HI5li5dioKCAjzxxBOQyWR48skncf/996O8vNz8nL/+9a/w8fHBkiVLcO7cOXTp0gXDhg3Dq6++2qoaBLGtE+AQERERdaKamhqcP38eISEhUKvVUpdj1W71b8U+gkREREQOikGQiIiIyEExCBIRERE5KAZBIiIiIgfFIEhEREQ2ieNdb+1W/0YMgkRERGRTnJycAADV1dUSV2L9amtrAQByefNL4XEeQSIiIrIpcrkcXbp0QVFREQDAxcWlxcu0ORKj0Yji4mK4uLhAoWg+8jEIEhERkc3x8/MDAHMYpObJZDL06NHjhkGZE0oTERGRzTIYDKirq5O6DKulVCohk924JyCDIBEREZGD4mARIiIiIgfFIEhERETkoBgEiYiIiBwUgyARERGRg2IQJCIiInJQDIJEREREDopBkIiIiMhBMQgSEREROSgGQSIiIiIHxSBIRERE5KAYBImIiIgcFIMgERERkYNiECQiIiJyUAyCRERERA6KQZCIiIjIQTEIEhERETkoBkEiIiIiB8UgSEREROSgGASJiIiIHBSDIBEREZGDYhAkIiIiclAMgkREREQOyiaC4IoVKxASEgK1Wo2IiAikpKS06Hm7d++GQqHAkCFDmjy2efNmhIeHQ6VSITw8HFu2bGnnqomIiIism9UHwaSkJMybNw8LFixAZmYmYmNjMXnyZOTk5Nz0eeXl5ZgxYwZ+97vfNXksPT0d8fHxmD59Og4dOoTp06fj4Ycfxt69ezvqMoiIiIisjiCKoih1ETcTGRmJYcOGYeXKleZ9YWFhmDp1KpYsWXLD502bNg19+vSBXC7H119/jaysLPNj8fHx0Ol0+P777837Jk2ahK5duyIxMbFFdRmNRuTn58Pd3R2CINz+hREREVGnE0URFRUV6NatG2Qyq78f1uEUUhdwM7W1tcjIyMArr7xisT8uLg5paWk3fN7atWtx9uxZfPHFF/jb3/7W5PH09HS88MILFvsmTpyIZcuW3fCcer0eer3e/HVeXh7Cw8NbeCVERERkTXJzcxEQECB1GZKz6iBYUlICg8EAX19fi/2+vr4oLCxs9jmnT5/GK6+8gpSUFCgUzV9eYWHhbZ0TAJYsWYJFixY12Z+bmwuNRnOrSyEiIiIroNPpEBgYCHd3d6lLsQpWHQQbXd/0Kopis82xBoMBjz76KBYtWoS+ffu2yzkbzZ8/HwkJCeavG3+QNBoNgyAREZGNYbcuE6sOgl5eXpDL5U3u1BUVFTW5owcAFRUVOHDgADIzM/Hcc88BMPXlE0URCoUC27dvxx133AE/P78Wn7ORSqWCSqVqh6siIiIisg5W3UtSqVQiIiICycnJFvuTk5MRHR3d5HiNRoPDhw8jKyvLvM2ZMwf9+vVDVlYWIiMjAQBRUVFNzrl9+/Zmz0lERERkr6z6jiAAJCQkYPr06Rg+fDiioqKwevVq5OTkYM6cOQBMTbZ5eXlYv349ZDIZBgwYYPF8Hx8fqNVqi/1z587FmDFjsHTpUkyZMgVbt27Fjz/+iNTU1E69NiIiIiIpWX0QjI+PR2lpKRYvXoyCggIMGDAA27ZtQ1BQEACgoKDglnMKXi86OhobN27Ea6+9htdffx29evVCUlKS+Y4hERERkSOw+nkErZVOp4NWq0V5eTkHixAREdkIfn5bsuo+gkRERETUcRgEiYiIiBwUgyARERGRg2IQJCIiInJQDIJEREREDopBkIiIiMhBMQgSEREROSgGQSKiVtLXG1Clr5e6DCKiVrP6lUWIiKxBvcGI00WV+PViGX69WI5fL5bjRKEOTnIZPntyJEYEe0hdIhHRbWMQJCK6jiiKOFdSZRH6juaXo6bO2OTYOoMBT3+ega+fiUEPTxcJqiUiaj0GQSKia4iiiJe+/BVfZlxs8pi7SoEB3bUYFKDFoIAu6OfnjheSsnA4rxxPfrYfXz0TDY3aSYKqiYhah0GQiOgaX2ZcxJcZFyGXCRgS2KUh9JmCX4inK2QyweL4Tx4fjikf7saZoko8+++DWPvECCjk7H5NRLaBQZCIqEHu5Wos+vYYACBhQl88O773LZ/jq1Hjk8eH46FV6Ug5XYLF/z2GxVMGdHSpRETtgr+2EhEBMBhFvJCUhUp9PUYEd8Wcsb1a/NwB3bVYNm0IBAFYn34Bn6Vld1yhRETtiEGQiAjAqp1nceDCFbipFHj34SGQX9cEfCsT+/vhz5NCAQCLvj2KX04WdUSZRETtikGQiBzekbxyvJd8CgDwl3vDEejRutG/T4/piYciAmAUgec2ZOJkYUV7lklE1O4YBInIodXUGTAvKQv1RhGT+vvhwYiAVp9LEAT8/f6BGBnigUp9PZ76bD9KKvXtWC0RUftiECQih/bm9ydwpqgS3u4q/OP3AyEIt9ckfD2lQoaPH4tAkKcLLl65iqc/z0BNnaGdqiUial8MgkTksHadKsa6hoEd/3xwEDxcle1y3q6uSnz6+Aho1ApkXLiCP2/+FaIotsu5iYjaE4MgETmkK1W1ePE/hwAAM6KCMK6fT7uev7ePG1Y+FgG5TMDWrHx88POZdj0/EVF7YBAkIocjiiIWfH0YRRV69PJ2xfzJYR3yOjG9vfDXhjkF300+hTNFlR3yOkRErcUgSEQOZ0tmHrYdLoRCJmBZ/FA4K+Ud9lqPRvbAuH7eAIBvsvI67HWIiFqDQZCIHMrFK9X4y9ajAIB5d/bBwABth7/m1CHdAQDfHMpnX0EisioMgkTkMAxGEQmbDqFCX4+IoNtbPaQtJoT7Qu0kQ3ZpNY7k6TrlNYmIWoJBkIgcxtrd57Hv/GW4KuV49+HBUMg75y3QVaXA78J8AQDfHGLzMBFZDwZBInII+noDVu08BwB49e4wBHm6durr3ze4GwDgv78WwGhk8zARWQcGQSJyCNsOF6CkUg9fjQoPDw/s9Ncf188b7moFCsprsD/7cqe/PhFRcxgEicjuiaKItbuzAQDTRwXBqZOahK+lUsgxqb8fANOgESIia8AgSER272BOGX69WA6lQoZHRvaQrI57G5qHtx0uQJ3BKFkdRESNGASJyO41LiM3ZXA3eLqpJKsjupcnvNyUuFJdh9QzJZLVQUTUiEGQiOxaYXkNvj9cAAB4IiZY0loUchnuGugPAPg2i83DRCQ9BkEismtf7LmAeqOIkSEe6N+t4yePvpXG0cM/HC1ETZ1B4mqIyNExCBKR3aqpM2DDvhwAwB+jg6UtpsGwHl3RvYszqmoN+PlEkdTlEJGDs4kguGLFCoSEhECtViMiIgIpKSk3PDY1NRUxMTHw9PSEs7MzQkND8d5771kcs27dOgiC0GSrqanp6Eshok70zaF8XK6qRfcuzpgQ7it1OQAAmUzAPYNNzcPfsHmYiCSmkLqAW0lKSsK8efOwYsUKxMTE4OOPP8bkyZNx7Ngx9OjRdPSfq6srnnvuOQwaNAiurq5ITU3F008/DVdXV8yePdt8nEajwcmTJy2eq1arO/x6iKhzWEwZExXUaauItMR9g7vh453n8PPJIuhq6qBRO0ldEhE5KOt5Z7yBd999F0899RRmzpyJsLAwLFu2DIGBgVi5cmWzxw8dOhSPPPII+vfvj+DgYDz22GOYOHFik7uIgiDAz8/PYiMi+7Hv/GUcL9BB7STDtBGdP4H0zYT7a9DL2xW19UZsP3pJ6nKIyIFZdRCsra1FRkYG4uLiLPbHxcUhLS2tRefIzMxEWloaxo4da7G/srISQUFBCAgIwD333IPMzMybnkev10On01lsRGS9GqeMuX9oALq4KKUt5jqCIOC+wd0BcHJpIpKWVQfBkpISGAwG+Ppa9u3x9fVFYWHhTZ8bEBAAlUqF4cOH49lnn8XMmTPNj4WGhmLdunX45ptvkJiYCLVajZiYGJw+ffqG51uyZAm0Wq15Cwy0rjsMRPSbi1eq8cNR03vEE1YySOR69w0xjR7efaYEpZV6iashIkdl1UGwkSAIFl+Lothk3/VSUlJw4MABrFq1CsuWLUNiYqL5sVGjRuGxxx7D4MGDERsbi02bNqFv37744IMPbni++fPno7y83Lzl5ua27aKIqMN8vucCjKJpAud+fu5Sl9OsEC9XDOyuhcEoYlvDPIdERJ3NqgeLeHl5QS6XN7n7V1RU1OQu4fVCQkIAAAMHDsSlS5ewcOFCPPLII80eK5PJMGLEiJveEVSpVFCppFuRgIhaprq2Hhv3mX5R+2NMiMTV3Nx9g7vhcF45vjmUj+lRwVKXQ0QOyKrvCCqVSkRERCA5Odlif3JyMqKjo1t8HlEUodffuOlFFEVkZWXB39+/1bUSkXX4OjMf5VfrEOjhjDtCfaQu56buGewPQQD2Z19BXtlVqcshIgdk1XcEASAhIQHTp0/H8OHDERUVhdWrVyMnJwdz5swBYGqyzcvLw/r16wEAH330EXr06IHQ0FAApnkF3377bTz//PPmcy5atAijRo1Cnz59oNPpsHz5cmRlZeGjjz7q/AskonYjiiLWpZ0HADweFQy57OZdSKTmr3XGiGAP7Dt/Gf89lI+nx/aSuiQicjBWHwTj4+NRWlqKxYsXo6CgAAMGDMC2bdsQFBQEACgoKEBOTo75eKPRiPnz5+P8+fNQKBTo1asX3nzzTTz99NPmY8rKyjB79mwUFhZCq9Vi6NCh2LVrF0aOHNnp10dE7SftbClOXaqEi1KOh4bbxoCu+wZ3w77zl/ENgyARSUAQRVGUughbpNPpoNVqUV5eDo1GI3U5RARg5mcH8OPxS5g+Kgh/nTpA6nJa5HJVLUb+/UfUG0X89P/Gope3m9QlEdk1fn5bsuo+gkRELXWhtAo/nTBNzvy4lU4Z0xwPVyVG9/ECwCXniKjzMQgSkV1Yn34BogiM6euN3j62dVftvsGmOQW/PZQPNtIQUWdiECQim1epr8em/Q1TxtjQ3cBGcf39oFLIcK6kCkfzuWoREXUeBkEisnlfHbyICn09QrxcMbavt9Tl3DY3lQK/CzNNdcMl54ioMzEIEpFNMxpFrNudDQB4PCoIMiufMuZGrm0eNhrZPExEnYNBkIhs2i+ninCupAruKgUetJEpY5ozrp8PXJRyFJTX4Hghm4eJqHMwCBKRTVuTmg0AiB8RCDeV1U+NekNqJzkiQzwAALvPlEhcDRE5CgZBIrJZJwsrkHqmBDLBtqaMuZGY3qZpZHafKZW4EiJyFAyCRGSz1u42LSc3sb8fAj1cJK6m7RqD4L7zl1Fbb5S4GiJyBAyCRGSTSiv1+CozDwDw5OgQiatpH/183eHpqsTVOgMyc65IXQ4ROQAGQSKySYn7clBbb8TA7loMD+oqdTntQiYTEN3YPHyWzcNE1PEYBInI5tTWG7E+/QIA4MnRwRAE25wypjkxvTwBcMAIEXUOBkEisjnbDhegqEIPb3cV7h7YTepy2lVjP8Gs3DJU1NRJXA0R2TsGQSKyKaIoYk3DIJEZo4KgVNjX21ighwt6eLjAYBSx7/xlqcshIjtnX++gRGT3Mi5cwa8Xy6FUyPBoZA+py+kQnEaGiDoLgyAR2ZRPU013A+8f0h2ebiqJq+kYMb3ZT5CIOgeDIBHZjNzL1fjhaCEA4I+jg6UtpgNF9zLdETx5qQJFFTUSV0NE9oxBkIhsxvr0bBhF0x2zUD+N1OV0GA9XJcL9TdeXzmlkiKgDMQgSkU2o1Ndj4/5cAMBTdjKB9M2M7tPYT5DNw0TUcRgEicgmbM64iIqaeoR4uWJcXx+py+lw0eb5BEshiqLE1RCRvWIQJCKrZzSK5nWF/xgTDJnMfiaQvpGRIR5wkgvIK7uKC6XVUpdDRHaKQZCIrN6Ok0XILq2Gu1qBB4YFSF1Op3BRKjC0h2npvFQ2DxNRB2EQJCKr1ziB9CMje8BVpZC4ms4zumE+wbSzDIJE1DEYBInIqp0o1GH3mVLIBGBGVJDU5XSqxvkE086WwmhkP0Eian8MgkRk1damZgMAJg3wQ0BXF2mL6WSDArrATaVAWXUdjhXopC6HiOwQgyARWa2SSj22ZOUBAJ6Msf8pY67nJJchMsQDAPsJElHHYBAkIqu1cV8OauuNGBSgRURQV6nLkcRv6w4zCBJR+2MQJCKrZDSKSNxnmkB6RlQwBMH+p4xpTmMQ3J99Gfp6g8TVEJG9YRAkIquUcqYEeWVXoVErcM8gf6nLkUxfXzd4ualQU2fEwQtlUpdDRHaGQZCIrFLi3hwAwO+HBUDtJJe4GukIgnDN6GE2DxNR+2IQJCKrU1RRgx+PXwIATBsZKHE10mtsHuaAESJqbwyCRGR1vsy4iHqjiKE9uiDUTyN1OZJrDIK/XiyHrqZO4mqIyJ4wCBKRVTEaRWxsGCTyyMgeEldjHbp3cUawpwsMRhF7z12WuhwisiM2EQRXrFiBkJAQqNVqREREICUl5YbHpqamIiYmBp6ennB2dkZoaCjee++9Jsdt3rwZ4eHhUKlUCA8Px5YtWzryEoiohdLPlSLncjXcVY49SOR6nEaGiDqC1QfBpKQkzJs3DwsWLEBmZiZiY2MxefJk5OTkNHu8q6srnnvuOezatQvHjx/Ha6+9htdeew2rV682H5Oeno74+HhMnz4dhw4dwvTp0/Hwww9j7969nXVZRHQDG/aZ/m9PGdoNLkrHWVf4VhgEiagjCKIoWvUClpGRkRg2bBhWrlxp3hcWFoapU6diyZIlLTrH73//e7i6uuLzzz8HAMTHx0On0+H77783HzNp0iR07doViYmJLTqnTqeDVqtFeXk5NBr2YSJqD6WVeoxa8hPqDCK++9No9O+mlbokq3GlqhbD/pYMUQT2vfo7+GjUUpdEZJP4+W3Jqu8I1tbWIiMjA3FxcRb74+LikJaW1qJzZGZmIi0tDWPHjjXvS09Pb3LOiRMn3vScer0eOp3OYiOi9rX54EXUGUQMDtAyBF6nq6sS/buZPrR2cxoZImonVh0ES0pKYDAY4Ovra7Hf19cXhYWFN31uQEAAVCoVhg8fjmeffRYzZ840P1ZYWHjb51yyZAm0Wq15CwzklBZE7UkUf1tJZBoHiTTrt+bhUokrISJ7YdVBsNH1S0uJonjL5aZSUlJw4MABrFq1CsuWLWvS5Hu755w/fz7Ky8vNW25u7m1eBRHdzJ5zl3G+pAquSjnuHdxN6nKsUkyv3/oJWnmvHiKyEVbdE9vLywtyubzJnbqioqImd/SuFxISAgAYOHAgLl26hIULF+KRRx4BAPj5+d32OVUqFVQqVWsug4haYON+0yCR+4Z0h5vKqt+aJDMi2ANKuQwF5TU4X1KFnt5uUpdERDbOqu8IKpVKREREIDk52WJ/cnIyoqOjW3weURSh1+vNX0dFRTU55/bt22/rnETUfq5U1eL7w6Zfzh7hSiI35KyUY1hQFwAcPUxE7cPqf+1OSEjA9OnTMXz4cERFRWH16tXIycnBnDlzAJiabPPy8rB+/XoAwEcffYQePXogNDQUgGlewbfffhvPP/+8+Zxz587FmDFjsHTpUkyZMgVbt27Fjz/+iNTU1M6/QCLC5oMXUWswon83DQZ25yCRmxnd2wt7zl3G7jOlmB4VLHU5RGTjrD4IxsfHo7S0FIsXL0ZBQQEGDBiAbdu2ISgoCABQUFBgMaeg0WjE/Pnzcf78eSgUCvTq1Qtvvvkmnn76afMx0dHR2LhxI1577TW8/vrr6NWrF5KSkhAZGdnp10fk6ERRxMb9v60kcqv+v44uurcXsP0U0s6WwGAUIZfx34uIWs/q5xG0VpyHiKh97M++jIdWpcPZSY59C34Hd7WT1CVZtXqDEUMXJ6NCX49vnovBoIAuUpdEZFP4+W3JqvsIEpH9S9xruqN/72B/hsAWUMhliOzpCQBIZT9BImojBkEikkx5dR2+O1wAwNQsTC0zurcpCKZxPkEiaiMGQSKSzJbMi9DXGxHq544hgV2kLsdmjO5jmk9wf/Zl1NQZJK6GiGwZgyARSeLalUQ4SOT29PJ2g4+7Cvp6Iw5euCJ1OURkwxgEiUgSmbllOHmpAiqFDFOHdpe6HJsiCAJGNyw3x36CRNQWDIJEJInGQSL3DOoGrTMHidyu6MZ1h8+ynyARtR6DIBF1Ol1NHb79NR8AVxJprZiGASOHL5ahvLpO4mqIyFYxCBJRp9v2awFq6ozo4+OGiKCuUpdjk/y1zujp7QqjCKSf411BImodBkEi6nQpp0392u4Z1I2DRNqgsZ9g2ln2EySi1mEQJKJOZTSK5jtYjc2b1DrRvThghIjahkGQiDrVyUsVuFxVCxelnMujtVFUT0/IBOBccRUKyq9KXQ4R2SAGQSLqVGkNo1xHhnhAqeBbUFtoXZwwsLsWALCbq4wQUSvwXZiIOlVaQzNmdC82C7eHmMZ+gmweJqJWYBAkok5TbzBi7/nLAH7r30Ztc+3E0qIoSlwNEdkaBkEi6jSH88pRqa+H1tkJYf4aqcuxC8OCukKlkKGoQo+zxZVSl0NENoZBkIg6TWP/wFE9PSCXcdqY9qB2kmNEsAcAIPU0m4eJ6PYwCBJRp0lvCIJsFm5f0Q3T8HC5OSK6XQyCRNQpauoM2J9t6h/I+QPbV2M/wT1nS1FvMEpcDRHZEgZBIuoUmTll0Ncb4e2uQi9vN6nLsSv9u2mhUStQoa/Hr3nlUpdDRDaEQZCIOkX62d+mjeGycu1LLhPMze2cRoaIbgeDIBF1ijRz/0A2C3eExuZ2LjdHRLeDQZCIOlyVvh5ZuWUAOFCkozROLH3wQhmu1hokroaIbAWDIBF1uH3Zl1FvFBHQ1RmBHi5Sl2OXQrxc0U2rRq3BaB6UQ0R0KwyCRNThGqeNieHdwA4jCAKiG+4K7j7L5mEiahkGQSLqcGmNA0U4bUyHapxGZjf7CRJRCzEIElGHKquuxdF8HQAgqieDYEdqHIhzNF+HK1W1EldDRLaAQZCIOtSec5chikBvHzf4aNRSl2PXfDRq9PV1gygC6ee4yggR3RqDIBF1qLRr5g+kjtc4KpvNw0TUEgyCRNSh0ri+cKdiP0Eiuh0MgkTUYYp0NThTVAlBAEb19JC6HIcQ2dMDcpmA7NJqXLxSLXU5RGTlGASJqMM09lPr302DLi5KiatxDO5qJwwO0AIA0s6wnyAR3RyDIBF1mMbmSTYLd67GVUa43BwR3QqDIBF1mMb+gVEcKNKpGoNg2tkSiKIocTVEZM1sIgiuWLECISEhUKvViIiIQEpKyg2P/eqrrzBhwgR4e3tDo9EgKioKP/zwg8Ux69atgyAITbaampqOvhQih5F7uRoXr1yFQiZgZDD7B3amoT26wNlJjpLKWpy8VCF1OURkxaw+CCYlJWHevHlYsGABMjMzERsbi8mTJyMnJ6fZ43ft2oUJEyZg27ZtyMjIwPjx43HvvfciMzPT4jiNRoOCggKLTa3mHGdE7aVx2pghgV3gqlJIXI1jUSnkGBFiCt+72U+QiG7C6oPgu+++i6eeegozZ85EWFgYli1bhsDAQKxcubLZ45ctW4aXX34ZI0aMQJ8+ffCPf/wDffr0wbfffmtxnCAI8PPzs9iIqP38Nm0Mm4WlMLphOT9OI0NEN2PVQbC2thYZGRmIi4uz2B8XF4e0tLQWncNoNKKiogIeHpZNU5WVlQgKCkJAQADuueeeJncMr6fX66HT6Sw2ImqeKIrX9A/kQBEpNA7Q2XuuFHUGo8TVEJG1suogWFJSAoPBAF9fX4v9vr6+KCwsbNE53nnnHVRVVeHhhx827wsNDcW6devwzTffIDExEWq1GjExMTh9+vQNz7NkyRJotVrzFhgY2LqLInIAZ4oqUVyhh0ohw9AeXaQuxyGF+2vQxcUJVbUG/HqxXOpyiMhKWXUQbCQIgsXXoig22decxMRELFy4EElJSfDx8THvHzVqFB577DEMHjwYsbGx2LRpE/r27YsPPvjghueaP38+ysvLzVtubm7rL4jIzjXeDRwe3BVqJ7nE1TgmmUxAVE9T83D6WTYPE1HzrDoIenl5QS6XN7n7V1RU1OQu4fWSkpLw1FNPYdOmTbjzzjtveqxMJsOIESNuekdQpVJBo9FYbETUvN/WF2azsJQa+2dywAgR3YhVB0GlUomIiAgkJydb7E9OTkZ0dPQNn5eYmIgnnngCGzZswN13333L1xFFEVlZWfD3929zzUSOzmAUsefcZQAcKCK16Ib5BDNyrqCmziBxNURkjax+ToeEhARMnz4dw4cPR1RUFFavXo2cnBzMmTMHgKnJNi8vD+vXrwdgCoEzZszA+++/j1GjRpnvJjo7O0OrNS27tGjRIowaNQp9+vSBTqfD8uXLkZWVhY8++kiaiySyI8fydSi/Wgc3lQIDu2ulLseh9fRyha9GhUs6PQ5euGIOhkREjaz6jiAAxMfHY9myZVi8eDGGDBmCXbt2Ydu2bQgKCgIAFBQUWMwp+PHHH6O+vh7PPvss/P39zdvcuXPNx5SVlWH27NkICwtDXFwc8vLysGvXLowcObLTr4/I3jQ2C0eGeEAht/q3GLsmCIK5eb6x3yYR0bUEkesPtYpOp4NWq0V5eTn7CxJd4/E1+7DzVDFeuzsMM2N7Sl2Ow9t0IBcvf/krhvbogi3PxEhdDpHk+Pltib+uE1G7qa03Yn92Y/9ANkNag8Z+mr9eLEdFTZ3E1RCRtWEQJKJ28+vFMlTXGuDhqkSon7vU5RCAgK4uCPJ0gcEomkM6EVEjBkEiajcZF64AAEYEd4VMduu5PqlzNN4VTOM0MkR0HQZBImo3R/JNSy8OCugibSFkoXGZv90cMEJE12EQJKJ2czTPtJTZAE4bY1UaVxg5XqDD5apaiashImvCIEhE7aKipg7nSqoAAP27cSSeNfF2V6Gfr6nP5p5zvCtIRL9hECSidnGsoVnYX6uGl5tK4mroelGN/QS57jARXYNBkIjaxWE2C1s1DhghouYwCBJRuzjacEdwQDcGQWsU2dMTMgE4V1KFgvKrUpdDRFaCQZCI2sWRhjuCAwPYP9AaaZ2dzGs/p3P0MBE1YBAkojarrq3H2eJKALwjaM2iuO4wEV2HQZCI2ux4gQ5G0TQ61UejlrocuoHf+gmWgMvMExHAIEhE7eBInql/4EAOFLFqI4I94CQXkF9egwul1VKXQ0RWgEGQiNrMPGKY8wdaNWelHEN7dAXA5mEiMmEQJKI2axwo0p93BK1eNOcTJKJrMAgSUZvU1Blwusg0UIRNw9YvumHASPrZUhiN7CdI5OgYBImoTU4UVsBgFOHhqoS/lgNFrN2QwC5wdpKjtKoWp4oqpC6HiCTGIEhEbXLkmhVFBEGQuBq6FaVChhEhHgC4yggRMQgSURsd4UARm8N+gkTUiEGQiNrkSD7XGLY1jUFw77nLqDcYJa6GiKTEIEhEraavN+BkoamfGQeK2I7+3bTQqBWo0NfjSMMa0UTkmBgEiajVTl+qRJ1BhNbZCQFdnaUuh1pILhMwqiebh4mIQZCI2uC3gSIaDhSxMb8tN8cBI0SOjEGQiFrttxVF2Cxsa6J7m+YT3J99Gfp6g8TVEJFUGASJqNUa+5dxRRHb08fHDV5uKujrjcjMKZO6HCKSCIMgEbVKncGI4wWmIMiBIrZHEIRrppFh8zCRo2IQJKJWOVNUidp6I9xUCgR5uEhdDrXCb/0EOWCEyFExCBJRqzQOFAnvpoFMxoEitqhx3eGs3DJU6eslroaIpNBuQVAURRQXF+PYsWPIyMjAhQsXUF1d3V6nJyIr0xgE2SxsuwI9nNG9izPqjSL2Z1+WuhwikoCiLU8+ffo0kpKSsGvXLqSnpzcb/Pr06YPY2FjExcVh6tSpcHJyastLEpGVaBwoMqA7l5azVYIgIKa3JzYduIj0s6UY189H6pKIqJO1Kgj+5z//wYcffojU1FQApruBACCTyaDVauHs7IzLly+jpqYGp06dwqlTp7BmzRp4eHhgxowZSEhIQPfu3dvvKoioUxmMIo7lc6CIPYju5YVNBy5iNyeWJnJIt9U0/NNPP2HEiBGYNm0aUlJSMGjQILz66qvYunUr8vPzUVdXh9LSUly8eBHV1dW4evUqDhw4gBUrVuCRRx5BbW0t3nvvPfTt2xfz589HeXl5R10XEXWgc8WVuFpngLOTHCFeblKXQ20Q3ds0YORovg6llXqJqyGiznZbdwQnTJgArVaLP//5z3j88cfRr1+/mx6vUqkwbNgwDBs2DHPmzIFer8e3336LDz74AEuXLoWzszPeeOONNl0AEXW+I/m/DRSRc6CITfNxVyPUzx0nCiuw+2wp7hvcTeqSiKgT3dYdwUWLFiE7Oxv/+Mc/bhkCm6NSqfDggw9i586d2LlzJ4YOHdqi561YsQIhISFQq9WIiIhASkrKDY/96quvMGHCBHh7e0Oj0SAqKgo//PBDk+M2b96M8PBwqFQqhIeHY8uWLbd9PUSO6vBFNgvbk9g+ptHDKaeKJa6EiDrbbQXB119/HVpt+7zxx8bG4t57773lcUlJSZg3bx4WLFiAzMxMxMbGYvLkycjJyWn2+F27dmHChAnYtm0bMjIyMH78eNx7773IzMw0H5Oeno74+HhMnz4dhw4dwvTp0/Hwww9j79697XJtRPau8Y5g/24cKGIPYvt4AwBSz5SY+3wTkWMQRCv/Xx8ZGYlhw4Zh5cqV5n1hYWGYOnUqlixZ0qJz9O/fH/Hx8eZm6Pj4eOh0Onz//ffmYyZNmoSuXbsiMTGxRefU6XTQarUoLy+HRsMPQ3IcRqOIQYu2o1Jfj//Ni0WoH3/+bV1NnQGDFm1Hbb0RPyaMQW8fd6lLIuow/Py21OZ5BBcvXozFixfj9OnTtzx23bp1WLx4cYvPXVtbi4yMDMTFxVnsj4uLQ1paWovOYTQaUVFRAQ8PD/O+9PT0JuecOHHiTc+p1+uh0+ksNiJHlF1ahUp9PVQKGXp7c6CIPVA7yTEy2PQeuesURw8TOZI2B8GFCxdi0aJFiIyMxPbt22967KeffopFixa1+NwlJSUwGAzw9fW12O/r64vCwsIWneOdd95BVVUVHn74YfO+wsLC2z7nkiVLoNVqzVtgYGCLr4PInjTOHxjqr4FCzsWJ7IW5n+Bp9hMkciTt8i6uVqtRVlaGu+++G++88057nNKCIFiOShRFscm+5iQmJmLhwoVISkqCj4/lRKm3e87G6W4at9zc3Nu4AiL78duKImxSsSeN/QT3nLsMfb1B4mqIqLO0SxCMiIjAhg0b4OTkhJdffhnTp0+HXt/2+ai8vLwgl8ub3KkrKipqckfveklJSXjqqaewadMm3HnnnRaP+fn53fY5VSoVNBqNxUbkiBqD4IBuHDFsT0L93OHlpsLVOgMOXiiTuhwi6iTt1q4zbdo0pKamonv37tiwYQPGjBmD/Pz8Np1TqVQiIiICycnJFvuTk5MRHR19w+clJibiiSeewIYNG3D33Xc3eTwqKqrJObdv337TcxKR6c65OQhy6hi7IpMJGN0wuTSbh4kcR7t28Bk2bBgyMjIQExOD/fv3Y8SIEdizZ0+bzpmQkIBPPvkEa9aswfHjx/HCCy8gJycHc+bMAWBqsp0xY4b5+MTERMyYMQPvvPMORo0ahcLCQhQWFlqsYjJ37lxs374dS5cuxYkTJ7B06VL8+OOPmDdvXptqJbJ3uZevQldTDye5gL6+HFlqbxqbh1NOc8AIkaNo957e3t7e+PnnnzF79mwUFBRg/PjxWLNmTavPFx8fj2XLlmHx4sUYMmQIdu3ahW3btiEoKAgAUFBQYDGn4Mcff4z6+no8++yz8Pf3N29z5841HxMdHY2NGzdi7dq1GDRoENatW4ekpCRERka2/sKJHEDj/IH9/NyhVHCgiL1pHDByJL8cl6tqJa6GiDrDbS0x1+KTKhRYtWoVBg8ejHnz5mHWrFnIyspCfX19q873zDPP4Jlnnmn2sXXr1ll8/csvv7TonA8++CAefPDBVtVD5Kh+GyjCZmF75KO5Zrm5MyW4l8vNEdm9Dv2V/v/+7//w448/wsvLCx999BH27dvXkS9HRB3scF7jiiIMgvZqdG9OI0PkSDq8bSc2Nhb79+/H4MGDuXQRkQ0TRRFHG+YQ5EAR+xXbt2G5udNcbo7IEbS5adhoNN7ymB49eiAtLY1r+RLZsPzyGlyuqoVcJiDUjwNF7NXIYA8oFTLkl9fgbHEVevtw9Rgie9YhfQSbo1arMXbs2M56OSJqZ439A/v4uEHtJJe4GuoozkrTcnOpZ0qQcrqYQZDIznHYHxG1yFEOFHEYo83LzXEaGSJ7d1tB8K677mqX5t2qqiq8+eabWLFiRZvPRUSd4zAnknYYjdPI7DlXitr6W3f/ISLbdVtBMCUlBdHR0bjzzjvx+eefo6Ki4rZeLDMzEy+++CKCgoKwYMGCdlmGjog6xxHzQBEur2jvwvw08HJTorrWgIM5V6Quh4g60G31ETx37hwWLlyITz75BDt27IBKpcLo0aMxcuRIREREwN/fHx4eHlCpVCgrK8Ply5dx/PhxHDhwAKmpqTh79ixEUURYWBjWrFmD++67r6Oui4ja0SVdDYor9JAJQJg/g6C9My0354Wvs/KRcroYo3p6Sl0SEXWQ2wqC3t7e+Oijj/Diiy9i1apV+Oyzz/Djjz/ixx9/hCAIN3yeKIoQBAF33HEHZs+ejQceeAAyGbsnEtmKxoEivbzd4KLstDFmJKHRfbwbgmAJXpoodTVE1FFa9Y4eEhKCpUuX4u9//zt27NiBXbt2IS0tDRcuXEBJSQlqamrg4eEBHx8fDBkyBKNHj8aECRPMy8IRkW05zIEiDqexn+DhvHJcqapFV1elxBURUUdo06/2CoUCEyZMwIQJE9qrHiKyQocvcqCIo/HVqNHP1x0nL1Vg99kS3DOIy80R2SO2zxLRLZnvCAYwCDqSxruCKac4jQyRvWIQJKKbKtLVoKhCD0EAwjlQxKE0zieYeobLzRHZq3br9a3X67Fx40b88MMPOHXqFCoqKuDu7o6+ffsiLi4O06ZNg1qtbq+XI6JOcviagSKuKg4UcSSRIZ5QymXIK7uKcyVV6OXNVUaI7E27vKunpaXhsccew4ULF5r81njw4EEkJSVh0aJF+OKLLxATE9MeL0lEnYQDRRyXs1KOESFdsftMKVJOFTMIEtmhNgfBo0ePYsKECbh69Sr8/Pwwc+ZMhIWFwdfXF0VFRTh+/Dg+/fRTXLhwAXFxcdi7dy8GDBjQHrUTUSc4wiDo0GL7eJuC4OkSPBETInU5RNTO2hwEX3vtNVy9ehWPPfYYPv30Uzg5OTV7zMyZM/H555/jjTfewFdffdXWlyWiTsKBIo5tdG/L5eaUCnYtJ7Inbf4fvWvXLmg0GqxevbrZEAgATk5O+Pjjj6HRaPDLL7+09SWJqJMUVdTgko4DRRxZuL8Gnq5KVNUakMnl5ojsTpuDYG1tLfr163fLgSBqtRr9+vVDXV1dW1+SiDrJEQ4UcXgymWAePZxymtPIENmbNgfBsLAwXLx4sUXH5ubmon///m19SSLqJL9eZP9AMvUTBICUMwyCRPamzUFw3rx5KCgowPvvv3/T45YvX47CwkLMmzevrS9JRJ2k8Y4gVxRxbI39BH+9WIay6lqJqyGi9tTmtp5HH30UeXl5+POf/4ydO3fimWeeQVhYGHx8fFBcXIzjx49jxYoV+O677/DWW29h2rRp7VE3EXUCTh1DAOCnVaOvrxtOXarE7jOluHuQv9QlEVE7EcQ2Thcvl8vbXoQgoL6+vs3n6Uw6nQ5arRbl5eXQaNiJnuxPUUUNRv79JwgCcGThRPYRdHB//e8xfJp6HvHDA7H0wUFSl0PUavz8ttTmpmFRFNu8GY3G9rgWImpHHChC1xrb19RP8Mfjl1Bn4Hs2kb1ocxA0Go3tshGRdTl8UQeAzcJkEt3LE56uSpRW1SKVg0aI7AZnBiWiZh3mQBG6hkIuw72DuwEAvs7Mk7gaImovDIJE1CwuLUfXmzLEFAS3H72EKr1t9esmouYxCBJRE0UVNSjU1UAQgP7d2JmaTIYEdkGwpwuu1hmw/Vih1OUQUTtgECSiJhrvBvb0cuVAETITBAFThnQHAHydmS9xNUTUHhgEiaiJxoEigwK6SFsIWZ2pQ01BMPVMCYor9BJXQ0RtxSBIRE1woAjdSIiXKwYHdoHBKOK/v/KuIJGtYxAkoiY4UIRuZmrDoJGvsxgEiWwdgyARWSiu0HOgCN3UPYO6QS4TcCi3DOdLqqQuh4jawCaC4IoVKxASEgK1Wo2IiAikpKTc8NiCggI8+uij6NevH2QyGebNm9fkmHXr1kEQhCZbTU1NB14FkW3gQBG6FW93FUb39gLAOQWJbJ3VB8GkpCTMmzcPCxYsQGZmJmJjYzF58mTk5OQ0e7xer4e3tzcWLFiAwYMH3/C8Go0GBQUFFptare6oyyCyGYfZLEwtcH/DoJGtWXlo45L1RCQhqw+C7777Lp566inMnDkTYWFhWLZsGQIDA7Fy5cpmjw8ODsb777+PGTNmQKu98QeZIAjw8/Oz2IiIA0WoZSaE+8LZSY7s0mpk5ZZJXQ4RtZJVB8Ha2lpkZGQgLi7OYn9cXBzS0tLadO7KykoEBQUhICAA99xzDzIzM296vF6vh06ns9iI7NHhi7wjSLfmqlJgYn9fAMBWDhohsllWHQRLSkpgMBjg6+trsd/X1xeFha2f1T40NBTr1q3DN998g8TERKjVasTExOD06dM3fM6SJUug1WrNW2BgYKtfn8haWQwUYRCkW5jS0Dz87aF81BmMEldDRK1h1UGwkSAIFl+Lothk3+0YNWoUHnvsMQwePBixsbHYtGkT+vbtiw8++OCGz5k/fz7Ky8vNW25ubqtfn8haXTtQxI0DRegWYnt7wdNVidKqWqSeKZG6HCJqBasOgl5eXpDL5U3u/hUVFTW5S9gWMpkMI0aMuOkdQZVKBY1GY7ER2RsOFKHboZDLcO/ghjkFOXqYyCZZdRBUKpWIiIhAcnKyxf7k5GRER0e32+uIooisrCz4+/u32zmJbBEHitDtmtIwufT2o5dQpa+XuBoiul1W3/aTkJCA6dOnY/jw4YiKisLq1auRk5ODOXPmADA12ebl5WH9+vXm52RlZQEwDQgpLi5GVlYWlEolwsPDAQCLFi3CqFGj0KdPH+h0OixfvhxZWVn46KOPOv36iKwJVxSh2zUksAuCPV2QXVqN5GOXzGsRE5FtsPogGB8fj9LSUixevBgFBQUYMGAAtm3bhqCgIACmCaSvn1Nw6NCh5r9nZGRgw4YNCAoKQnZ2NgCgrKwMs2fPRmFhIbRaLYYOHYpdu3Zh5MiRnXZdRNampFKPgnIOFKHbIwgCpgzpjvd/Oo0tmXkMgkQ2RhA5E2ir6HQ6aLValJeXs78g2YUdJ4vwx7X70dPbFT//v3FSl0M25HxJFca//QvkMgF75v8O3u4qqUsiuiF+fluy6j6CRNR5jjTMHziIdwPpNoV4uWJwYBcYjCL++yvnFCSyJQyCRAQA+JUDRagNpjYMGvmak0sT2RQGQSICwIEi1Db3DOoGuUzAodwynC+pkrocImohBkEi4kARajNvdxVG9/YCwDkFiWwJgyARmecPDOGKItQGU4eamoe3ZuWB4xCJbAODIBGZB4qwWZjaIi7cD85OcmSXViMrt0zqcoioBRgEiYhLy1G7cFUpENfftPznFjYPE9kEBkEi4kARajcPDAsAAGw5mMcl54hsAIMgkYMrqdQjnwNFqJ2M7u2Fnl6uqNDX4yveFSSyegyCRA6OA0WoPclkAqZHmZYAXZ+WzUEjRFaOQZDIwXGgCLW3ByIC4KKU43RRJdLPlkpdDhHdBIMgkYPjQBFqbxq1k7mv4Gfp2dIWQ0Q3xSBI5OCOcGk56gAzGpqHk49dwsUr1RJXQ0Q3wiBI5MBKGwaKAED/bhqJqyF70sfXHTG9PWEUgX/vzZG6HCK6AQZBIge2P/syAKC3jxvc1U4SV0P2ZkZUMABg474c1NQZpC2GiJrFIEjkwHaeKgYAxPbxkrgSskd3hvmiexdnXKmuw7eH8qUuh4iawSBI5KBEUcTOk6YgOLavt8TVkD2SywQ8NsrUV/CzdE4lQ2SNGASJHNTZ4krkl9dAqZAhMsRT6nLITk0bEQiVQoYjeToczCmTuhwiug6DIJGD+qXhbmBkiAeclXKJqyF71dVVifsGdwMArOdUMkRWh0GQyEE19g9kszB1tMejgwEA2w4XoKiiRtpiiMgCgyCRA6qpM2DfedOIYQZB6mgDumsREdQVdQYRiXtzpS6HiK7BIEjkgPacK4W+3ohuWjV6+7hJXQ45gMYJpv+99wJq640SV0NEjRgEiRxQY7PwmL7eEARB4mrIEUwe4A9vdxWKKvT44Wih1OUQUQMGQSIHtIv9A6mTKRUyPDqyBwDgs7RsaYshIjMGQSIHk3u5GmeLqyCXCYjuzYmkqfP8IbIHFDIBBy5cMa9xTUTSYhAkcjC7TpvuBg4N7AKtM5eVo87jo1Fj8kB/AMDn6RckroaIAAZBIofDZmGS0uMNg0a+zsrDlapaiashIgZBIgdSZzBi95lSAMDYfgyC1PkigrqifzcN9PVGbDrAqWSIpMYgSORADl64gkp9PTxclRjQTSt1OeSABEHA41HBAIDP91yAwcj1h4mkxCBI5EAa+wfG9vGCTMZpY0ga9w3phi4uTrh45Sp+PlEkdTlEDo1BkMiBmOcP7MNmYZKO2kmO+BGBALj+MJHUGASJHERxhR5H8nQAgNi+nDaGpPWHkUEQBCDldAkulFZJXQ6Rw2IQJHIQqWdMdwP7d9PAx10tcTXk6Hp4upjvTG/YmyNxNUSOyyaC4IoVKxASEgK1Wo2IiAikpKTc8NiCggI8+uij6NevH2QyGebNm9fscZs3b0Z4eDhUKhXCw8OxZcuWDqqeyDrsPPnbsnJE1uCxUaapZDYdyIW+3iBxNUSOyeqDYFJSEubNm4cFCxYgMzMTsbGxmDx5MnJymv8NUq/Xw9vbGwsWLMDgwYObPSY9PR3x8fGYPn06Dh06hOnTp+Phhx/G3r17O/JSiCRjNIrYdboEAOcPJOtxR6gPumnVuFJdh+8Pc/1hIikIoiha9dj9yMhIDBs2DCtXrjTvCwsLw9SpU7FkyZKbPnfcuHEYMmQIli1bZrE/Pj4eOp0O33//vXnfpEmT0LVrVyQmJraoLp1OB61Wi/Lycmg0mpZfEJEEDl8sx70fpsJNpcDB1ydAqbD63wHJQSz/6TTeTT6F4UFd8eX/RUtdDjkAfn5bsupPg9raWmRkZCAuLs5if1xcHNLS0lp93vT09CbnnDhx4k3PqdfrodPpLDYiW7HzlGmKjqhengyBZFWmjQiEvGH94ROFfF8l6mxW/YlQUlICg8EAX19fi/2+vr4oLGx9M0JhYeFtn3PJkiXQarXmLTAwsNWvT9TZdnJZObJSPho14sJN78f/3sNBI0SdzaqDYCNBsJz4VhTFJvs6+pzz589HeXm5ecvN5dJIZBt0NXU4mFMGgEGQrFPjoJEtmXmo0tdLXA2RY7HqIOjl5QW5XN7kTl1RUVGTO3q3w8/P77bPqVKpoNFoLDYiW5B2pgQGo4ieXq4I9HCRuhyiJqJ7eaKnlysq9fXYmpUvdTlEDsWqg6BSqURERASSk5Mt9icnJyM6uvWdiqOiopqcc/v27W06J5G1Mq8mwruBZKUEQcCjkT0AAF/suQArH8NIZFcUUhdwKwkJCZg+fTqGDx+OqKgorF69Gjk5OZgzZw4AU5NtXl4e1q9fb35OVlYWAKCyshLFxcXIysqCUqlEeHg4AGDu3LkYM2YMli5diilTpmDr1q348ccfkZqa2unXR9SRRFHErlOcNoas34MRAXjrh5M4VqBDVm4ZhvboKnVJRA7B6oNgfHw8SktLsXjxYhQUFGDAgAHYtm0bgoJMfUoKCgqazCk4dOhQ898zMjKwYcMGBAUFITs7GwAQHR2NjRs34rXXXsPrr7+OXr16ISkpCZGRkZ12XUSd4WxxJfLKrkKpkCGyp4fU5RDdUBcXJe4Z5I+vDubhiz05DIJEncTq5xG0VpyHiGzBJynn8LfvjiO2jxc+f4q/6JB1O5hzBb9fkQaVQoa9r/4OXVyUUpdEdoif35asuo8gEbVN42oijWu6ElmzoYFdEOavgb7eiC8zLkpdDpFDYBAkslM1dQbsPVcKABjbj0GQrJ8gCHhslGnQyIa9ORw0QtQJGASJ7NSec6XQ1xvhr1Wjj4+b1OUQtciUId3hplLgXEkV0s+WSl0Okd1jECSyU42jhcf08W7zBOxEncVNpcDUod0AAF/svSBxNUT2j0GQyE41ri/MZmGyNX+INM0Ksf3oJRTpaiSuhsi+MQgS2aGDOVdwtrgKMgGI6eUldTlEtyXMX4OIoK6oN4pI2s/lPIk6EoMgkZ2pMxjx6leHAQD3Dw2A1sVJ4oqIbl/joJHEfTkwGDlohKijMAgS2Zm1u8/jRGEFurg44dW7QqUuh6hVJg/wR1cXJ+SX12DHiSKpyyGyWwyCRHYk93I13ks+DQB49a4weLqpJK6IqHXUTnI8NDwQAAeNEHUkBkEiOyGKIt7YegRX6wwYGeKBhyICpC6JqE0eHWlqHt55qhi5l6slrobIPjEIEtmJ748UYsfJYjjJBfzj/oGcMoZsXrCXK2L7eEEUeVeQqKMwCBLZAV1NHRZ+cxQA8H/jeqM3J5AmOzEjKhgAsHFfLqpr66UthsgOMQgS2YG3fziJogo9Qrxc8cy4XlKXQ9Ru7gj1QZCnC8qv1mHzwTypyyGyOwyCRDYuK7cMn+8xNZv9feoAqJ3kEldE1H7kMgFPRAcDMI2IN3IqGaJ2xSBIZMPqDUbM/+owRBH4/dDuiO7NyaPJ/jw0PBDuKgXOFVdh5+liqcshsisMgkQ2bO3ubBwv0KGLixMW3B0mdTlEHcJNpUD8CNNUMmtSz0tcDZF9YRAkslEXr1Tj3eRTAIBXJ3POQLJvj0cHQyYAKadLcOpShdTlENkNBkEiG2SaM/Dob3MGDuecgWTfAj1cEBfuB8DUV5CI2geDIJEN+t+RQvx8oqhhzsABnDOQHMJTsSEAgK8O5uFyVa3E1RDZBwZBIhtTUVOHhd82zBk4thd6+7hLXBFR5xge1BUDu2uhrzdiAyeYJmoXDIJENkQURbz5/Qlc0ukR7OmCZ8b3lrokok4jCAKeHB0MAFiffgG19UZpCyKyAwyCRDYiu6QKj326F//emwMA+Pv9AzlnIDmcuwd2g4+7CkUVemw7XCB1OUQ2j0GQyMrVGYz4aMcZTFy2C7vPlEKlkOEv94YjhnMGkgNSKmSYERUEAFiz+zxEkRNME7UFgyCRFTuYcwX3LE/FP384CX29EbF9vLD9hTH4Y0yI1KURSeaRkT2gUsjw68VyHLhwRepyiGyaQuoCiKipipo6/POHk/h8zwWIIuDhqsTr94Rh6pDuHCFMDs/TTYX7h3bHxv25WJN6HiOCPaQuichmMQgSWZn/HSnEX745gks6PQDgwYgAvHpXGDxclRJXRmQ9nhwdgo37c/HD0ULkXq5GoIeL1CUR2SQ2DRNZiYLyq5i1/gDmfJFhHhW8YWYk3n5oMEMg0XX6+rojto8XjCKwPj1b6nKIbBaDIJEVOHWpAvcsT0XysUtQyAQ8N743/jdvDKI5IITohp5s6Cu7cV8uKvX1EldDZJsYBIkkdqaoAo/+aw9Kq2oR6ueO7/4Uixcn9uPUMES3MLavN3p6u6JCX48vD+RKXQ6RTWIQJJLQ2eJKPPKvvSiprEW4vwYbZ49CPz+uFELUEjKZYB5BvzYtG0Yjp5Ihul0MgkQSyS6pwqP/2oPiCj1C/dzxxcxIdHFhX0Ci2/HAsO7QqBW4UFqNn04USV0Okc1hECSSQE5pNR751x5c0unR19cN/54ZyQEhRK3golTgkcgeAIA1qeclrobI9jAIEnWy3MumEFhQXoPePm7498xR8HRTSV0Wkc16PCoYcpmA9HOlOJpfLnU5RDbFJoLgihUrEBISArVajYiICKSkpNz0+J07dyIiIgJqtRo9e/bEqlWrLB5ft24dBEFostXU1HTkZRDh4hVTCMwru4qe3q7YMCsS3u4MgURt0a2LMyYP8AMAvJd8WuJqiGyL1QfBpKQkzJs3DwsWLEBmZiZiY2MxefJk5OTkNHv8+fPncddddyE2NhaZmZl49dVX8ac//QmbN2+2OE6j0aCgoMBiU6vVnXFJ5KDyy67i0X/txcUrVxHi5YrEWaPg486fOaL2MO/OvpDLBPx4/BL2niuVuhwim2H1QfDdd9/FU089hZkzZyIsLAzLli1DYGAgVq5c2ezxq1atQo8ePbBs2TKEhYVh5syZePLJJ/H2229bHCcIAvz8/Cw2oo5SWF6DR/+1BzmXq9HDwwUbZkXCV8MQSNReevu4YdqIQADAP74/AVHkCGKilrDqIFhbW4uMjAzExcVZ7I+Li0NaWlqzz0lPT29y/MSJE3HgwAHU1dWZ91VWViIoKAgBAQG45557kJmZedNa9Ho9dDqdxUbUEkU6UwjMLq1GQFdnJM4eBX+ts9RlEdmduXf2gYtSjkO5Zdh2uFDqcohsglUHwZKSEhgMBvj6+lrs9/X1RWFh8//JCwsLmz2+vr4eJSUlAIDQ0FCsW7cO33zzDRITE6FWqxETE4PTp2/ct2TJkiXQarXmLTAwsI1XR46gps6Ax9fux7mSKnTv4ozEWaPQvQtDIFFH8HFXY/aYngCAt344gdp6o8QVEVk/qw6CjQRBsPhaFMUm+251/LX7R40ahcceewyDBw9GbGwsNm3ahL59++KDDz644Tnnz5+P8vJy85aby1ns6dbe/P4Ejhfo4OmqROKsUQj0cJG6JCK7Niu2J7zcVLhQWo1/770gdTlEVs+qg6CXlxfkcnmTu39FRUVN7vo18vPza/Z4hUIBT0/PZp8jk8kwYsSIm94RVKlU0Gg0FhvRzew4WYR1adkAgLcfGowengyBRB3NVaXACxP6AACW/3Qaupq6WzyDyLFZdRBUKpWIiIhAcnKyxf7k5GRER0c3+5yoqKgmx2/fvh3Dhw+Hk5NTs88RRRFZWVnw9/dvn8LJ4RVX6PHSfw4BAJ6IDsb4UB+JKyJyHPHDA9HL2xVXquuw6pezUpdDZNWsOggCQEJCAj755BOsWbMGx48fxwsvvICcnBzMmTMHgKnJdsaMGebj58yZgwsXLiAhIQHHjx/HmjVr8Omnn+LFF180H7No0SL88MMPOHfuHLKysvDUU08hKyvLfE6ithBFES9/eQgllbXo5+uOVyaHSl0SkUNRyGV4ZXIYAODT1PMoKL8qcUVE1kshdQG3Eh8fj9LSUixevBgFBQUYMGAAtm3bhqCgIABAQUGBxZyCISEh2LZtG1544QV89NFH6NatG5YvX44HHnjAfExZWRlmz56NwsJCaLVaDB06FLt27cLIkSM7/frI/nyWlo0dJ4uhVMiw/JGhUDvJpS6JyOHcGeaDkcEe2Jd9Ge9sP4W3HxosdUlEVkkQOdlSq+h0Omi1WpSXl7O/IJmdKNThvg93o7beiIX3huOJmBCpSyJyWJk5V3D/ijQIArDtT7EI8+d7NfHz+3pW3zRMZCtq6gyYm5iF2nojxvfzxuPRwVKXROTQhvboirsH+kMUTSP4iagpBkGidvLm9ydw8lIFvNyU+OdDg286xRERdY6XJ/WDk1zAzlPFSD1dInU5RFaHQZCoHew48dtUMf98aDC83FTSFkREAIAgT1f8IdLUp3zJ98dhNLI3FNG1GASJ2qi4Qo+Xvrxmqph+nCqGyJo8f0dvuKsUOJqvw9ZDeVKXQ2RVGASJ2kAURbzUMFVMqB+niiGyRp5uKswZ1wsA8PYPp1BTZ5C4IiLrwSBI1Abr0rLxS8NUMe9P41QxRNbqyZgQ+GnUyCu7ivXp2VKXQ2Q1GASJWulEoQ5LGkYiLrgrDP383CWuiIhuxFkpx/+L6wsA+PDnM7hSVStxRUTWgUGQqBV0NXV49t8HUVtvxB2hPpgRFSR1SUR0C78fFoBQP3foauoxLykLBg4cIWIQJLpdBqOIuYmZOFtcBT+NGm89OIhTxRDZALlMwDsPD4baSYadp4rxzx9OSl0SkeQYBIlu0z9/OIkdJ4uhUsiwekYEp4ohsiH9u2nx1oOm5eZW7TyLbw7lS1wRkbQYBIluw9asPKzaeRYA8NaDgzAooIu0BRHRbbtvcDc8PbYnAODlLw/hSF65xBURSYdBkKiFfr1Yhpe//BUAMGdsL0wZ0l3iioiotV6eGIqxfb1RU2fE059noLRSL3VJRJJgECRqgSJdDWavz4C+YXDISxP7SV0SEbWBXCZg+bShCPZ0QV7ZVTy74SDqDEapyyLqdAyCRLegrzdgzhcZKNTVoJe3K5ZNGwK5jINDiGyd1sUJq2cMh6tSjj3nLuPv3x2XuiSiTscgSHQToijitS1HcDCnDBq1Av+aMRwatZPUZRFRO+nr64734ocAME0Qv+lArrQFEXUyBkGim1i7Oxv/ybgImQB8+Ogw9PR2k7okImpncf39MO/OPgCA17YcQWbOFYkrIuo8DIJEN5Byuhh/++4YAODVu8Iwpq+3xBURUUf50x19EBfui1qDEXO+yECRrkbqkog6BYMgUTOyS6rw3IZMGEXg98O646nRIVKXREQdSCYT8G78EPTxccMlnR5Pf5EBfb1B6rKIOhyDINF1KmrqMHP9AZRfrcOQwC74x/0DuXIIkQNwUzX2A1YgM6cMb3x9FKLIZejIvjEIEl2joqYOs9YfwJmiSvhqVFg9PQJqJ7nUZRFRJwn2csXyR4ZCJgBJB3Lxp41ZqNTXS10WUYdhECRqUFyhx7TVe7Dn3GW4KuX4ePpw+GjUUpdFRJ1sXD8f/G3qQChkAr49lI/7PkjF8QKd1GURdQgGQSIAF0qr8OCqNBzN18HTVYmNs6MwJLCL1GURkUQejeyBpKdHwV+rxrmSKkz9aDc27c9lUzHZHQZBcnhH8srxwMp0XCitRqCHM778v2gMDNBKXRYRSSwiyAPf/SkWY/t6Q19vxMubf8X/+88hVNeyqZjsB4MgObS0syWYtnoPSir1CPPXYPOcaIR4uUpdFhFZCQ9XJdY+MQIvTewHmQB8dTAPUz7cjTNFFVKXRtQuGATJYW07XIAn1uxHpb4ekSEeSHp6FPsEElETMpmAZ8f3xoZZo+DtrsLpokrc+8FubMm8KHVpRG3GIEgO6fM9F/DshoOoNRgxqb8fPntyJJeOI6KbGtXTE9v+FIuY3p64WmfAC0mHMP+rX1FTx/kGyXYxCJJDEUUR7yWfwutfH4EomjqEf/SHYZwihohaxNtdhfVPRmLu7/pAEIDEfbmY8uFuJB+7xIEkZJMEkT+5raLT6aDValFeXg6NRiN1OdQCBqOIN7Yewb/35gAA5v6uD+bd2YeTRRNRq6ScLsa8jVkoraoFAIT5a/D8Hb0xqb8fZDK+r1grfn5bYhBsJf4g2Za0MyVY+r8TOHSxHIIALJ4yANNHBUldFhHZuNJKPf6Vch6fp2ejqtbURNzbxw3Pje+Newb5QyFnw5u14ee3JQbBVuIPkm04kleOpf87gZTTJQAAF6Ucbz80GHcN9Je4MiKyJ1eqarF293msTctGRY1peplgTxc8M7437h/aHU4MhFaDn9+WGARbiT9I1u1CaRXe3n4K3x7KBwA4yQU8OrIHnrujD7zdVRJXR0T2SldTh/Vp2fgk9TzKqusAAAFdnfF/43rhwYgAqBTsjyw1fn5bYhBsJf4gWaeiihp88NMZJO7LQb3R9KM9ZUg3/L8J/dDD00Xi6ojIUVTp6/HFngv4V8o5lFSa+hB6uCoxvp8P7gzzweg+XnDnTAWS4Oe3JQbBVuIPknWpqKnD6l3n8GnqeVQ39NMZ29cbL0/qh/7duEoIEUmjps6AxH05+HjnORTqasz7neQCIkM88bswH/wu1Je/qHYifn5bsolOCytWrEBISAjUajUiIiKQkpJy0+N37tyJiIgIqNVq9OzZE6tWrWpyzObNmxEeHg6VSoXw8HBs2bKlo8qndmY0isgprcb2o4VY/tNpPPvvgxjz1g588PMZVNcaMDiwCxJnjcJnT45kCCQiSamd5PhjTAhS/jweG2ZFYuboEIR4uaLOICL1TAkWfXsMY/65AxPe3Ykl3x/HvvOXUW8wSl02ORCrvyOYlJSE6dOnY8WKFYiJicHHH3+MTz75BMeOHUOPHj2aHH/+/HkMGDAAs2bNwtNPP43du3fjmWeeQWJiIh544AEAQHp6OmJjY/HXv/4V999/P7Zs2YI33ngDqampiIyMbFFdjvIbhSiKqKo1QHe1DtW1BtTUmbardQbU1Bkb/rx2M0IuE6BSyKBSyKBUyKBSyC3+rmx4TC4ToJALUMgEyAQBCpkMcrkAuSCYHpMJMIgizhZV4kRhRcOmw6nCCvPovGv19HbFyxP7YWJ/P04JQ0RW7VxxJX4+UYQfj1/C/uwrMBh/+yhWymUI8HBGsKcrgjxdLP7s3tWZA0/ayFE+v1vK6oNgZGQkhg0bhpUrV5r3hYWFYerUqViyZEmT4//85z/jm2++wfHjx8375syZg0OHDiE9PR0AEB8fD51Oh++//958zKRJk9C1a1ckJia2qK7GH6Rj2QVwb6cfpJZ+J0QRMIriNVvD10bTn42P1xuN0NcZoa83Ql9vgL7eiJo605+m/aa/V+rrobtaj4qaOuhq6kx/19eZ9xmt8CdEKZeht48bQv3cEervjjB/DaJ6enKqBiKyOeVX67DzVDF+Pn4JO04Wo/xq3Q2PlcsEdO/ijCBPF3i7q+CilMNFqYCzkxyuKjmclQq4XPt3pRxOchlkAiATBAiC6RwyQYBMAATB9Mt342MtYeu/Z1fodAgP9mcQbKCQuoCbqa2tRUZGBl555RWL/XFxcUhLS2v2Oenp6YiLi7PYN3HiRHz66aeoq6uDk5MT0tPT8cILLzQ5ZtmyZTesRa/XQ6/Xm7/W6XSm5y1LgUxl/307nOSC+c3GWWm6w+eslEOtMH2tdpJB7SSHSiGH0Sii1tAQNOuMpr9fEzxr603htN5ohMEowmAUUX/Nn8aGPxsFdHVGqJ87+vm5I9RPg1A/dwR7ufK3YiKyC1pnJ9w3uBvuG9wNBqOIgvKruFBajezSKuQ0/Nn4dU2dETmXq5FzuVrqsm2WUc9/u2tZdRAsKSmBwWCAr6+vxX5fX18UFhY2+5zCwsJmj6+vr0dJSQn8/f1veMyNzgkAS5YswaJFi5rsVypkkCvaL5Bc+5uWAKHZ/QAgb/jtTXbdb3bm3/oAODU0wTY2zaqcTH9XO1k217qqFNConaBxNv3prlZA4+xk2tfwd5VC1qnNrWLDnU5RFHmXj4gchlwmIKCrCwK6uiCmt5fFY6IooqhCj+wSUzC8Ul2L6loDqmvrUV1rwNVaA6oa/t64Xa2tR51BNL+nWrQiiaZfvEURMFzXJHXtlyLEZvfbKoOBnynXsuog2Oj6ACKK4k1DSXPHX7//ds85f/58JCQkmL/W6XQIDAzEwdcn8NZyBzA1VwCAjbdBEBG1E0EQ4KtRw1ejRmRPT6nLsVk6nQ7at6WuwnpYdRD08vKCXC5vcqeuqKioyR29Rn5+fs0er1Ao4OnpedNjbnROAFCpVFCpOBExERER2Q+rvj+qVCoRERGB5ORki/3JycmIjo5u9jlRUVFNjt++fTuGDx8OJyenmx5zo3MSERER2SOrviMIAAkJCZg+fTqGDx+OqKgorF69Gjk5OZgzZw4AU5NtXl4e1q9fD8A0QvjDDz9EQkICZs2ahfT0dHz66acWo4Hnzp2LMWPGYOnSpZgyZQq2bt2KH3/8EampqZJcIxEREZEUrD4IxsfHo7S0FIsXL0ZBQQEGDBiAbdu2ISgoCABQUFCAnJwc8/EhISHYtm0bXnjhBXz00Ufo1q0bli9fbp5DEACio6OxceNGvPbaa3j99dfRq1cvJCUltXgOQSIiIiJ7YPXzCForTkhJRERke/j5bcmq+wgSERERUcdhECQiIiJyUAyCRERERA6KQZCIiIjIQTEIEhERETkoBkEiIiIiB8UgSEREROSgGASJiIiIHBSDIBEREZGDsvol5qxV44IsOp1O4kqIiIiopRo/t7mwmgmDYCtVVFQAAAIDAyWuhIiIiG5XRUUFtFqt1GVIjmsNt5LRaER+fj7c3d0hCILU5bSaTqdDYGAgcnNzueaixPi9sB78XlgPfi+siz18P0RRREVFBbp16waZjD3keEewlWQyGQICAqQuo91oNBqb/U9tb/i9sB78XlgPfi+si61/P3gn8DeMwkREREQOikGQiIiIyEExCDo4lUqFv/zlL1CpVFKX4vD4vbAe/F5YD34vrAu/H/aHg0WIiIiIHBTvCBIRERE5KAZBIiIiIgfFIEhERETkoBgEiYiIiBwUgyA1odfrMWTIEAiCgKysLKnLcTjZ2dl46qmnEBISAmdnZ/Tq1Qt/+ctfUFtbK3VpDmPFihUICQmBWq1GREQEUlJSpC7J4SxZsgQjRoyAu7s7fHx8MHXqVJw8eVLqsgim740gCJg3b57UpVA7YBCkJl5++WV069ZN6jIc1okTJ2A0GvHxxx/j6NGjeO+997Bq1Sq8+uqrUpfmEJKSkjBv3jwsWLAAmZmZiI2NxeTJk5GTkyN1aQ5l586dePbZZ7Fnzx4kJyejvr4ecXFxqKqqkro0h7Z//36sXr0agwYNkroUaiecPoYsfP/990hISMDmzZvRv39/ZGZmYsiQIVKX5fD++c9/YuXKlTh37pzUpdi9yMhIDBs2DCtXrjTvCwsLw9SpU7FkyRIJK3NsxcXF8PHxwc6dOzFmzBipy3FIlZWVGDZsGFasWIG//e1vGDJkCJYtWyZ1WdRGvCNIZpcuXcKsWbPw+eefw8XFRepy6Brl5eXw8PCQugy7V1tbi4yMDMTFxVnsj4uLQ1pamkRVEWD6PwCA/w8k9Oyzz+Luu+/GnXfeKXUp1I4UUhdA1kEURTzxxBOYM2cOhg8fjuzsbKlLogZnz57FBx98gHfeeUfqUuxeSUkJDAYDfH19Lfb7+vqisLBQoqpIFEUkJCRg9OjRGDBggNTlOKSNGzfi4MGD2L9/v9SlUDvjHUE7t3DhQgiCcNPtwIED+OCDD6DT6TB//nypS7ZbLf1eXCs/Px+TJk3CQw89hJkzZ0pUueMRBMHia1EUm+yjzvPcc8/h119/RWJiotSlOKTc3FzMnTsXX3zxBdRqtdTlUDtjH0E7V1JSgpKSkpseExwcjGnTpuHbb7+1+LAzGAyQy+X4wx/+gM8++6yjS7V7Lf1eNL7R5ufnY/z48YiMjMS6desgk/H3to5WW1sLFxcX/Oc//8H9999v3j937lxkZWVh586dElbnmJ5//nl8/fXX2LVrF0JCQqQuxyF9/fXXuP/++yGXy837DAYDBEGATCaDXq+3eIxsC4MgAQBycnKg0+nMX+fn52PixIn48ssvERkZiYCAAAmrczx5eXkYP348IiIi8MUXX/BNthNFRkYiIiICK1asMO8LDw/HlClTOFikE4miiOeffx5btmzBL7/8gj59+khdksOqqKjAhQsXLPb98Y9/RGhoKP785z+zud7GsY8gAQB69Ohh8bWbmxsAoFevXgyBnSw/Px/jxo1Djx498Pbbb6O4uNj8mJ+fn4SVOYaEhARMnz4dw4cPR1RUFFavXo2cnBzMmTNH6tIcyrPPPosNGzZg69atcHd3N/fR1Gq1cHZ2lrg6x+Lu7t4k7Lm6usLT05Mh0A4wCBJZme3bt+PMmTM4c+ZMkxDOG/gdLz4+HqWlpVi8eDEKCgowYMAAbNu2DUFBQVKX5lAap+8ZN26cxf61a9fiiSee6PyCiOwUm4aJiIiIHBR7nxMRERE5KAZBIiIiIgfFIEhERETkoBgEiYiIiBwUgyARERGRg2IQJCIiInJQDIJEREREDopBkIiIiMhBMQgSkUNZuHAhBEHAwoUL23Se4OBgCIKA7Ozs23reuHHjIAgCfvnllyaPVVdX48UXX0RISAicnJwgCAJX0SCiDsUl5oiIrMSsWbOwYcMGuLi4YMiQIVCpVOjbty8AmINrWwMsEdG1GASJiDpRjx490K9fP7i4uFjsv3LlCjZu3AgXFxecOHECgYGBFo8vWrQIAIMgEbUvBkEiok60fv36ZvefPn0aRqMRAwYMaBICiYg6CvsIEhFZgatXrwIAnJ2dJa6EiBwJgyARSUIQBAiCAADYvHkzxowZgy5dujQZgHH58mUsWLAAAwYMgKurK9zd3TFq1Cj861//gtFobPbc9fX1eOuttxAaGgq1Wo3u3btj1qxZuHTp0g3rEUUR69evN9ehVCrh5+eHiIgIvPzyy7h48eINn7tnzx5MnjwZXbt2haurK2JjY/Hzzz83e+z1g0Wys7MhCALGjRsHANi5c6f536ZxsEjjv9O1/26N2+0OViEiuhabholIUkuXLsUrr7wCX19f9O3b1yLYHD16FBMnTkReXh6USiV69+4NvV6Pffv2Ye/evdi+fTs2bdpkEZQMBgN+//vf49tvvwUA9O3bF87Ozli7di22b9+O++67r9k6XnrpJbzzzjsATP34+vbti5KSEhw5cgQHDx5EdHQ0AgICmjzvv//9LxISEqDRaNCrVy+cOXMGqampmDhxIpKTk80B70bUajViYmJQXl6OI0eOQKPRYODAgebH+/bti5iYGOzevRsAEBMT0+T5REStJhIRSQCACEBUKpXi6tWrRaPRKIqiKNbV1Yl1dXViZWWl2KtXLxGA+Kc//UksLy83P/fo0aNi//79RQDihx9+aHHe999/XwQgdu3aVUxJSTHvP3/+vDhgwADRyclJBCD+5S9/MT9WVFQkymQyUavViqmpqRbnu3r1qpiYmCgeOnTIYn9QUJAIQHRychKXLFki1tfXi6IoirW1teIf/vAHEYAYGRnZ5LrHjh0rAhB37NhhsX/Hjh0iAHHs2LE3/fciImpPbBomIkk9/fTTmDVrlvmunkKhgEKhwJo1a3D27Fncf//9eP/996HRaMzPCQ8Px4YNGyAIAt59913zflEUzXf1/va3v2H06NHmx4KDg/HZZ5+hrq6uSQ1nz56F0WjEHXfc0ewdt2nTpmHQoEHN1j9p0iS88sorkMvlAAAnJycsW7YMKpUKe/fuxZUrV1r5L0NE1PEYBIlIUjNmzGh2/1dffQUAmDlzZrOPDxo0CMHBwTh37py5/97x48eRk5MDtVrd7ETMw4YNw6hRo5rsbxylu3fvXuTk5NxW/c3V5+XlheDgYADAuXPnbut8RESdiX0EiUhSYWFhze4/fPgwAOCNN97AP/7xj2aPKSkpAQDk5eUhICAAp06dAgAEBQU1mafv2tfbs2ePxb7u3bvjoYcewn/+8x/07t0b48ePx7hx4xAbG4tRo0ZBobjxW2WvXr2a3e/j44OTJ0+isrLyhs8lIpIagyARScrV1bXZ/eXl5QCAjIyMW56jceqVxtDl7e19w2N9fX2b3b9+/XqEh4fjk08+wfbt27F9+3bzuV5++WUkJCRAJmvaiHKj+huPFUXxlvUTEUmFTcNEZJXc3NwAmCZaFkXxplvjyNzG5xQXF9/wvEVFRc3uV6vVWLhwIS5evIjjx4/j448/xr333ovS0lK89NJLFn0RiYjsBYMgEVml8PBwAMCRI0da/JzGdXlzcnJQXV3d7DHHjx+/5XlCQ0Mxe/ZsfPPNN1ixYgUA4F//+leL6yAishUMgkRklX7/+98DAJYvX97i5tXQ0FAEBgbi6tWrzS7llpWVhfT09Nuqo3FwSX5+/m09r701rjjS2AxORNQeGASJyCo9/fTT6NmzJ3bs2IE//OEPKCgosHi8srISmzZtQkJCgnmfTCYzf71gwQKkpaWZH7tw4QIef/xxODk5NXmtn376CS+99BKOHTvW5DX++c9/AjCNOJZSz549AZhWHiEiai8MgkRkldzc3PDdd98hJCQEiYmJCAgIQHh4OEaNGoV+/fqhS5cuiI+Ptwh7APD888/jrrvuwuXLlxETE4OwsDAMHToUvXv3RllZGZ5++ukmr1VRUYG3334b/fv3h4+PD0aMGIEhQ4bA19cX//73v6HVavHee+911qU3Kz4+HgBwzz33YNiwYRg3bhzGjRuHwsJCSesiItvGUcNEZLVCQ0Nx6NAhrFixAlu2bMHx48dx7tw5+Pv7Y+zYsbjrrrvwwAMPWDxHLpfj66+/xjvvvIO1a9fi3Llz8PT0xOOPP46///3vWLlyZZPXiY2NxfLly5GcnIwjR47g2LFjcHJyQu/evTFp0iS88MIL8PPz66zLbtYrr7wCg8GAjRs34tixY9Dr9QCAmpoaSesiItsmiJzbgIiIiMghsWmYiIiIyEExCBIRERE5KAZBIiIiIgfFIEhERETkoBgEiYiIiBwUgyARERGRg2IQJCIiInJQDIJEREREDopBkIiIiMhBMQgSEREROSgGQSIiIiIHxSBIRERE5KAYBImIiIgc1P8HGsNJj4gfUPwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Take 100 random samples from each of 2 PDFs\n", "samples = norm_dist1.rvs(size=(2, 1000))\n", @@ -412,9 +1373,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The input and output shapes are: (11,) (1, 11)\n", + "Spline knots [[-5. -5. -5. -5. -3. -2. -1. 0. 1. 2. 3. 5. 5. 5. 5.]] [[ 1.48609459e-06 1.68880388e-03 -5.05824770e-03 2.11574348e-02\n", + " 2.37684221e-01 4.79319775e-01 2.37684221e-01 2.11574348e-02\n", + " -5.05824770e-03 1.68880388e-03 1.48609459e-06 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00]] [[3]]\n", + "(1, 15)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# To make a spline you need the spline knots, you can get those from the xval, yval values\n", "splx, sply, spln = qp.spline_gen.build_normed_splines(np.expand_dims(xvals,0), yvals)\n", @@ -442,9 +1426,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axes = qp.plotting.plot_native(norm_dist1, xlim=(-5., 5.), label=\"norm\")\n", "qp.plotting.plot_native(hist_dist1, axes=axes)\n", @@ -480,9 +1475,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This object represents 2 pdfs\n", + "The input and output shapes are: (51,) (2, 51)\n" + ] + } + ], "source": [ "# This is a trivial extension, with the number of pdfs as a member of the `scipy.stats.norm_gen` distribution.\n", "loc = np.array([[0],[1]])\n", @@ -496,20 +1500,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For an input vector of shape (51,) the output shape is (2, 51)\n" + ] + } + ], "source": [ "print (\"For an input vector of shape %s the output shape is %s\" % (xvals.shape, yvals.shape))" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[21], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# In this case we return an array were the rows are the evaluation points and the columns the different PDFs\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m vector_pdf \u001b[38;5;241m=\u001b[39m \u001b[43mqp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstats\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0.\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m vector_pdf\u001b[38;5;241m.\u001b[39mpdf([[\u001b[38;5;241m0.\u001b[39m], [\u001b[38;5;241m0.5\u001b[39m]])\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:136\u001b[0m, in \u001b[0;36mPdf_gen.create\u001b[0;34m(cls, **kwds)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 135\u001b[0m obj, kwds_freeze \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_gen(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[0;32m--> 136\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mobj\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds_freeze\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/scipy/stats/_distn_infrastructure.py:849\u001b[0m, in \u001b[0;36mrv_generic.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 848\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[0;32m--> 849\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:412\u001b[0m, in \u001b[0;36mPdf_gen_wrap._my_freeze\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_my_freeze\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[1;32m 399\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Freeze the distribution for the given arguments.\u001b[39;00m\n\u001b[1;32m 400\u001b[0m \n\u001b[1;32m 401\u001b[0m \u001b[38;5;124;03m Parameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 410\u001b[0m \u001b[38;5;124;03m The frozen distribution.\u001b[39;00m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 412\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrv_frozen_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:176\u001b[0m, in \u001b[0;36mrv_frozen_func.__init__\u001b[0;34m(self, dist, *args, **kwds)\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(dist, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m 175\u001b[0m array_list \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39marray(val) \u001b[38;5;28;01mfor\u001b[39;00m val \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds\u001b[38;5;241m.\u001b[39mvalues()]\n\u001b[0;32m--> 176\u001b[0m bc \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbroadcast\u001b[49m\u001b[43m(\u001b[49m\u001b[43marray_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 177\u001b[0m ss \u001b[38;5;241m=\u001b[39m bc\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(ss) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m2\u001b[39m:\n", + "\u001b[0;31mValueError\u001b[0m: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part." + ] + } + ], "source": [ "# In this case we return an array were the rows are the evaluation points and the columns the different PDFs\n", "vector_pdf = qp.stats.norm(loc=[0., 1., 2], scale=1.)\n", @@ -518,9 +1546,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[22], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# This is the same, except we use `numpy.expand_dims` to shape the input array of evaluation points\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m vector_pdf \u001b[38;5;241m=\u001b[39m \u001b[43mqp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstats\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0.\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m vector_pdf\u001b[38;5;241m.\u001b[39mpdf(np\u001b[38;5;241m.\u001b[39mexpand_dims(np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m0.\u001b[39m, \u001b[38;5;241m0.5\u001b[39m]), \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m))\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:136\u001b[0m, in \u001b[0;36mPdf_gen.create\u001b[0;34m(cls, **kwds)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 135\u001b[0m obj, kwds_freeze \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_gen(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[0;32m--> 136\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mobj\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds_freeze\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/scipy/stats/_distn_infrastructure.py:849\u001b[0m, in \u001b[0;36mrv_generic.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 848\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[0;32m--> 849\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:412\u001b[0m, in \u001b[0;36mPdf_gen_wrap._my_freeze\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_my_freeze\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[1;32m 399\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Freeze the distribution for the given arguments.\u001b[39;00m\n\u001b[1;32m 400\u001b[0m \n\u001b[1;32m 401\u001b[0m \u001b[38;5;124;03m Parameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 410\u001b[0m \u001b[38;5;124;03m The frozen distribution.\u001b[39;00m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 412\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrv_frozen_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:176\u001b[0m, in \u001b[0;36mrv_frozen_func.__init__\u001b[0;34m(self, dist, *args, **kwds)\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(dist, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m 175\u001b[0m array_list \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39marray(val) \u001b[38;5;28;01mfor\u001b[39;00m val \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds\u001b[38;5;241m.\u001b[39mvalues()]\n\u001b[0;32m--> 176\u001b[0m bc \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbroadcast\u001b[49m\u001b[43m(\u001b[49m\u001b[43marray_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 177\u001b[0m ss \u001b[38;5;241m=\u001b[39m bc\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(ss) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m2\u001b[39m:\n", + "\u001b[0;31mValueError\u001b[0m: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part." + ] + } + ], "source": [ "# This is the same, except we use `numpy.expand_dims` to shape the input array of evaluation points\n", "vector_pdf = qp.stats.norm(loc=[0., 1., 2], scale=1.)\n", @@ -529,9 +1573,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[23], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# In this case we return an array were the rows are pdfs and the columns the evaluation points\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m vector_pdf \u001b[38;5;241m=\u001b[39m \u001b[43mqp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstats\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0.\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m vector_pdf\u001b[38;5;241m.\u001b[39mpdf([\u001b[38;5;241m0.\u001b[39m, \u001b[38;5;241m0.5\u001b[39m])\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:136\u001b[0m, in \u001b[0;36mPdf_gen.create\u001b[0;34m(cls, **kwds)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 135\u001b[0m obj, kwds_freeze \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_gen(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[0;32m--> 136\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mobj\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds_freeze\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/scipy/stats/_distn_infrastructure.py:849\u001b[0m, in \u001b[0;36mrv_generic.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 848\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[0;32m--> 849\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:412\u001b[0m, in \u001b[0;36mPdf_gen_wrap._my_freeze\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_my_freeze\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[1;32m 399\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Freeze the distribution for the given arguments.\u001b[39;00m\n\u001b[1;32m 400\u001b[0m \n\u001b[1;32m 401\u001b[0m \u001b[38;5;124;03m Parameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 410\u001b[0m \u001b[38;5;124;03m The frozen distribution.\u001b[39;00m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 412\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrv_frozen_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:176\u001b[0m, in \u001b[0;36mrv_frozen_func.__init__\u001b[0;34m(self, dist, *args, **kwds)\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(dist, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m 175\u001b[0m array_list \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39marray(val) \u001b[38;5;28;01mfor\u001b[39;00m val \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds\u001b[38;5;241m.\u001b[39mvalues()]\n\u001b[0;32m--> 176\u001b[0m bc \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbroadcast\u001b[49m\u001b[43m(\u001b[49m\u001b[43marray_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 177\u001b[0m ss \u001b[38;5;241m=\u001b[39m bc\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(ss) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m2\u001b[39m:\n", + "\u001b[0;31mValueError\u001b[0m: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part." + ] + } + ], "source": [ "# In this case we return an array were the rows are pdfs and the columns the evaluation points\n", "vector_pdf = qp.stats.norm(loc=[[0.], [1.], [2]], scale=1.)\n", @@ -540,9 +1600,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[24], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# This is the same, except we use `numpy.expand_dims` to shape the input array of pdf parameters\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m vector_pdf \u001b[38;5;241m=\u001b[39m \u001b[43mqp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstats\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexpand_dims\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0.\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m vector_pdf\u001b[38;5;241m.\u001b[39mpdf([\u001b[38;5;241m0.\u001b[39m, \u001b[38;5;241m0.5\u001b[39m])\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:136\u001b[0m, in \u001b[0;36mPdf_gen.create\u001b[0;34m(cls, **kwds)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 135\u001b[0m obj, kwds_freeze \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_gen(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[0;32m--> 136\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mobj\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds_freeze\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/scipy/stats/_distn_infrastructure.py:849\u001b[0m, in \u001b[0;36mrv_generic.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 848\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[0;32m--> 849\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfreeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:412\u001b[0m, in \u001b[0;36mPdf_gen_wrap._my_freeze\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 398\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_my_freeze\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[1;32m 399\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Freeze the distribution for the given arguments.\u001b[39;00m\n\u001b[1;32m 400\u001b[0m \n\u001b[1;32m 401\u001b[0m \u001b[38;5;124;03m Parameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 410\u001b[0m \u001b[38;5;124;03m The frozen distribution.\u001b[39;00m\n\u001b[1;32m 411\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 412\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrv_frozen_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/qp/pdf_gen.py:176\u001b[0m, in \u001b[0;36mrv_frozen_func.__init__\u001b[0;34m(self, dist, *args, **kwds)\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(dist, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m 175\u001b[0m array_list \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39marray(val) \u001b[38;5;28;01mfor\u001b[39;00m val \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds\u001b[38;5;241m.\u001b[39mvalues()]\n\u001b[0;32m--> 176\u001b[0m bc \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbroadcast\u001b[49m\u001b[43m(\u001b[49m\u001b[43marray_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 177\u001b[0m ss \u001b[38;5;241m=\u001b[39m bc\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(ss) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m2\u001b[39m:\n", + "\u001b[0;31mValueError\u001b[0m: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part." + ] + } + ], "source": [ "# This is the same, except we use `numpy.expand_dims` to shape the input array of pdf parameters\n", "vector_pdf = qp.stats.norm(loc=np.expand_dims([0., 1., 2], -1), scale=1.)\n", @@ -558,7 +1634,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -580,9 +1656,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The shapes are: (51,) (100, 51)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "vals_n = ens_n.pdf(xvals)\n", "print(\"The shapes are: \", xvals.shape, vals_n.shape)\n", @@ -600,9 +1694,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Making hist\n", + "Making interp\n", + "Making spline\n", + "Making quants\n", + "Making mixmod\n" + ] + } + ], "source": [ "bins = np.linspace(-5, 5, 11)\n", "quants = np.linspace(0.01, 0.99, 7)\n", @@ -631,9 +1737,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Making hist\n", + "Making interp\n", + "Making spline\n", + "Making quants\n", + "Making mixmod\n" + ] + } + ], "source": [ "print(\"Making hist\")\n", "ens_h2 = qp.convert(ens_n, \"hist\", bins=bins)\n", @@ -667,9 +1785,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnkAAAHsCAYAAACuSrvMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACq40lEQVR4nOzdd3RUZfrA8e+dlpn0XoBUCBB66L0oxYJrW1dFZHWBXd21gA392dBd14qC62JXXCusa0UU6b0lVCEQWhIgCSEhvU27vz8mGQgJJCFlUp7POXNOcu977/vcSXvyVkVVVRUhhBBCCNGmaFwdgBBCCCGEaHyS5AkhhBBCtEGS5AkhhBBCtEGS5AkhhBBCtEE6VwcghBDCdWw2GxaLxdVhCCEug16vR6vVXvS8JHlCCNEOqapKZmYmeXl5rg5FCNEAvr6+hIaGoihKtXOS5AkhRDtUmeAFBwfj7u5e4x8IIUTLpaoqJSUlZGVlARAWFlatjCR5QgjRzthsNmeCFxAQ4OpwhBCXyWQyAZCVlUVwcHC1rluZeCGEEO1M5Rg8d3d3F0cihGioyp/jmsbWSpInhBDtlHTRCtH6XernWJI8IYQQQog2SJI8IYQQl63MYuO297Zw23tbKLPYXB2O06JFi/D19XV1GK3GXXfdxQ033ODqMGqUkpKCoijs3r3b1aG0OpLkCSGEaDUuloysXbsWRVGcS8LceuutJCcn1+mebTkhrEyQKl8Gg4EuXbrwj3/8A1VVneUWLFjAokWLGlTX3Llzq9RV+erevXsDn0JcLpldK4QQos0xmUzOmYcticViQa/XN3u9K1eupGfPnpSXl7Nx40ZmzJhBWFgY06dPB8DHx6dR6unZsycrV66sckynk1TDVaQlTwghRJtzYevcnj17GDduHF5eXnh7ezNgwAASEhJYu3Ytd999N/n5+c6Wp7lz5wKQm5vLtGnT8PPzw93dnauvvprDhw9Xqef9998nPDwcd3d3brzxRl5//fUq9c6dO5d+/frx0UcfERMTg5ubG6qq8ssvvzBy5Eh8fX0JCAhg8uTJHD161HldZQvckiVLGDVqFCaTiUGDBpGcnMyOHTsYOHAgnp6eXHXVVZw5c6bW9yMgIIDQ0FAiIyO54447GD58ODt37nSev7CFdOzYsTzwwAM89thj+Pv7Exoa6nxfLkWn0xEaGlrlFRgY6DwfFRXFP//5T/70pz/h5eVFREQE7733XpV7bN++nfj4eIxGIwMHDmTXrl1Vzufm5nLHHXcQFBSEyWQiNjaWjz/+uNbY2iNJ8oQQQrR5d9xxB506dWLHjh0kJiby+OOPo9frGT58OPPnz8fb25uMjAwyMjJ45JFHAEfik5CQwA8//MCWLVtQVZVrrrnGuVTFpk2buOeee3jwwQfZvXs3EyZM4IUXXqhW95EjR1iyZAn/+9//nOPKiouLeeihh9ixYwerVq1Co9Fw4403Yrfbq1z77LPP8tRTT7Fz5050Oh233347jz32GAsWLGDDhg0cPXqUZ555pl7vRUJCAjt37mTIkCGXLPfJJ5/g4eHBtm3beOWVV3j++edZsWJFveqqybx585zJ21//+lfuvfdeDh48CDjel8mTJ9OtWzcSExOZO3eu8+tR6emnn+bAgQP8/PPPJCUl8fbbb1dJJMV5VCGEEO1KaWmpeuDAAbW0tLTh9zJb1Vvf3aze+u5mtdRsbYToLu2Pf/yjqtVqVQ8Pjyovo9GoAmpubq6qqqr68ccfqz4+Ps7rvLy81EWLFtV4zwvLqqqqJicnq4C6adMm57Hs7GzVZDKpS5YsUVVVVW+99Vb12muvrXLdHXfcUeVezz77rKrX69WsrKxLPldWVpYKqPv27VNVVVWPHz+uAuoHH3zgLPPll1+qgLpq1SrnsRdffFHt1q3bRe9beR+TyaR6eHioer1eBdQ///nPVcr98Y9/VK+//nrn52PGjFFHjhxZpcygQYPUOXPmXLSuZ599VtVoNNW+NtOnT3eWiYyMVKdOner83G63q8HBwerbb7+tqqqqvvvuu6q/v79aXFzsLPP222+rgLpr1y5VVVX1uuuuU+++++6LxtHeXOrnWTrKhRBCtCrjxo3j7bffrnJs27ZtTJ069aLXPPTQQ8yYMYNPP/2U8ePHc8stt9C5c+eLlk9KSkKn01Vp7QoICKBbt24kJSUBcOjQIW688cYq1w0ePJilS5dWORYZGUlQUFCVY0ePHuXpp59m69atZGdnO1vw0tLS6NWrl7Ncnz59nB+HhIQA0Lt37yrHKre1upTFixcTFxeHxWJh3759PPDAA/j5+fHSSy9d9Jrz6wbHtlm11dWtWzd++OGHKse8vLwuel9FUQgNDXXeNykpib59+1ZZqHvYsGFVrr/33nu5+eab2blzJxMnTuSGG25g+PDhl4yrvZLuWiGEEK2Kh4cHXbp0qfLq2LHjJa+ZO3cu+/fv59prr2X16tX06NGDb7/99qLl1fNmnl54vHLx2fM/vtR1Hh4e1Y5dd9115OTk8P7777Nt2za2bdsGgNlsrlLu/EkalXVdeOzCLt6ahIeH06VLF+Li4vjDH/7ArFmzmDdvHmVlZRe95sIJInWpq3L27vmvyuS0Lve92Pt+vquvvprU1FRmzZpFeno6V155ZbUuXeEgSZ4QQoh2oWvXrsyePZtff/2Vm266yTlY32AwYLNVXeOvR48eWK1WZ/IFkJOTQ3JyMnFxcQB0796d7du3V7kuISGh1jhycnJISkriqaee4sorryQuLo7c3NyGPl69aLVarFZrtaTS1Xr06MGePXsoLS11Htu6dWu1ckFBQdx111189tlnzJ8/v9rkDeEgSZ4QQog2rbS0lPvuu4+1a9eSmprKpk2b2LFjhzNZi4qKoqioiFWrVpGdnU1JSQmxsbFcf/31zJw5k40bN7Jnzx6mTp1Kx44duf766wG4//77WbZsGa+//jqHDx/m3Xff5eeff651uzg/Pz8CAgJ47733OHLkCKtXr+ahhx5q0vcgJyeHzMxMTp48yc8//8yCBQsYN24c3t7ejVqP1WolMzOzyuv06dN1vn7KlCloNBqmT5/OgQMHWLZsGa+99lqVMs888wzff/89R44cYf/+/SxdutT5tRRVSZInhBCiTdNqteTk5DBt2jS6du3KH/7wB66++mqee+45AIYPH84999zDrbfeSlBQEK+88goAH3/8MQMGDGDy5MkMGzYMVVVZtmyZs7txxIgRvPPOO7z++uv07duXX375hdmzZ2M0Gi8Zj0aj4auvviIxMZFevXoxe/ZsXn311SZ9D8aPH09YWBhRUVH8+c9/5pprrmHx4sWNXs/+/fsJCwur8oqMjKzz9Z6envz4448cOHCA+Ph4nnzySV5++eUqZQwGA0888QR9+vRh9OjRaLVavvrqq8Z+lDZBUevSAS6EEKLNKCsr4/jx40RHR9eakNR6L4uNuz52dFkuunswRr22MUJstWbOnMnBgwfZsGGDq0MR7cSlfp5ldq0QQghxmV577TUmTJiAh4cHP//8M5988gkLFy50dVhCAJLkCSGEEJdt+/btvPLKKxQWFhITE8Obb77JjBkzXB2WEIB01wohRLvTmN21QgjXutTPs0y8EEIIIYRogyTJE0IIIYRogyTJE0IIIYRogyTJE0IIIYRogyTJE0IIIYRogyTJE0IIIYRogyTJE0II0eYsWrQIX19fV4chGomrv55RUVHMnz/fZfVfLknyhBBCnDNPab7XZbjrrru44YYbqh1fu3YtiqKQl5cHwK233kpycnKd7unqBKIppaSkoCgKu3fvrvM1c+fOpV+/fk0WU3NpzsRs7ty5KIqCoihotVrCw8OZMWMGZ86ccZapPK8oCh4eHsTGxnLXXXeRmJhY5V6V38sXvp566ql6xyU7XgghhGhzTCYTJpPJ1WFUY7FY0Ov1rg6jWbSnZwXo2bMnK1euxGazsWvXLqZPn86pU6f4+eefnWU+/vhjrrrqKsrKykhOTua9995jyJAhfPTRR0ybNq3K/Q4dOoS3t7fzc09Pz3rHJC15Qggh2pwLW+f27NnDuHHj8PLywtvbmwEDBpCQkMDatWu5++67yc/Pd7aYzJ07F4Dc3FymTZuGn58f7u7uXH311Rw+fLhKPe+//z7h4eG4u7tz44038vrrr1ept7JV7KOPPiImJgY3NzdUVeWXX35h5MiR+Pr6EhAQwOTJkzl69KjzusoWuCVLljBq1ChMJhODBg0iOTmZHTt2MHDgQDw9PbnqqquqtBbVprKVaNWqVQwcOBB3d3eGDx/OoUOHnO/bc889x549e5zvx6JFiwDIz8/nz3/+M8HBwXh7e3PFFVewZ8+eWp917Nix3Hfffdx3333O533qqac4f8OturzX5zt69CjXX389ISEheHp6MmjQIFauXOk8P3bsWFJTU5k9e7bzOSpt3ryZ0aNHYzKZCA8P54EHHqC4uNh5Pisri+uuuw6TyUR0dDSff/55nd5bnU5HaGgoHTt2ZPLkyTzwwAP8+uuvlJaWOsv4+voSGhpKVFQUEydO5Ouvv+aOO+7gvvvuIzc3t8r9goODCQ0Ndb4kyRNCCCFqcMcdd9CpUyd27NhBYmIijz/+OHq9nuHDhzN//ny8vb3JyMggIyODRx55BHB0DSckJPDDDz+wZcsWVFXlmmuuwWKxALBp0ybuueceHnzwQXbv3s2ECRN44YUXqtV95MgRlixZwv/+9z9nt2lxcTEPPfQQO3bsYNWqVWg0Gm688UbsdnuVa5999lmeeuopdu7ciU6n4/bbb+exxx5jwYIFbNiwgaNHj/LMM8/U+/148sknmTdvHgkJCeh0Ov70pz8Bjm7uhx9+mJ49ezrfj1tvvRVVVbn22mvJzMxk2bJlJCYm0r9/f6688krOnj17yWcF+OSTT9DpdGzbto0333yTN954gw8++MB5vrb3+kJFRUVcc801rFy5kl27djFp0iSuu+460tLSAPjmm2/o1KkTzz//vPM5APbt28ekSZO46aab2Lt3L4sXL2bjxo3cd999VWJJSUlh9erVfP311yxcuJCsrKx6v8cmkwm73Y7Var1kudmzZ1NYWMiKFSvqXUdtpLtWCCFEq7J06dJqrRo2m+2S16SlpfHoo4/SvXt3AGJjY53nfHx8UBSF0NBQ57HDhw/zww8/sGnTJoYPHw7A559/Tnh4ON999x233HIL//rXv7j66qudSWHXrl3ZvHkzS5curVK32Wzm008/JSgoyHns5ptvrlLmww8/JDg4mAMHDtCrVy/n8UceeYRJkyYB8OCDD3L77bezatUqRowYAcD06dOdLW318cILLzBmzBgAHn/8ca699lrKysowmUx4eno6W6UqrV69mn379pGVlYWbmxsAr732Gt999x1ff/01f/7zny/6rADh4eG88cYbKIpCt27d2LdvH2+88QYzZ86s03t9ob59+9K3b1/n5//4xz/49ttv+eGHH7jvvvvw9/dHq9Xi5eVV5TleffVVpkyZwqxZswDH98Gbb77JmDFjePvtt0lLS+Pnn39m69atDBkyxPm1iYuLq9f7e/DgQd5++20GDx6Ml5fXJctWfk+mpKRUOd6pU6cqn6emphIQEFCvOKQlTwghRKsybtw4du/eXeV1fqtQTR566CFmzJjB+PHjeemll6p0jdYkKSkJnU7n/EMPEBAQQLdu3UhKSgIcY6YGDx5c5boLPweIjIyslvQcPXqUKVOmEBMTg7e3N9HR0QDOlqhKffr0cX4cEhICQO/evascu5xWpvPvGxYWBnDJ+yQmJlJUVERAQACenp7O1/Hjx6u8lzU9K8DQoUOrdJkOGzaMw4cPY7PZ6vReX6i4uJjHHnuMHj164Ovri6enJwcPHqz2/tX0HIsWLaryDJMmTcJut3P8+HFnLAMHDnRe07179zpNzNm3bx+enp6YTCZ69OhBeHh4nbp6K7utz39/ADZs2FDle9zPz6/We11IWvKEEEK0Kh4eHnTp0qXKsZMnT17ymrlz5zJlyhR++uknfv75Z5599lm++uorbrzxxhrLnz9e7MLjlX+Mz//4Utd5eHhUO3bdddcRHh7O+++/T4cOHbDb7fTq1Quz2Vyl3PkTFyrruvDYhV28dVHTfS91H7vdTlhYGGvXrq127vwEqKZnrU1d3usLPfrooyxfvpzXXnuNLl26YDKZ+P3vf1/t/buQ3W7nL3/5Cw888EC1cxEREc6xiRer91K6devGDz/8gFarpUOHDs4Wz9pUJrKViX6l6OjoBs/6liRPCCFEu9C1a1e6du3K7Nmzuf322/n444+58cYbMRgM1bp7e/TogdVqZdu2bc4uxJycHJKTk51dd927d2f79u1VrktISKg1jpycHJKSknj33XcZNWoUABs3bmyMR2wUNb0f/fv3JzMzE51OR1RUVL3vuXXr1mqfx8bGotVq6/ReX2jDhg3cddddziS9qKioWnfnxZ5j//791f5JqBQXF4fVaiUhIcHZKnvo0CHn0jyXYjAYLnrfS6kcEzp+/Ph6X1sb6a4VQgjRppWWlnLfffexdu1aUlNT2bRpEzt27HAmEFFRURQVFbFq1Sqys7MpKSkhNjaW66+/npkzZ7Jx40b27NnD1KlT6dixI9dffz0A999/P8uWLeP111/n8OHDvPvuu/z888+1tgL5+fkREBDAe++9x5EjR1i9ejUPPfRQk78PdRUVFcXx48fZvXs32dnZlJeXM378eIYNG8YNN9zA8uXLSUlJYfPmzTz11FN1SmxPnDjBQw89xKFDh/jyyy/517/+xYMPPghQp/f6Ql26dOGbb75h9+7d7NmzhylTplRriYyKimL9+vWcOnWK7OxsAObMmcOWLVv429/+xu7du53jAe+//37A0Rp31VVXMXPmTLZt20ZiYiIzZsxotOV48vLyyMzMJDU1lRUrVvD73/+eL774grfffrtJ1mqUJE8IIUSbptVqycnJYdq0aXTt2pU//OEPXH311Tz33HMADB8+nHvuuYdbb72VoKAgXnnlFcCxptmAAQOYPHkyw4YNQ1VVli1b5uzqHDFiBO+88w6vv/46ffv25ZdffmH27NkYjcZLxqPRaPjqq69ITEykV69ezJ49m1dffbVp34R6uPnmm7nqqqsYN24cQUFBfPnllyiKwrJlyxg9ejR/+tOf6Nq1K7fddhspKSnOsYKXMm3aNEpLSxk8eDB/+9vfuP/++52TNaD29/pCb7zxBn5+fgwfPpzrrruOSZMm0b9//yplnn/+eVJSUujcubNznGCfPn1Yt24dhw8fZtSoUcTHx/P00087xyVWxhIeHs6YMWO46aabnMvGNIa7776bsLAwunfvzr333ounpyfbt29nypQpjXL/CynqxTrDhRBCtEllZWUcP36c6OjoWhMSUT8zZ87k4MGDbNiwwdWhtBhjx46lX79+rXJbsNbgUj/PMiZPCCGEuEyvvfYaEyZMwMPDg59//plPPvmEhQsXujosIQBJ8oQQQojLtn37dl555RUKCwuJiYnhzTffZMaMGa4OSwhAkjwhhBDisi1ZssTVIbR4NS27IpqHTLwQQgghhGiDJMkTQgghhGiDJMkTQgghhGiDJMkTQgghhGiDJMkTQgghhGiDJMkTQgghhGiDJMkTQghx2azlKl/dncVXd2dhLW/fGyitXbsWRVGcm9kvWrSoSfYjFaKuJMkTQggh6mns2LHMmjWryrHhw4eTkZGBj4+Pa4IS4gKyGLIQQgjRCAwGA6Ghoa4OQwgnackTQgjRahQXFzNt2jQ8PT0JCwtj3rx5VVrVFEXhu+++q3KNr68vixYtcn4+Z84cunbtiru7OzExMTz99NNYLBbn+blz59KvXz8+/fRToqKi8PHx4bbbbqOwsBCAu+66i3Xr1rFgwQIURUFRFFJSUqp119bkxx9/ZMCAARiNRmJiYnjuueewWq2N9fYIUYUkeUIIIVqNRx99lDVr1vDtt9/y66+/snbtWhITE+t1Dy8vLxYtWsSBAwdYsGAB77//Pm+88UaVMkePHuW7775j6dKlLF26lHXr1vHSSy8BsGDBAoYNG8bMmTPJyMggIyOD8PDwWutdvnw5U6dO5YEHHuDAgQO8++67LFq0iBdeeKFe8QtRV9JdWwO73U56ejpeXl4oiuLqcIQQolGZzWbsdjs2mw2bzdage9lsKqqqVnxsQ7E13e/MoqIiPvzwQxYtWsQVV1wBwEcffURkZCSqqjqfpfLZznf+sSeeeMJ5PDw8nNmzZ7NkyRIefvhhZ1m73c6HH36Il5cXAHfccQcrV67k+eefx9PTE71ej8lkIigoyHmvyvtXvq92u73K8X/84x889thjTJ06FYDIyEiee+45Hn/8cZ566qnGfbPaKVVVsdvt6PV6+fuNJHk1Sk9Pr9N/ZUII0RpFRkbyzjvvUFpa2uB72cxQVOQHwO7dJ9AaGnzLi0pOTsZsNuPl5cWuXbucx8PDw8nKynIeO3bsWJXzNpuN1NRU57FVq1bx5ZdfcuLECUpLS7HZbHh4eDjPZ2ZmEhISwpEjR5z3sNvtnDx50lmmqKioSp2As/zevXvx8vIiNTUVm83mLJOQkMCOHTuqtNzZ7XbKy8vZsmULRqOxUd+v9qxPnz4YDE34zdhKSJJXg8r/3E6cOIG3t7eLoxFCiMZlNps5ffo0UVFRDU4srOUqxzxzAOjXLxKdW9O1nlS2zPTs2ZOIiAjncXd3d4KDg4mPj0dRFKKjo4mPj3eet9vtREZGEh8fz9atW3nyySd59tlnmThxIj4+PixevJg33njDeU1oaCje3t5V7rF+/Xr0er3zmKenp7POSvn5+YAjwfD19WXv3r1otdoqZebOncuNN95Y7dliYmLQaGQEVUPZbDb27t0r72UFSfJqUPmLxNvbW5I8IUSbU1ZWxpkzZ9BqtWi12gbdS9Wqzt+Zjvs1XZLXrVs39Ho9O3bsIDo6GoDc3FySk5MZM2YMWq2WoKAgTp8+7Xyuw4cPU1JSgkajQavVsnXrViIjI3n66aed9z1x4oQzfsCZIJz/3lx4zM3NDbvdXqVM5ceV7+uF1/Tv35/Dhw/TrVu3Rn5nxIWkq9ZBkjwhhBCtgqenJ9OnT+fRRx8lICCAkJAQnnzyySqtNldccQVvvfUWQ4cOxW63M2fOHPR6vfN8ly5dSEtL46uvvmLQoEH89NNPfPvtt/WOJSoqim3btpGSkoKnpyf+/v61XvPMM88wefJkwsPDueWWW9BoNOzdu5d9+/bxj3/8o94xCFEbac8UQgjRarz66quMHj2a3/3ud4wfP56RI0cyYMAA5/l58+YRHh7O6NGjmTJlCo888gju7u7O89dffz2zZ8/mvvvuo1+/fmzevLlKq15dPfLII2i1Wnr06EFQUBBpaWm1XjNp0iSWLl3KihUrGDRoEEOHDuX1118nMjKy3vULUReKWjktSjgVFBTg4+NDfn6+dNcKIdqcsrIyjh8/TnR0dKOMyfv6njMA/P6doCYdk3cxY8eOpV+/fsyfP7/Z6xYtS+VEl/j4+AYPRWgtLvXzLC15QgghhBBtkCR5QgghhBBtkEy8EEIIcdl0bgq3fRzs0hjWrl3r0vqFaKmkJU8IIYQQog2SJE8IIYQQog2SJE8IIYQQog2SJE8IIYQQog2SJE8IIYQQog2SJE8IIYQQog2SJE8IIYRoBGvXrkVRFPLy8gBYtGgRvr6+Lo1JtG+S5AkhXMJmt7Hz9E5KraWuDkWIehs7diyzZs2qcmz48OFkZGTg4+PjmqCEuIAshiyEaHbbM7bz8o6XSc5NpkdADz6e9DHuevfaLxSiBTMYDISGhro6DCGcpCVPCNFsThSeYNaaWUz/dTrJuckAHMg5wOy1s7HYLC6OTrQGxcXFTJs2DU9PT8LCwpg3b16VVjVFUfjuu++qXOPr68uiRYucn8+ZM4euXbvi7u5OTEwMTz/9NBbLue+/uXPn0q9fPz799FOioqLw8fHhtttuo7CwEIC77rqLdevWsWDBAhRFQVEUUlJSqnXX1uTHH39kwIABGI1GYmJieO6557BarY319ghRhSR5QogmZ7PbWLBzAdd/dz2r0lahVbTc1u02Fl65EJPOxOb0zTyz+Rnsqt3VoYoW7tFHH2XNmjV8++23/Prrr6xdu5bExMR63cPLy4tFixZx4MABFixYwPvvv88bb7xRpczRo0f57rvvWLp0KUuXLmXdunW89NJLACxYsIBhw4Yxc+ZMMjIyyMjIIDw8vNZ6ly9fztSpU3nggQc4cOAA7777LosWLeKFF16oV/xC1JV01wohmtxXh77ig30fADAsbBiPDXqMLn5dAHhtzGs8sPoBlh5bSpB7EA8NeMiVobZ7Oz4pJOE/hbWWC4nTc9NbQVWOfXPfGU4n1d4iO3CaF4P+6FXv2IqKivjwww/5z3/+w4QJEwD45JNP6NSpU73u89RTTzk/joqK4uGHH2bx4sU89thjzuN2u51Fixbh5eWI884772TVqlW88MIL+Pj4YDAYcHd3r1f37AsvvMDjjz/OH//4RwBiYmL4+9//zmOPPcazzz5br2cQoi4kyRNCNCmb3cbnSZ8D8GD/B5neazqKojjPj+40mrnD5/L0pqf5+LePCTYFM7XHVFeF2+6Zi+wUnbbVWs4rVFvtWElu3a41F11ei+3Ro0cxm80MGzbMeczf359u3brV6z5ff/018+fP58iRIxQVFWG1WvH29q5SJioqypngAYSFhZGVlXVZcVdKTExkx44dVVrubDYbZWVllJSU4O4u41JF45IkTwjRpDac2sCJwhN4GbyY0n1KlQSv0g1dbiC7NJsFOxfwyo5X6ODZgSsirnBBtMLgqcEzpHoCdyF3v+qjfdz96natwfPyRgqpqlprGUVRqpU7f7zd1q1bue2223juueeYNGkSPj4+fPXVV8ybN6/KNXq9vtp97faGDSew2+0899xz3HTTTdXOGY3GBt1biJpIkieEaFKfHfgMgN/H/v6SM2in95pOZnEmiw8t5q3dbzEufFyNCaFoWoP+eHldqUC17tvG1qVLF/R6PVu3biUiIgKA3NxckpOTGTNmDABBQUFkZGQ4rzl8+DAlJSXOzzdt2kRkZCRPPvmk81hqamq9YzEYDNhstbdanq9///4cOnSILl261Ls+IS6HJHlCiCZz6OwhtmVuQ6toub377ZcsqygK98ffz3dHvuNw7mH2Ze+jT1CfZopUtAaenp5Mnz6dRx99lICAAEJCQnjyySfRaM61DF5xxRW89dZbDB06FLvdzpw5c6q0ynXp0oW0tDS++uorBg0axE8//cS3335b71iioqLYtm0bKSkpeHp64u/vX+s1zzzzDJMnTyY8PJxbbrkFjUbD3r172bdvH//4xz/qHYMQtZHZtUKIJvPFwS8AuDLiSsI8w2ot7+Pmw8TIiQB8nfx1k8YmWqdXX32V0aNH87vf/Y7x48czcuRIBgwY4Dw/b948wsPDGT16NFOmTOGRRx6pMtbt+uuvZ/bs2dx3333069ePzZs38/TTT9c7jkceeQStVkuPHj0ICgoiLS2t1msmTZrE0qVLWbFiBYMGDWLo0KG8/vrrREZG1rt+IepCUesyyKGdKSgowMfHh/z8/GqDcYUQdXO27CwT/jsBs93Mp1d/Sr/gfnW6bufpnfzxlz9i0plYfctqPA2eTRtoO1RWVsbx48eJjo5uE2PBxo4dS79+/Zg/f76rQxEuZrPZ2LVrF/Hx8Wi1tY8PbQsu9fMsLXlCiCbx30P/xWw30zOgJ32D+tb5uvjgeGJ8Yii1lrLs+LImjFAIIdo2SfKEEI3OYrOw+NBiAKb2mFqvCRSKonBTrGP24f8O/69J4hNCiPZAkjwhRKNbnrqcM6VnCDIFMSlyUr2v/13n36HX6DmQc4ADOQeaIELRlqxdu1a6aoWogSR5QohGpaqqc9mU27rfhl6rr+WK6vyMfoyPGA/A5/uX8HXiSXaknMVik23PhBCirmQJFSFEo9qXvY/9OfsxaAz8vuvvL/s+V3a6jp9Tfub7o0v5PLkvqAY8DFqGxAQwsksgo2IDiQ25vPXchBCiPZAkTwjRqNafXA/AFRFX4G+sfe2wC2Xkl/LO2qN8uaMAfWQAGkMOnTodouTsAM4Wm1l9MIvVBx3bS909IopnJveQRZOFEKIGkuQJIRrV1oytAAzrMKyWktX9uj+T+77YhbmiW7Yjo8nmWyKj9vHpvXNIyixg4+FsNh5xvD7elAIgiZ4QQtRAxuQJIRpNkbmI37J/A2Bo2NB6XXsws4BZi3djttkZFOXHFzOHsOSO+9EpOvZm7+Vo/hF6dvDhL2M68+n0Ibx0U28APt6Uwj+XJdVpX1MhhGhPJMkTQjSaxNOJ2FQb4V7hdPDsUOfrcovNzPxPAiVmGyO6BPDlzKEM7xxIkHsQY8PHAvDdke+qXHProAj+eaMj0Xt/w3Fe/uWQJHpCCHEeSfKEEI2msqt2SNiQOl9jtdn52xc7OXG2lAh/d966vT867blfTdfGXAucG+t3vilDIvj79T0BeGfdUV77VRK9tm7s2LHMmjXL1WEI0SpIkieEaDSVSV59umpfWJbE5qM5uBu0vD9tIH4ehirnh4YNRafoSClIIa2g+v6gdw6LYu51PQD495qjfL6t9j1ERev1zTff8Pe//71OZVNSUlAUhd27dzdtUEK0UJLkCSEaRXZpNkfyjgAwOHRwna5ZknDCOXni9T/0o1to9SVRPA2exIfEA7Dh1IYa73PXiGgendQNgFd+OcjZYnN9wxethL+/P15ezb90jsViafY6hWgoSfKEEI1iW8Y2AOL84/Az+tVafn96Pk9965ikMWt8LFf1CgXAXGKnJNdW5TXEfwQA61I2UJJrozTPVu1+fxoYTa8AHwrKrLy+4lBjPZZoYc7vro2KiuKf//wnf/rTn/Dy8iIiIoL33nvPWTY6OhqA+Ph4FEVh7NixznMff/wxcXFxGI1GunfvzsKFC53nKlsAlyxZwtixYzEajXz22WcsWrQIX19fvvvuO7p27YrRaGTChAmcOHGiWZ5diPqSJVSEEI2ivuPxXvr5IGabnfFxwTxwRSwAa17NJeGTompl8wK6wZ9g+6kdLBh3DE93d+7f3LFKmTUv5THmh0jcu5zmCyWNO4ZEEhfm3cCnakdUFSwlzV+v3h0asPzNvHnz+Pvf/87//d//8fXXX3PvvfcyevRounfvzvbt2xk8eDArV66kZ8+eGAyOoQDvv/8+zz77LG+99Rbx8fHs2rWLmTNn4uHhwR//+EfnvefMmcO8efP4+OOPcXNz49dff6WkpIQXXniBTz75BIPBwF//+lduu+02Nm3a1OC3QojGJkmeEKLBVFWt13i8rcdy2HA4G71W4dnreqLROP7Ih/Qw1FjeJycC94IgSrzPkBm+jy451RNJuxVQYeDRYH6LzOH5Hw/wxcwhsn5eXVlK4J91nxHdaP4vHQwel335Nddcw1//+lfAkZS98cYbrF27lu7duxMUFARAQEAAoaGhzmv+/ve/M2/ePG666SbA0eJ34MAB3n333SpJ3qxZs5xlKlksFt566y2GDHF8D37yySfExcU5E0ohWhJJ8oQQDZZWmEZmcSY6jY744PhLllVVlXm/HgIVbh0UTri/u/Nct4nu7Py8CJOvplrjTo+yoSR4/0jRqF1EnRlT7b4Z+xzj8BS7Qu+TAWwxnmb5/kyu6hXW8AcULVafPn2cHyuKQmhoKFlZWRctf+bMGU6cOMH06dOZOXOm87jVasXHx6dK2YEDB1a7XqfTVTnevXt3fH19SUpKkiRPtDiS5AkhGqxyPF7foL64690vWXZd8hl2HM/l9vVd6Wv24XhQKdEjTABo9QpTvwip8Tq/tAkkrPmR9M4JTH60+nZpf/ggiPevykC1w8CMILbHnOYfPyUxtlswRr22gU/YDujdHa1qrqi3IZfr9VU+VxQFu91+0fKV595//31na1wlrbbq94mHR80tjDW1DkuLsWiJWsXEi4ULFxIdHY3RaGTAgAFs2FDzDLsLbdq0CZ1OR79+/Zo2QCHaubp21Tpa8ZIJy3XHv9BIyopyEv5TfQxeTYaEDUGv0XOy6CQpBSnVzvt00NF5jNHxSb6G/oWBnMwt5cONx+v1LO2Woji6TZv71YTJUeUYPJvt3ESdkJAQOnbsyLFjx+jSpUuVV+VEjUuxWq0kJCQ4Pz906BB5eXl079698R9AiAZq8Une4sWLmTVrFk8++SS7du1i1KhRXH311aSlXXotrPz8fKZNm8aVV17ZTJEK0T7ZVTvbM7cDtSd5y/efZt+pfHpknGuJ63Ft3Vpy3PXuDAgZAMDGUxtrLBN/+7mlNcblOMaXvbX6CJn5ZXWqQ7QtwcHBmEwmfvnlF06fPk1+fj4Ac+fO5cUXX2TBggUkJyezb98+Pv74Y15//fVa76nX67n//vvZtm0bO3fu5O6772bo0KHSVStapBaf5L3++utMnz6dGTNmEBcXx/z58wkPD+ftt9++5HV/+ctfmDJlCsOG1X+TdCFE3R08e5D88nw89B70DOx50XI2u8rrKw6hsSt0P+1YYkVvUogdb6pzXaM6jgJgw8maW/Mjh7rhF+UYhVJ6AEZ5BlFqsfHOuqN1rkO0HTqdjjfffJN3332XDh06cP311wMwY8YMPvjgAxYtWkTv3r0ZM2YMixYtqlNLnru7O3PmzHH+fTGZTHz11VdN/ShCXJYWPSbPbDaTmJjI448/XuX4xIkT2bx580Wv+/jjjzl69CifffYZ//jHP2qtp7y8nPLycufnBQUFlx+0EO1MZVftwJCB6DX6i5b7cU86yaeL6JHnCyWOLrou40wY3Ov+v+aoTqN4NeFVEk4nUGIpqTb+T9EoxN/qyeqX8wAYn9eJDboz/C/xJI9O6oaHW4v+lSfqYO3atc6PU1JSqp2/cHeLGTNmMGPGjGrlpkyZwpQpU2qsIyoq6pLb4910003VZt0K0RK16Ja87OxsbDYbISFVB2KHhISQmZlZ4zWHDx/m8ccf5/PPP0enq9sv9BdffBEfHx/nKzw8vMGxC9FeVE66uFRXrcVmZ/7KZADGl55b367H5PoNuo/yjqKjZ0csdouzi/hCPa/3QG9yJJG56+3EentSWG7lu92n6lWXEEK0dq3i39oLZy2pqlrjTCabzcaUKVN47rnn6Nq1a53v/8QTT/DQQw85Py8oKJBET4iLmXfuZ8+Mws6AOFA0DPl1Bvx8Z42X/FQ2lpTCRwixFsJeC6DF5JZD5LYY2GGtc9UKMMojjK9MAWz4aQpjizOqlTECceEvcvD47+gZ+TUexYd4gSn854elTNlwn2Oc/8MXb6URQoi2okW35AUGBqLVaqu12mVlZVVr3QMoLCwkISGB++67D51Oh06n4/nnn2fPnj3odDpWr15dYz1ubm54e3tXeQkhardXZ6JM0RBgt9DFVn7Rcl+WTQLg1pyT2GyOGbDdY35Aq6l7gldplLkQgI0GLy6Wqo3s/xr33jqY8UOf5Q++32OijEO2KLZbLj5mUIja3HXXXeTl5bk6DCHqrEUneQaDgQEDBrBixYoqx1esWMHw4cOrlff29mbfvn3s3r3b+brnnnvo1q0bu3fvrrYmkhCiYX7TOyZNxFtKuNhCGMesHdhm6Y0GG0EnopzHe8R8d1l1DrIUY1DtpGsNHNO61VjGw5SDQV8MgI+mmBuMawH4T9nky6pTCCFaoxbfXfvQQw9x5513MnDgQIYNG8Z7771HWloa99xzD+Doaj116hT/+c9/0Gg09OrVq8r1wcHBGI3GaseFEA23X+dI8npaSy9aZknZBADGandjKRsBgK9XCmFBuy6rThMqgyzFbDJ4scHgSefSi7cgVrrT9BNfll3F8vJhnLb5U/Nyy0II0ba0+CTv1ltvJScnh+eff56MjAx69erFsmXLiIyMBCAjI6PWNfOEEE3jN51j4sTFkjyLquV/5Y61Kv/g8QuTbniW0zm9KS3zb9AauCPNRWwyeLFV78ldpTmXLFta7oP5+HCG+h1mqyaWL8quYvblVy2EEK1Gi0/yAP761786N6C+0KJFiy557dy5c5k7d27jByVEO5evaDmpdewo0OMiSd4a80DO2P0JVHK50rAdRYHQwH0NrnuwxbFLxk69BxYU9BcZnbcv+Q/8uuWf2O0Grhn0IVtD4Iuyq/ib1Y5B16JHqwghRIPJbzkhxGXZr3NMoAi3leOj1rxX6OKKCRc3G1ejV2w1lrkcsbZy/O1WShUN+3QXX0w52P8AdrsjEdWl9SJIc5Yzdn+W7695CSYhhGhLJMkTQlyWA7WMx8u0BbDG7NiG7AZlS6PWrXCuNW+bvuZN5AGCA34jwOcwAKdOD+E2m2Ph5k+3pDZqPEII0RJJkieEuCy1Tbr4X9kV2NEyWPcb65d9yH9+WMrOA3c1Wv2DzY7Zs9sNnhctoygQ1/lb5+d90j0Yq9nFzSdfIvnI4UaLRbRca9euRVGUFrn0SUpKCoqiVNulQ4jGIkmeEOKynEvyyqqds6sKi8smAnB90XEKisI5ndOHYyfHNVr9QyyOJG+PzkTpRRdwgbiY7wHQKBZCtFksMrzKrbq1ZK38V6PFIlqu4cOHk5GRgY+Pj6tDEaLZtYqJF0KIliVH0ZKhNaCoKnE1tORttfQmzR6Gl1KMX1oM6RXH4zp/12gxhNvNhNrMZGoN7Na7M6wi6buQr9cJunRazqAun9Ep8NyyLT6nt2K3q2g0DZjmK1o8g8FAaGioq8MQwiWkJU8IUW+V4/GibOV41jDpwtmKp1/P0ZSrAdDrSoiNWN5oMTjG5TkSu236i3fZYtUyedATdArcRbnFk+TTowDobj/CnmMnGy0e0TzGjh3L/fffz6xZs/Dz8yMkJIT33nuP4uJi7r77bry8vOjcuTM///wzUL279k9/+hN9+vShvNyxvqLFYmHAgAHccccdwLku1CVLljBq1ChMJhODBg0iOTmZHTt2MHDgQDw9Pbnqqqs4c+aMMy673c7zzz9Pp06dcHNzo1+/fvzyyy9VYt++fTvx8fEYjUYGDhzIrl2Xt1akEHUlSZ4Qot4u1VWbZ/fk53LHjjRjcwopM/sC0CViOQZ9SaPGUdllu72myRcqUO4GpR7otWZO58bxn5VLWJX4LGd1oegVG/u3/tqo8bRmqqpSYilp9peq1n8f4U8++YTAwEC2b9/O/fffz7333sstt9zC8OHD2blzJ5MmTeLOO++kpKT699ubb75JcXExjz/+OABPP/002dnZLFy4sEq5Z599lqeeeoqdO3ei0+m4/fbbeeyxx1iwYAEbNmzg6NGjPPPMM87yCxYsYN68ebz22mvs3buXSZMm8bvf/Y7Dhx1jP4uLi5k8eTLdunUjMTGRuXPn8sgjj9T72YWoD+muFULU26UmXfxcPgIzBuK0xyhOHeo83uO8CRCNpXKG7X6diUJFg1dlq6JdgTIT2Cp+xenNbDl8N3nFEQAUegzDP/9b7MfWY7f/SbpsgVJrKUO+aP6tH7dN2Ya73r1e1/Tt25ennnoKcOx69NJLLxEYGMjMmTMBeOaZZ3j77bfZu3dvtWs9PT357LPPGDNmDF5eXsybN49Vq1ZVG7P3yCOPMGmSYwmgBx98kNtvv51Vq1YxYoRj15bp06dXWaf1tddeY86cOdx2220AvPzyy6xZs4b58+fz73//m88//xybzcZHH32Eu7s7PXv25OTJk9x77731enYh6kNa8oQQ9Xap5VN+KR8GwGTNdo6eGA+AuzGbqA4bGj2OULuVKGs5dkUhsbI1z6qFEo+KBE8FYwkYy+ges5SQgL2MG/wcgQMcu3D0se4lITW30eMSTatPnz7Oj7VaLQEBAfTu3dt5LCTEsXFdVlZWjdcPGzaMRx55hL///e88/PDDjB49+pJ1VN7vwjoq719QUEB6erozAaw0YsQIkpKSAEhKSqJv3764u59LaIcNG1a3BxbiMklLnhCiXrI0OrK0ejSqSrcLkrx8uwebLX0BiMs0kWhzLJjcPfpHNJrGWwz5fIMtRaTo3Nim82BsoRnMBkABjQ1MpaBxtO51i1pK9+iljov6zoXV0Fs5zsu7khkcPfSi928vTDoT26Zsc0m99aXX66t8rihKlWNKxZ55dnvNi3Tb7XY2bdqEVqt1dqdeqo7K+1147ML7Kxfs1aeqqvPY5XRLC9FQ0pInhKiXyla8GFs57hdsJ7bGPAgLerpqUzmTcoXzeFwTdNVWqpx8sV3nBWY3QAG9GdyLnQkeUHWvXJ9OlHhGoFVUsvevwWaXP8CKouCud2/214WJUXN49dVXSUpKYt26dSxfvpyPP/64Qffz9vamQ4cObNy4scrxzZs3ExcXB0CPHj3Ys2cPpaXn/jHaunVrg+oVojaS5Akh6uVS4/Equ2on6bfipi9AozHj63WcsMDdTRbPoFLH5I9kgxtnNYqze/YSS+cB4BbrWLOvR/keth8/22TxiZZl9+7dPPPMM3z44YeMGDGCBQsW8OCDD3Ls2LEG3ffRRx/l5ZdfZvHixRw6dIjHH3+c3bt38+CDDwIwZcoUNBoN06dP58CBAyxbtozXXnutMR5JiIuS7lohRL1cLMkrVd1YW7GN2VWmjfS88lNKy3zJLwqnSRprVMBswN/sRtdyM8luBrb7KlxlsV76MhVO7zeTs78/PfmEYZoDfLkvnWGdA5ogSNGSlJWVcccdd3DXXXdx3XXXAY4JFD/99BN33nkn69evv+x7P/DAAxQUFPDwww+TlZVFjx49+OGHH4iNjQUcEz5+/PFH7rnnHuLj4+nRowcvv/wyN998c6M8mxA1UVQZKFBNQUEBPj4+5Ofn4+3t7epwhGgxVFVl7KIenNXo+CLvKL3PS/R+KR/GPQVPEq7JZL3/jKZJ7CpdMHv25UBvPvPy5ZbSszxTnH7JS7fu+Rsbds7Bw3iGv04eh11VGK/7iF//7wZ02vbRuVFWVsbx48eJjo7GaDS6OhwhGo3NZmPXrl3Ex8ej1WpdHU6zuNTPc/v4jSaEaBSZxZmc1ejQqSpdL1gjb3lFV+1VbpubNsGrNnu2lKH2fAC2G2pYL+8C0Z3WAlBcFkS+OQaNohJbule6bIUQbY4keUKIOtufsx+AWFsZbudNujCrOlaaBwMwsuwkNpu+xusbRAXKDVDqDqrGMXvWvRj0FgZYi9GqKqlaNzI1l6472H8/ATGOFsBjJwYBMFRzgB/3ZjR+zEII4UKS5Akh6qwyyetxwXi8LZY+FKqeBClnSVo9l4WLE1i55XkabTCIXXEkd2YjoICuYvas1jF71lO1O8cIbqtp94vzKAr0mOwok5blSEyHaQ7wy28ZWG01L7khhBCtkSR5Qog625/tSPJ6WqomeZWzaq8uOElhcSfKyv3IK4xsnG7bGrpnMVWfPXtuH9vau2zjrnUsSHvijKMlr7vmBEpJDluO5TRCwEII0TJIkieEqBNVVZ0teefPrLWpGlaUOxYT7nwq0Hm8wduYXaJ7tiZDK7Y426r3pLYGRJ+OOjr2N1Bq9udMvmP241DNAVYl1bxDQlsl8+6EaP0u9XMsSZ4Qok5OFp2kwFyAXrUTayt3Hk+0xJGt+uFrLyY/zZHs6XXFdIlYfvmV1dI9W5N+lhKMqp0zWj1HtW61VnGuy9bRmjdMc4DVB7PaReJTuXNDSUmJiyMRQjRU5c/xhTvBgKyTJ4Soo4NnDwIQay1Hf15b2S/miq7as2cor/i4S8RyDPrqiyXXiVXrWB5F1QAquJU5Wu9qW9wYlf6WYjYbvNiq96TLeYloTbpNMrHqn7mcODOYAbFfMFx7gKfPlnA8u5iYIM/Li72V0Gq1+Pr6OvdedXd3zc4TQjQ2m82xfWJZWVmbX0JFVVVKSkrIysrC19e3xueVJE8IUSfJuckAdLOdWzpFVWF5+XAAok8FkV9xvOfldNVWLG7s3JpMY3OMv7tE692FhlmK2GzwYovBg6lllx5fZ/LREjPaxIkNg1BVhc5KOkHksubQmTaf5AGEhoYCOBM9IdoCu91OdnY2KSkpaDTto7PS19fX+fN8IUnyhBB1kny2Isk7bzzefmtnTtmD8bZYKDrVHwB34xkiO2ys8R4XpSpQaoTKpVd0FkeCV8/GpaHmYvCAHXoPLEBtC7n0vtEDvSkMs3cv3Ar3MUxzgDUHY5k+Mrp+FbdCiqIQFhZGcHAwFkvN4xyFaG2Kioq49tprSUhIwNOz7f+zptfrL9liKUmeEKJOKlvyup7XDbrGPBCAiWcKsdkd4+C6R/+IRmOr+41tWiitf/dsTbrayvC3Wzmr0bFX584A66XHnHUZZ6LLOBMsHwNbHEneM8dHUlxuxcOtffx61Gq1bb5bS7QfZrOZ1NRUDAaD7OaCTLwQQtRBsaWYk0UnAYg9b6eL9WZH6134yXNdBT06f1O3m1Z2z5ZUzJ5VKmbPGi4vwQPHL7QhlbNsDfX4Lz5qFACj9ElYbCqbjmRfXgBCCNGCSJInhKjV4dzDAAS7B+OrOlrpCuzu7LR2BxU6B2/Byz0dP+9jhAburf2GKo7Wu/LK2bMW8Lj07Nm6Gmp2rJe3RV+PJC9yGCgaOqmZhJHDmkNnGhyHEEK4WvvojxBCNIizq9avK6StBmCzpS82tMToTjB50LOoA+dSWBxW+wLIjdg9W5NhFS15v+lMFCoavNTaE0ez3Qubex9MxbsZpSax9lBHVFWVGadCiFZNWvKEELWqkuRVWGceAMBowy4AFEXF2zP94jep1j1rb3D3bE3C7BYibeXYFIUdddj9AmDLOwXs3enoep5kOUxGfhmHThc2XlBCCOECkuQJIWp1YZKnqufG443RJ9Z+AxXH2ndVumeLGqV7tiZDzed2v6iL7te4O/exHWD4DYA1B6XLVgjRukmSJ4S4JFVVqyV5R22dOGUPJiLHQE9LLZMUbBoo9gSrHkf3bOllLY9SH5VdtnUdlxfcTU+ZzyBsdh2+xgy6l51lzSFZP04I0bpJkieEuKT04nSKLcXoNDqifKIAWGfuDypM2t2JT/67jiXLP8Nuv+DXiQqY9VDi0aTdszUZZClGo6qk6NzI1NS2Wp5jzbjYq4PJzO0JwHVFx0lMzSW/VNaPE0K0XpLkCSEuqXIR5M4+ndFXJEzrzAPocNYDQ6knoEGrsaDRnNf16uyeNdEc3bMX8lbt9KpYtHlLHcflxV17rst2pCYJm01l42FZSkUI0XpJkieEuCTndmb+3QAoUw1ss/Si6ylfZ5m4mO/OXVCte7asybtnazK0nl22Ph10lPqOACDGN5HAAiOrD0qXrRCi9ZIkTwhxSReOx9tu6YnFZiQ2wxsAva6YLhG/XqJ71tzsCR6cm3yxzeBJXdsPA8aNxGrT4+V+mjHZRaxLzsJuV5suSCGEaEKS5AkhLqkyyYv1iwUcXbWRWV4YLI6u29jI5Rh0pS7tnq1JP2spJtXOWY2Ow9q6bW/U9Wp/MnL7AjDOdoicQjP7TuU3ZZhCCNFkJMkTQlxUqbWUtMI04FxL3npzPN1O+TnL9Iv9DIo9XN49eyE9KgMsjt0vNtdxizOTj5Yij+EAdPZLJDjPnY2yxZkQopWSJE8IcVFH845iV+34G/0JNAWSnldKalk0UVlegMqgrh/SwfMQqNqK7tkSl3XP1mSk2bGg8VqDV52v8R05DoDI6B2c9itm81FJ8oQQrZMkeUKIi7pwPN765DN0zvDFqCll8uDHGNvnDRQU0FZ2z9pcGW41V1Qkebt17uQo2jpdE3b1CNAZcbfm0EU5RUJKLmWWlvVcQghRF5LkCSEu6sIkb13yGcbmnWHalX8gLuJnVBVH96zJ9d2zNQmzW4izlmJXFNbXtTVP5wbhjqVUJpqSKbfa2ZmW24RRCiFE05AkTwhxUecneVabnaAjS5g1cDr+XqkUlQW4dPZsXY0rLwBgtcG77hdFjQZgoofj+TcfyWn0uIQQoqlJkieEqNGF25kl797E87yDm8aMqrVi9E1H0bX8bswrzI4kb4vBk5K6ZqPRowDoXrCXWzbEsOWgJHlCiNZHkjwhRI2ySrLIL89Hq2iJ8Y2hYO9SAParESimEnT6chdHWDddbeV0tJkpVzRsqeMsWzr0x4YJo5JHT06Rv8tOYZlscSaEaF0kyRNC1KiyFS/aJxo3rRuemVsBKNLqW3T37IUUYJy5nl22OgPlAUMACA/aTlSGN9uPn22iCIUQomlIkieEqNH5iyCXl5UQW3oAgBDtGVeGdVkqZ9muM3hhreM1xj5jAIgI2kHUaW82H5IuWyFE6yJJnhCiRodyDwGO8XhHd67FTWOmuCyAX35YgtXq5uLo6ifeUoyP3Uq+RscunXudrtF0diR54UEJGK2QtLG4KUMUQohGJ0meEKJGh3MPA44kL3/XagDSsgbj6Z6FTtc6xuNV0gFjKlrzVrvVscs2rC82rSdGQwHBvgfRH9CTU9S6nlsI0b5JkieEqMZsM3M8/zjgSPKC0rcDkHZmMDGd1rgytMtWOct2jcEbVVVrv0CrQ4l0bHEWEbyd6NPebJYtzoQQrYgkeUKIao7lH8Om2vA2eOODO1Ha/UBlkrfaxdFdnmHmItxUO6e0Bud4w9poujjWywsP2o5HuZ7ta/ObMkQhhGhUkuQJIaqp7KqN9YvlyPbV6DRWCktCsBijCAn4zcXRXR53VIaZiwBYc6KOrZFRjvXyOgXuRFGsnNlS12kbQgjhepLkCSGqcSZ5vrEUb1sLOFrxoke6oyh16OpsoSq7bFen1bE1MrQ3qpsPbvpiQv0O4Jtm4lReaRNGKIQQjUeSPCFENYfzzrXkhebuAByTLmLGGF0ZVoONNheiqCpJZ5PILM6s/QKNFiVqJACmEWv434gjMi5PCNFqSJInhKimsiWvkyGEcLckAE6cHUzU0Nad5AWoNuKtJQD8mvJr3S6q2OKsf/BeLDo7m4/KenlCiNZBkjwhRBX55fmcLjkNgDUhFa3GRl5xR7zjYnDzav2/Mq4ud0ye+PbIt3WbZVsxLi+iaC96rGw+ml2364QQwsVa/29sIUSjOpp3FIBQj1DcTm0DIDV3EDGjWncrXqVry/Mwao0cyTvCnjN7ar8guAeY/NHaShmgO87pgnKOnpGFkYUQLZ8keUKIKs6fdOFf5EjyyiYPYcBUL1eG1Wi8VDtXRV8FwH+T/1v7BRqNs8t2ij2NCTvDWbVIumyFEC2fJHlCiCoqJ11EuncixnIEgIiBV6HVK64Mq1H9vuvvAViespz88jqsfVfRZds37ze6pvuRtV6WUhFCtHyS5AkhqqhsyfPKLkarqJxQOhDWKcbFUTWuPoF9iPWLpdxWzk/Hfqr9gmjHosgdA3eh1ZSjT9NhLrU3cZRCCNEwkuQJIZxUVXW25IUcSQUg3XegK0NqEoqicHPszQB8ffjr2idSBHYFzxB0GjMdAvagtWvYva6gGSIVQojLJ0meEMLpdMlpCs2FaBUtg04dBCB336g2OZt0csxk3LRuHM49zN7svZcurChQsV5eRJBjH99dKwubOkQhhGgQSfKEEE5H8hxj8DroOxDh5WjRK9GNQFHazni8Sj5uPkyKmgTA18lf135Bxbi88IokL2e3jMsTQrRskuQJIZwqx+MF5ZoAyM7vTPTYSFeG1KQqJ2D8cvwXCs21tMxVjMvrELAXnbYUfaaO4hxbU4cohBCXTZI8IYRTZUte1FnH/qyO/Wrbxvp4NekX1I/OPp0ps5XVPgHDPwa8OqDVWOkYsBuAPWuky1YI0XJJkieEcKpsyYu3pgNwyjwY3046V4bUpBRFcbbmfZ1cywQMRXGul1fZZbtvtSR5QoiWS5I8IQQAVrvVudtFf90JAJTYEa4MqVlc1/k6DBoDh3IPsS9736ULV25xFuxI8vJ229vkpBQhRNsgSZ4QAoAThScw280Y7Do6Wa1k5XUjdmy4q8Nqcj5uPs4dMBbuXnjpwhUteWH++9kdd5wdozOaOjwhhLhskuQJIYBzXbWdit3QAGlnBhE5pO2OxzvfPX3uQafRsSl9E1vSt1y8oF8U+EagUazoYjeSQA5ni83NFqcQQtSHJHlCCODcdmbdLMUApCuDMXq3j18R4d7h3NrtVgDeSHwDu3qJ3SyiHLNsr/F0vF87UnKbPD4hhLgc7eM3uBCiVkdyHTNre6m52FUN2h5tfzze+f7c58946j1JOpvEsuPLLl6wost2hC4JgO3HzzZHeEIIUW+S5AkhgHMtebFmM0lEM+YvUa4NqJn5G/35U68/AfCvnf/CbLtIN2zF5IuOJYeILLSR/r2FM8nSZSuEaHkkyRNCUGotJa0gDYBYi4U0nwF4BrTdpVMuZmqPqQSbgkkvTufLg1/WXMinI/jHoGDnweR8Om/1Z9/PRc0bqBBC1EGrSPIWLlxIdHQ0RqORAQMGsGHDhouW3bhxIyNGjCAgIACTyUT37t154403mjFaIVqfY/nHUFHxsakE2OzYK1qr2huTzsR98fcB8N7e98gvz6+5YOVSKhXr5R1cX9Is8QkhRH20+CRv8eLFzJo1iyeffJJdu3YxatQorr76atLS0mos7+HhwX333cf69etJSkriqaee4qmnnuK9995r5siFaD0qZ9Z2NZdjUzV06DPOxRG5zu86/44uvl0oMBfw4W8f1lyoYouzTmHbACg6bKe88BKTNYQQwgVafJL3+uuvM336dGbMmEFcXBzz588nPDyct99+u8by8fHx3H777fTs2ZOoqCimTp3KpEmTLtn6J0R7V5nkxZotpBbHERsc5uKIXEer0TJ7wGwAPj/wOaeKTlUvFDUSgBDPZIz6fBS7QtqO8uYMUwghatWikzyz2UxiYiITJ06scnzixIls3ry5TvfYtWsXmzdvZsyYMRctU15eTkFBQZWXEO3J4bOOmbWxFjOZmcPw8NK6OCLXGtVxFINDB2O2m/m/Df+H1W6tWsArFAK7oigq4UE7ADi6UbpshRAtS4tO8rKzs7HZbISEhFQ5HhISQmZm5iWv7dSpE25ubgwcOJC//e1vzJgx46JlX3zxRXx8fJyv8PC2v8q/EOc7lJ0MQBezhVOeA1EUxcURuZaiKMwdPhdPvSc7s3by9p4aeg4qxuV1qtji7Mim0uYMUQghatWik7xKF/7BUVW11j9CGzZsICEhgXfeeYf58+fz5ZcXmSkHPPHEE+Tn5ztfJ06caJS4hWgN8sryOGvNBiCmTMUYP9TFEbUM4V7hPDvsWQDe3/s+2zK2VS1QsV5eRAdHkld6SqUg44IWPyGEcKEWneQFBgai1WqrtdplZWVVa927UHR0NL1792bmzJnMnj2buXPnXrSsm5sb3t7eVV5CtBeV6+N1sFjJz+7DsMkdXBxRy3FV9FXcHHszKiqPb3icnNKccycrWvKC3Y9gMjgWRE7dUuaKMIUQokYtOskzGAwMGDCAFStWVDm+YsUKhg8fXuf7qKpKebkMihaiJvvTDwLQ1WzmaFF/gjq6uTiilmXO4DnE+MSQXZrNk5uePLflmUcgBPcEcI7LO75ZkjwhRMvRopM8gIceeogPPviAjz76iKSkJGbPnk1aWhr33HMP4OhqnTZtmrP8v//9b3788UcOHz7M4cOH+fjjj3nttdeYOnWqqx5BiBZt9xHH9lzdzBZOeQ92cTQtj0ln4rUxr+GmdWPTqU38Z/9/zp2s6LIN67CVwx3yMMW7KEghhKhBi1/S/tZbbyUnJ4fnn3+ejIwMevXqxbJly4iMjAQgIyOjypp5drudJ554guPHj6PT6ejcuTMvvfQSf/nLX1z1CEK0aEfy9oEbdC5TKR0sSV5NYv1imTN4Ds9veZ4FOxfQN7gv8cHxji7bbe/QqfNWfg25kRHRXkCgq8MVQggAFFVVVVcH0dIUFBTg4+NDfn6+jM8TbZrNbmPQogFYtDbe2RNI7P/9QnBgLd2189rAzNuH6/9rT1VVHlv/GL+k/IK/0Z8vrv2Cjlp3eDkaUBlc9m8G9+nBW1P6N368Qog6kb/fVbX47lohRNNJPpmCRWvDaLdTmDuo9gSvHVMUheeGP0ecfxxny85y36r7KNYZILQ3AEM1B0hIyUX+bxZCtBSS5AnRjqXZHDNru1gsnOghA8pq4653580r3iTQFMiRvCPMWT8HW8Us2xHaA2SfLWfH8nys5ZLoCSFcT5I8Idqx5JOOnWNiym34jx3i4mhah1CPUN4c9yZuWjfWnVzHfI1jh5xxajIzfu3JukcKObVLZvMLIVxPkjwh2rFDp3cBYCgPYED0pdeeFOf0DurNP0b8A4BFGev41suTYN0pfN1OA5Ai6+UJIVoASfKEaMcOFZ0EoMwWS2SAu4ujaV2uir6Ke/veC8DzAf7scTMQEeTY/UIWRRZCtASS5AnRTq3/5CSZimMbLnf3ce1+v9rLcU/fe5gQOQGrAnOCAvGM2AjA6SQLJbk2F0cnhGjvJMkTop06sO9nAEIsNkI6jHZxNK2TRtHw3PDn6Ojmzym9jq977kVFBRXStsm4PCGEa0mSJ0Q7ZC6xc0bdAEDHIk8GDQpycUStl5fBi1dHv4JOVVnjreXUgK8A6bIVQrieJHlCtEOndpaTH+xYPsVY2JGeHXxcHFHr1rvDEB6wOxZe3TD6C/IC0kjZUiZr5gkhXEqSPCHaodTNhaT75AKganpj0Mmvgob6Y8RVjCgpxaKzsf66FzmbVUJemtXVYQkh2jH5zS5EO1SwJ4EjbloAgrqOdHE0bYMmZjT/OJODv9VOXlAqCWM/kKVUhBAuJUmeEO1MUbYNi2YlpRoNervCuF69XR1S2xA+hEBFx4tnsgFIjv+JQ7pEFwclhGjPJMkTop1J21qGOdyRfPgVezMoMtDFEbURehN0GsTwsjI650QA8I3bQuyq3cWBCSHaK0nyhGhnUrcUkBN4AgCdLRIfd72LI2pDKvaxvS2/HOxGks4m8dOxn1wclBCivZIkT4h2RFVVyg4kcNToWPjYN6iPiyNqY6IdSd6VJFOePRaAN3e9SZlVxuYJIZqfJHlCtCOKonD19N84ZHC03g3q1MPFEbUxnQaBzkiQkk94bhTe+iAyizP5POlzV0cmhGiHJMkTop2xnFnPCb0jyZvUpb+Lo2ljdG4QPhiAW7PT6blyKgDv7/2A3LJcV0YmhGiHdK4OQAjRjCxlHD29B8IC0No86BXWwdURuca8Jtynt9wAGOln3Eve6j9zqPsPnA05yruLevB4cWbj1vWwLLYshLg4ackToj05uZ3DFfMsvLXRKEoTJjvtlc4GQDef3SjAgLXTAVhsDCBNY3BhYEKI9kaSPCHaicz9Zo5/voJkgyPRiPGNdXFEbZTGBqj4aAsI8EkmLK0fUWlxWBWF+R4hro5OCNGOSJInRDtxZHUp+swNJFdOuujQ08URtVEKoHW05vlHbAKg96r70agqK9x8OKg1ujA4IUR7IkmeEO3Eia1nCfXfx2G9oyVvXHQ/1wbUlmkde9Z2DN0GgF92FENyvAFYbPR3WVhCiPZFkjwh2oGyAju609s4bVAp1GpQVC2xfjGuDqvt0jmSvO5eu1FwtOr13j8agJ+MvhQq8qtXCNH05DeNEO1A2vYywgO3c7BiPJ6fPgK9Vna6aDIaOyoqXpoS/AMOAKDs+z2drWWUKhp+dPN1bXxCiHZBkjwh2oHULWVEBO3gQEWS19Wvu4sjauMUUCq6bH0jHePySktDuOasI7FeYvRHFj8RQjQ1SfKEaAdObcsh1G8/SW6OJG94eF8XR9QOVCylEh603fGptoyBJ6MwqXaO6owk6txdGZ0Qoh2QJE+INi7/lBWvsm1oNDb26x0zO/uH9nJxVO1ARUtenOc+1g3dyX2396Z/xM9cU54HwBKTTMAQQjQtSfKEaONStpQREbydM1oNZ/UKoNDVr6urw2r7KsbleSql6IJSSNf4AXBr6VkAVhi8yVa0roxQCNHGSZInRBuXuqWM8KAdJFWMxwtyi8CkM7k4qnZAAaVilu0wzQESLXEAxNnK6GMpwapo+M7o58oIhRBtnCR5QrRx8TdZCfFL4kDFeLxegT1cHFE7UrEo8jDNfhIs5973P5Q5WvP+a/SvWGBFCCEanyR5QrRx4f4JKKgk6B2L8Q4Mk/F4zaZiXN5ATTJnDo/nu9Xv8N/lnzKpPB9vu5V0rYFNek8XBymEaKskyROirUvZAOCcWdsjQFrymo3Gjh1wV8qJP2vhcOo1pKSPQi335oaKCRiLZQKGEKKJNFqSp6oqZ86c4cCBAyQmJpKamkpJSUlj3V4IcbmObyBXo6FAX7ELg7+skddsFNDoLAAEhW+qOKghLWMEf6iYgLFB70WmRhamFkI0Pl1DLj58+DCLFy9m/fr1bNmypcakLjY2llGjRjFx4kRuuOEG9Hr5ZSZEc7CU2Un+/gQ9s/aTZHQsnRJi6oSnQboHm5XWClY9nf0TSKk4lHJqFJOiltHfUsxOvQcrDd5MLctxZZRCiDboslry/vvf/zJmzBi6d+/Os88+y8qVKykuLkZRFHx9fQkLC8PNzQ1VVUlOTubDDz/ktttuo0OHDjz88MOcOnWqsZ9DCHGBk4lmjny0EoAtmhAA+gb3dGVI7VPF5IuebgdRdI5/hFPTRwEwobwAgJVu3q6JTQjRptUryVu1ahWDBg3itttuY8OGDfTp04f/+7//4/vvvyc9PR2LxUJOTg4nT56kpKSE0tJSEhISWLhwIbfffjtms5k33niDrl278sQTT5Cfn99UzyVEu5e6pYyI4G0AJBgcSURPmVnb/DR2rCi4KRaMkY7dL/KLIsgtiORKsyPJ26lzlzXzhBCNrl7dtRMmTMDHx4c5c+bwxz/+kW7dul2yvJubG/3796d///7cc889lJeX8+OPP/Kvf/2Ll19+GZPJxDPPPNOgBxBC1CxlSxnXVSQVR90drUlx/nGuDKl9UkCrM4NVT1DHraQdHQs4WvP6eX9GL0sJv+ndWWPw5pbyXNfGKoRoU+rVkvfcc8+RkpLCP//5z1oTvJq4ubnx+9//nnXr1rFu3Tri4+PrfQ8hRO2Ks22UpKYT4H2cfDSUuhUBkuS5ilKxlEqs707nsZT0kQDO1jzpshVCNLZ6teQ9/fTTjVbxqFGjGu1eQoiqUrc5drkAWE8UYCXUPQxfo68rw2q/dFYoh176Q6w25qGW+ZKWMQK7XcP48gIWeISyXe9JvqLBR7W7OlohRBsh6+QJ0QalbikjIsjRVbvazTHpQsbjuZCiUo4Wg2LDFLUFgHKzD6dzehFlN9PFWoZVUVhnkNY8IUTjadASKgDPP/88ALfffjuxsbGXLLto0SLS0tJkHJ4QTUhVVVK3lDM03jHpYpeH48dc1sdzIee4PC1e4dvp7rWfvp1+JsDnMADjzQUc0RlZafDmdxWLJAshREM1uCVv7ty5PPfccwwZMoRff/31kmU//PBDnnvuuYZWKYS4hLPHrVBwEj/PE9hVDTlGx7IdstOFa+l0ZgB6eu2moMteAn0PoyiOc+PLHSsNbDZ4UiIdLEKIRtIov02MRiN5eXlce+21zJs3rzFuKYS4TOd31e4vj0U1ZAMy6cLlKiZf9FGOsddStdejq62ccFs55YqGDbJYtRCikTRKkjdgwAC++OIL9Ho9jz32GHfeeSfl5eWNcWshRD15hWqJ6+WYxfmjIQJFUQk0BRLkHuTiyNo5jUoJevSKDbPVWOWUAoyXhZGFEI2s0foFbrvtNjZu3EjHjh354osvGD16NOnp6Y11eyFEHcVeYSI6zNGSt8HD0SokrXgtg1Kxj22Ems3BjNFs3PUQO5OmAY5xeQDr9V6Uo7gsRiFE29Gogz/69+9PYmIiI0aMYMeOHQwaNIitW7c2ZhVCiNrkpkD+CWxoSTM6luOIC5AkryUw6UoBGK5J4sfln7Bl9yz2HJwKQC9rKcE2CyUaLVuky1YI0QgafYRvUFAQq1ev5s9//jMZGRmMGzeOjz76qLGrEUJcTMoGAPbRBdWYCUAPf5l00SJUjMvroTmOIdAxszY7rztFJcFoONeat1KWUhFCNIImmcal0+l45513+Pe//43dbmfmzJk88MADWK3WpqhOCFEh+4gF9ZgjyVtj64bG7TQgLXkthkalECNaRcUj4lwvR2rF7heVSd4agxcWlwQohGhLmnSu/r333svKlSsJDAzk3//+N9u3b2/K6oRo18oL7Sy6OYPihLUArNWHoih2/Nz8CPMIc21wwsmudewj7B2Y5DyWku7YAai/pRhfu5UCjY69OneXxCeEaDuafEGmUaNGsWPHDvr27Yuqqk1dnRDtVtqOcnxNqXgas7CqepLdHIP3+wT1QVFkIH9L4aVztNb1dP8NjdYxRi81fSSqClpgqMWxz7CMyxNCNFSDkzy73c769esvWSYiIoLNmzezZs0aVq9e3dAqhRA1SN1SRkSwY5eLZGscqskxu713YG9XhiUuoNE5hq3EadIwddgLQHFpCDl5XQEYZi4GYItekjwhRMM029LqRqORMWPGMGbMmOaqUoh2JeW8RZBX2LuiNaUBjpY80YJoVM7igUZR8eq0w3m4sst2WEVL3m86EwWK7H4hhLh88htEiDagIMNKboqF8CBH0rBWG43GkIuCQq/AXi6OTlzIonF0n3v4H3Eeq5x8EWa3EGUtx64obJfWPCFEA9QrybvmmmvYtm1bgystLi7mpZdeYuHChQ2+lxDC0VUb4H0UD+NZLKobSUYtADE+MXgZvFwcnbiQn+EsAD3cDmE0ObadO5E5FJtND5xrzdui93BNgEKINqFeSd6GDRsYPnw448eP59NPP6WwsLBele3atYtHHnmEyMhInnzySdn6TIhGkrKl3NlVe4ie2CvG40lXbctk0Dp+93XXnMC38yr6dP2Cq0c+4jw/XCZfCCEaga4+hY8dO8bcuXP54IMPWLNmDW5ubowcOZLBgwczYMAAwsLC8Pf3x83Njby8PM6ePUtSUhIJCQls3LiRo0ePoqoqcXFxfPTRR/zud79rqucSot1Q7SqpW8uY2N3Ryv6rLRat6QQgSV6LpVHJwptgCtB2X8skr5+qnB5kKUanqpzQunFSo6eTXVbNE0LUX72SvKCgIP7973/zyCOP8M477/DJJ5+wcuVKVq5cecklGlRVRVEUrrjiCv785z9z8803o9HIcEAhGkPWIQuluVbCAxMA2GDrhs60E5CZtS1ZqUYHdvCymaud81Dt9LGWsFPvwRa9J7eU57ogQiFEa1evJK9SdHQ0L7/8Mi+88AJr1qxh/fr1bN68mdTUVLKzsykrK8Pf35/g4GD69evHyJEjmTBhApGRkY0dvxDtXvEZG5ExRzC55WPGnd8Mnhg15Zh0Jrr4dnF1eOIi/PRnoRx6KGnk2z3w0RRXOT/UXORI8gyS5AkhLs9lJXnOi3U6JkyYwIQJExorHiFEPcWMNhGtS4Jf4aChF2jOrY+n1WhdHJ24GG99AfYyHzprMthojmUAKaRmjMTXK5XQwH0MtxSxkBC26T2w4VgoWQgh6qNBSZ4QomVQUjYCsMLcFY2fY3086apt4RTIUPzoyFnOnu3KW8u/AzT07fYpoYH76Gktxctuo0Cj44DORG9rqasjFkK0MjIwTojWzmaF1E0ArC3vjt5dJl20FkUax5Ip7qYsNBrHThipFYsi64DBzqVUZJatEKL+Gi3JKy8v55NPPmHKlCkMHDiQbt26MXDgQKZMmcKiRYsoKytrrKqEEBXsVhUy90B5AWadF/uVUBR9FiBJXmvgp88DIFZzktCg3QDkFUaRVxgOnFtKZbMspSKEuAyN0l27efNmpk6dSmpqKqqqVjm3c+dOFi9ezHPPPcdnn33GiBEjGqNKIVqfeRefgX65Pv/xB3pG/ED/GDhk8UcxpoOi0sFmJnBhUKPXJxpXkO4M1jJfIjVZ7O24nfTTgwFHa55vty+c+9ju0ZkoQYM7dleGK4RoZRrckrd//34mTJhASkoKISEhPPXUU3z++eesXLmSL774gqeffpqwsDBSU1OZOHEiv/32W2PELUS7V1LmT2Z2P3zdHRMtVtviz+1Xay1xZWiijhQNnCQQAEPIQefxyn1sw+1mOtrMWBUNCXp3l8QohGi9GtyS99RTT1FaWsrUqVP58MMP0ev1NZaZMWMGn376Kc888wzffPNNQ6sVot1LTR+BRrHQKTARgF9sQ9Ca1gDQxyKD9FuLQo0bqGAyZeNmyKfc7ENaxnDsdg0ajZ1h5iK+NvmzxeDJ6IruWyGEqIsGt+StX78eb29v3nvvvRoTPAC9Xs+7776Lt7c3a9eubWiVQggcG9qH+v+GQVdKmd2Ng2onDKYUQFryWhPvinF5nZUMwsM2A1BW7kfW2V7AeVucyeQLIUQ9NTjJM5vNdOvWDaPReMlyRqORbt26YbHI9jxCNJSqOsZtVe5Xe0QJBX0edl0ZOtVOd6tMdGotOukzsKgaOio5+HTY7jxe2WU72FKERlU5qjOSpZFVr4QQddfgJC8uLo6TJ0/WqeyJEyfo2bNnQ6sUot3LLYimoLgTEUE7AFhj7+vcrzbOWoYb6qUuFy2IVmMnhRDHx0HHnMdTT40EwEe1083mSNp36mRcnhCi7hqc5M2aNYuMjAwWLFhwyXJvvvkmmZmZzJo1q6FVCtHupaSPQqsx0yFwFwDfW0fKpItWLF/j6Akx6grx9TpOh6AEIjtsdJ4fYHHMsk3Qe7gkPiFE69TgJG/KlCm8/PLLzJkzh5tuuomVK1dy6tQpLBYL6enprFq1iptvvpnHHnuMV155hdtuu63edSxcuJDo6GiMRiMDBgxgw4YNFy37zTffMGHCBIKCgvD29mbYsGEsX768IY8oRIuTmj6KMP+96LXllNndOKJ2xMN0BEB2RmiFvHQFAEQrp7n7hiu5Y/JNDO37b+f5gRVJXqIkeUKIemjwAA+t9tyOit9//z3ff//9RcvOmTOHOXPmVDuuKApWq7XGaxYvXsysWbNYuHAhI0aM4N133+Xqq6/mwIEDREREVCu/fv16JkyYwD//+U98fX35+OOPue6669i2bRvx8fGX8YRCtCx2u5a0jGEMjP0UgKOaYFCs2IxnAOhjkZa81ibKcAKz2ZtgJZ8T9kDCyaxyPr7ia3pEZyRP0eKr2lwRphCilWlwS56qqg1+2e0XX+Dz9ddfZ/r06cyYMYO4uDjmz59PeHg4b7/9do3l58+fz2OPPcagQYOIjY3ln//8J7Gxsfz4448NfVQhWoTsvK6YLZ7O8XhrbY7xeHZFJdBuoZNdJje1Nm4aK4fpAMBpS3C18/6qjc4Vk2l2ynp5Qog6anCSZ7fbG+VVE7PZTGJiIhMnTqxyfOLEiWzevLnO8RUWFuLv73/RMuXl5RQUFFR5CdFSBfsncd9tfelYsT7e/6xj0Lo7BuwPtBTT+PtqiOaQpzEBoLU5voKqCtm5XSk3ewEyLk8IUX+NtndtU8jOzsZmsxESElLleEhICJmZmRe5qqp58+ZRXFzMH/7wh4uWefHFF/Hx8XG+wsPDGxS3EE3NpC9Co6iUo+WY2gEP90MADJCu2lbLXedYDy+CbA4ev5a3F+/g4+9WcvTEFcC5r22iTpI8IUTdtOgkr5KiVG2bUFW12rGafPnll8ydO5fFixcTHFy9C6TSE088QX5+vvN14sSJBscsRJOyOYbTHiEMsGE3nQLODdAXrU8XfQplqp4ApRDVrYDiUsc/t6kV6+X1tzq+tgd1RoqUVvGrWwjhYi36N0VgYCBarbZaq11WVla11r0LLV68mOnTp7NkyRLGjx9/ybJubm54e3tXeQnRolkdE57W2fqiMZ3CrrHjZ7fS2Vbu4sDE5fLSlnJQdfQiWLzPotM6ZkmnpI9CVSHUbqWTzYxdUdgt6+UJIeqgRSd5BoOBAQMGsGLFiirHV6xYwfDhwy963Zdffsldd93FF198wbXXXtvUYQrRbLbu+RsrNv8d1ebYQvBr6zh0FePxBsh4vFYvR+PoitWq0Cl0GwBFJWGcze8CnBuXJ0upCCHqokUneQAPPfQQH3zwAR999BFJSUnMnj2btLQ07rnnHsDR1Tpt2jRn+S+//JJp06Yxb948hg4dSmZmJpmZmeTn57vqEYRoNAeO3kReXmcURaUMPcfUDpjckwEZj9cWmHSOJK6TmkNk2Ln1QFPTHbtfnEvypCVPCFG7Fp/k3XrrrcyfP5/nn3+efv36sX79epYtW0ZkZCQAGRkZpKWlOcu/++67WK1W/va3vxEWFuZ8Pfjgg656BCEaRWFxKDn5sUQEO/Y3PUYwYENxd3z/y3i81i/WcJxi1Q0fpYQOHc6tIFC5j23l13ifzkSZtNsKIWrRKna7/utf/8pf//rXGs8tWrSoyudr165t+oCEcIHK1pyIIEeSt97eB40xHZvGhpfdRmzF/qai9QrS5rNdHchgJZlioxl34xlKyoI4kTkUm11HJywE2yxkafXs07szyNUBCyFatBbfkieEcEhJH4lBV0iI3wEAFpuvQOt+HHB042kvdbFoNSrH5WHXOvevNVu8yDgTj8J56+XJ5AshRC0kyROiFVBVSM0YSXhQIhrFThlajtMRo/thAAZYpau2rXDXOr6WHdWzRHVY7zzu7LK1yuQLIUTdSJInRCtwJrc7JaXBzq7a40oIYEfrngLAQJl00WZ0NxylQDXhqZQREur4ersZ8kF1jMGrnGCzR++OxSZb2AkhLq5VjMkTor2rXBA3vCLJ22DrjcYtE5vWgofdRndrqSvDE40oRJfLFnUIw5Qk8rQGpv3uKoL8DqLROLZ/jLGV42e3kqvRsT9nP/2C+7k2YCFEiyUteUK0AqnpIzEa8gj2dWxftthybjxeP2uJ/LfWxpzVOMbbKTYtIQEHnAkegAL0r1xK5XSiK8ITQrQSkuQJ0cJZbQZOZA4lPHCHY308RctRNRw39yOALJ3SFnnoCgHooOaCWv28cx9bSfKEEJcgDQBCtHAaxcotk+5AY3b8uB4jBFDRexzFiiR5bVGc/ih5Fg98lWKKrB546h1fY6vVDZ2u3DnDdlfWLmx2G1qNzK0WQlQnLXlCtHAajZ1OIQl08N8HwFpbPzSGLKxaM0bVTk+rrI/X1oToctmnRgGQaQkh6dh1LFn+Of/6Yh/5RR3pZivDw26jyFLEkbwjrg1WCNFiSZInRGtgV8DuaK350nKlczxeX0sJ+pr680Srl3feuLzcghhS00dhtRlJTR+JFuhTMdlmZ9ZOF0YphGjJJMkTojWwORK8UkXLCTUMN4+K9fGkq7bNqhyX11E9e8E+to6Z1vHnddkKIURNJMkTogU7eXoQCfunU1oSAMAROgAqBvejgIzHa8t66I+Qo3phVCx4+x7GoC8AIDV9BKqqEG91TL7YnbXbhVEKIVoySfKEaMH2H7mZNdufpbQ4BIA1tng0hiwsujLcVLuzy060PaG6s+xTowE4YwskImwLAKXlAWTl9KSPpRStoiWjOIPM4kxXhiqEaKEkyROihVJVx/p4HsYs/L1SUFH50jIerWcy4GjFc5PxeG1ansYEgMamIbLDuS7blIyRuGOnq19XQFrzhBA1kyRPiBYqrzCS/KII51ZmpYqeDDUQo0cSAMPMRa4MTzQDL52ji7bDBfvYOsflBccDMi5PCFEzSfKEaKEq/5BHBDuSvEN0BMWCUrFf7QiLJHltXU/9YbJUXwyKDYPpDN4eJwHHWE2L1U2SPCHEJUmSJ0QLlZI+EsDZkrfKOgCtKQVVYyfYZqGzrdyV4Ylm4BiXFwXAGUsQkR02AmCzGTl1erBz39pDuYcolkk4QogLSJInRAtkt2tIyxiBt3s6vp4nK8bjXYnO07F0ynBLEYqLYxTNo3JcntZedVze6ZxehHqE0sGjA3bVzt4ze10VohCihZIkT4gWKDOnD+VmH8IrWvGKFQM5+GHwOAjAcBmP12546/IBCFPPEhW2nqtGPsxfbhnCkD5vAzhb82TyhRDiQpLkCdECpZ6qGI9XkeQdVMNRdAVgzEJRVYbKeLx2o5c+mXTVH71ix66z0jv2v3h7ZjjPy7g8IcTFSJInRAuUmjESUJ2TLn61DURbsctFD2spfqrNhdGJ5hSmO8tvFePyTpuDq52vTPL2nNmD1W5tztCEEC2cJHlCtEA9u3xNfLf/4O2eiYrKYssV6DzOjccT7UuRRg+Azl59JGYX3y546j0psZZwOPdwc4cmhGjBJMkTogXqHftfxg98HoBCxUg+nug9HIsgy3i89idAfxZw7GOLCimnRrF62zMsmZmFRtHQN6gvIF22QoiqJMkToqWy6QA4oEagccsAXQnudht9ZSuzdqef4SAn7IFoFTtnLX5s/+0vJB6YQeqWcnJTrDL5QghRI0nyhGiJVMCmBeAX2yDn0imDLcXoZSuzdsdHU8whOgGQdd56eQApW8rOTb44Iy15QohzJMkTogUpLfMl5dQoLBYjqBpUVL62jENb2VUr4/HarXKtYzyeu81K1Hnr5aVuKaN3YG+0ipbM4kwyizNdFaIQooWRJE+IFuTYySv476+fs37b0wDkKe4UKXp0FVuZyXi89itUnwVAR3II8j2AuzEbgLTt5RgVE939uwMyLk8IcY4keUK0ICkV+9V2CnT8od6txqD1OAaKnY42MxF2syvDEy7Uy3CYFHsIWkUl3RpKRNgmAMzFKhn7zM4u252nd7oyTCFECyJJnhAthKpCavpIwO7c6eJ760h0582qla3M2i83xcoxQgDIs/hV6bJN2VJ2bvLFmd0uiE4I0RJJkidEC5Gd15Xi0hACvY/g7paHHfjJOsKZ5I2wFLo2QOFyqtaxCLaXvbzK5IvU8yZfJOcmUyTd+kIIJMkTosVIreiqrdzlIkvxxqrPQ+OWjU5VGWwpdmV4ogXo5JYOQDjZGN2z8ItyLLOTvteMjz2Qjp4dsat29mbvdWWYQogWQpI8IVqIlAv2q91h747OKwmAAZZivFS7y2ITLUOsLo1j9lA0ikpqeThRw4wAqDY4saNc9rEVQlQhSZ4QLYDVZuDk6aEo2AivaMn72jIGnacjyRtnLnBleKKF0CgqJxV/AIqsXnSdYGLgHz35/TuBRA51kyRPCFGFztUBCCEg40w8Fqs7wb4HMOqLsKGwkS6Y3JcAMMYs4/GEg1ZrBjsEqMVEDDYSMdjoPFeZ5O09sxeL3YK+Ys9bIUT7JC15QrQAF3bVniQAxfMIiqISay2jk93iyvBECxLtlgZAhHKGwpz0Kuc6+3bGy+BFqbWU5LPJrghPCNGCSJInRAtgMubi73PYOelio72XczzeWOmqFefpoMvmqBoGwPGE5VXOaRQN/YL6AdJlK4SQJE+IFmFgzw+ZfuOVxIStB2CJZTQ6j0MAjJOuWnGB04o3AOWH1wGQn25l79dF7PyikP4h/QHYmSWLIgvR3smYPCFaCrsWBbCgYb+7gklbTqDNQk9rqasjEy2MUVcCVgg5ux27VWXRjZmYi1Xc/TUMXtwXgN1Zu1FVFUWRJbSFaK+kJU+IlsKqBeAooWg9DwIwxlIoP6Sims6GFKyqhgj7KXKObiV8kBsAJWfthOZ2Q6fRcab0DCeLTro4UiGEK8nfDyFcrLg00PGBzdGwvsoW7xyPN65cumpFdT7aYjaoPQEoW/UykUPPzbDN2AY9AnoAjtY8IUT7JUmeEC6UVxjOwq928sl3y7BZHK0x/9PGodHn4abaGWKR7alEzU5pfbCrCuFZa+jc/ajzeOqWcvoHy7g8IYQkeUK4VOVWZnqNGa3GRjk6TnqeBWCYuQgjqivDEy1YP7eDLLMPAcDr6Bt4hji6+08mltPHrx8gLXlCtHeS5AnhQikX7FebpIajqxiPJ7NqxaX01B3jC7dbANAkfU/PYY7xd9ZylaBTcQAcyTtCfnm+y2IUQriWJHlCuIjdriEtfQQAkcGbAfgffdGaTqKoMFrWxxOXoCjQqfsgfrUNQEGlb9h7znOp3xmI8o4CpDVPiPZMkjwhXOR0Ti/KzL5oNeV0CNgLwCp3HwB6WUsJVG2uDE+0AuO6BfMv640AeGd/Q2jHUwAcXlVKLy/HUiqyKLIQ7ZckeUK4SGqGo6u2Q8AetBorRbiR6+nYpuoKs3SxidqNiA0kSenMWltfFNXGhLGLAFBt4H/UMcNWkjwh2i9J8oRwkdRTI4Fz+9VuIBat+xEAxsp4PFEH3kY9A6P8eLOiNS/E8jUxfc4w8Vk/brhhKAC/Zf+G2WZ2ZZhCCBeRJE8IFzBb3DmVNRCA6NANAHxujEDR2IiwWuhsK3dleKIVGdctmJ1qVw649UOxW7h56pf0vcWTLsHR+Bv9MdvNHMg54OowhRAuIEmeEC6wZvuz2Oxu6LSlhPg6Fj4+4FkCwNXmXGQjKlFX47oHA/BSyXWOA4mfQGEmiqLQL6gfIF22QrRXkuQJ4QJdo37CaMgjImgbGo2dNLwwe6QCMFGWvBD1EBvsSQcfI+st3ckP7A+2ctj8LwD6h8iiyEK0Z5LkCeEC0R3Xc+fvruWKgS8A8JEpBkVjo4PVTqx01Yp6UBSFsd2DAYUfvKc4DiZ8xOnEdEq+iQYcy6jYVbvrghRCuIQkeUK4iK/XCfzcTwCw3lMPwOTybOmqFfU2rpujy/bd9BjUsH5gKSFtwRvk/7cTWosbeeV5HMs75toghRDNTpI8IZqBzaKSdOx3qOfvUqYCdi1FisIZ9xwAJsrSKeIyDO8cgEGr4WReGZl97wcgPuYL3LUlBKU7dr9IOJ3gyhCFEC6gc3UAQjSnrINm9n5TjLVMJThOT//bvaqcX/dGHqW5tXdr9ZjsTsRgo/PzomwbG9+8eIKWn24lbetbHEmbwKQRj2HQl4JNByh84x4EGhvBFoWu0lUrLoOHm44hMf5sOJzNT+Z+zAjuiS5rP/27fMGOE73IjNzN0lWb8f1iovOa8IFu9PydR5X7rPj7WWyW2uuLv82TkB4G5+dnUyxs/6jqsj8aHcRd4074QOOFlwshmokkeaJdWfpYDjnHrAB0ucJULck79EsJ+adq32kitKeBiMHnPjcX2dn3TXGt1yWnXs2gXu8TGrgXrI4N5b939wdKmGw+I1214rKN7RbMhsPZrEnOZsboh+HrPzE47jN+TJzPbuCQspu93xShVHyXabRUS/J++74Ea5la/eYXiBltrJLkleTU/P1/6JdS7l3TAZ2bfGcL4QrSXSvaDVVVOZtidWEEdiYO+z9Hggdg01GkKBxxLwPgGnOuC2MTrd24bkEAbD9+loKYayEgFoMmn0leu9BY9ZR55FLgd6pZYyorsFOaK9vzCeEq0pIn2g1rmUrlBMPQXgaufMK3WpnfvxuEvQ55oEdQ1f+PvDvouPu70EteY/yyI57uZxyfqIBdwzoPE3aNHX+LTrpqRYPEBHnSOciDo2eKWZOcw/WjHobv7mFc/Bf09hvOnsLddH4xletCHYtwG72r/49/5+IQx/dmLbxCtVU+D47TV/n+3/BmPkdWlwJgLq7DDYUQTUKSPNFumEvO/bHxCNDgHVb9298/Sn9Z99YZFAK71HJtZYIHYHWMx/vW3R+Aq8plAWTRcJN6hrJw7VGW78/k+ttugbUvouSlMkyvZQ9w0L6Lu7vcdtHrAztf3ve/wV1DYJdzSaNXyLkk0FwiS7cI4SrSXSvajfNbFAweLv7Wt2kpVhQS3B1/DG+ynHZtPKJNuKqXozVtzcEzlNkVGPUQAAOPbwMcM2xVtelb1gzu5/5lOf+fKyFE85IkT7Qb57co6D1c3G5m07HO3YRNo+JtMdDVVubaeESb0LujDx18jJRabGw4nA19bwfvjvTJzUCHhqySLE4WnmzyOM7/J0q6a4VwHUnyRLthOa9FweDuwm99uwJ2Lb96uAMwtqxUumpFo1AUhYk9Ha15v/yWCTo3GDELk6rS2+KYANEc6+X1vtmD6T+Gcu/qDsSMkiVUhHAVSfJEu2EuPteSd353UrOzaSnQKKw3mQC403LcdbGINqeyy3bVwdNYbHbofyd4BDOwuABoniTPI0CLf7Qez2AtWr38CyOEq0iSJ9oNvVEhrK+BwC66KgPDm51Nx0p3dywaBW+ziW526aoVjWdQlD/+HgbySixsP34W9CYY8QADyxyztxMyd7g4QiFEc5EkT7Qb4YOMTP08hLu/C6PP7z1dFofdqmOpp2MR2kllRdJVKxqVVqMwIS4EgOX7Mx0HB9xNP8UdraqSXpxBelG6CyMUQjQXSfKEaE52hdMaPTtMjnFKMyxHXByQaIsqu2yX78/EblfBzRP3oX+jZ7kZgISMpm3NK8m1sXtJETsWFXB8U2mT1iWEuDhJ8oRoTjYtP1W04gWVetNBrcNGoULU0/AuAXi66ThdUM6ek3mOg4NnMqBioe+E5G+atP6iLBsrns9l7Wv5JP8qSZ4QriJJnhDNyGrVs9TTMav2mvJ8F0cj2io3nZZx3YMB+KWyy9bow8DoiQAkZO2GJlwvr8oSKrJOnhAuI0meaDe2vlfA53ecZsnMLHLTXLOH7W9ab44aDGjsGqZbD7kkBtE+TOpZMS7vt0znAsj9R8xBo6qc0Ng5/duSJqu7ymLIxbLjhRCuIkmeaDdyjltI32MmdUs5qs0FrQt2hZUebgB0KPXBD9ckmqJ9GNstGINOQ0pOCcmniwDw9Amnu8EPgITtC5qsNU9a8oRoGSTJE+2Gq7c1K7caWFaxAPJ15bnNXr9oXzzddIyODQQqFkauMDBqAgCJJelwbE2T1K01gKZia2hpyRPCdVpFkrdw4UKio6MxGo0MGDCADRs2XLRsRkYGU6ZMoVu3bmg0GmbNmtV8gYoWzXLetmYGF2xrtkobwhmdDqNNw922A81ev2h/nLtf7D8vyes0CoAdRiOse7VJ6lUUBX1Fl61FWvKEcJkWn+QtXryYWbNm8eSTT7Jr1y5GjRrF1VdfTVpaWo3ly8vLCQoK4sknn6Rv377NHK1oyc7vNtKbmj/JW+1uAKBrsScmRVo3RNObEBeCTqOQlFHAkSxHl23/kP5o0JBi0JN5ahukbGqSuiu3DpSWPCFcp8Unea+//jrTp09nxowZxMXFMX/+fMLDw3n77bdrLB8VFcWCBQuYNm0aPj4+zRytaMkq/9joTQqKpnmTvMLMJDZ4OJK8SeUFzVq3aL/8PAyM7hoEwPe7TwHg4+ZDr8BeAGwxGWH9K01Sd2Vr+fnDJIQQzatFJ3lms5nExEQmTpxY5fjEiRPZvHlzo9VTXl5OQUFBlZdoeyr/2Liiq/brLe9TotEQZIHbSGr2+kX7dUN8RwC+233KOct2WIdhAGxxN8GxtXCi8RdHrmzJs5SqqHZJ9IRwhRad5GVnZ2Oz2QgJCalyPCQkhMzMzItcVX8vvvgiPj4+zld4eHij3Vu0HJVjg/Tuzf9tvzLH8U9JfJEbBsXW7PWL9mtCXAgeBi0nzpayM80x4Wd4h+EAbPH0xg6w4bVGr9enkw7/aB2hPfVYyyXJE8IVWnSSV0lRqra8qKpa7VhDPPHEE+Tn5ztfJ06caLR7i5ZBVVXMFRMvmrsl71TqZn7TOcZDjS8vbta6hTAZtEyqmIDx3S7HnrW9g3rjofcgT7WS5OYGyb9Axp5Grfe6VwOY/mMYdy4ORW9qFX9qhGhzWvRPXmBgIFqttlqrXVZWVrXWvYZwc3PD29u7yku0LTYz2CuWpWvW5VNsVv73y4PYFYXYUg3jNYebr24hKlR22S7dm47FZkev0TModBAAW6IGOgqtb/zWPCGEa7XoJM9gMDBgwABWrFhR5fiKFSsYPny4i6ISrdXoWT4MnelF3DXuzVanff1r/KwtBCCsqAN6jXTViuY3vHMAgZ5u5JZYWJ98xnHsvC5bAJJ+gCwZLypEW9KikzyAhx56iA8++ICPPvqIpKQkZs+eTVpaGvfccw/g6GqdNm1alWt2797N7t27KSoq4syZM+zevZsDB2RdsvZM56YwZIY3ox70pd8fPJun0lM72b59Pif1erQ2HdPtso2ZcA2dVsN1fcMA+G63o8u2MsnbmXeIku7XOgpumOeS+IQQTUPn6gBqc+utt5KTk8Pzzz9PRkYGvXr1YtmyZURGRgKOxY8vXDMvPj7e+XFiYiJffPEFkZGRpKSkNGfooj2zlMK3f+FbT0erodE6lP7ad1wclGjPbozvyMebUlhxIJOicisRXhF09OzIqaJTJPSYxOiDP8Fv/4OxT0BA5wbXl7yihL3fFGMutjPqAR/CBxob4SmEEPXR4lvyAP7617+SkpJCeXk5iYmJjB492nlu0aJFrF27tkp5VVWrvSTBE81q5Vzyzx5mZeU2ZjE3uDYe0e717uhDTKAHZRY7y3/LRFEUhoYNBWBLWSZ0vQpUO2x4vVHqK8y0cXxDGad2minKkmEKQrhCq0jyhGgoS5md4hwbljK7c62wJnN0DWx7h588PDArCvayMGYOHtO0dQpRC0VRuL7fuTXz4LxxeelbYPSjjoJ7v4Lc1AbXd/4sdlkQWQjXkCRPtAvH1pexcEw68weeYseiwqarqDQPvv8bKvC5n+MPapTbOIK9patKuN4N8R0A2HQkm6zCMoaEDUGjaDiaf5RMv04QM84xDX3T/AbXdf56lLK1mRCuIUmeaBfO3yTd0JSLIS97FApOcSAwmjRtKapdx119bmq6+oSoh8gAD+IjfLGrsHRPhmOLs4CKLc7Ob83b9RkUpDeoLmnJE8L1JMkT7cL5LQlNthjy/m9h3xJQNLzfaQgASklvruvdpWnqE+Iy3FDRZfvtLkeX7dAOFePyMrZA1AiIHOFYWHLTmw2q5/z1KM0lkuQJ4QqS5Il24fyWhCbZ1qwwE5bOBqB0+AOsy98FwLDgazDqtY1fnxCXaXKfMPRahX2n8vntVL5zXN7W9K3YVTuMfsRRMHERFGVddj169/Na8kqku1YIV5AkT7QL5/+RafSWPFWF7++D0lwI7cOPHXtjpRS72Z+ZgyY0bl1CNFCApxtX9XKsmffF9jT6BPXBXedObnkuB88edIzL6zgQrKWw5a3Lruf8YREW6a4VwiUkyRPtgrnKmLxGTvISPoIjK0DrBje9zyf7vwbA0zKcgZH+jVuXEI1gyuAIAL7fdYpyi8LgsMEAbE7fDIpybmzejg+h5Oxl1VF1TJ605AnhCpLkiXahypi8xuyuzTkKvz7l+Hj8sxzSKaSV7EdVNdwUewOK0kTj/4RogKEx/sQEeVBstvHdrlMMCxsGVEy+AOg6CUJ7g7kItr59WXWc/8+UTLwQwjUkyRPtQpXZtY3VXWuzwrd/AUsJRI2CIffyzq5PHKcKe3HnoD6NU48QjUxRFO4Y4tg16PNtaee2ODu9kwJzQdXWvG3vQll+vevQGRXib/dk8HQvelzXfPtFCyHOkSRPtAvntyScP+uvQTa9ASd3gJs33PA2+ZZC1pxcDkC872Q6+Joapx4hmsDN/TviptOQlFFAbr4PnX06Y1WtrD+53lGg+3UQ1B3K82H7e/W+v6IojH/SjzGzfelzczPtFy2EqEKSPNEunN9dqzc1Qkte+m5Y+5Lj46tfAd9wvkj6LzbM2MrCuG+YTLgQLZuvu4HJfRyLI3++LY0rIq4AYHXaakcBjQZGVcy03bIQyotcEaYQogEkyRPtwrUvBTD1y2Bu/SgIja6BSZ6lzNFNa7dC3HXQ9zZsdhuf7f8SAH/rOIZ1DmiEqIVoWlOGOCZg/LgnnSHBjq33Np7aSJm1zFGg543gHwOlZx0TjIQQrYokeaJd8A3XEdbbjYjBjbC92Krn4cxB8AiGyQtAUVh3Yh0F1ixUqzvT42+WCReiVegf4Uv3UC/KrXZ+O+5FiHsIpdZStmZsdRTQ6mDUw46PN/8LLKX1rsNmUSnNtzX9ntFCiGokyROiPo6vh63/dnx8/Vvg4Wixe3vXfwBQigbzhwExropOiHpRFIU7hjomYHy54wRXhDu6bFelrTpXqM+t4BMBxVmw8z/1uv9//3KG1+NP8taIdCylkuQJ0dwkyROirsry4dt7HR/3/6NjmQngWP4xDuYnoqoKV0fehIebzoVBClE/N/TrgLtBy5GsIjoYBgGw9sRarHaro4BWDyNnOT7etACs5XW+t87t/F0vJMkTorlJkifaPLtVZc/XRSQtK+bUrrr/garm58eh4CT4RcGkfzoPv7/7MwCsRd25Z8SgBkYrRPPyMuq5vp9jAsaOg354G7zJK89jV9auc4X63QFeYVBwCvZ8Wed7nz/JySILIgvR7CTJE21eebGdX+fmsvSxs2x5r+DybpL0I+z5AhQN3PguuDmWhCgyF/FL6o8AxLlfQ0yQLBUhWp/KNfOW/5bF4JCRwHmzbAH0Rhj+gOPjDa+DzVKn+1bZ9UJa8oRodpLkiTavyhp5l7OlWeFp+PFBx8cjHoSIoc5TXyd/h1Utw1YexH3DrmpoqEK4RK+OPgzvHIDVrlKcGwc4krwqkyUG3AXugZCXCvv+v707j2+qSh8//rk3S9N0oxTaQoFSNlkKIqAgiBQcQXDcv35x5DcuI4yMuEBHHdD5DuqojIqCqCyO+zCCjguK4ggioICgIChCAaF0gRZKoVu6ZLvn90e6hZZNadOmz/v1ui/Se8+5eZKQ5Mk595zz3hmdt/aclLK0mRCNT5I8EfR+1ZJmSsHye6HsGMT1hZSHqg95DS+v7fgXAOHOEaScF3dO4hUiECaP6ArA1z+0JsQUQk5pDruP764pYLXD0Lt9t7+eDYb3tOeUpc2ECCxJ8kTQ+1VLmn3/Fuz9L5iscP3LYLZWH/o8YyUFrhyUx85tfW/EpMu0KaL5Gt69DX3aR1LuMhFvOR84YZQtwIUTwdYKju2DXctOe87aLXlu6a4VotFJkieC3i9e0uz4Afi8suVu1P9BXO/qQ0opnt+yCACt5BImDO5+TmIVIlA0TeNPKb7WvKyDvn+/zP7Sv1BIBAy5y3f7q9lgnLoL1r8lT7prhWhsMteDCHp+S5qd6TV5hhc+nAwuByQOg4un+B1ef2g9OeX7UYaVm3v+jqhQy7kMWYgz8+y5bT0eq3QS9YVkHutOZAz8XPAz2XNC6Gi4agopgAjI2wVPh4DFc9LzWdKvAnzzSrpWTIXMV+sv+Gdp5ROiIUhLngh6rl/SXbtxHmRvAmsEXLsAdJPf4We/Xei7UTyYuy7td65CFSKgTJrBH+0fgGFHL+sIwOqQCP9CGmCtTPpcIZVJX/2sltLq2y532DmOVghxOpLkiaDnKjvLgReHd8CXT/huj/0HRCf6Hd6et539JT+ilInru06gld1az0mEaJ5usK2mjVZAackFAKyyRtUtZHEBCgwTeE/eIdSu7TZuHD2Bm6+8ln49ljZQxEKIk5EkTwQ9d61r8k7bXetxwgd3guGG8670TQJ7gqc3LQBAlQzg3pRB5zRWIQLNprm5w74MT0kyKI0fLXYy9BN+yOiqMtEDnNaTtubZbQV0TviahNjvCbfnNWzgQog6JMkTQc9k1Qhrq2MN0wgJP81/+S8fh7ydENYWrnoeNP+kcO/xvewo2IhSGld2upk24SENGLkQgTHB9hnhXhOe0h4AfGSLrlvIWtWaZwavqe5xIUTASZIngt6gWyK4a00C923uQOIQ28kLZmyAjS/4bl81D8Lb1inyzCbftXiGI5n7R17SEOEKEXCRehkTbCtwFw4E4OOQVtSZFU9XYKlc+cIlP3aEaIokyRMCoKIYlk0GFFzw/6DnuDpFDjkOsSnPN2/Yb9qNJzbyFAmjEM3cH+wfYXF0QXns5JksfGOpZ8k+qxNQvuvyPHVb85TSOHBwBHsOXEn6wZQGj1kI4U+SPCEAPp8BhVnQqhOMmVVvkac2LgTNwFvajemXjW7kAIVoXLF6IZNCP8Zd7JsY+YOQ1nULnUFr3nur3uTjtQvYsC21oUIVQpyEJHlC7P4Uti0GNLhuEdgi6xTJLs5mbc5yAC5pO572rUIbOUghGt8fQz8krOg8AL4MiaRIq+fau9qteV7/rxRNU1jMZYBMoSJEIEiSJ4Le2tmFLL8/n89nHkcZJwwDdByFj+/13R56DyQOrfccf133LErzYpR2Z+bl1zRwxEI0DeF6OdPMq/FWtMOrwQfWNnUL6QrMJ2/Nq5orzy1JnhCNTpI8EfQyNlaw+7/l7FxeilZ7fVmlYPl9UJYPsX1g1F/rrb8jL43vj/mWd7omcSIJ0oonWpCbbCuJLO4GwJvWTvUXqhpp67HUac2zWhwAuDyS5AnR2CTJE0GvajLkOuvWbv837PkUdAtcvwjM9V9TNH3tU6ApTGX9+evlci2eaFksmpcHvN+jlIljIeV8o8XWLWQywFy5vNkJrXlVLXkudzhKVi8TolFJkieCnqtyMuTai6VTkAmfTffdHvUwxPett+4X6RvJKt+KUjp3X3A3dqss9yxanuvNm4lwJAAwyzyg/kJWp+9fj/+1eVVJnlImPF6ZakWIxiRJngh67sq1ay1VS5oZXlj2J3CVQKeLYei99dZTSvHohtkARHku4Q8XXdQo8QrR1GgaTHQfACA97Di7PB3rFjIZldfmaeCqWSHDf/3aeqZhEUI0GEnyRFAzPAqPs7IlL6yyJe+blyBzA1jD4doFoNc/W/8b2z+l0PgZZVj4+4ip6PpplkQTIojdaqRh8YSgmcuYoa6ov+u1ujXPAobv/VJ1TR5IkidEY5MkTwQ1V611a61hOhzZCV/+3bdjzJPQOqneeh6vhxe3zwMgyXIFo7p3b/BYhWjKzMBVFYUA7I04zsfOEXULmQwwefC15vm6Zi3mmpY8t8fe8IEKIapJkieCWtWgCwCb3QUf3AleF/QYCwNuOWm9x9ctxqXnoryhPDdmaiNEKkTT9wdXNigwh+9hpus6jhl155QkpLI1z+1rzbNaHJhNFdht+Xi9lsYNWIgWTpI8EdRcZTUteb0j5sGRHWCPgavn+S40qkfG8aO8n/EyAIOjb6R723pGEwrRAiUaLn7jKgagImYLjzr+WLeQyevXmpdy4RNMu6UHU343gHZtf2zcgIVo4STJE0HNVepryUuI+Z4uui9x46rnIbz+xE0pxcTlj4GpBLM3jjlj726sUIVoFiaV5QFgjvyB5UZfvnDWMyDJWtOapym5llWIQJH5IETz8Owv+6IILU5kQK9bGdLtTTQMMLtgxdWwov7y84xhHIktAmBGYSaRL8k1RELU1ttbwTBXCRusEVhjvuKveXdxkeUnIvWymkImL+geMMy+kbY2Z+ACFqIFk5Y8EdSiIzO5rP/ThIUUgGaAreKkZbO9MbwS6btYvIejFf+r9jVWmEI0KxPLjgJgjfqOI7qVf5Te7l9Ao9a1edbqkbZCiMYlSZ4Ibh6z70sGBbZy35dPPZSCiaYxYMtD94awsGJzo4YpRHMy0FPGBe5S0A2srdfzdsVYvnGdMKG4yQu6F9BIP3A5n341lz0HrgxIvEK0VJLkieBlaFBh8922uMDsPWnRl9yXc6h1GgB3OQpoi7sxIhSiWdKoac0LjV4Pehl/LpnG8dqjbTWqr81LiN7B/qzLOJzfr/GDFaIFkyRPBCcFOG2gdF9rQsjJrwnK8MazICICTXeTUGHjj+70xotTiGZquNtBD085Xt0gLua/5Bix3Fd8P15V62vF7MFtWAixlDKw279xyTx5QjQqSfJEcPJYwGPBUDqLv1jCS0u/5+DhuqMAy1QItxvj0SP2oimdF8t2nKxHVwhRiwZMqmzN01tvJlQr4mv3AOaU3exXyImvNX1A98UYXhnrJ0RjkiRPBJ9a3bQHjg4h93h/yiraoOke/2JK457SyRxt+w0AN5UW082QUYBCnKnLXcV08jpx6Bq/jZ8LwItlN/lPq2J2c6w4iVBrMR1a/xCYQIVooSTJE8FFARWhgAa6h325NUsvWWstrwQwt2w838TuQzOX0dmleKAis3FjFaKZMwF/KMsH4JvIEn4X9j4A00pSyfC2A8BqLWXz7okAdI3/yvceFUI0CknyRHBxW8FrBhSEluN011wIbrXUJHmfOYeyMKwNJnsmIYbGfMdeLPLtI8RZu8ZZwHmecop0M8R+wQBzGiUqnMlFD1GuQrCYy9iVfSWFjg7YLI7K0e5CiMYgSZ4IHl4dnL557gipAF35LYhutTgA2OlJ4s/eqwlpsxaAJx2ZdDRkNK0Qv4QZ+D9HDppSfGKL4s6Y52ijFbDbm8T9JVMx0DCbnGze42vNw2WV1jwhGokkeSI41O6mNbnB4kvaXO7w6iJWSylHjVbc4ZiG1v5DAP63/DijK9fiFEL8Mud7yvmfigIAXooMY07kU1hw86lzOA85pmC1lPJTxjU4ytv4Rry7LQGOWIiWQZI8ERxcIWCYala1qBwi63KHAaDrLgq1UP5f4aMUtVuFbi6lu9vJg6W5AQxaiOBxX9lhWhseDpht7I46wrzIZ9Dx8k7FGEpMJgxlYevPv/cVdoVIa54QjUCSPNH8eU2+LiCo7qatUtWSZ7GUcXPhk2TE7MEcdoBQQzGnJJMQ+aYR4pyIUgYPVP5oWmRvS3LoFp6OeB6AHW0UdPwRt675fogp3TfNkRCiQUmSJ5o3BZTbAA3MLrD4T5NSNflqoW4lPSoLa8xXADzqOEii4WrkYIUIblc6ixjscuDUdJ4Ib8cNti/5e/h81ifn8NL5sO/8HWCtfN85pTVPiIYmSZ5o3pw2ULW6aU/gckcAsKfPGmxxKwBILT3MWFdRo4YpREugAX915GBRBhusEXxujeT3oSv4S9jrAPyj9HbecI9GUdWaJ5MjC9GQJMkTzZfHXDMdg62cE5eqOOJtzaZBO/ho9HJ+TFkAwG1lR7m9PL+RAxWi5ehsuJhY+R57NDyBdFMIf7K/z932pQA8UjaZ1VzgKyzX5gnRoCTJE82TqlnVAosTzF6/w1vdPbmqcA5bOuZQ1Pdl0AyuqSggtexIAIIVomWZVHaUAe5SHLqJuyM7UaiZ+LN9MQ+FvYqGwbSKeyhVlYOlpDVPiAYjSZ5ofhS+BE/poHshxH8psiXlY7ipcBb51nLCOr4BupcUZzGPOA7JurRCNAILijnFWSR4XWSbQpioD+HF/3xD2ftPMNv5Hm50XvFeCYDLGQZKmvOEaAiS5Inmx2OuHJmn/LppXcrMQyVTmOG4ByN8HxGJC1AmFwPcpTxTko20FwjReForLy8UZ2I3vOyJLmLNsPdxecIYoGXwTqsZfGwMxqFsWJXi0MePQmF2oEMWIuhIkieaF0OrnPQYsDrBZACQ423D7wqf5O2KsVij1xPW4U0M3Uv/EjMP72+FuzQ2gEEL0TJ19zp5piQbTcHP5/+X3QM+wuUO53zLz7zV6m98alwEQMK2OTA3GeOFQfDZX2DvSnCVnubsQojT0ZSSdvITFRcXExUVRVFREZGRkaevIBres1rldCl239q0ugfsZXjRWVwxjqdLb6FU2YiI+xBafwfAmOMW2r7+PrphZnDfl7h00FOBfQxCtFBPloxmSVIOmqHz573tuLXN5wCUeENZVzqUeFXEBdrPmLRaX0cmK3S6GLqOgm6XQVwyaHLBhTg1+f72Jz1YovlwW30JHgpCK9jr7cRfSu5lm6cn6E7iO8ynNPwgANNKDzM8oz/LDN9/cYtFWgWECJRr8kL51nE5+/uu4rnzDmF3RHOjs4AIUzm/jVzNf8fkMOqDzfSq2EaKaQfj7LuIdObCgXW+7YuZEB4HXUb6Er4uIyG8baAflhBNniR5onnw6r7JUwFXiIcXy3/HgrL/wY2F8LAdRLVfSrHZi1UZPFlykDGuYnadsG6tECIwrOYyhqy8G6UZpCev5rGIBLJNVqaWHUEHrkhux6DOY3nogw5M33UR04sUKTFF/KV7Dj1Lv0PL+BocR+DHpb4NoN35vla+rpdBx8Fgtgb0MQrRFEmSJ5o+r7vyOjyNbFpzXfFj5KvWoFfQtd0r5EVmUgwkeF08VZLN+Z5yoGbdWgCrxRGY2IUQWC2lmAwLwz5LpXdINp9038vr9rYcNFl5ouQgoUCb8BAW/X4gH3x/iL9/uou1x1qx9lgrBiYO46Gbnmegthf2fwn7V8PhHZD7g29bPwes4dB5eE3Xbusu0rUrBJLkiWbAs+YpzIaJImXnBuffySeauIhvMLf7mDyT7xqe35UfY2rpEewY1fX8kjxzWaPHLYTwqfqRpaFx2Z7zGRa/mr+FJ7AqJIrDuoW5ZXnE2mPRNI0bBnbg8j5xLFq3n1fXH2BrZgE3/LOA3/SKY8rIqVxw+aNQcgTS11QmfV9C6VHY+5lvA2iVWJPwJV0KtqgAPnohAkeSPNF0GAYUH4Rj++DYfkpydpOfsYuOhZsAeNh9B1rYAc5vO5f0UN/ceB29Th4rOcQgT90kzuWp3V0rLXlCBErtyyVc7nB+6yyindfNfZGd2GGxc/Wyq/nT+X/i5l43Y9EtRNosPDCmJ7dc3Jm5X+zlne+y+SLtCF+kHaFfhyhuubgzv+13I7bzb/J9bhzZAftW+xK+rE1QmAlbX/dtmgk6XOhL+LpeBu37g24K3JMhRCOS0bX1kNE5DUgp36/uykTO92/l7YID4Km7/izAi5Z+/LdNOZk2X3JnUoqbK45xT+kRQk+yLtKX3/4fW3dOAuB3466nQ9yWhnlMQohTKimNZ+G73wLQPXEF146aDECmbmVGRAd2WOwAdInqwozBMxjSbohf/X15Duav2ccnP+bi8vpa66PtFv73wo5cd0EC58VFoFV1zzodkLG+pmv32D7/YEKjfQM3uo7ybVEJDfjIRWOT729/kuTVo+o/yZH848TGRAc6nF+kwu3lttd9H6pv3H4RNksj/3ItL4Tj+ysTuVrJ3PF0cBaftJobE5lGHAdUO/bQlox2oWy25FBozQXArAyucRZyR9lROhruU4bw+YZ/8OPemwGIi9nOzeNuBOC9VW8C8D+X34rZ7Dxp/WDl8YQ06HNwrs/f1M8XqPto6mo/B9eOmkRa+rVsS7sFk8nJhCtvqH5ODGBs1NOUhy+nwFkAwOWJl3PX+XfRLbqb3zmPOZy8syWbf2/K4lBhefX+pDZhXJEcz9jkePomRNUkfAAFmb5kb99qOPBV3c+ftr0qu3ZHQeIwsISe1eMM+GftORIMj6PC7WXC/DV8MPVySfIqSXet+OXc5b6krbpVrlYyV5Z/0moKDXd4B/KsHdjpbMu3xdHs88aTruLJUdFEx2bTPmEXOa4tOA3fF4FFGVxfUcAd5fm0O01yV6X2NXm65j1FSSFEQzKbXPTt/i57Mq6sc0wHoo1LWHzVRF7duYglu5ewKnMVqzJX0b9tf27ocQNjOo8h1BxKTHgId6V0485Lu7I67Qjvbsnmq5/zOZBfyoK1+1mwdj8JrUIZ1i2GwUkxDO7Smg7RiTDoD77N64FDW2q6dg9thaNpvm3TS2C2QeLQmlG7sb1kAIdo1iTJE6fmdUNhln+3atW/xQdPXTc8DtW6K6URnckxdWCnsw3rj0fxxWE7RflVvxIVujWPuISDRLfeSFsjjVJPMQcqe207hnekovB83i6eTbzhOavQPV5b9W1NlyRPiKZqaclQWAjTgetMISy0x7LGGsn2o9vZfnQ7T3/9EOOchYx0lXCBuxQ7itHAaMARFcqXrgv5r3Moa1yDOFQI7245yLtbfJ9PCfoRBlt2kmzeR29zOr3MB4jSK68RDMe3TKLXXLlcYkXNYA7+CpoBJg+YPWD2gla348sGLAVuitjYGE+VEGelWSR58+fP55lnniE3N5c+ffowd+5chg8fftLy69atIzU1lZ07d9K+fXsefPBBJk+e3IgRNzOGASU5tRK59JrbhZlwquTKFoWK6YYrqguFoZ3INbVnv4pnW0kMO44Z/JxRQpmrKsEy0KzHMNkyiYjJo1WrfJym/ZQbRTgAh8tXqrWtNWOTxnJl0pV0i+rF7W98R7zxj7N+WNddNgmnM5z3vngDXTu7BFEIERjneZ3MKcnmqGbmI1sr3re15qDJyjuhMbwTGoNZGfT1lHORu5QL3aWc56ngattXXG37inIVwiZXXza5k9nsTmaHpzuHjDg+cMbxgXNU9X0k6Hn0NGfQ2ZRDoinXt9lySNDysXj1ysTPBEoHj9W3oUA3fAmfyQMmb/W62UI0VU0+yXvnnXeYOnUq8+fPZ9iwYSxatIixY8eya9cuOnXqVKf8gQMHGDduHJMmTWLx4sVs2LCBu+66i7Zt23LDDTcE4BEE1tKSoTAP35JgSgND931wGSdsp/i08qJRqlkpIow8ojio2pKu4tltJJJe0o7colgcWNFMZZVbOpp5O7qlCK11IXZzASHWfAxLAYZeM8VJIYABNmXQ313Ghe5SBrlL6ef5CfPBr+DrGb7H8Csev8nkxqRLgidEoBWWdMLpCked4ZLpbZWHieX5/KE8n82WMFaEtGKzJYxck5VtljC2WcJYVFm2teEhyeuki8dJkvcAA4y9jDHexe41ke3qxg5XL9I8SaR5kjhoxHPIiOWQq+561hoGbfRCYvXjJOh5DNZ3cz7pdOEIrSkFwwQuExCCARgmLyazC80snzGiaWrySd5zzz3HHXfcwcSJEwGYO3cun3/+OQsWLGDWrFl1yi9cuJBOnToxd+5cAHr16sWWLVuYPXv2WSd5L//jMUJtIWi+DKlyo/JvAIUlShGa5Bs0qgEoReluL8pNrXpU19cANN+/1niFuRWoymPKCRUHjMpytevVJEZV5zF3NMAMShm+PcUKVeA7l1IKhWKg18tCfQR2ayF2SyFmkwtl8p3N0MBAq77tVjrFniiKvFEUeSIp9kZQYoThMOyUayYM3YvDXk5JuAN0J5qeD3oOoR4vJquDCMupLyyv+gi0KYOungo6lNnQMi6h47F4Eo7HYla+7tvsyq22q0ZMQa+VHO7cdz37si8/9YsHtI3ezUXJC09bTgjR8D5Z9yJHC3oBik/WzUPTjTplNAyuHjnFb9/On28k7+AoBgEDURSEFZPe9hDpsQfJbJNLUZiD47qZ47qZrZawOucEN1Z3GjZ3Oja3lV5uK2a3Hc0dCl4bymOjJNRDns2MR9koUjqlHgtabjQfGUP4SA1DUxp2UxntQzNICE0nwZ6B3VQGlZ/7GnB94QSWPW9C95rQqloB0Xyf5krHd/Wh7ktylYYyaahIzbdf09A0E0aJjnLpKKVXfgtUnkNV1sO3Xw/XMcXooFUe13QqDlSWq7xfo6oupspvHh2lNKydTJijaup5SnXK9oFSOt3KPCg0Xnz043p/90f013x36XuxcOYonLmnf+3NYWDvWfuEGmVpBvXMfFWHrZ2GtX1NXeWFku11/+/4DkJSQcnpT9qCNOkkz+VysXXrVqZPn+63f/To0WzcWP/1D9988w2jR4/22zdmzBheffVV3G43FoulTh2n04nTWZOkFBUVAfCv9iswhZ7BCKOjJ/x9NksqFp3wd7szrOehJnMCCAHiT1XBXrmdigEUVG7183vfG1Cu18SiGTrWijCsFZHYHdGEOmIIc8Rgd7QhJWkpg1t9T3vDjQ5k5g5h2er7KKLuU3CiEYNBr/XjPyMviR/3X3qaWtAh3kLPboqyyk+S4gpf4lz7b3OTfgc0DI9HNehzcK7P39TPF6j7aOpOfA482hEqvB0A2HHgknrraJqXlIv99x043LXO+90K9Kzc3JYKiqMPYu2ympi+S8gyWTmmmzmmmzmiwvCY3ZTjpVyr8FU8xepntV+m9HomVvih+lZI5XYyCvgF1wGfzZzNJ842FXeG9TzAsRP2neksMid+1+lnUffwCX9HV26/pO4p7tMb43veZeKQSqoJO3TokALUhg0b/PY/8cQTqkePHvXW6d69u3riiSf89m3YsEEBKicnp946M2fOrN1UJ5tssskmm2yyNeMtOzv73CQizVyz+H2pnTCEXSlVZ9/pyte3v8qMGTNITU2t/tswDI4fP05MTMwp76epKy4upmPHjmRnZ8t8QQEmr0XTIa9F0yKvR9MRDK+FUoqSkhLat28f6FCahCad5LVp0waTycThw/5ttXl5ecTF1d82HR8fX295s9lMTExMvXVCQkIICfFvem/VqtUvD7yJiYyMbLZv2GAjr0XTIa9F0yKvR9PR3F+LqKioQIfQZJzZMKcAsVqtDBw4kFWrVvntX7VqFUOHDq23zsUXX1yn/MqVKxk0aFC91+MJIYQQQgSjJp3kAaSmpvLKK6/w2muvkZaWxrRp08jKyqqe927GjBnccsst1eUnT55MZmYmqamppKWl8dprr/Hqq69y//33B+ohCCGEEEI0uibdXQswfvx4jh07xmOPPUZubi7JycmsWLGCxMREAHJzc8nKyqoun5SUxIoVK5g2bRovvfQS7du3Z968eS1yjryQkBBmzpxZpytaND55LZoOeS2aFnk9mg55LYKPppSMMxZCCCGECDZNvrtWCCGEEEKcPUnyhBBCCCGCkCR5QgghhBBBSJI8IYQQQoggJEleC+N0Ounfvz+aprF9+/ZAh9PiZGRkcMcdd5CUlERoaChdu3Zl5syZuFyuQIfWYsyfP5+kpCRsNhsDBw7k66+/DnRILc6sWbO48MILiYiIIDY2lmuvvZY9e/YEOiyB77XRNI2pU6cGOhRxDkiS18I8+OCDstxLAO3evRvDMFi0aBE7d+5kzpw5LFy4kIceeijQobUI77zzDlOnTuXhhx9m27ZtDB8+nLFjx/pNwyQa3rp165gyZQqbNm1i1apVeDweRo8eTWlpaaBDa9G+++47Xn75Zfr16xfoUMQ5IlOotCCfffYZqampvP/++/Tp04dt27bRv3//QIfV4j3zzDMsWLCA9PT0QIcS9AYPHsyAAQNYsGBB9b5evXpx7bXXMmvWrABG1rIdPXqU2NhY1q1bx6WXXhrocFokh8PBgAEDmD9/Po8//jj9+/dn7ty5gQ5L/ErSktdCHDlyhEmTJvGvf/0Lu90e6HBELUVFRbRu3TrQYQQ9l8vF1q1bGT16tN/+0aNHs3HjxgBFJcD3HgDkfRBAU6ZM4corr+Q3v/lNoEMR51CTX/FC/HpKKW677TYmT57MoEGDyMjICHRIotL+/ft54YUXePbZZwMdStDLz8/H6/USFxfntz8uLo7Dhw8HKCqhlCI1NZVLLrmE5OTkQIfTIi1dupTvv/+e7777LtChiHNMWvKasUceeQRN0065bdmyhRdeeIHi4mJmzJgR6JCD1pm+FrXl5ORwxRVXcOONNzJx4sQARd7yaJrm97dSqs4+0XjuvvtufvzxR5YsWRLoUFqk7Oxs7rvvPhYvXozNZgt0OOIck2vymrH8/Hzy8/NPWaZz587cdNNNLF++3O+LzOv1YjKZmDBhAm+++WZDhxr0zvS1qPoQzcnJYeTIkQwePJg33ngDXZffWw3N5XJht9v5z3/+w3XXXVe9/7777mP79u2sW7cugNG1TPfccw/Lli3jq6++IikpKdDhtEjLli3juuuuw2QyVe/zer1omoau6zidTr9jonmRJK8FyMrKori4uPrvnJwcxowZw3vvvcfgwYPp0KFDAKNreQ4dOsTIkSMZOHAgixcvlg/QRjR48GAGDhzI/Pnzq/f17t2ba665RgZeNCKlFPfccw8ffvgha9eupXv37oEOqcUqKSkhMzPTb9/tt99Oz549+ctf/iJd6M2cXJPXAnTq1Mnv7/DwcAC6du0qCV4jy8nJISUlhU6dOjF79myOHj1afSw+Pj6AkbUMqamp/P73v2fQoEFcfPHFvPzyy2RlZTF58uRAh9aiTJkyhbfffpuPPvqIiIiI6msio6KiCA0NDXB0LUtERESdRC4sLIyYmBhJ8IKAJHlCNKKVK1eyb98+9u3bVyfBlkb1hjd+/HiOHTvGY489Rm5uLsnJyaxYsYLExMRAh9aiVE1hk5KS4rf/9ddf57bbbmv8gIQIUtJdK4QQQggRhORqbyGEEEKIICRJnhBCCCFEEJIkTwghhBAiCEmSJ4QQQggRhCTJE0IIIYQIQpLkCSGEEEIEIUnyhBBCCCGCkCR5QgghhBBBSJI8IUTQeOSRR9A0jUceeeRXnadz585omkZGRsZZ1UtJSUHTNNauXVvnWFlZGffffz9JSUlYLBY0TZPVHYQQDUqWNRNCiEYwadIk3n77bex2O/379yckJIQePXoAVCelvzY5FUKI2iTJE0KIc6RTp06cd9552O12v/0FBQUsXboUu93O7t276dixo9/xRx99FJAkTwhxbkmSJ4QQ58hbb71V7/6ff/4ZwzBITk6uk+AJIURDkWvyhBCigZWXlwMQGhoa4EiEEC2JJHlCiHNO0zQ0TQPg/fff59JLL6VVq1Z1BjMcP36chx9+mOTkZMLCwoiIiGDIkCH885//xDCMes/t8Xh4+umn6dmzJzabjYSEBCZNmsSRI0dOGo9Sirfeeqs6DqvVSnx8PAMHDuTBBx/k4MGDJ627adMmxo4dS3R0NGFhYQwfPpwvv/yy3rInDrzIyMhA0zRSUlIAWLduXfVzUzXwoup5qv28VW1nO/BDCCFqk+5aIUSDeeqpp5g+fTpxcXH06NHDL2nZuXMnY8aM4dChQ1itVrp164bT6eTbb79l8+bNrFy5knfffdcvCfJ6vVx//fUsX74cgB49ehAaGsrrr7/OypUrufrqq+uN44EHHuDZZ58FfNfN9ejRg/z8fH766Se+//57hg4dSocOHerU++STT0hNTSUyMpKuXbuyb98+1q9fz5gxY1i1alV18nYyNpuNYcOGUVRUxE8//URkZCR9+/atPt6jRw+GDRvGhg0bABg2bFid+kII8YspIYQ4xwAFKKvVql5++WVlGIZSSim3263cbrdyOByqa9euClD33nuvKioqqq67c+dO1adPHwWoF1980e+8zz//vAJUdHS0+vrrr6v3HzhwQCUnJyuLxaIANXPmzOpjeXl5Std1FRUVpdavX+93vvLycrVkyRL1ww8/+O1PTExUgLJYLGrWrFnK4/EopZRyuVxqwoQJClCDBw+u87hHjBihALVmzRq//WvWrFGAGjFixCmfLyGEOJeku1YI0WDuvPNOJk2aVN0aZzabMZvNvPbaa+zfv5/rrruO559/nsjIyOo6vXv35u2330bTNJ577rnq/Uqp6ta4xx9/nEsuuaT6WOfOnXnzzTdxu911Yti/fz+GYTBq1Kh6W8puuukm+vXrV2/8V1xxBdOnT8dkMgFgsViYO3cuISEhbN68mYKCgl/4zAghRMOTJE8I0WBuueWWevd/8MEHAEycOLHe4/369aNz586kp6dXXy+XlpZGVlYWNput3kmEBwwYwJAhQ+rsrxrNunnzZrKyss4q/vria9OmDZ07dwYgPT39rM4nhBCNSa7JE0I0mF69etW7f8eOHQD87W9/48knn6y3TH5+PgCHDh2iQ4cO7N27F4DExMQ689DVvr9Nmzb57UtISODGG2/kP//5D926dWPkyJGkpKQwfPhwhgwZgtl88o/Brl271rs/NjaWPXv24HA4TlpXCCECTZI8IUSDCQsLq3d/UVERAFu3bj3tOaqmH6lKqNq2bXvSsnFxcfXuf+utt+jduzevvPIKK1euZOXKldXnevDBB0lNTUXX63ZsnCz+qrJKqdPGL4QQgSLdtUKIRhceHg74JglWSp1yqxrBWlXn6NGjJz1vXl5evfttNhuPPPIIBw8eJC0tjUWLFnHVVVdx7NgxHnjgAb9r/4QQIlhIkieEaHS9e/cG4KeffjrjOlXrvGZlZVFWVlZvmbS0tNOep2fPnvzxj3/k448/Zv78+QD885//POM4hBCiuZAkTwjR6K6//noA5s2bd8Zdnj179qRjx46Ul5fXu3zY9u3b+eabb84qjqqBGjk5OWdV71yrWgmjqmtaCCHOBUnyhBCN7s4776RLly6sWbOGCRMmkJub63fc4XDw7rvvkpqaWr1P1/Xqvx9++GE2btxYfSwzM5Nbb70Vi8VS575Wr17NAw88wK5du+rcxzPPPAP4RuYGUpcuXQDfihhCCHGuSJInhGh04eHhfPrppyQlJbFkyRI6dOhA7969GTJkCOeddx6tWrVi/PjxfokcwD333MO4ceM4fvw4w4YNo1evXlxwwQV069aNwsJC7rzzzjr3VVJSwuzZs+nTpw+xsbFceOGF9O/fn7i4OP79738TFRXFnDlzGuuh12v8+PEA/Pa3v2XAgAGkpKSQkpLC4cOHAxqXEKJ5k9G1QoiA6NmzJz/88APz58/nww8/JC0tjfT0dNq1a8eIESMYN24cN9xwg18dk8nEsmXLePbZZ3n99ddJT08nJiaGW2+9lSeeeIIFCxbUuZ/hw4czb948Vq1axU8//cSuXbuwWCx069aNK664gmnTphEfH99YD7te06dPx+v1snTpUnbt2oXT6QSgoqIioHEJIZo3TckcAEIIIYQQQUe6a4UQQgghgpAkeUIIIYQQQUiSPCGEEEKIICRJnhBCCCFEEJIkTwghhBAiCEmSJ4QQQggRhCTJE0IIIYQIQpLkCSGEEEIEIUnyhBBCCCGCkCR5QgghhBBBSJI8IYQQQoggJEmeEEIIIUQQkiRPCCGEECII/X+MuwOXPGtjCgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axes = qp.plotting.plot_native(ens_n[15], xlim=(-5.,5.))\n", "qp.plotting.plot_native(ens_h[15], axes=axes)\n", @@ -690,7 +1819,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": { "scrolled": true }, @@ -702,9 +1831,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 0.0\n" + ] + } + ], "source": [ "cached_gridded = ens_n.gridded(grid)[1]\n", "check = gridded - cached_gridded\n", @@ -720,7 +1857,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -739,9 +1876,33 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.00328146 0.00054128 0.00336019 0.00313608 0.00309157 0.00439593\n", + " 0.00351473 0.00401957 0.00307561 0.00071542 0.00399572 0.00071199\n", + " 0.00020325 0.00094967 0.00241168 0.00375948 0.00220818 0.0030863\n", + " 0.00087861 0.00405013 0.00232632 0.00215408 0.00367854 0.00158009\n", + " 0.00425325 0.00375375 0.00304016 0.00358496 0.0018729 0.00274755\n", + " 0.00328138 0.00191869 0.00110029 0.00266608 0.00426591 0.0032709\n", + " 0.00099753 0.00148295 0.004339 0.00128665 0.0034808 0.00202899\n", + " 0.00317622 0.00062753 0.00030643 0.00220329 0.00193671 0.0026318\n", + " 0.00346929 0.00288634 0.00097727 0.00379207 0.00123326 0.00201153\n", + " 0.00345742 0.00339039 0.00340414 0.00334835 0.00324942 0.00234062\n", + " 0.00291409 0.00192987 0.00339078 0.00449794 0.0016507 0.00100137\n", + " 0.00282526 0.00433243 0.0037402 0.00143214 0.00249251 0.00273985\n", + " 0.00383852 0.00032115 0.00387173 0.00048201 0.00359615 0.00135482\n", + " 0.00343967 0.00069775 0.00178008 0.00276994 0.0044026 0.0042397\n", + " 0.00361834 0.00195354 0.00372586 0.00249882 0.00290852 0.00372111\n", + " 0.001671 0.001206 0.00316984 0.00365273 0.00424861 0.00378746\n", + " 0.00405003 0.00343775 0.00375975 0.00236313]\n" + ] + } + ], "source": [ "# for a single pair of pdfs. (the 15th in each ensemble)\n", "klds = qp.metrics.calculate_kld(ens_n, ens_s, limits=symm_lims)\n", @@ -750,9 +1911,305 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hist approximation: KLD over 1, 2, 3, sigma ranges = ['1.16e-02 +- 3.49e-03', '2.76e-02 +- 5.08e-03', '3.72e-02 +- 5.09e-03']\n", + "interp approximation: KLD over 1, 2, 3, sigma ranges = ['3.16e-02 +- 1.09e-02', '2.33e-02 +- 2.57e-03', '1.01e-02 +- 1.84e-03']\n", + "broken KLD: (array([-3.34073758e-04, 3.30912703e-03, -4.93786389e-04, -8.37800072e-05,\n", + " -4.23816201e-05, -2.63557762e-03, -3.80957819e-04, -1.11335081e-03,\n", + " 8.56201563e-04, 4.02000723e-03, -1.49144484e-03, 3.46311341e-03,\n", + " 3.08394516e-03, 2.79441731e-03, 2.24046439e-03, -9.31299916e-04,\n", + " 3.02823460e-03, -1.94305192e-05, 3.43139231e-03, -1.98802528e-03,\n", + " 1.39418648e-03, 2.30234841e-03, -1.09911717e-03, 3.72754266e-03,\n", + " -2.51893030e-03, -3.63005093e-04, 3.41980113e-05, -8.76962967e-04,\n", + " 1.43427777e-03, 1.23864114e-03, -3.64128172e-04, 3.00846302e-03,\n", + " 2.02608266e-03, 5.47566568e-04, -2.57346642e-03, -3.45660996e-04,\n", + " 5.36599725e-03, 1.75650112e-03, -2.69549032e-03, 3.86151018e-03,\n", + " 2.22526000e-05, 1.25840398e-03, -1.95085916e-04, 2.25503028e-03,\n", + " 4.76528933e-03, 1.10201119e-03, 1.60199763e-03, 2.19871055e-03,\n", + " -6.86871403e-04, 5.56883181e-04, 1.96662508e-03, -3.56015982e-04,\n", + " 3.34035129e-03, 2.87996865e-03, -6.70192665e-04, 2.49894002e-04,\n", + " -5.73335278e-04, 3.65654803e-04, -2.91298470e-04, 1.70596857e-03,\n", + " 7.31942748e-04, 2.02205407e-03, -4.57115313e-04, -3.27536178e-03,\n", + " 1.59061460e-03, 4.40963646e-03, 7.06550418e-04, -2.78845406e-03,\n", + " -1.16320575e-03, 4.19302957e-03, 2.63697340e-03, 5.01463826e-04,\n", + " -1.12696721e-03, 2.70562216e-03, -1.26008305e-03, 2.62483104e-03,\n", + " -7.60031839e-04, 4.45010272e-03, -4.29970668e-04, 4.36210604e-03,\n", + " 3.54380054e-03, 4.14320241e-04, -2.98455986e-03, -2.34217789e-03,\n", + " -8.69640835e-04, 2.65701800e-03, -1.20133261e-03, 2.34313665e-03,\n", + " 8.26396096e-04, -1.19196031e-03, 3.51193861e-03, 3.31317572e-03,\n", + " -6.04159737e-05, -1.05284311e-03, -2.44199150e-03, -1.35348935e-03,\n", + " -1.74683330e-03, -6.17281392e-04, -1.27508474e-03, 2.50276099e-03]), array([[0.04158177, 0.0424172 , 0.04326552, ..., 0.09409137, 0.09261009,\n", + " 0.09114391],\n", + " [0.22697479, 0.22927238, 0.23157117, ..., 0.00691147, 0.00672226,\n", + " 0.00653761],\n", + " [0.05572842, 0.05675937, 0.05780428, ..., 0.07616999, 0.07489766,\n", + " 0.07364005],\n", + " ...,\n", + " [0.04474244, 0.04563761, 0.04654641, ..., 0.08447921, 0.08308015,\n", + " 0.08169675],\n", + " [0.07038916, 0.07169775, 0.07302346, ..., 0.04471112, 0.04379051,\n", + " 0.04288462],\n", + " [0.1660937 , 0.16854776, 0.17101843, ..., 0.00669825, 0.00649407,\n", + " 0.00629539]]), array([[0.04154382, 0.04243922, 0.04334912, ..., 0.09415211, 0.09259685,\n", + " 0.09106071],\n", + " [0.22650018, 0.22869495, 0.23089381, ..., 0.00686016, 0.00669047,\n", + " 0.00652394],\n", + " [0.05568083, 0.05677995, 0.05789545, ..., 0.07625346, 0.0749063 ,\n", + " 0.07357716],\n", + " ...,\n", + " [0.04470637, 0.04566969, 0.04664857, ..., 0.08457681, 0.08309406,\n", + " 0.08163088],\n", + " [0.07035097, 0.07176398, 0.07319822, ..., 0.04485835, 0.04385139,\n", + " 0.04286135],\n", + " [0.16575272, 0.16822305, 0.17071705, ..., 0.00661015, 0.00644473,\n", + " 0.00628247]]), 0.010025062656641603)\n", + "spline approximation: KLD over 1, 2, 3, sigma ranges = ['2.68e-03 +- 1.17e-03', '2.22e-16 +- 0.00e+00', '1.06e-03 +- 2.69e-04']\n", + "broken KLD: (array([ 8.98303006e-03, -9.51730506e-03, 1.02657120e-02, 8.21684653e-03,\n", + " 8.82376378e-03, 5.52704766e-03, 3.69761907e-03, 2.30600025e-03,\n", + " 3.41303958e-06, -1.22217422e-02, 4.68953407e-03, -9.53594768e-03,\n", + " -1.03834940e-02, -5.52635528e-03, -4.50462474e-03, 4.36753856e-03,\n", + " -8.84482248e-03, 8.37814814e-03, -8.86003955e-03, 9.16933360e-03,\n", + " 7.26076775e-04, -3.53858869e-03, 9.47791805e-03, -1.04950079e-02,\n", + " 8.34050626e-03, 1.12269468e-03, 8.62456698e-03, 8.62174010e-03,\n", + " 1.16448736e-03, -4.89657041e-05, 1.05526680e-02, -7.16580349e-03,\n", + " -1.94642870e-03, 6.40059194e-03, 8.59098151e-03, 1.04199251e-02,\n", + " -1.86149581e-02, -6.27756444e-04, 7.33944011e-03, -1.07431237e-02,\n", + " 1.40951178e-03, 2.22707432e-03, 1.01779843e-02, -4.34822157e-03,\n", + " -1.69841441e-02, 3.12338404e-03, 2.49338826e-04, -5.85061824e-03,\n", + " 9.97693830e-03, 3.54686773e-03, -2.01669921e-03, 7.56522646e-04,\n", + " -7.82094707e-03, -6.72017358e-03, 1.03380400e-02, 9.58239564e-04,\n", + " 1.04071456e-02, 6.69538020e-04, 9.31046635e-03, -7.90115892e-04,\n", + " 1.85082323e-03, -1.46541344e-03, 7.41023694e-03, 7.91552391e-03,\n", + " 2.41475339e-04, -1.37123607e-02, 2.79547603e-03, 8.72110195e-03,\n", + " 7.65545758e-03, -1.29067450e-02, -8.00376766e-03, 6.06385450e-03,\n", + " 4.60158237e-03, -7.98838212e-03, 5.11902225e-03, -6.69771362e-03,\n", + " 6.06818233e-03, -1.42314129e-02, 5.62386452e-03, -1.39184950e-02,\n", + " -1.00694190e-02, 7.06452359e-03, 8.30182856e-03, 6.69491806e-03,\n", + " 7.02665715e-03, -5.02592561e-03, 9.41870860e-03, -5.88154551e-03,\n", + " 1.27468312e-03, 9.46231543e-03, -9.44962320e-03, -7.68794941e-03,\n", + " 6.71995803e-03, 9.86061149e-03, 7.50096427e-03, 9.88916702e-03,\n", + " 5.74703133e-03, 9.44853227e-03, 9.33492462e-03, -6.08304168e-03]), array([[0.19407733, 0.19621106, 0.19835029, ..., 0.29135321, 0.28934976,\n", + " 0.28733408],\n", + " [0.38768602, 0.38790636, 0.38808966, ..., 0.06825522, 0.06701765,\n", + " 0.06579622],\n", + " [0.22420955, 0.22635334, 0.22849729, ..., 0.26192881, 0.25983483,\n", + " 0.25773464],\n", + " ...,\n", + " [0.20520294, 0.20740271, 0.20960669, ..., 0.28152676, 0.27941066,\n", + " 0.27728483],\n", + " [0.27173328, 0.27407637, 0.27641221, ..., 0.21682929, 0.21446226,\n", + " 0.21210001],\n", + " [0.40731394, 0.40862415, 0.40989122, ..., 0.08246851, 0.08087256,\n", + " 0.07929834]]), array([[0.2053355 , 0.20719401, 0.20905251, ..., 0.29001173, 0.28815322,\n", + " 0.28629471],\n", + " [0.37724886, 0.37724886, 0.37724886, ..., 0.11480744, 0.11480744,\n", + " 0.11480744],\n", + " [0.23092716, 0.23275527, 0.23458339, ..., 0.2633345 , 0.26150639,\n", + " 0.25967827],\n", + " ...,\n", + " [0.21537287, 0.21727029, 0.21916772, ..., 0.28128067, 0.27938324,\n", + " 0.27748582],\n", + " [0.27384254, 0.27588112, 0.2779197 , ..., 0.22680026, 0.22476168,\n", + " 0.22272309],\n", + " [0.39879348, 0.40057706, 0.40236064, ..., 0.126082 , 0.126082 ,\n", + " 0.126082 ]]), 0.010050251256281407)\n", + "broken KLD: (array([-0.02357027, 0.19435049, -0.0203779 , -0.02469229, -0.02230252,\n", + " 0.05360906, 0.07383069, 0.14531838, 0.15401953, 0.21311165,\n", + " 0.06821509, 0.19530729, 0.19312893, 0.16398985, 0.18763004,\n", + " 0.06059787, 0.20747871, -0.0237511 , 0.19316534, -0.03439368,\n", + " 0.07633188, 0.16680545, -0.02726511, 0.20926851, -0.04007309,\n", + " 0.15582073, -0.02254734, -0.02824433, 0.01226846, 0.13823826,\n", + " -0.01838484, 0.19520918, 0.10274156, -0.02517309, -0.03990016,\n", + " -0.01870853, 0.23672516, 0.05785032, -0.04349694, 0.21232491,\n", + " 0.13770425, -0.02148004, -0.01841089, 0.1367145 , 0.22781226,\n", + " -0.02844367, 0.05932573, 0.19655473, -0.02277272, 0.01762231,\n", + " 0.0972065 , 0.17011663, 0.1921205 , 0.19247703, -0.02149333,\n", + " 0.14579567, -0.02051636, 0.14813254, -0.02217115, 0.13225046,\n", + " 0.08832894, 0.12624929, -0.02938114, -0.04638294, 0.02990044,\n", + " 0.2190113 , 0.04295165, -0.04115844, -0.03279453, 0.22111803,\n", + " 0.20540574, -0.02678819, 0.06247494, 0.17536923, 0.04422412,\n", + " 0.16062781, -0.02664251, 0.22567953, -0.01834663, 0.21713483,\n", + " 0.21296867, -0.02452218, -0.04347256, -0.01711435, -0.03280182,\n", + " 0.18537584, -0.02815838, 0.20092492, 0.10841399, -0.02797071,\n", + " 0.20943696, 0.19544909, -0.02932595, -0.02582038, -0.04142031,\n", + " -0.02794344, 0.02215109, -0.02395557, -0.02891548, 0.19312418]), array([[0.04158177, 0.0424172 , 0.04326552, ..., 0.09409137, 0.09261009,\n", + " 0.09114391],\n", + " [0.22697479, 0.22927238, 0.23157117, ..., 0.00691147, 0.00672226,\n", + " 0.00653761],\n", + " [0.05572842, 0.05675937, 0.05780428, ..., 0.07616999, 0.07489766,\n", + " 0.07364005],\n", + " ...,\n", + " [0.04474244, 0.04563761, 0.04654641, ..., 0.08447921, 0.08308015,\n", + " 0.08169675],\n", + " [0.07038916, 0.07169775, 0.07302346, ..., 0.04471112, 0.04379051,\n", + " 0.04288462],\n", + " [0.1660937 , 0.16854776, 0.17101843, ..., 0.00669825, 0.00649407,\n", + " 0.00629539]]), array([[0.11162411, 0.11162411, 0.11162411, ..., 0.11162411, 0.11162411,\n", + " 0.11162411],\n", + " [0.23475385, 0.23671494, 0.23867604, ..., 0. , 0. ,\n", + " 0. ],\n", + " [0.11070769, 0.11070769, 0.11070769, ..., 0.11070769, 0.11070769,\n", + " 0.11070769],\n", + " ...,\n", + " [0.11278684, 0.11278684, 0.11278684, ..., 0.11278684, 0.11278684,\n", + " 0.11278684],\n", + " [0.1169069 , 0.1169069 , 0.1169069 , ..., 0.1169069 , 0.1169069 ,\n", + " 0.1169069 ],\n", + " [0.18348414, 0.18584932, 0.1882145 , ..., 0. , 0. ,\n", + " 0. ]]), 0.010025062656641603)\n", + "quant approximation: KLD over 1, 2, 3, sigma ranges = ['2.22e-16 +- 0.00e+00', '2.22e-16 +- 0.00e+00', '3.15e-01 +- 8.59e-02']\n", + "broken KLD: (array([ 7.80063387e-03, 2.94335652e-03, -4.61147929e-04, 1.11253852e-02,\n", + " 3.11477444e-02, 6.03501135e-03, 1.26756289e-02, 2.29322839e-02,\n", + " -2.24205487e-02, 5.15568373e-03, -5.46595929e-03, -1.73646005e-03,\n", + " 1.37062559e-02, -6.94627895e-03, 9.52552610e-03, 6.23852763e-03,\n", + " -1.85879105e-02, -1.27292400e-02, -2.24968187e-03, 1.62342912e-02,\n", + " 6.49114330e-04, -6.94648665e-03, 1.68811821e-02, 7.59902714e-03,\n", + " -1.23527939e-02, -7.57307332e-03, 2.70911447e-03, -6.11975783e-03,\n", + " 1.08761641e-02, -1.50760107e-02, 1.86577739e-02, -1.68893045e-02,\n", + " 1.73401673e-02, 7.61505105e-03, 5.51848137e-02, 6.36643662e-03,\n", + " 7.20372862e-03, 2.12848604e-02, 1.81775812e-02, 1.16965547e-02,\n", + " 1.23390794e-02, 3.49405203e-02, 2.60155703e-02, -1.41870440e-02,\n", + " -3.17658862e-03, 9.98062060e-03, 2.60518823e-02, -3.46898433e-04,\n", + " 9.83126688e-03, -2.17161762e-02, -1.15239088e-02, -2.53479136e-02,\n", + " -1.69489099e-02, -1.07280190e-02, 3.86241686e-03, -1.50393350e-02,\n", + " 2.01861332e-04, 1.47854861e-02, 7.11512059e-03, 3.71516374e-03,\n", + " -1.34900652e-02, 9.42189229e-03, -1.09521565e-02, 8.56822042e-03,\n", + " -7.98139182e-03, 5.24890412e-03, -1.19728832e-02, 1.46401984e-02,\n", + " 2.43949425e-03, 1.56621758e-03, -5.38799314e-03, -1.13412226e-02,\n", + " -1.56844491e-02, 3.53863422e-02, 1.49320654e-02, 1.20238218e-03,\n", + " 1.24321685e-02, 4.64911750e-03, 6.60211936e-03, -2.00605266e-03,\n", + " 9.71759125e-04, -1.48541386e-02, 3.48928246e-02, 4.06531301e-02,\n", + " -6.37506417e-05, -7.79669837e-03, 4.18335121e-02, 1.44635000e-02,\n", + " -2.11948574e-02, 1.78358204e-02, 6.96966918e-03, 1.90352430e-03,\n", + " 1.74320636e-02, 7.57413871e-03, 1.36202542e-02, 3.21833516e-03,\n", + " 1.68450071e-02, 2.41603511e-02, 1.96869204e-02, 2.33321177e-03]), array([[0.19407733, 0.19621106, 0.19835029, ..., 0.29135321, 0.28934976,\n", + " 0.28733408],\n", + " [0.38768602, 0.38790636, 0.38808966, ..., 0.06825522, 0.06701765,\n", + " 0.06579622],\n", + " [0.22420955, 0.22635334, 0.22849729, ..., 0.26192881, 0.25983483,\n", + " 0.25773464],\n", + " ...,\n", + " [0.20520294, 0.20740271, 0.20960669, ..., 0.28152676, 0.27941066,\n", + " 0.27728483],\n", + " [0.27173328, 0.27407637, 0.27641221, ..., 0.21682929, 0.21446226,\n", + " 0.21210001],\n", + " [0.40731394, 0.40862415, 0.40989122, ..., 0.08246851, 0.08087256,\n", + " 0.07929834]]), array([[0.17385592, 0.17562417, 0.17741141, ..., 0.26521649, 0.26361563,\n", + " 0.26203605],\n", + " [0.40217844, 0.40251923, 0.40277776, ..., 0.08724369, 0.08564275,\n", + " 0.08405297],\n", + " [0.23104453, 0.23239689, 0.23374614, ..., 0.24212153, 0.23997808,\n", + " 0.23785036],\n", + " ...,\n", + " [0.19274212, 0.19386868, 0.19499448, ..., 0.26842007, 0.26680753,\n", + " 0.26521952],\n", + " [0.24872105, 0.2504306 , 0.25215592, ..., 0.2251332 , 0.22389317,\n", + " 0.22264964],\n", + " [0.44789748, 0.45104328, 0.45411757, ..., 0.07590187, 0.07403968,\n", + " 0.07219892]]), 0.010050251256281407)\n", + "broken KLD: (array([ 3.89800923e-03, 1.38596342e-02, -8.69286877e-03, -3.00516601e-03,\n", + " 1.83243916e-02, 4.04879963e-07, 8.33086880e-03, 1.66504198e-02,\n", + " 8.46235117e-03, 1.05139011e-02, 1.91429545e-03, -2.09859674e-03,\n", + " 1.88961432e-03, 6.68010018e-03, 7.75665394e-03, -1.75135738e-04,\n", + " 1.20420045e-02, 1.00846912e-02, 1.72322487e-02, -5.81967548e-03,\n", + " 1.16584878e-02, -3.26805442e-03, 2.92448568e-03, 2.64355613e-03,\n", + " -5.85684242e-03, 8.83206489e-03, 4.82844972e-03, 5.21939021e-03,\n", + " 1.17723418e-02, 1.38341470e-02, 1.07731057e-02, 1.39602592e-02,\n", + " 1.30948122e-02, 3.17822594e-02, 1.03833609e-02, -5.93727085e-04,\n", + " 2.19135591e-02, 7.17424530e-03, 1.96775658e-03, 8.60985529e-03,\n", + " 4.15006735e-03, 2.20306378e-02, 1.29131731e-03, -2.08071161e-03,\n", + " 1.30881947e-02, 3.50644719e-03, 1.34911648e-02, 9.52032687e-03,\n", + " 7.59406291e-03, 2.22814116e-02, 5.39039650e-04, 5.70152803e-03,\n", + " 1.85218014e-02, -4.37046496e-03, -1.99261538e-03, 8.22808398e-03,\n", + " 4.06796577e-04, 1.12832456e-02, 1.30902640e-02, 6.38532803e-03,\n", + " -1.21173698e-03, 1.02705388e-02, -4.98564975e-03, -7.50734841e-04,\n", + " 4.49616767e-03, 1.69380224e-02, -4.50833118e-04, 1.22986759e-02,\n", + " 8.87656331e-03, 1.79375427e-02, 1.05595480e-02, -9.78783721e-04,\n", + " 8.41800444e-03, 1.31925778e-02, 6.89334523e-03, 9.39811690e-03,\n", + " -6.90893029e-03, 1.54415292e-02, -1.16088108e-02, 6.26749546e-03,\n", + " 1.78137596e-02, -6.20870031e-03, 1.60730122e-02, 1.26099423e-02,\n", + " 1.29003617e-02, 9.33053317e-03, 1.11465595e-02, 2.05201292e-02,\n", + " 9.63597539e-04, 8.82980102e-03, 8.54578277e-03, -1.22506690e-03,\n", + " 2.02601975e-03, -4.42461493e-04, -4.55828689e-03, -6.95544895e-03,\n", + " 1.69249181e-02, -8.42420247e-04, -4.85236762e-03, 8.44683456e-03]), array([[0.04158177, 0.0424172 , 0.04326552, ..., 0.09409137, 0.09261009,\n", + " 0.09114391],\n", + " [0.22697479, 0.22927238, 0.23157117, ..., 0.00691147, 0.00672226,\n", + " 0.00653761],\n", + " [0.05572842, 0.05675937, 0.05780428, ..., 0.07616999, 0.07489766,\n", + " 0.07364005],\n", + " ...,\n", + " [0.04474244, 0.04563761, 0.04654641, ..., 0.08447921, 0.08308015,\n", + " 0.08169675],\n", + " [0.07038916, 0.07169775, 0.07302346, ..., 0.04471112, 0.04379051,\n", + " 0.04288462],\n", + " [0.1660937 , 0.16854776, 0.17101843, ..., 0.00669825, 0.00649407,\n", + " 0.00629539]]), array([[0.04557598, 0.04648284, 0.04739998, ..., 0.11483988, 0.11304784,\n", + " 0.11126016],\n", + " [0.21415397, 0.2155769 , 0.21701159, ..., 0.00462714, 0.00444237,\n", + " 0.00426402],\n", + " [0.05822308, 0.05969578, 0.06118993, ..., 0.07704586, 0.07574702,\n", + " 0.07445847],\n", + " ...,\n", + " [0.04783781, 0.0490491 , 0.05027867, ..., 0.10593383, 0.10400378,\n", + " 0.10208384],\n", + " [0.07237078, 0.07400938, 0.07566618, ..., 0.05533433, 0.05389895,\n", + " 0.05248662],\n", + " [0.19321142, 0.19554537, 0.19785858, ..., 0.00118733, 0.00111924,\n", + " 0.00105469]]), 0.010025062656641603)\n", + "broken KLD: (array([ 0.00037892, 0.00416815, 0.00124518, -0.00062712, 0.00535232,\n", + " 0.00631271, 0.00397351, 0.00526432, 0.00474574, 0.00417993,\n", + " 0.00256004, 0.00812561, -0.0051976 , 0.00071233, 0.00024649,\n", + " 0.0073929 , 0.0083365 , 0.00949517, 0.00370527, 0.00410983,\n", + " 0.00347266, -0.00168024, 0.00278787, 0.00209189, 0.00363793,\n", + " 0.00448957, 0.00480085, 0.00586501, 0.00540291, 0.00543357,\n", + " 0.00281299, 0.00396522, 0.0025778 , 0.01074646, 0.01315307,\n", + " 0.00113892, 0.00496295, 0.00463911, 0.00539903, 0.00063421,\n", + " 0.00459521, 0.00857241, 0.00210322, -0.00262056, 0.0002028 ,\n", + " -0.00263139, 0.00560573, 0.00141607, 0.00196885, 0.013081 ,\n", + " 0.00569797, 0.00866603, 0.00561906, -0.00222925, 0.0025128 ,\n", + " 0.00316278, 0.00631116, 0.00434194, 0.00832284, 0.0004473 ,\n", + " 0.00082714, -0.00022826, 0.00021287, 0.00103077, -0.00021547,\n", + " 0.01046714, 0.00103249, 0.0051404 , 0.00452998, 0.00830518,\n", + " 0.00232325, -0.00061037, 0.00590099, 0.01483251, 0.00619957,\n", + " 0.01631126, 0.00124339, 0.00315322, 0.00531008, 0.00315004,\n", + " 0.00429979, -0.00016729, 0.00681256, 0.01065329, 0.00637827,\n", + " 0.003303 , 0.00496244, 0.00434683, 0.00316507, 0.00436015,\n", + " 0.00106826, 0.00067624, 0.00221516, -0.00020236, 0.01089469,\n", + " -0.00047484, 0.00729501, 0.0029492 , 0.00403226, 0.00793439]), array([[0.00363569, 0.00374212, 0.00385132, ..., 0.01240032, 0.01209618,\n", + " 0.01179844],\n", + " [0.05148891, 0.05250597, 0.05353802, ..., 0.00027118, 0.00026127,\n", + " 0.0002517 ],\n", + " [0.00573615, 0.005894 , 0.00605565, ..., 0.00917286, 0.00894046,\n", + " 0.00871318],\n", + " ...,\n", + " [0.00390716, 0.00402196, 0.00413975, ..., 0.01015272, 0.00989362,\n", + " 0.00964025],\n", + " [0.00682197, 0.00701746, 0.00721783, ..., 0.0034495 , 0.00334542,\n", + " 0.00324417],\n", + " [0.02158595, 0.02215696, 0.02274046, ..., 0.0001734 , 0.0001662 ,\n", + " 0.00015929]]), array([[2.70969543e-03, 2.81132450e-03, 2.91625850e-03, ...,\n", + " 7.89372723e-03, 7.59609738e-03, 7.30799135e-03],\n", + " [6.20659620e-02, 6.34533793e-02, 6.48565730e-02, ...,\n", + " 2.61901952e-05, 2.45870268e-05, 2.30768026e-05],\n", + " [1.28438413e-03, 1.35197915e-03, 1.42275373e-03, ...,\n", + " 6.20458473e-03, 5.99782732e-03, 5.79695464e-03],\n", + " ...,\n", + " [1.13382865e-03, 1.19168327e-03, 1.25217854e-03, ...,\n", + " 4.83418986e-03, 4.62657185e-03, 4.42672686e-03],\n", + " [2.14097709e-03, 2.24627671e-03, 2.35614600e-03, ...,\n", + " 1.05016025e-03, 9.95479080e-04, 9.43387339e-04],\n", + " [1.22608563e-02, 1.28128255e-02, 1.33851187e-02, ...,\n", + " 5.98669929e-07, 5.45263785e-07, 4.96450629e-07]]), 0.01001669449081803)\n", + "mixmod approximation: KLD over 1, 2, 3, sigma ranges = ['2.22e-16 +- 0.00e+00', '2.22e-16 +- 0.00e+00', '2.22e-16 +- 0.00e+00']\n" + ] + } + ], "source": [ "# Loop over all the other ensemble types\n", "ensembles = [ens_n, ens_h, ens_i, ens_s, ens_q, ens_m]\n", @@ -773,11 +2230,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hist approximation: RMSE over 1, 2, 3, sigma ranges = ['4.98e-02 +- 6.10e-03', '5.02e-02 +- 5.34e-03', '4.36e-02 +- 3.81e-03']\n", + "interp approximation: RMSE over 1, 2, 3, sigma ranges = ['2.35e-02 +- 3.98e-03', '1.89e-02 +- 2.86e-03', '1.65e-02 +- 2.40e-03']\n", + "spline approximation: RMSE over 1, 2, 3, sigma ranges = ['4.09e-03 +- 1.76e-03', '3.40e-03 +- 1.26e-03', '2.88e-03 +- 1.02e-03']\n", + "quant approximation: RMSE over 1, 2, 3, sigma ranges = ['1.10e-02 +- 4.44e-03', '2.69e-02 +- 5.00e-03', '3.22e-02 +- 2.81e-03']\n", + "mixmod approximation: RMSE over 1, 2, 3, sigma ranges = ['2.35e-02 +- 8.10e-03', '2.06e-02 +- 5.97e-03', '1.75e-02 +- 4.80e-03']\n" + ] + } + ], "source": [ "for ensemble in ensembles[1:]:\n", " D = []\n", @@ -807,9 +2276,221 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['meta', 'data'])\n", + "\n", + "Meta Data\n", + "{'pdf_name': array([b'norm'], dtype='|S4'), 'pdf_version': array([0])}\n", + "\n", + "Object Data\n", + "{'loc': array([[ 0.21890181],\n", + " [-0.93534652],\n", + " [ 0.07903113],\n", + " [ 0.28176773],\n", + " [-0.24968255],\n", + " [-0.26335094],\n", + " [-0.42948521],\n", + " [-0.4387297 ],\n", + " [-0.57217189],\n", + " [-0.92455534],\n", + " [ 0.34858641],\n", + " [-0.91406855],\n", + " [-0.98414987],\n", + " [-0.86060038],\n", + " [-0.69508709],\n", + " [-0.38516899],\n", + " [ 0.75300729],\n", + " [-0.27768773],\n", + " [ 0.89066815],\n", + " [ 0.07691531],\n", + " [-0.60425626],\n", + " [ 0.70749606],\n", + " [ 0.12587212],\n", + " [-0.82361134],\n", + " [-0.11546958],\n", + " [ 0.49798422],\n", + " [-0.26760305],\n", + " [ 0.20776273],\n", + " [ 0.6291673 ],\n", + " [-0.59647901],\n", + " [-0.00848918],\n", + " [-0.76643467],\n", + " [-0.79806762],\n", + " [-0.4022234 ],\n", + " [-0.08351926],\n", + " [-0.0671515 ],\n", + " [-0.91445451],\n", + " [ 0.71709338],\n", + " [-0.17404626],\n", + " [ 0.85493452],\n", + " [-0.50612038],\n", + " [ 0.58551973],\n", + " [ 0.12310108],\n", + " [ 0.89065211],\n", + " [ 0.98553825],\n", + " [-0.54523168],\n", + " [-0.64930249],\n", + " [-0.6904524 ],\n", + " [ 0.10365389],\n", + " [ 0.48165105],\n", + " [-0.81445327],\n", + " [ 0.50516354],\n", + " [-0.84387341],\n", + " [-0.7536708 ],\n", + " [-0.02983834],\n", + " [ 0.52625015],\n", + " [ 0.0251668 ],\n", + " [-0.53713988],\n", + " [-0.19856034],\n", + " [ 0.64554989],\n", + " [ 0.5297811 ],\n", + " [-0.69668053],\n", + " [-0.29724201],\n", + " [-0.07584431],\n", + " [ 0.67563132],\n", + " [-0.89806725],\n", + " [-0.5085701 ],\n", + " [-0.00230427],\n", + " [ 0.24542697],\n", + " [-0.85116672],\n", + " [ 0.7220289 ],\n", + " [ 0.4094468 ],\n", + " [ 0.36862184],\n", + " [ 0.95756083],\n", + " [-0.34470474],\n", + " [-0.92832706],\n", + " [-0.33563417],\n", + " [ 0.8647574 ],\n", + " [ 0.36856708],\n", + " [-0.9321885 ],\n", + " [-0.80126137],\n", + " [ 0.36804869],\n", + " [ 0.06692571],\n", + " [ 0.2286091 ],\n", + " [ 0.29082508],\n", + " [ 0.7435764 ],\n", + " [ 0.12353467],\n", + " [-0.70184026],\n", + " [-0.5470406 ],\n", + " [-0.1198184 ],\n", + " [-0.80795649],\n", + " [-0.8460751 ],\n", + " [ 0.34980147],\n", + " [ 0.08250539],\n", + " [-0.18080125],\n", + " [-0.02415185],\n", + " [ 0.29852082],\n", + " [ 0.16449945],\n", + " [-0.12600999],\n", + " [-0.71552244]]), 'scale': array([[1.05628552],\n", + " [1.02699736],\n", + " [1.06502927],\n", + " [1.06092663],\n", + " [1.07481621],\n", + " [0.90373225],\n", + " [0.96129187],\n", + " [0.90162672],\n", + " [0.94565748],\n", + " [0.98378847],\n", + " [0.93155093],\n", + " [1.012214 ],\n", + " [1.04801547],\n", + " [1.03997191],\n", + " [0.94610651],\n", + " [0.94807385],\n", + " [0.92175172],\n", + " [1.06866137],\n", + " [1.00618853],\n", + " [0.97491666],\n", + " [1.03004701],\n", + " [0.97416184],\n", + " [1.01915825],\n", + " [0.94269106],\n", + " [0.94427332],\n", + " [0.90704054],\n", + " [1.0774135 ],\n", + " [1.01872588],\n", + " [1.08736909],\n", + " [0.97311218],\n", + " [1.07810052],\n", + " [0.95297913],\n", + " [1.08745088],\n", + " [1.0863323 ],\n", + " [0.94525947],\n", + " [1.07747709],\n", + " [0.90734377],\n", + " [1.08832187],\n", + " [0.92557912],\n", + " [0.95820683],\n", + " [0.9323448 ],\n", + " [1.09059329],\n", + " [1.08510689],\n", + " [1.08773728],\n", + " [0.96730724],\n", + " [1.08696857],\n", + " [1.06120851],\n", + " [0.92081073],\n", + " [1.04875741],\n", + " [1.02002314],\n", + " [1.09783552],\n", + " [0.90057407],\n", + " [0.99066761],\n", + " [0.95133835],\n", + " [1.05478905],\n", + " [0.93307612],\n", + " [1.06184084],\n", + " [0.93248613],\n", + " [1.06442614],\n", + " [0.99735603],\n", + " [0.9907961 ],\n", + " [1.02248052],\n", + " [1.0229267 ],\n", + " [0.91247745],\n", + " [1.0917688 ],\n", + " [0.94950303],\n", + " [1.01468626],\n", + " [0.93893304],\n", + " [0.99063856],\n", + " [0.93046741],\n", + " [0.91248718],\n", + " [1.07302298],\n", + " [0.94408806],\n", + " [1.06640794],\n", + " [0.94751646],\n", + " [1.06756101],\n", + " [0.98475575],\n", + " [0.92380544],\n", + " [0.99388315],\n", + " [0.9683748 ],\n", + " [0.93527174],\n", + " [1.08436163],\n", + " [0.92703754],\n", + " [0.92987075],\n", + " [0.99505897],\n", + " [0.97200232],\n", + " [1.01325771],\n", + " [0.9285457 ],\n", + " [0.98174109],\n", + " [1.01429324],\n", + " [0.94676408],\n", + " [0.99403992],\n", + " [1.03596655],\n", + " [1.0266698 ],\n", + " [0.93673041],\n", + " [1.01194906],\n", + " [0.93848628],\n", + " [1.04539621],\n", + " [1.00855411],\n", + " [0.93516073]])}\n" + ] + } + ], "source": [ "tabs = ens_n.build_tables()\n", "print(tabs.keys())\n", @@ -830,9 +2511,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_n fits 0.0 0.0\n", + "_n hf5 0.0 0.0\n", + "_h fits -1.1102230246251565e-16 5.551115123125783e-17\n", + "_h hf5 -1.1102230246251565e-16 5.551115123125783e-17\n", + "_i fits -1.1102230246251565e-16 5.551115123125783e-17\n", + "_i hf5 -1.1102230246251565e-16 5.551115123125783e-17\n", + "_s fits 0.0 0.0\n", + "_s hf5 0.0 0.0\n", + "_q fits 0.0 0.0\n", + "_q hf5 0.0 0.0\n", + "_m fits -1.1102230246251565e-16 0.0\n", + "_m hf5 -1.1102230246251565e-16 0.0\n" + ] + } + ], "source": [ "suffix_list = ['_n', '_h', '_i', '_s', '_q', '_m']\n", "filetypes = ['fits', 'hf5']\n", @@ -866,9 +2566,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "moments: range(0, 3)\n", + "norm: ['9.92e-01 +- 6.50e-03', '-1.02e-01 +- 5.32e-01', '1.23e+00 +- 2.43e-01']\n", + "hist: ['9.93e-01 +- 6.63e-03', '-1.03e-01 +- 5.31e-01', '1.39e+00 +- 2.36e-01']\n", + "interp: ['9.87e-01 +- 8.52e-03', '-9.91e-02 +- 5.18e-01', '1.34e+00 +- 2.16e-01']\n", + "spline: ['9.91e-01 +- 6.62e-03', '-1.02e-01 +- 5.33e-01', '1.23e+00 +- 2.48e-01']\n", + "quant: ['1.07e+00 +- 1.45e-02', '-1.10e-01 +- 5.72e-01', '1.56e+00 +- 2.36e-01']\n", + "mixmod: ['9.93e-01 +- 6.73e-03', '-1.05e-01 +- 5.37e-01', '1.26e+00 +- 2.52e-01']\n" + ] + } + ], "source": [ "which_moments = range(3)\n", "all_moments = []\n", @@ -884,6 +2598,20 @@ " print(ens.gen_class.name+': '+str(mom))" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -908,7 +2636,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.9.undefined" }, "vscode": { "interpreter": { diff --git a/nb/priors_example.ipynb b/nb/priors_example.ipynb new file mode 100644 index 00000000..a8845edf --- /dev/null +++ b/nb/priors_example.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy.linalg import cholesky\n", + "import matplotlib.pyplot as plt\n", + "from scipy.interpolate import interp1d\n", + "import scipy.stats as stats\n", + "import sys\n", + "\n", + "sys.path.insert(1, '/home/jaimerz/Documents/UCL/qp/src')\n", + "import qp" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "dummy = np.load('../src/qp/projectors/tests/dummy.npz')\n", + "zs = dummy['zs']\n", + "pzs = dummy['pzs']\n", + "cov = np.cov(pzs.T)\n", + "dz = np.mean(np.diff(zs))\n", + "zs_edges = np.append(zs - dz/2, zs[-1] + dz/2)\n", + "q = qp.Ensemble(qp.hist, data={\"bins\":zs_edges, \"pdfs\":pzs})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure, axis = plt.subplots(2, 1, figsize=(5,10))\n", + "figure.subplots_adjust(wspace=0, hspace=0.01)\n", + "for i in range(100):\n", + " axis[0].plot(zs, pzs[i], 'k-', alpha=0.05)\n", + "axis[0].set_ylabel(r'$p(z)$')\n", + "im = axis[1].imshow(abs(cov), aspect='auto',\n", + " origin='lower', cmap='gray',\n", + " extent=[min(zs), max(zs), max(zs), min(zs)])\n", + "axis[1].set_xlabel(r'$z$')\n", + "cbar_ax = figure.add_axes([0.905, 0.11, 0.02, 0.38])\n", + "figure.colorbar(im, cax=cbar_ax)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Shifts" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45 (100, 45)\n" + ] + } + ], + "source": [ + "shifts = qp.projectors.projector_shifts.ProjectorShifts(q)\n", + "#shifts = rp.ProjectorShifts(zs, pzs)\n", + "print(len(shifts.z), shifts.pzs.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "pz_fid = [shifts.z, shifts.pz_mean]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "shifted_pzs = np.array([shifts.evaluate_model(pz_fid, shifts.sample_prior())[1] for i in range(100)])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "shifted_cov = np.cov(shifted_pzs.T)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure, axis = plt.subplots(2, 1, figsize=(5,10))\n", + "figure.subplots_adjust(wspace=0, hspace=0.01)\n", + "for i in range(100):\n", + " pz = shifted_pzs[i]\n", + " axis[0].plot(shifts.z, pz, 'k-', alpha=0.05)\n", + "axis[0].errorbar(shifts.z, shifts.pz_mean, yerr=np.sqrt(np.diag(shifted_cov)), fmt='k-')\n", + "axis[0].set_ylabel(r'$p(z)$')\n", + "im = axis[1].imshow(abs(shifted_cov), aspect='auto',\n", + " origin='lower', cmap='gray',\n", + " extent=[min(zs), max(zs), max(zs), min(zs)])\n", + "axis[1].set_xlabel(r'$z$')\n", + "cbar_ax = figure.add_axes([0.905, 0.11, 0.02, 0.38])\n", + "figure.colorbar(im, cax=cbar_ax)\n", + "#plt.savefig('docs/source/assets/shifts.png')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Moments" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Covariance matrix is not positive definite\n", + "The covariance matrix will be regularized\n", + "Warning: regularization failed\n", + "The covariance matrix will be diagonalized\n" + ] + } + ], + "source": [ + "moments = qp.projectors.projector_moments.ProjectorMoments(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "moments_pzs = np.array([moments.evaluate_model(pz_fid, moments.sample_prior())[1] for i in range(100)])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "moments_cov = np.cov(moments_pzs.T)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure, axis = plt.subplots(2, 1, figsize=(5,10))\n", + "figure.subplots_adjust(wspace=0, hspace=0.01)\n", + "for i in range(100):\n", + " axis[0].plot(moments.z, moments_pzs[i], 'k-', alpha=0.05)\n", + "axis[0].errorbar(moments.z, moments.pz_mean, yerr=np.sqrt(np.diag(moments_cov)), fmt='k-')\n", + "axis[0].set_ylabel(r'$p(z)$')\n", + "im = axis[1].imshow(abs(moments_cov), aspect='auto',\n", + " origin='lower', cmap='gray',\n", + " extent=[min(zs), max(zs), max(zs), min(zs)])\n", + "axis[1].set_xlabel(r'$z$')\n", + "cbar_ax = figure.add_axes([0.905, 0.11, 0.02, 0.38])\n", + "figure.colorbar(im, cax=cbar_ax)\n", + "#plt.savefig('docs/source/assets/moments.png')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tutorials", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qp/projectors/projector_base.py b/src/qp/projectors/projector_base.py index cb5fe001..6370219b 100644 --- a/src/qp/projectors/projector_base.py +++ b/src/qp/projectors/projector_base.py @@ -28,7 +28,7 @@ def _project_base(self, zs, pzs): self.pz_mean = np.mean(self.pzs, axis=0) self.prior = None - @dispatch(qp.ensemble.Ensemble) + @dispatch(Ensemble) def _project_base(self, ens, z=None): if z is None: z = np.linspace(0, 1.5, 45) diff --git a/src/qp/projectors/tests/__init__.py b/src/qp/projectors/tests/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/qp/projectors/tests/dummy.npz b/tests/qp/dummy.npz similarity index 100% rename from src/qp/projectors/tests/dummy.npz rename to tests/qp/dummy.npz diff --git a/src/qp/projectors/tests/test_projector_base.py b/tests/qp/test_projector_base.py similarity index 77% rename from src/qp/projectors/tests/test_projector_base.py rename to tests/qp/test_projector_base.py index f93229a0..73f7ba59 100644 --- a/src/qp/projectors/tests/test_projector_base.py +++ b/tests/qp/test_projector_base.py @@ -1,6 +1,6 @@ import qp +import qp.projectors as proj import numpy as np -import rail_projector.projectors as rp def make_qp_ens(file): @@ -12,9 +12,9 @@ def make_qp_ens(file): return q def test_base_from_qp(): - file = np.load('rail_projector/tests/dummy.npz') + file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) - projector = rp.ProjectorBase(ens) + projector = proj.ProjectorBase.ProjectorBase(ens) m, n = projector.pzs.shape k, = projector.z.shape pzs = file['pzs'] @@ -23,10 +23,10 @@ def test_base_from_qp(): assert np.allclose(projector.pz_mean, np.mean(pzs, axis=0)) def test_base_from_arrs(): - file = np.load('rail_projector/tests/dummy.npz') + file = np.load('tests/qp/dummy.npz') zs = file['zs'] pzs = file['pzs'] - projector = rp.ProjectorBase(zs, pzs) + projector = proj.ProjectorBase.ProjectorBase(zs, pzs) m, n = projector.pzs.shape k, = projector.z.shape pzs = file['pzs'] diff --git a/src/qp/projectors/tests/test_projector_moments.py b/tests/qp/test_projector_moments.py similarity index 86% rename from src/qp/projectors/tests/test_projector_moments.py rename to tests/qp/test_projector_moments.py index d9030748..b8663bb8 100644 --- a/src/qp/projectors/tests/test_projector_moments.py +++ b/tests/qp/test_projector_moments.py @@ -1,6 +1,6 @@ import qp import numpy as np -import rail_projector.projectors as rp +import qp.projectors as proj def make_qp_ens(file): @@ -13,9 +13,9 @@ def make_qp_ens(file): def make_projector(): - file = np.load('rail_projector/tests/dummy.npz') + file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) - return rp.ProjectorMoments(ens) + return proj.projector_moments.ProjectorMoments(ens) def test_prior(): diff --git a/src/qp/projectors/tests/test_projector_shifts.py b/tests/qp/test_projector_shifts.py similarity index 87% rename from src/qp/projectors/tests/test_projector_shifts.py rename to tests/qp/test_projector_shifts.py index 1cc5f253..207bf887 100644 --- a/src/qp/projectors/tests/test_projector_shifts.py +++ b/tests/qp/test_projector_shifts.py @@ -1,6 +1,6 @@ import qp import numpy as np -import rail_projector.projectors as rp +import qp.projectors as proj def make_qp_ens(file): @@ -13,9 +13,9 @@ def make_qp_ens(file): def make_projector(): - file = np.load('rail_projector/tests/dummy.npz') + file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) - return rp.ProjectorShifts(ens) + return proj.projector_shifts.ProjectorShifts(ens) def test_prior(): From 4b59eb0573522a0281376bc3b960eee7f0e7b154 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Tue, 11 Jun 2024 10:57:28 +0100 Subject: [PATCH 03/13] trying to get the tests to work --- nb/priors_example.ipynb | 30 ++++++++++++++---------------- tests/qp/test_projector_base.py | 4 ++-- tests/qp/test_projector_moments.py | 2 +- tests/qp/test_projector_shifts.py | 2 +- 4 files changed, 18 insertions(+), 20 deletions(-) diff --git a/nb/priors_example.ipynb b/nb/priors_example.ipynb index a8845edf..3958bf5c 100644 --- a/nb/priors_example.ipynb +++ b/nb/priors_example.ipynb @@ -26,11 +26,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "dummy = np.load('../src/qp/projectors/tests/dummy.npz')\n", + "dummy = np.load('../tests/qp/dummy.npz')\n", "zs = dummy['zs']\n", "pzs = dummy['pzs']\n", "cov = np.cov(pzs.T)\n", @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -79,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -91,14 +91,12 @@ } ], "source": [ - "shifts = qp.projectors.projector_shifts.ProjectorShifts(q)\n", - "#shifts = rp.ProjectorShifts(zs, pzs)\n", - "print(len(shifts.z), shifts.pzs.shape)" + "shifts = qp.projectors.ProjectorShifts(q)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -116,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -125,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -166,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -181,12 +179,12 @@ } ], "source": [ - "moments = qp.projectors.projector_moments.ProjectorMoments(q)" + "moments = qp.projectors.ProjectorMoments(q)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -195,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -204,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "metadata": {}, "outputs": [ { diff --git a/tests/qp/test_projector_base.py b/tests/qp/test_projector_base.py index 73f7ba59..cc10427e 100644 --- a/tests/qp/test_projector_base.py +++ b/tests/qp/test_projector_base.py @@ -14,7 +14,7 @@ def make_qp_ens(file): def test_base_from_qp(): file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) - projector = proj.ProjectorBase.ProjectorBase(ens) + projector = proj.ProjectorBase(ens) m, n = projector.pzs.shape k, = projector.z.shape pzs = file['pzs'] @@ -26,7 +26,7 @@ def test_base_from_arrs(): file = np.load('tests/qp/dummy.npz') zs = file['zs'] pzs = file['pzs'] - projector = proj.ProjectorBase.ProjectorBase(zs, pzs) + projector = proj.ProjectorBase(zs, pzs) m, n = projector.pzs.shape k, = projector.z.shape pzs = file['pzs'] diff --git a/tests/qp/test_projector_moments.py b/tests/qp/test_projector_moments.py index b8663bb8..60dbe880 100644 --- a/tests/qp/test_projector_moments.py +++ b/tests/qp/test_projector_moments.py @@ -15,7 +15,7 @@ def make_qp_ens(file): def make_projector(): file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) - return proj.projector_moments.ProjectorMoments(ens) + return proj.ProjectorMoments(ens) def test_prior(): diff --git a/tests/qp/test_projector_shifts.py b/tests/qp/test_projector_shifts.py index 207bf887..7007a49a 100644 --- a/tests/qp/test_projector_shifts.py +++ b/tests/qp/test_projector_shifts.py @@ -15,7 +15,7 @@ def make_qp_ens(file): def make_projector(): file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) - return proj.projector_shifts.ProjectorShifts(ens) + return proj.ProjectorShifts(ens) def test_prior(): From 231779a3d7f65d4b01e3c867c194596cf1178ff4 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Tue, 11 Jun 2024 12:09:17 +0100 Subject: [PATCH 04/13] docs --- src/qp/projectors/projector_base.py | 24 ++++++++++++++++++++++++ src/qp/projectors/projector_moments.py | 19 +++++++++++++++++++ src/qp/projectors/projector_shifts.py | 6 ++++++ 3 files changed, 49 insertions(+) diff --git a/src/qp/projectors/projector_base.py b/src/qp/projectors/projector_base.py index 6370219b..71df24b9 100644 --- a/src/qp/projectors/projector_base.py +++ b/src/qp/projectors/projector_base.py @@ -4,6 +4,17 @@ class ProjectorBase(object): + """ + Base class for projectors. Projectors are used to project the measured + photometric distributions by RAIL onto the space of a given generative + photometric model for inference. + This class is not meant to be used directly, + but to be subclassed by specific projectors. + The subclasses should implement the following methods: + - evaluate_model: given a set of parameters, evaluate the model + - get_prior: return the prior distribution of the model given + the meadured photometric distributions. + """ @dispatch() def __init__(self): self._project_base() @@ -45,16 +56,29 @@ def _normalize(self, pzs): return pzs def evaluate_model(self, *args): + """ + Evaluate the model at the given parameters. + """ raise NotImplementedError def get_prior(self): + """ + Returns the calibrated prior distribution for the model + parameters given the measured photometric distributions. + """ if self.prior is None: self.prior = self._get_prior() return self.prior def sample_prior(self): + """ + Draws a sample from the prior distribution. + """ prior = self.get_prior() return prior.rvs() def save_prior(self): + """ + Saves the prior distribution to a file. + """ raise NotImplementedError diff --git a/src/qp/projectors/projector_moments.py b/src/qp/projectors/projector_moments.py index 391b1705..5e59b6b9 100644 --- a/src/qp/projectors/projector_moments.py +++ b/src/qp/projectors/projector_moments.py @@ -7,6 +7,20 @@ class ProjectorMoments(ProjectorBase): + """ + Projector for the moments model. + The moments model assumes that meausred photometric distribution + is Gaussian meaning that it can be fully described by its mean and + covariance matrix. Conceptually, this is equavalent to a + Gaussian process regressio for a given p(z). The details can be found + in the paper: 2301.11978 + + Some measured photometric distributions will possess non-invertible + covariance matrices. If this is the case, ProjectorMoments will + attempt regularize the covariance matrix by adding a small jitter + to its eigen-values. If this fails, the covariance matrix will be + diagonalized. + """ @dispatch() def __init__(self): self._project_base() @@ -47,6 +61,11 @@ def _is_pos_def(self, A): return np.all(np.linalg.eigvals(A) > 0) def evaluate_model(self, pz, alpha): + """ + Samples a photometric distribution + from a Gaussian distribution with mean + and covariance measured from the data. + """ z = pz[0] pz = pz[1] return [z, pz + self.pz_chol @ alpha] diff --git a/src/qp/projectors/projector_shifts.py b/src/qp/projectors/projector_shifts.py index 11be278e..f5514d02 100644 --- a/src/qp/projectors/projector_shifts.py +++ b/src/qp/projectors/projector_shifts.py @@ -26,6 +26,12 @@ def _project(self): self.shift = self._find_shift() def evaluate_model(self, pz, shift): + """ + Aplies a shift to the given p(z) distribution. + This is done by interpolating the p(z) distribution + at the shifted z values and then evaluating it at the + original z values. + """ z = pz[0] pz = pz[1] z_shift = z + shift From 354356331ac8ca759994e5ebe7a3e362a9f334c9 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Thu, 13 Jun 2024 19:24:12 +0100 Subject: [PATCH 05/13] main functions --- nb/priors_example.ipynb | 148 ++++++++++++++++++++----- src/qp/projectors/__init__.py | 1 + src/qp/projectors/projector_base.py | 53 ++++----- src/qp/projectors/projector_moments.py | 26 ++--- src/qp/projectors/projector_shifts.py | 38 +++---- 5 files changed, 172 insertions(+), 94 deletions(-) diff --git a/nb/priors_example.ipynb b/nb/priors_example.ipynb index 3958bf5c..b1c018f7 100644 --- a/nb/priors_example.ipynb +++ b/nb/priors_example.ipynb @@ -4,7 +4,21 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (projector_shifts_widths.py, line 71)", + "output_type": "error", + "traceback": [ + "Traceback \u001b[0;36m(most recent call last)\u001b[0m:\n", + "\u001b[0m File \u001b[1;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3508\u001b[0m in \u001b[1;35mrun_code\u001b[0m\n exec(code_obj, self.user_global_ns, self.user_ns)\u001b[0m\n", + "\u001b[0m Cell \u001b[1;32mIn[1], line 9\u001b[0m\n import qp\u001b[0m\n", + "\u001b[0m File \u001b[1;32m~/Documents/UCL/qp/src/qp/__init__.py:38\u001b[0m\n from . import projectors\u001b[0m\n", + "\u001b[0;36m File \u001b[0;32m~/Documents/UCL/qp/src/qp/projectors/__init__.py:3\u001b[0;36m\n\u001b[0;31m from .projector_shifts_widths import ProjectorShiftsWidths\u001b[0;36m\n", + "\u001b[0;36m File \u001b[0;32m~/Documents/UCL/qp/src/qp/projectors/projector_shifts_widths.py:71\u001b[0;36m\u001b[0m\n\u001b[0;31m return mvn([1], [self.width**2])S\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], "source": [ "import numpy as np\n", "from numpy.linalg import cholesky\n", @@ -26,14 +40,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "dummy = np.load('../tests/qp/dummy.npz')\n", "zs = dummy['zs']\n", "pzs = dummy['pzs']\n", - "cov = np.cov(pzs.T)\n", "dz = np.mean(np.diff(zs))\n", "zs_edges = np.append(zs - dz/2, zs[-1] + dz/2)\n", "q = qp.Ensemble(qp.hist, data={\"bins\":zs_edges, \"pdfs\":pzs})" @@ -41,12 +54,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base = qp.projectors.ProjectorBase(q)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAANBCAYAAACF3EZzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9e5Dkd3UdfvrxffZ7ZnZntWL1QDZGi7AJKyykRGAboweuGBuIliS12MEQqyiXkBQ7WAKCQ9UvQmViKxiQgi2KkDigcgSYxKIiEduKQGuChJBdRjyMZVbS7mqe/fr2u/v7+2Pq3Lnd89jZx+z0zNxTNbU7Pd/+vmb6e8/n3nPPTcRxHMNgMBgMBoNBIbnVJ2AwGAwGg2H8YATBYDAYDAbDChhBMBgMBoPBsAJGEAwGg8FgMKyAEQSDwWAwGAwrYATBYDAYDAbDChhBMBgMBoPBsAJGEAwGg8FgMKxAeqtPYDdhMBjg+PHjyOVySCQSW306BoPBYNgixHGMWq2G/fv3I5kcz7W6EYTziOPHj+PAgQNbfRoGg8FgGBM899xzeMlLXrLVp7EqjCCcR+RyOQBLfxD5fH6Lz8ZgMBgMW4VqtYoDBw5IXBhHGEE4j2BZIZ/PG0EwGAwGw1iXm8ez8GEwGAwGg2FLYQTBYDAYDAbDChhBMBgMBoPBsAJGEAwGg8FgMKyAEQSDwWAwGAwrYATBYDAYDAbDChhBMBgMBoPBsAJGEAwGg8FgMKyAEQSDwWAwGAwrYATBYDAYDAbDChhBMBgMBoPBsAJGEAwGg8FgMKyAEQSDwWAwGAwrYATBYDBsG8RxjEajgU6ns9WnYjDseBhBMBgM2wb9fh/9fh/dbnerT8Vg2PEwgmAwGLYNBoPB0L8Gg2HzYATBYDBsG2hiEMfxFp6JwbDzYQTBYDBsGxhBMBjOH4wgGAyGbQNNEKzMYDBsLowgGAyGbYE4joeyBpZBMBg2F0YQDAbDtsBoxsAyCAbD5sIIgsFg2BYYJQSWQTAYNhdGEAwGw7YACUIikQBgBMFg2GwYQTAYDNsC/X4fAJBKpQBYicFg2GwYQTAYDNsCJATpdBqAZRAMhs2GEQSDwTD20B0MzCAYQTAYNhdGEAwGw9hD6w+SyeSK1w0Gw7mHEQSDwTD2IBEgOeC/lkUwGDYPRhAMBsPYY5QgWCeDwbD5MIJgMBjGHmsRBCsxGAybByMIBoNh7GElBoPh/MMIgsFgGHtYBsFgOP8wgmAwGMYamgRYBsFgOH8wgmAwGMYao9kDwESKBsP5gBEEg8Ew1liPIJxJiWEwGBixMBg2gLEjCJ/85Cdx6aWXwvd9HDp0CI899ti62z/66KM4dOgQfN/HS1/6Utx3330rtnnwwQdx8OBBeJ6HgwcP4otf/OIZHfeZZ57BL/7iL6JQKCCXy+G1r30tjh07duYXazAYTgmSADooAsNk4XSC/WAwQBRFaDab5+4EDYYdirEiCA888ABuvfVWvP/978dTTz2Fa6+9FjfeeOOaQfjZZ5/Fm970Jlx77bV46qmncOedd+KWW27Bgw8+KNscPXoUhw8fxpEjR/D000/jyJEjuOmmm/CNb3zjtI77wx/+EP/kn/wTvPzlL8df/uVf4umnn8YHP/hB+L6/eTfEYDCsmkEAzqzMwIFP/NdgMKyNRDxGubarrroKr371q3HvvffKa5dffjl+6Zd+CXfdddeK7d/3vvfhy1/+Mp555hl57eabb8bTTz+No0ePAgAOHz6MarWKr3zlK7LNDTfcgFKphM997nMbPu7b3/52OI6D//pf/+sZX1+1WkWhUEClUkE+nz/j/RgMuwn1eh1xHCOTyQyRhCiKMBgMEASBDHA6FVqtFrrdLgAgDMOhrITBcD6xHeLB2GQQOp0OnnzySVx33XVDr1933XV4/PHHV33P0aNHV2x//fXX44knnpCHwFrbcJ8bOe5gMMCf/dmf4WUvexmuv/567N27F1dddRW+9KUvnfH1GgyGU0MPaWLGgDiTTgadObAWSYNhfYwNQZibm0O/38f09PTQ69PT0zh58uSq7zl58uSq2/d6PczNza27Dfe5kePOzMygXq/jIx/5CG644QY8/PDD+OVf/mW85S1vwaOPPrrmNbXbbVSr1aEvg8GwcejywihBOJMSgyYFRhAMhvWxsbzcecToQyCO4xWvnWr70dc3ss/1tuGD5M1vfjNuu+02AMCrXvUqPP7447jvvvvw+te/ftVzu+uuu/Dv//2/X/PcDQbD+lhLfwCcfifDqO7AdAgGw/oYmwzC1NQUUqnUimzBzMzMitU9sW/fvlW3T6fTmJycXHcb7nMjx52amkI6ncbBgweHtrn88svX7WK44447UKlU5Ou5555bc1uDwbAS6xGE0y0x6JHR+nuDwbA6xoYguK6LQ4cO4ZFHHhl6/ZFHHsE111yz6nuuvvrqFds//PDDuPLKK+E4zrrbcJ8bOa7runjNa16D733ve0PbfP/738fFF1+85jV5nod8Pj/0ZTAYNo7NyCDw2RDHsZEEg2E9xGOEz3/+87HjOPH9998ff+c734lvvfXWOJPJxP/wD/8Qx3Ec//Zv/3Z85MgR2f7v//7v4zAM49tuuy3+zne+E99///2x4zjx//gf/0O2+frXvx6nUqn4Ix/5SPzMM8/EH/nIR+J0Oh3/1V/91YaPG8dx/IUvfCF2HCf+1Kc+Ff/gBz+I/+AP/iBOpVLxY489tuHrq1QqMYC4UqmczW0yGHYN6vV6XK1W416vt+Jn/X4/rlarca1W29C+oiiKq9Vq3O12h/5vMGwFtkM8GCuCEMdx/IlPfCK++OKLY9d141e/+tXxo48+Kj/7lV/5lfj1r3/90PZ/+Zd/Gf+jf/SPYtd140suuSS+9957V+zzT/7kT+Kf+ImfiB3HiV/+8pfHDz744Gkdl7j//vvjH/uxH4t9349/6qd+Kv7Sl750Wte2Hf4gDIZxQrVajavVajwYDFb8bDAYyM9PZ1/9fj9uNptxtVqNW63WuT5lg2FD2A7xYKx8EHY6tkPfq8EwLqDrYSKRQDabldd7vR6SySSSySRqtRoArPBIONW+Op0O2u020uk0giDY9GsxGEaxHeLB2GgQDAaDQWM1/UG/30ez2RSr5I0KFak/4PY0SLJOBoNhbRhBMBgMY4nVCAJfGwwG6Pf7G/ZCGJ3noImFJVENhtVhBMFgMIwl1iMIANDtdjfcyTCaQUgkEvJ/62QwGFaHEQSDwTCWGA3qwNKKv9frYTAYiBaBr6+H9SZCWpnBYFgdRhAMBsNYgkFfE4Rut4tms4lWq4U4jiW4r0cQBoOBOKPqfZEsWAbBYFgdRhAMBsPYgUEdWEkQWq0Wer0eAMi/6wV5nYmI4xjNZhOdTscyCAbDKWAEwWAwjB3WclBst9vo9XrigkgicaoMArCUMej3++j1ekMEwTIIBsPqMIJgMBjGDmsJFClMTCaTGAwGSCQS6Ha76xIEnUEYLUnYXAaDYW0YQTAYDGOHtQjCaGujJghrkYTRDIJ+3coMBsPaMIJgMBjGDhshCMwgsNywGkEY1TLoTMFgMDChosGwDowgGAyGscNqBKHb7Qop4DaJRGLdMoPOHpAsdDod9Pt99Pt9yyAYDOsgvdUnYDAYDBq6XKAJQqfTAQCk02mk02khCMlkUsiD9jkAVuoP+v0+2u02EokEHMexDILBsA4sg2AwGMYKDNbMDhAkCEEQCEEAltsXu93umvui/qDf78NxHDFc0noGIwkGwzCMIBgMhrHCei2OAOC6LtLppeRnr9eT//PnGjqDQA1Du91Gp9MRR0ZrdzQYVocRBIPBMFZYiyDQFMn3faRSKdEVcLtRHYIWKDKD0Ol0pIRBgmBlBoNhdZgGwWAwjBXWGvPMkoDjOBgMBkin00NaBQZ9x3FW7IeZhG63i16vJ9v1ej0b/WwwrAHLIBgMhrHCagSB5YNUKoVkMolkMik6BJIFGikRDPjMNPR6PbRaLQBL+oZ+v49ut2sZBINhDRhBMBgMY4XVJi8y8LuuCwBCEvh/+iH0+315vyYavV4P9Xodg8EA9Xp9TcvlU02FNBh2E4wgGAyGscFaHQxaoAhgBTno9/tIpVJSZgCGMwj1el1KC7VaDdVqVcoNcRybUNFgWAVGEAwGw9hAEwQNtjiSIPDnOrBTmzBqvdxut8Unge2M7XYb7XZbygxmmGQwrIQRBIPBMDZYzSAJWC4xeJ4nGQIAkjXQhGIwGAih6Ha78n/HcdBqtcQzYTWCYBkEg2EZRhAMBsPYYHTKIgARGAJLhKDZbKLVaq1ZZgCWswY0R/I8TzIHjuOILoFkwjoZDIaVMIJgMBjGBqsRBHoX6LZGPUeBgkXdsthoNIREsPOh3+8jjmO4rotkMolWq4VOp7NCqGgwGJZgBMFgMIwN1iIIAKSVkSt/ggSAuoM4jhFFEXq9HjzPE21CFEUAMPRaq9WSVkk9BMpgMBhBMBgMY4T1CILrumi32zh+/Djm5ubk5/RBAIZLC4PBAGEYCqmgUJEZBzorsvRgQkWDYRhGEAwGw9jgVASBLYoLCwsiXBwMBtLdUK1WASyVHTzPG3JQbLfb6PV6CIIAnuchmUzK6GczTDIYVsIIgsFgGBusRxBSqRRqtZqQhGazCWC5xZHZgziOkclkkEqlxD+h3W6j0WgglUrBdV3kcjl5nZkEHtMyCAbDEowgGAyGscEoQWAXQiKRQDKZlAxBr9cTTQGwFOjpc5BIJOC6rhCEfr+PcrmMXq8H3/cBLI2MTiQS6PV6Q+8FLINgMBBGEAwGw9hglCAwI5BOp6XjgHqDWq0mxkjtdhvpdFp8EtjK2Ol0UK1W0Wq1hggCAGl91EJFnoNZLhsMRhAMBsOYQK/cRwlCKpVCFEXodrtwXRfpdFr8EBjgM5mMEAlgSbPQ6XQwMzODer0O13URBAEcx0EqlYLv+0gkEmg2m1JmMKGiwbAMIwgGg2EssJr+gAQhmUyi0WhgMBjA8zz4vo92u41KpSI/D8MQACQb0Ov1sLi4KNtkMhkUi0Wk02kkEglks1kAEKEiSxnch8Gw25He6hMwGAwGYH2BYhzH4nhI/UC1WkWj0UAmk5FsQCKRQLfbRbValemOcRzDcRwUCgV4nieEIggCJJNJdLvdodZIwDIIBgNgGQSDwTAmGJ3DwJkJwBJR6PV6UibgttQkMGvQarWk9MD2x3w+j1QqJV/UMriuC9d1RfBoQkWDYRhGEAwGw1hgNIPQ6/VkJc9Rzb7vo1ariYVyIpFAp9NBvV5Hs9mU2QqJRAKpVArZbBa9Xg/JZBKu66Lf76PRaKDdbiORSEjmgd0OWqhoMOx2GEEwGAxjgbU6GOI4HrJXTiaTcBwHYRiKDoFTGjlrwfd9JJNJyQrQjrnZbKLdbosVczabFaEij9fr9YwgGAwwgmAwGMYEq2UQ2MZI0ONA/7zdbiOOY3ieBwAyjCmOYwwGA+lYiOMYzWYTqVRKuhbCMJSyAwkCsxZGEgy7HUYQDAbDWGA1gsD5CcwMdLtdKT2wGwFYIgVRFMl2nueJPwJLEcwUcDx0p9NZMbiJ3Qz6fAyG3QrrYjAYDGOB1UoM2maZWQFgyeSIK/9UKoVGoyEkIJPJAFjqRCBBYAah0+lI+aHX6yGRSCAIAjQajSGhopklGQyWQTAYDGMCTRDoY8AVfSqVkuDNFkXaKff7fdTrdbTbbfi+LxkBti6mUimEYSidEPQ74L7ph8BZDrRgNoJg2O0wgmAwGMYCmiB0u10RHqZSKZmxACxnE/ivzjTQhpkaA2BJ1JhOp8XvQB+v2+1KmaHT6aDVagGAEQSDAUYQDAbDmEATBK0/cF13KO1PIWEqlRoSFjKbwO9ZktDGSyQLvu+j3++j1WrB8zzxQyAp0Z4IBsNuhREEg8Gw5Ridw9But6VLgeJEdiTQ04CzE1KplIgSWZqgvoD705Me4zhGEASSZXAcRwY30c7ZCILBYATBYDCMAUYFigzUjuPINv1+X8yO2M0QxzGy2axMbgQgw5foyEj9wmAwQDqdFlMkvV/OcWi1WrIfc1M07HaMHUH45Cc/iUsvvRS+7+PQoUN47LHH1t3+0UcfxaFDh+D7Pl760pfivvvuW7HNgw8+iIMHD8LzPBw8eBBf/OIXT/u4v/qrvyoqaX699rWvPbuLNRgMAFYKFOlL4DiOpPwHgwH6/T7K5TIWFhaQSCRk9d/v98UxkVMfmV0All0ZU6mUTHyktoGdDY7joNfrodFoADCCYDCMFUF44IEHcOutt+L9738/nnrqKVx77bW48cYbcezYsVW3f/bZZ/GmN70J1157LZ566inceeeduOWWW/Dggw/KNkePHsXhw4dx5MgRPP300zhy5AhuuukmfOMb3zjt495www04ceKEfD300EObcyMMhl0GPYeB0xXjOJY5C/Qu0ELDVCoF13UlsPPnnLXA0gNJADMIbHmkcJGZCc/zZC4DYATBYEjEY1Rou+qqq/DqV78a9957r7x2+eWX45d+6Zdw1113rdj+fe97H7785S/jmWeekdduvvlmPP300zh69CgA4PDhw6hWq/jKV74i29xwww0olUr43Oc+t+Hj/uqv/irK5TK+9KUvnfH1VatVFAoFVCoV5PP5M96PwbDT0Ol00G634TgOGo0G5ubmUKlUUCgUJDvQaDTQbDZlVHMul5OZC/Pz80in0/A8TwY18b3UGgwGA/i+jyAI0Ov10G630Wg0kMvlkM/ncfz4cczPzyOXy+GSSy5BLpdDoVDY6ltj2KHYDvFgbDIInU4HTz75JK677rqh16+77jo8/vjjq77n6NGjK7a//vrr8cQTT8gqY61tuM/TOe5f/uVfYu/evXjZy16Gd7/73ZiZmVn3mtrtNqrV6tCXwWBYCa5T4jgWjQD1B5ypACxpBHSHg+M46Ha74qrIgU3aAyGdTqPX6wGAlClYvmCmIo5j+L4PANLuaCOfDbsdY0MQ5ubm0O/3MT09PfT69PQ0Tp48uep7Tp48uer2vV4Pc3Nz627DfW70uDfeeCP++I//GH/+53+O//gf/yO++c1v4ud+7ufQbrfXvKa77roLhUJBvg4cOHCKu2Aw7E7oMcsM7ul0WsgBswjdbhflchmzs7Oo1+sS7F3Xle4Hbc+cSCTENbHVaiGZTCKZTMrcBr1/Oix2u10RSRoMuxljQxAI3bMMYEUf80a2H319I/s81TaHDx/GL/zCL+CKK67AP/2n/xRf+cpX8P3vfx9/9md/tua53XHHHahUKvL13HPPrbmtwbCboTMIeh6C/hmDPACZs9BqtVCtVof8D7QbYiKRkAxCo9EQMSK1CQBE85BOp8VzoVqtmt2yYddjbGYxTE1NIZVKrcgWzMzMrFjdE/v27Vt1+3Q6jcnJyXW34T7P5LgAcMEFF+Diiy/GD37wgzW38TxPVioGg2FtMBD3+33pWKBlMr0Ler0ems0m9u7du2IUdK/XQ6fTkRJDNptFq9VCoVAQvQGw9JkMwxCtVguJRAK+70u2gJbMrVYLjUZD9r/eAsVg2MkYmwyC67o4dOgQHnnkkaHXH3nkEVxzzTWrvufqq69esf3DDz+MK6+8UuqXa23DfZ7JcQFgfn4ezz33HC644IKNXaDBYFgTmiBQUKiHM+lWRzof0hWRg5u4Ta/XQ71el8wChY2u68J1XQRBIC2Seu4CScnoFEmDYbdibDIIAHD77bfjyJEjuPLKK3H11VfjU5/6FI4dO4abb74ZwFLK/oUXXsBnP/tZAEsdCx//+Mdx++23493vfjeOHj2K+++/X7oTAOC9730vXve61+Huu+/Gm9/8Zvzpn/4pvvrVr+JrX/vaho9br9fxO7/zO3jrW9+KCy64AP/wD/+AO++8E1NTU/jlX/7l83iHDIadCQZi6g+oHdCv09uA7YosObiuC9/30ev1kE6nhzILCwsLInrM5XLyXrZIao2C4zhiuczXjCAYdjPGiiAcPnwY8/Pz+PCHP4wTJ07giiuuwEMPPYSLL74YAHDixIkhb4JLL70UDz30EG677TZ84hOfwP79+/Gxj30Mb33rW2Wba665Bp///OfxgQ98AB/84Adx2WWX4YEHHsBVV1214eOmUin8zd/8DT772c+iXC7jggsuwM/+7M/igQceQC6XO093x2DYuRg1Q9I2ycBSR1AURZItoCCx3W4jk8mI7sB1XXkfBY/sWEgmk6jVaiJETKVScBwHjuMgiiIUi0XxXQBsYJPBMFY+CDsd26Hv1WA43xgMBoiiSEyK2FlE8h3HMY4dO4YXX3wRYRjiJS95CRKJBF588UUEQYB9+/ah3W5jMBig3W6jXq8jjmO4rotisShGSfl8XjoYWKrodruYn59Hq9XChRdeiHa7jWeeeQZxHOMnf/IncdFFF5mOyLAp2A7xYGw0CAaDYfMRxzEajYbMGxgHaJ0BxYc6g0BNAssAnU5HtqnVavIzAPLzKIpEo5BIJJDJZFAqleA4Dmq1GprNJnq9HoIgGMpeENRCmBeCYTfDCILBsIvAFsJ2uz026fNRgsDOBWDJp6DRaIjxGVf+9Ejo9/uoVCoAICSBpQHta8DWRu6DAsQ4jqXUQCLC4U783mDYrTCCYDDsIuiAx4C61dBEhW2OJAicvkgxInUGvu+LZ0Gz2RTnw2azKR0NFC5ysiMHN3Hf9EzwfR+pVEqGNJF4kKwYDLsVYyVSNBgMmwsdjLmy3mroFkcSBHYwJJNJtFottNttuK6LdHrpkcUZDK7rCiloNBoyoIlZAO6fJkoAZOYDzZVIPGisxHNhucNg2K2wDILBsIswWmcfhxo7A7h2UUylUjLZkSZIAERDUKlUxDaZ5YB2u41ms4lMJgPf9yUDwMwB98XMA4kIJ0Xqe0Ndg2UQDLsZRhAMhl2EUSty1va3ElokyDZHDllqNBoSqLU1MrsedCmAgsZEIoEgCGSqIwlAtVoVgyQSAAoZNUnhseifYDDsVhhBMBh2Ebgipl/AOPT6Mygz5c9VP30Ler0eUqkUUqkUer0eqtUqFhcXZb4ChzCl02k4joNmswnXdcUHIZ1Oy+wGkgBqFqhp4DFZZjCCYDAYQTAYdhVIBmgcRMfBrT4nndJPJBIyZIkdDCQAzWZTRIn8YiCnhTJLE4lEQkhHu90WosEMgi5BOI4j50GC0O12t/zeGAxbCSMIBsMugc4UMNUObH2ZQWcQaJcMLI9+poMiCQKHLy0sLIglMoN9EASiOSApoIkSSw1seex0Omi1WvA8D77vDx2/2+2i0+mYUNGwq2EEwWDYJWB5IZlc+tiTILBzYKugxYn0JaCegHbK7FhoNBoyL6FSqciApWq1CgCiPwCWrrdWq0m3Bic10nCp2+2i2WzCcRxks1lxXHRdd2iqpAkVDbsVRhAMhl2CUYEi0/jA1mYRKApkiYHnRCEiAHmNngYc58xr6XQ6qNfrAJYIUBAESCaTiKIIrVZLTJOYTaDegASkVCpJJ4MWcG41eTIYthJGEAyGXQIGOgZAAFteZtCrdG2nDCxNUWUJwHEcNBoN8T/I5XLiX8DyQrvdFj8DHeg7nY74IgwGAxEocrRzvV5HJpMZEjZSg2AEwbCbYQTBYNglYAaBJQYAMqtgq8SKusWRK3g6GdbrdbTbbfi+L/oDYCngN5tNTE1NiXuiHhPd7XbRarXEjtl1XckcdDodmdiYTqeH5jbk83kkEgk0m025J2a3bNjNMIJgMOwSrJZBALY2i6AFitrUaDAYoFqtitMhh0zRWrnZbCIMQyE75XIZ/X4f6XRaOhuSySQymYxss7i4ONS+mE6nZYJkr9dDqVQS0SMJE4mHwbAbYQTBYNgl0Gp8/X8ShK1wDtQZBGYAgOUsQSKRQC6XQ7vdltV8GIYyyZGuiZzXkEgkxBuBZYRsNivTGdvtthgjMcNAsSLLFjwvm8dg2O0wgmAw7BIwGDOAEnqQ0fnOIowSBA5a0gJFx3GkRKCHL5E0ZDIZ0SDU63UxO6J/gu/7oi2gxwI9EtjSWK/XpdMhlUoJMaAbo8GwG2EEwWDYJdD2wqMOilw5byVB0GOf6/U64jhGGIay+meAX1hYkExDrVZDMplEoVBAo9HA/Py8uCOylJDJZGSgk+u60uqoRz6znKHLFiQVZpZk2K0wgmAw7AIw+I628RFbJVZkfV9rEHq9Hmq1mngatNtt6SzgdXBWQ6vVQqfTQS6Xk2DOUoXuQKCzou/7qNfrImx0HEfKEixfsORCUeNWG0kZDFsFIwgGwy6AHn1MEV+r1VpVi3A+A6IO4kz5U4SYSqUQBIEEc2DJHTGbzYoOgQZLLCc0Gg2k02npTPB9H+VyeWjWg+d5cjxOc+QxXNcV22XeCyMIht2K9FafgMFg2Hww4OnsQKfTEbHeaAYhjuMV3Q6bAU0QeI71eh2dTge+7yOVSg2JBbk9WyK1O2S325UhT5VKBZlMBo7joNPpSAah1+vB930AQKVSQRiGcuwoiqSlkjoEKzEYdjMsg2Aw7ALoejsAUfCzFk+Ff7PZRBRF4jmw2eD8A54jgzlX+jpIU4PgOI4EfhoasVRAkqADPt0SAYg+gVkCtkMmk0nU63Upa5CYsGRh8xgMuxFGEAyGXQCKAekjkEqlpEUwCAKZ7shJh1EUnZfzGp3BQOMjLTTsdDqybTKZRKlUklZFdhlw4FK9Xhe9Ajs22I1AIhAEAXzfRyKREPfFVCqFRqMhZQ46L1LoaJ0Mht0IIwgGwy6AHqmsQedC3/eRyWSQz+cB4Lyl1TVB0C6IdECkXoLn6XmeOB5yvkKlUkE6nUYul0Ov18Pc3Bw8z0MqlUK5XEatVkMQBGLNTDLBLAL1C8xSpNPpoZHQzCIYDLsNRhAMhl0A3UrIaYmEJgP8GQnFZoLEgCSB1scMxqlUSkoO7XZb2hBzuRwcx0EQBCgWi+h2u2g0GshmswAwZNEcRRHq9bq8T3dp0D+BGQoSAsdxxI7ZzJIMuxlGEAyGXQBtaQxAzIKA4a6FRCIhPgCbrd7XtX2WD7hiT6VSkt7nTATHcTA5OSn6g1wuh8nJSel0oPkT2yS5v3a7jTAMJavAbcMwFILADIbWP/C4VmIw7FYYQTAYdgG0W2Gz2RTRnv4ZoUcrbyYYeDmcSQ9Hcl0XjUZDOioGgwEcxxHbZbZATk9PS+ag3W6L62Kj0cDs7KyUFFzXlUFNjUYDzWZTuhn4XnowkCSx7KCzGgbDboIRBINhh0Ov0umkqIMzsLLMMPraZoDnoM+PAkPHccQ2WesPcrkcWq0WXNdFoVCA4zjI5/NilETBYRRFmJubQ7vdRqlUGjJgopAxiiLpWKC7ovZK4HvMC8GwW2EEwWDY4WCGgMGYQVgPR9IBkIZJ5yuDQLDtkBmDZrMp551MJpHL5aSFkd0X3W4XhUIBYRiKbgBYIjnVahVRFIk7YhRFqFarUkZoNpviAUH9AY/NEgxLEOaFYNiNMIJgMOxwaP1Bv98Xe2JNAHSZ4XxlEEY9BhiISV50myEzBSQ0QRCIk2Imk0Emk5HsAQARGlarVVSrVSEeLCEAkO4Fngs9EXSJweYxGHYzjCAYDDscOoPAGj/Fe4PBQDQHDILno5NhNdGktkPWgsN+v49sNotsNjvki8DzJBmgpqDX68FxHCkdNBoNLCwsIJVKIZ/PIwiCoXPhNMtutyvH1/ek2+3KMQ2G3QQjCAbDDgdX5FxB01a51WoNZRFYZuAKWgfwcw1NWlhCYICmwRFX891uF5lMBmEYol6vo9VqodVqyUAnnrvneRL8tV1zHMeo1WoYDAbIZrNwXRfJZHKotEBCwCmSNI4CIFkMg2G3wQiCwbDDoVfrDMYMvFqHoIN1Mpnc1AwCz4eZA54PSwwMyjxXBnYSB8dxRMDYbrdRrVaRSCQk6LNLgwJFAEPzHJrNJlzXlX3wfXRmpJtiIpFAFEWyncGwm2AEwWDY4aCDIrMInGWgAzFX0OwEIEHYzAwCz4dEhISFWgCaJHmeh2w2KxoFrUfwPE/GQbNVkTMlSqWSeBs4joN+vy/70AJFAENOjvo+8R5Q2Ggw7CYYQTAYdjiYOWCLo+u6YlPMWQVarMeVON+7GdAEgd9rfQRX7P1+X3QDtVpNTJQ4TyKdTst+MpmMeCIAkMxIuVxGuVyWDohGoyHHYMcGr1tnH/izVqslHQ4Gw26CEQSDYYdDB1sG/2w2K6v01boZmJbfrEmGuuRBaGIQx7H4NTDoa61ArVZDt9uV0kIQBNizZw8KhQKCIJDraLVamJ2dxczMjJQVOp2OtDymUin4vr9iHoSe8mjzGAy7FUYQDIYdDKbvuTLnYCbf92ViIVfuuszA+vuoy+K5ArUG2iSJ4kP+XBskOY6DVqs11L64sLAgBMfzvBVtkSwTsOxA8yOWVubn54UwMYPAVlC6ObJE0ev1rNXRsOuQ3uoTMBgMm4dRDwTHceB5nrQFdjod1Ot1GYHMQJhKpYaEiswonAswQ6C/eH4M5BQu0iaZxkWdTgdzc3OIogjJZFLcFEl+uD/qLDjKmoQhCAIEQYBOpyOlA5YrSIZ4D1zXlXtnGQTDboRlEAyGHQwd4IAl7wDW1llmaLVaQ2UE2g6z1fFcZxBG/Q+0MZJewTMz4LqubM/WTK7wC4WCXBN1FcyShGGIMAzl9VQqJdkEAGK3zG6GZrMp94PbA8sW0Ga3bNhtMIJgMOxg0PuAAVYr98MwRCqVEpU+A2G73UYURZKO3yyCoM2YaEbEVkSKAoMgkLHM9DaIogi+7yOfzwvJSafTaDabqFarIsLMZrPwPA/dbheu6yKOY8zNzYl4sdPpoNFoDJkkcTw0sygAhBxYicGw22AEwWDYweCKXBMErsDT6bTU5ev1Our1+pDxkNYvnEus5clA/QHPtdvtIpvNwvd9VKtVVCqVoaxCLpeTCZCc4MjZC8ViEdlsVnQJJEC9Xg9hGKJUKgnZSKfTCIJAsgf1eh1RFEmmBcCKCZgGw26AEQSDYQdjtFOAQrxmswkAMgBpcXFR7IQZtKns1xMXzwVGPRCAJbfCdrs9tEr3PE86GRYXF9HtdkVgSZJAvQAJQr/fR6FQQDabFbMjzp5gWyR1COl0WkoS2WxWNAv9fh+VSkVIFF0nLYNg2G0wgmAw7GD0ej0J/Ax2rPn3ej1kMhlZvTMV73mevBfAOS8zrNbiqANwo9GQLgbP8+R7x3GGJjdy2iNdELk/x3FQKpWktJJMJtFut+XaKH5k5qTb7SKXy0nZgveHWYRkMolmsymdFwbDboF1MRgMOxjUFegBRI1GQyYfkjRwpc7hRxQoaqfDc9HJoPdH3wH6FTAAN5tNCdau68p7C4XC0PW4rosgCBCGIZrNJl544QWkUikJ/tqJEQAWFhbk/dRitFotNJtNBEEgYsh0Oi1lC54nt+M5Gwy7AWOXQfjkJz+JSy+9FL7v49ChQ3jsscfW3f7RRx/FoUOH4Ps+XvrSl+K+++5bsc2DDz6IgwcPwvM8HDx4EF/84hfP6ri//uu/jkQigXvuuee0r89gOJ/QA5C0rXAcx5idnUWj0UA2m0UYhlKnJ0nQ3QXnKoOgyxXawIn+BQzMqVQKk5OT8H1fhIt0e1xcXESv10MURdKiGEURZmZmxBKZJQcOdIqiCMePH0e5XMZgMECtVpO2znq9jn6/LwSBvgskCzrjYhkEw27CWBGEBx54ALfeeive//7346mnnsK1116LG2+8EceOHVt1+2effRZvetObcO211+Kpp57CnXfeiVtuuQUPPvigbHP06FEcPnwYR44cwdNPP40jR47gpptuwje+8Y0zOu6XvvQlfOMb38D+/fvP/Q0wGM4h2MFATwEShCiKUKvV0Ol0UKlUUCqVZKYBOwiYLTjXQkXui6twnh/9COh2mMvlhoSDJC66y8F1XVQqFXS7XTQajSGhpeu6kn2gp0Oj0RD/h0QigUwmI5MeOa+BfgssT6RSKSnT0DDJYNgtGCuC8Hu/93v4tV/7NbzrXe/C5ZdfjnvuuQcHDhzAvffeu+r29913Hy666CLcc889uPzyy/Gud70L73znO/HRj35Utrnnnnvwxje+EXfccQde/vKX44477sAb3vCGodX/Ro/7wgsv4Dd+4zfwx3/8x0MKZ4NhHEGXRABDZYROpyOmQhQkUqxXqVRkpDJX7XRaPBdgRkI7KDL4MoNB+2NeA1sgE4mEdCSEYThUBuGER9/3kclksG/fPkxMTAghKJVKcBwHExMTCMNQtAicEEk9QzKZRBiGch50Ymw0GnJPDIbdgrEhCJ1OB08++SSuu+66odevu+46PP7446u+5+jRoyu2v/766/HEE0+Iqcla23CfGz3uYDDAkSNH8Fu/9Vt4xStesaFr4hha/WUwnC/0er2hbACDm27t8zxPev4HgwEWFxcl6LJDgKv2c5FeZwZhtMWRnQgAhrwNRuciUFiZz+dFnMiSw8TEBLLZLEqlkrggAhCzJG7PbgUAQ50Q9XpdLKbZGuq6rhCrWq1mboqGXYWxIQhzc3Po9/uYnp4een16ehonT55c9T0nT55cdfter4e5ubl1t+E+N3rcu+++G+l0GrfccsuGr+muu+5CoVCQrwMHDmz4vQbD2YKCPAoSKQZkvZ8OgwBknPLi4iLiOBbXwW63i1qtds7KDKMdDBQlUgdAEqJbFNmBACxpKsIwxPT0NFzXRRRFojvIZrPIZDLo9/uoVqsYDAbwfV/8EhzHQafTgeu6Uk5gJpDWyyQWJAV8H+9dvV4/63tgMGwXjA1BIEYVwqdSDa+2/ejrG9nnets8+eST+E//6T/hM5/5zGkpmO+44w5UKhX5eu655zb8XoPhbMHVPwBJx5M06P8DS34IAEQLkE6nkclkhFiw1n82oDiSXQgkJ81mUzwMUqmUOCFyZc+SAgN4JpNBJpMR8tBoNGT4FOc1UFRIfwO2TPZ6PfnXdd2hbgbeM3Z86LZJZi/MMMmwmzA2BGFqagqpVGpFtmBmZmbF6p7Yt2/fqtun02lMTk6uuw33uZHjPvbYY5iZmcFFF10kD5Qf/ehH+Df/5t/gkksuWfOaPM9DPp8f+jIYzhe0doACRT3emcFQp/bT6TSiKEKj0YDjOMjn85JJoGfAmWJUe8BMAgkCACkleJ4nBEaXF9jGqFsOdSskRYTMDNCmmQGfx6TpEp0l2frIDAEJFfUZPBa1EjaXwbAbMDYEwXVdHDp0CI888sjQ64888giuueaaVd9z9dVXr9j+4YcfxpVXXikPiLW24T43ctwjR47gr//6r/Htb39bvvbv34/f+q3fwv/+3//7zC/aYNhE0C2Rynz287NcwJQ5nQpLpRKCIBBXQwr/wjAEsBR89Ujm04XuYOD/aUjEgOt5nqT1SQ5IUOjZEASB+ByUSiURLrJs4Pu+ZCiYDeC4aM5raDab0tLIrAbHPtNcif+Onj+wPDTKYNjJGCujpNtvvx1HjhzBlVdeiauvvhqf+tSncOzYMdx8880AllL2L7zwAj772c8CAG6++WZ8/OMfx+233453v/vdOHr0KO6//3587nOfk32+973vxete9zrcfffdePOb34w//dM/xVe/+lV87Wtf2/BxJycnJSNBOI6Dffv24Sd+4ic2+7YYDGcEZgZIlpktYOBlO9/8/DzS6TT27t2LYrGI2dnZoQmPXM3ze3orsA1xo+DqXQ9parVaiKJIAi+1D5zWyHIH2xp930cQBBLQmRGhrsDzPLRaLQRBIESEJQ0eq9FoDLkjkgxoXYR2keR1MyNDItFsNpHJZMw4ybBjMVYE4fDhw5ifn8eHP/xhnDhxAldccQUeeughXHzxxQCAEydODHkTXHrppXjooYdw22234ROf+AT279+Pj33sY3jrW98q21xzzTX4/Oc/jw984AP44Ac/iMsuuwwPPPAArrrqqg0f12DYbuCQIi1QHAwGYi7UarVwwQUXoFwuY25uTtL4ruui2+2iWq0KkaAYkJ0PzEKw9s/yxUbOadRBkefCgMwMALMeWkMBLJUM6GlAXwLP85BOp2U4E6cv8v8UPJKQUKC5uLgo5kiNRkO2pTGSPmdmMVqtFjzPk9ebzaZkWAyGnYZEbNZg5w3VahWFQgGVSsX0CIZNRbfbxXe+8x3EcYxCoSAtt3/7t3+LRCKBgwcP4sCBA4jjGCdPnsTMzAyKxSIymQyee+45pNNpvOpVr5I2v0qlglQqhampKTiOIyl6ADI46VSo1+sS2CuVCmq1Go4dO4annnoKJ06cwGAwwOTkJC644AJcdtll0lpIgaHneZiamkIQBGKqxPIE2yJJCpilcF1XzI5OnDiBRCKBl770pcjlcqhWq0in0zh58iTK5TIuuugi5HI5zMzM4MUXXxQzpUqlgl6vh2KxiEOHDuE1r3mNkBSWQ+jbYDBsFNshHoyNBsFgMJw7aNMhBku28jUaDVQqFczMzEjA1sZEwFIwb7fbstpnloBZiTAMpXTRbrdFNLgW9AwGthFSE8BSSBzH8DxPSggsgdDHgSWFxcVFWfHr/bL0wQwCpzQyy+H7PprNJrrdLoIgQKfTQTqdRqlUkmvWXRbMJPDa6dXA86eXAo2cDIadBiMIBsMOBAWKqVRKAh0DOYMo6/FhGCKTySCdTqNQKEjAZWcBAMkQ6EDI0cvAUvBsNBpreiXo15l5iKJIRjGTHNCDodfrSRkijmOEYSh2yvzZqKgwk8kgCALk83kEQYBCoSAlCRIaihQBSAmD45+1LTVHT+sZECQIPH/t+Dg6qtpg2AkwgmAw7ECw04DGP8we0GaZ7X2pVArFYhF79uxBIpHAiy++KL4BtVptyLiIDoM6EDqOI0GYGofVWgB15oBkhR0RXK3Tb4CdB1zJAxBHReoO6HxIfQDfz+tiZoLzGbjK1/twXVeOT98FjoRmxkX7oeipk/r6mUkxK2bDToMRBINhB4IEgYI67aBIf47BYIB6vQ7XdTE1NSVjkWkpzIwAgyQnHI6ulLlCZypeB36CvgckCHRApBdDr9cbEicyeNP/gNfDLgKSFZKddDot58sMA7UKvAbf9+UamLFglsB1XfE4CMNQyhv84nlrS2iCJk10hTRZl2GnwAiCwbDDwA4GYLluzxU0V+tBEMiqnnX1AwcOiP/AaPqf+9Iraw0GZJIMTlgc7QZg4KX2geUMZg+4Gk8kEpIFiONYJjEGQYB0Oo1isYjJyUkUi0UxeKLBknZQpB+C7/uYmppCqVQSvYLuRnBdV9pA2RmhjZX0yOfVnBTZ8kkyZjDsBBhBMBh2GNjip8V1nJrIIN1oNKRDgXbFjuNgenpavASYceB7ODaZq/TV4LqurMCpYyABYaBlR4Ue1ETtAbMVLA/0+30peXCEM8dT79mzB3v27MHExIT8rNlsYn5+HlEUyT5JHIIggO/7Mu6aEyF5XzKZjOgTaK5EkgBACMJqBIAEiQTI7JgNOwFGEAyGHQYGdtbjGcxpDEQHxSiKpEbfbrdRqVRE6Efdgk6Zc4W/HkEAlsR7mUxmqMshiiJJ15N8MDhTc0AvBgBYWFiQY3DsMr0OPM+TlH+hUMDk5KQYFvGca7WalA96vR6q1aroBTqdDsrlskx15Llw9DMwPJuFoklmT9bqWCARAWBWzIYdgbEySjIYDGcPpuVTqZT8Xyvw6TrIlTH7+T3Pg+/76Pf7Qyl+LbyjeJABcy0XQRoecbYDhYPUNujBTdQf8DgsT7BTgVkMLUAkqWCGIJ1OIwxDlMtl2U+tVpMyB70a9uzZgxMnTsi50OeA2QtNfEYHv1EzwQ6R1cCsjekQDDsBlkEwGHYYKBCk/oCBnII9pvr37t2LfD4v5YN+v49KpSKrffoJMKXOwUXERlbJ1A3Qi2FhYUFW71yRM3PA7xnYWQKhiyNX/LymbreLhYUFLCwsDGUZwjCU9+oVveu62Lt3rwxlYsZET4FMpVJoNptDDpSe58n50/lxrW4FiiwBrLmNwbBdYATBYNhB0E6CBHUGFOBx1d3pdKQ2n0qlRH9ArwDdFqihfQE2ek6+70uw5whnfrHOz7IAuxd835dyAksJuVwO/X4f5XJZ9A21Wk1mo/i+LxqITCaDqakp5HI5xHGMer2ORCKBXC4nnhAkMMym0CuBJIodESRHfN965Ij33rIIhu0OIwgGww4CV/5ckTPwNZtNWa3ncjmZW8D3tNttLCwsiPcANQqcyaDLCXpewUZWyXpgEgA5t1qtNrR/ZhAymQwKhQLy+bwQi1wuJ2ZGDOzcJp/Pi+CQJGIwGIiV8vT0NDKZjBhEsVODNs7ZbFbOi+fKjIp2kmSJo16vr+ucSAJlGQTDdodpEAyGbQamwmlBrEG74VEHQKbGXddFPp/H5OSkrMTT6bR4FxSLRTiOg1QqJal+rpjpPwBAUu5sF1wPerS0HsPMNspOpwPXdZHL5eC6LoIgQDabFUMlmjFxLDVtky+44AKEYYhKpSIZEQAipGTWJJfLYWJiAsASuXFdF4lEApVKRfQJLDPw/tFngUSIRkwkMdVqFdlsdlUNhpUYDDsFlkEwGLYRuNpfq9deiwpZ2+90OiLWcxxHsgP0RkilUjIR0XVdvOQlL4Hv+4jjWDodqtWqCB+5b57PemBAXVhYwPz8vKTsgeVAzsxCv99HNpuVOQcscaRSKaTTaVSrVfFDmJiYkJHVjuMgl8vJuYVhKGJGZgQ4UCkIAhSLRbl2iiEpqKRokiSBRCiZTA6RCBKu1cB7YyUGw3aHEQSDYRtBGw/x/wSDMQMisNSixxUvAyrr/a1WS9T7rPfHcYzJyUlxWqSXAdshGdy5r9XOg+dHv4NKpSLH5+qfbY0628EUPq9jcXFRxilrC2aaI7EMQEGh4zgIwxClUmnI+ZDaB2ohWLpgoKdzo84Q8DzY7klbaoJEYrVSg2UQDDsFRhAMhm0EHXRGhXIMiFylM/iTIHClzO4EOio2Go2hroF+v48wDOV4juOgVqvJiGUSB7b08TwYTBuNxpCVMtsCc7mckINUKoXZ2VkJ4LlcbqidcHFxUYySaNzE6YzsaOCKX6/Y0+m0aBLYxshyBrMohUIBQRDIXAXer1wuJ50fJAhaqMjj6OmTengTYRkEw06BEQSDYRtBB6PR9D5r9hxgxBU5g7suJRQKhaHphiwhAJCuBn7PfTUaDbFJpiaBcxX4pQMmCUS/35eJiSQm3W4Xi4uLAJaIA1P4rusinU6LeVEul0OhUACwPMKa3RgUFa4mCiwUCjJpkZMqK5UK5ufnRdgIQDILvEaWVlqtlogx6STJr06nMzQCe3T+gokUDTsFRhAMhm0CrmiBZZGgJgk0IdL9//QVYIqcQXhqakoCZzKZFItiBn4GR9b8mUmg8G9+fl6Ih26FZJDNZrPwfV/0EhQGMsCzTZHujGy/zOfzyGQyAJYC+/T0tJQTtNuiFjvSr4CrfM5SYLDP5/MolUoAIOUOko4oiuTeMYvAcwSWNR8kCtQ0kEDwHLR5khYuWhbBsJ1hBMFg2CbgylwPNdJlBnYE0EOAK2HOF3BdF6lUCmEYYmJiApOTkwiCAKVSSfQEtVoNMzMzUpNvtVqyQmbXAcsH9XodwPLI42w2iyAI4DiOiPlITsIwlOBKW2faQTPIep4n3QokFTQ9or8BiQf3D0CIB1fsiUQCnuchDEPxhNCdG/R/cF1Xyi0M/hy6RFJAIsb9kozwntAESpMK/o4AyyIYtjeMIBgM2wQMNlxNAxDLY6b6AYh3AF/jICat8mdQ5//ZMsjgzKDIwUb0HuBQIwr7tEuiBr0UuNLmDIROp4NKpSKdApziSAfEZDKJarU6JCjUHgycmUD9gRYEaoMiPeGRWZZMJoN8Po92uy1lFAoNXdeV86HdNLMG7HjQds+tVkvGTbOUQc0FYEJFw86AEQSDYZtAZxDohggsT2ukIp/ZA+oFarXakMCu1+sNreypR2CQpl8BRYc6yLN+z1Q8pxeOugt2u13ZD50Kq9WqiAW73a4EVsdxZEXP7od+v49cLieaCT2WmcGdZQ1tCMX/s8zhuq4QnjAMpVXRdV14nidBndehDZH4um7DZODX18v2UABiw2xCRcNOgBEEg2GbQPsbABgqM1CRz2AVxzEqlQoWFxcRRZH07XNVPT8/L+LByclJaXFsNBqiN2CWgql3rqozmYyQFGoASDoYEEezB6z904iI5QVgOXVPw6Z2u410Oo1MJiNzELQfAQM9ywokBdrMid4ImjwAEMKRSqWkVNFqtUR0yCxBMpkcMk1i+yjPpdFoDLU40myJegTLIBh2AowgGAzbAFzRA5BSgW4zrFarMueAbYvz8/PSSghAHAm16RDNg3K5HABI8GbXAW2J+TrPgW2QDOxs+YuiSFwZmSVg22IURaIPYAaE18KSR6vVQhRF8DxPNA1M75NIUCdAckAvBq74qZ/IZrMrsgskBQDEYrler0vpotlsyvwHlm+0myKvmZkYTQBYbmHmhcc0GLYrzoogdLtdPPfcc/je976HhYWFc3VOBoNhBFqAR0EcBYTlchnlclmMjwaDAer1uvgWuK6LQqEwZDDUbDZRr9dlhZ/JZJDJZCSw6RV+vV4Xu2Td9sdAzRU5sFTC4KwClgFqtZqMVGZ3gb4mEoxUKoV6vY5er4dcLodisTgUjF3XleAPDJMmliA4Opr6Cgogub0eEU39RbvdFj8FZhKYQSBBYAmCugPef00QWN7R12YZBMN2xmkThHq9jv/8n/8zfuZnfgaFQgGXXHIJDh48iD179uDiiy/Gu9/9bnzzm9/cjHM1GHYtdJqcg5cYxBlA2drIbgUGRir66RSYSCTEt4CEIJPJiPjPdV1R+tOzgIZC1DYwmDIbwKDNYVEsd8zOzmJ+fl66ETheWrsTcvWuTZXY7sjAT10BzZxYZmFmg8GcJISlBD1Yiu/jMUkk2B4aBAGAJZEnyY22XdZdEyRMowRAuy3qtlSDYTvitAjC7//+7+OSSy7BH/7hH+Lnfu7n8IUvfAHf/va38b3vfQ9Hjx7Fhz70IfR6PbzxjW/EDTfcgB/84Aebdd4Gw64CA5GeiEghHoOZti9mOp5BWK/yGegWFhZw/PhxAMurX9b3AUj9nz4HJAuarFCEyJUz1f2pVApzc3MyUXFiYgK5XE7KBdwfSQ2Jjp7UqIMyyZDummCGgwQJwBBBACAdCRz6pMWDjuPIhEiWP0iSdBaB5IglDX7puReEHg2ttzUYtiNOa5rj448/jr/4i7/AK1/5ylV//tM//dN45zvfiXvvvRef/vSn8eijj+LHf/zHz8mJGgy7GaOBiMGuWq2i2WxKjZwrenY1MHWu/QbY5letVvHDH/5Q/AfCMEQul0O5XEa73ZauAgAi0tN1fwDSGhiGoegHmLIfJQc8Tx1Y9QAkXmehUMDExISQEwZzdh4waPM6GdwBSAmC9szsYuAIZxKLfr8P13WRzWYxPz8v5xYEARYWFiS7QELDjgdmInq9nlhBj4IkjcSATo0Gw3bDaRGEP/mTP5H/33PPPbjpppuwf//+Fdv5vo/3vOc9Z392BoMBAIaEdpyvQMMepuh934fv+xIQSRAoNgSWSgCO42D//v3SevijH/0Ie/bsGTI46nQ6kmqnpiEMQ1lJs5VPayNopVypVOTnxWIRxWJRlP0sb/B6mK7XMw+y2axkMmhIRB+HdDqNcrmMKIqkzNFutyXbQRdJlhH4OjMfJA/NZhNBEIhok+UN6irYCdFqtcSSmgRLlxhWm2Y5OgLaMgiG7YozFinefvvtuPbaa/H8888Pvd7pdEyDYDCcQ+jsQb/fx8zMjLTZJZNJlEqlIXdBChkbjcaQyRBb+DzPw9TUFC655BLk83lUq1UcP34cs7OzklanFwGJBQWKrPUDwyJBAEMZhjiOUSqVMDExIRqCZDIpbYwAhHzodk0OZKKOgj4M7KrQWghmImiHTH3BaJcEdQjNZlO6JViC4Whp+i/EcSzHBiAaBTowMtNBoaK+H8SoB4IJFQ3bFWfVxXDDDTfgda973RBJWFxcxGtf+9qzPjGDwbAEnT1gzz6DN53/GGzb7bYo7svlMpLJ5JDYj9MOfd/H3r17MTU1hcFgICtyLYCs1WoSKEkQmIofbQPsdrsiemTbZBiGQ/4JzAjocsKo3XIqlUIul5PuBXZMsCOBhIDlAnY9MDPCrgwGf51FIDGh0ZImHnr0MzMyDPQ8LkdfA5D9jbY6cntuw9+bwbAdccYEIZFI4EMf+hB+5Vd+ZQVJsA+EwXDuoAMQ2wdZ5wYg4joGdgBijETxIbMNDIh8P1frVP2zfEHHw2QyKd4GXNGPtvCxrNDtdkUDQAGlbhXU8xwY1ElAaLaUSCTEylkHbBogkeToDgTt9khxos4esGTA0gk7OlqtFjKZjLhCMtjTRInEgKUR3lcSHGYu1iIIq/3+DIbthNPSIKyGD33oQwCA173udfi///f/SvrOYDCcG4yOeKY4D4C0B7KFUVssa+U+XQaz2SxarRYWFhbEHrhQKIh4MJVKScaBgj7tuQBghcVxvV6XGj/fywDLgU7pdBoLCwtDWQd2VjAbQCvlfD4Px3GwsLAgJIb70NMb+azRwZ8EgdsDy06NbIfM5/Mi0qTAko6KzCpQl8BSQhiGUmIgESLJ4f0nRjMHRhAM2xVnnEHQWQKdSTh27Ng5OTGDwbAEBhj25BM61c/gygxAtVodmkbIQJpOpyXTwPZFkgsOSSoWixLo9QjlWq0mw5+433q9PjT5kOUA13VFx8BOBR6v1+uh1WoNZQZIfNh6yAwCZygAEDKhvREozqS3goYeBOU4jggLKagksWBWhQSAWQ36IvBaSWK0NwQJg8ZoacIyqobtijPOIPx//9//J3PbgeVMwi/8wi+c/VkZDAYAGBL9aYEcV90kDQyWcRwjiiJUKhXxSmBmwPd9MULiipoTFhn0tatitVqVdkcGYNd1MT8/jz179kgAp7CP4Gqa6fdMJiMTIaMoGnoPWw652mf6X5cg6GvAMgTB/dDQidfUarWGTJWA5WwCgzqPQ4KUyWSkTKKPp62amRlgBoEDqUaJCX9HmlBosajBsF1wxhmEO+64Y4ggAEsk4ZZbbhFfd4PBcHYY7RIAICttPVCI6XCK76rVKpLJpMxSYOkgkUhgYWEBi4uLoieo1+sieOS2FAVSnMhgzcwArZ2pU6DBEYkCxYTMQLTbbVQqFQmSXKVzdc7Sg9YfMOjzOrROQc+FoG6BWgIKDrX/A7MnXPGztEDCkc/nAUCIEnUZ1D00m005fr/fl5/RM2K1TgY9CdKyCIbtiHM+rOkDH/gAyuXyud6twbAroTsYSBDYy88VaqvVAoChlT4DO4Mahx81Gg1pNaSmIJvNwvd9mX7IMc1hGMqEQz1lkRkLCh1JNvQsAp4TxYDNZlNKDgCG7JL5PQO967qo1WpyTfp6aeFMcsM0Pj0NtN8DSYsmIyytUI/B89HOjSx/cJokSQHvN9/P0gvHV2uYDsGwE3BaBOF09QUvvPDCaW1vMBiGoTsG9LRC1u7pWcDXGcxpZcwAyto+W/24X8dxUCgUcMEFF2B6ehqFQkHew/ZJ6ho4NprahKmpqSEdAn0MdK3f8zwRG1IHoO2i2ZVA/QK1AZxzwHIIPRBoI60nLDLzwDIC98EyBdP9zG7QM0GPkmaGhcSCHR8s2/CesRODWQi+VqlUhrIEo50MlkEwbEecFkF4zWteg3e/+934f//v/625TaVSwR/+4R/iiiuuwBe+8IWzPkGDYTeDK1wd8Bm0OYlQDz1i2p+rfAASYNPpNJrNJubn51GpVNBoNJDL5bBv3z4ZjkRHRZYLmGpvt9uYn58XgsGOAdd1JZuQSCTk2FT2dzqdoWmM/BmwvMpmYAcg5clms4leryeuirqtk2ZQTP9TGEkBI4M7yxvMplCMybIMJ0vyfFjeILlhlwT1BnqSI383zIRQx6HJj75GyyAYtiNOS6T4zDPP4D/8h/+AG264AY7j4Morr8T+/fvh+z4WFxfxne98B3/7t3+LK6+8Er/7u7+LG2+8cbPO22DY8dDKeQYx3caXSqXEvZBBTKvqGYy1PwDNj/TApEwmgyiKZJ9cjXM2AbskKFqcmJgQFT8FhplMRgYj8dipVEqMhXSbITMhOg1PvYDnedKiWSgUxGyJ2YB0Oi2BmJ0MDPQsp5CMsDURgPhAsCxA8WUmk8HCwoKUR+gnwZZKEiS2QI5OmKQ4lPdI2zXz2gAjCIbtidPKIExMTOCjH/0ojh8/jnvvvRcve9nLMDc3J1Mb/+W//Jd48skn8fWvf93IgcFwltAtjVw1c7XNFLueHqjr/LqrgcZCTNsnEglxK+SwI+6XBIHpc90FwNIFHQW5ymeJQKf5AUggZ5siuxq0op9khWSEcw/Y/cDMwGh5gfdHayV0pwKwtIrP5XKizWBpodfrCWHwPE+yH+x64L2mdiOXyw2JQXUWgkSF2gd2UfD6dIukwbDdcEZtjr7v4y1veQve8pa3iM7gwgsvPKcnZjDsduiJidoYibV7BjkKCZneZwaBJke5XA6e56Ferw9ZLlPFX6/XZdWrV83siACW0u+NRgP1el3EfzQa4vmwLk+9gR5BTeEkywIM1Ez7a83D/Pw8UqmUlBf4Ht25wOwJzZnomsj7RRJCa2kKL9mlwUBPESSJDskUyQzJhbac5kRJ/o7Y9shSDAkIydvozAqDYbvgjLsYvv71r+PSSy/FRRddhIsuugjT09N43/veh2q1ei7Pz2DYtdACRVoA03Ro1CeAJQAtEGTwZVskHRGpLaCKv1wuY35+HidOnMDMzIwQCabiAUh2oNlsolqtIooizM3NibcCCQAAyVTooUhaTKnHH/PnzEBwTLXruiiVSkPXn0wmpQ2RAs04jmW2gg7kWufAcdbcBzsVSFAoVuS90p4OLDWEYSjlkTiOh8ocPBa7KYDlwVNmlmTYzjhjgvDrv/7reMUrXoFvfvOb+Ou//mv87u/+Lv7P//k/OHToEObm5s7lORoMuxKjAkWm8mk4BEAIAt0JOVAJWM428H1c1YZhiHw+LyvuRqOBarWKer2OF154AeVyWdoB2ePP1Xa73Ua9XketVkOtVhOlP7sYWAZgRkCPWo6iaGi0M8WQDMJsw+x2u8hkMmKxzCA8Km6kSRKzGABWlBkACFGhxiCRSKBWqwlZ0kSG+2JGgcRjVL/ALAHJC4AhF0YSAt4LXofBsJ1wxgThhz/8IX7/938fr371q/GKV7wC73jHO/DNb34Tr3rVq3DLLbecy3M0GHYduDplChtYnrvAlkOm8l3XFWEf6/daq8AVPAV7LEMEQYB8Po9cLieqf44+7vf7kvJnhwRT65VKBSdPnsTi4qIE4l6vJwSAAkWSGpZD9DCkwWAg9X9mFjzPkwxkoVCQYM6sCLsGmMonqWBQBoYJAoM0yw8cIkVPBbpNsgxCwsJ7RILF66Bwk26M1GTw96O7K9b6nRoM2wlnTBAuv/xynDx5cui1RCKBD3/4w/if//N/nvEJffKTn8Sll14K3/dx6NAhPPbYY+tu/+ijj+LQoUPwfR8vfelLcd99963Y5sEHH8TBgwfheR4OHjyIL37xi6d93N/5nd/By1/+cmQyGZRKJfz8z/88vvGNb5zxdRoM60HrD3R5gQSBBIIZBAZnBmJ2LXAbHcQYxLvdLgqFAiYmJpBKpTAxMYFCoQAA0gWQy+Wk5ZEiQgrxyuUyarUaqtUq5ufnsbCwIA6IDLqjKX3tXaADMrMgtDqemJiQ86c5Ub/fF0Fio9GQlL4mCNqASZsyMRugNQskWiQPFCqSiJBc8efAsjiU8yx0VwZ/V6MeCNbqaNiuOGOC8Ku/+qv41//6X68wT6pUKvKQOV088MADuPXWW/H+978fTz31FK699lrceOONaxo0Pfvss3jTm96Ea6+9Fk899RTuvPNO3HLLLXjwwQdlm6NHj+Lw4cM4cuQInn76aRw5cgQ33XTTUHDfyHFf9rKX4eMf/zj+5m/+Bl/72tdwySWX4LrrrsPs7OwZXavBsB5GBYpajMhMgLYa5kwFtjlyJUvXv3K5LF0HWjhHQkESQZMgAGJSRHLBkkEYhvA8D/1+H8899xza7bZoAwBI2p+Bm90V2lKZKX36G+hBU2EYio07raAZ+IMgkADN7zVBAFaWGXT3B7BEGFi+aDQaUu7Qmg3dLcEsBYM/iYHObGgh5VomSUYQDNsNifgM8176IfKWt7wFr3rVq9Dv9/Hf/tt/wwc+8AH883/+z097n1dddRVe/epX495775XXLr/8cvzSL/0S7rrrrhXbv+9978OXv/xlPPPMM/LazTffjKeffhpHjx4FABw+fBjVahVf+cpXZJsbbrgBpVIJn/vc587ouABQrVZRKBTw1a9+FW94wxs2dH18T6VSEe93g2E10K2P9X7f95HP51GtVtFqtYZq447j4Lvf/S5OnjyJSqWC559/XgJnrVbDK17xCgwGA1QqFQDA3r17cfnllyMIApkxQM0BV9StVgtzc3OIogjz8/Po9/vI5XJYWFiQ1r84jlEqlfBjP/Zj6PV6KBQK2Lt3r2QKuOp/9tln8cQTTwhJqdfr8H0fF198sZzj1NSU+CtcdtlleOUrXymZglarJav4MAxRrVbxwx/+EK7r4vLLL0c+nx9K6/f7fSEs2WwWvV4Pi4uLMjeBHQfNZhPNZlNKFv1+H5VKBYuLi6hUKpIlaDQaeP7553Hy5El0Oh2kUikcOHAAExMTmJiYwE/91E/hZS97GQaDAUqlkpRNdLcJtQ60ojYYtkM8OONpjidPnsRTTz2Fp59+Gt/+9rfxmc98Bj/4wQ+QSCTwkY98BH/2Z3+Gn/zJn8RP/uRP4oYbbjjl/jqdDp588kn89m//9tDr1113HR5//PFV33P06FFcd911Q69df/31uP/++6Xl6ujRo7jttttWbHPPPfec8XE7nQ4+9alPoVAo4Kd+6qfWvCaKvAjr8DBsFFr4BkB8Cbh65owDdis0Gg04joN6vT7USlgsFsVimWn2XC6HTCYjosUoipBMJlGr1ST1r41+9MwHditMTExgMBggiiJ0Oh3s2bNHdAfZbHZID8FArFfQXLEzs8BWSM/zUCqVpMWSokZmL4Bll8VisSilAQ2dAdDZF94rvsb2Rq31IHngtZNQMMDznPS4bIowgaWsxSgJ4O/DMgiG7YYzLjHs3bsX119/Pf7tv/23+O///b/jO9/5Dmq1Gr7+9a/jN37jN1AsFvHlL38Zb3/72ze0v7m5OfT7fUxPTw+9Pj09vULrQJw8eXLV7Xu9nnRSrLUN93k6x/1f/+t/yWCb3//938cjjzyCqampNa/prrvuQqFQkK8DBw6scwcMhmWwtKD9D6g/ACCtjWwLjOMYhUJBSEA2m8VgMEA+n4fv+xLIWFsnyeDkRjoiUojHrgUGzm63K66IJC379u1DHMeo1WpDWgHf9yWwUxzJoMzXGbT19bKdkK2C7MZgwE2n09JFsFZ5gdBlBmZa+C/vGwM/sOz0yDIDr52EiaUVXhOJPwdRETweACFpvOcmUjRsN5xxBmE1+L6P17zmNXjNa15zxvsYXQ2cao76atuPvr6RfW5km5/92Z/Ft7/9bczNzeEP//APRcuwd+/eVc/tjjvuwO233y7fV6tVIwmGU2K17AFX2GylYy2+2WxKyUFnGbgyLxQKEryZ+q/X66jX60IOaJIUBAE6nY6Qaw4u4nvpbUBLZXoXNJtNNBoNmcQIQLITcRyjWq2K+p8BlL4Eep4BnQ9Z+uB9CMNQDIq4aqdwcj2CQAEhuyV0WYZdFHp7kjBmF0YFnpwJQYJFUlGr1URcSaKjMTqe2mDYLjjn457PFFNTU0ilUitW7TMzMytW98S+fftW3T6dTmNycnLdbbjP0zluJpPBj/3Yj+G1r30t7r//fqTTadx///1rXpPnecjn80NfBsOpoNPVXNlr/3+K+5gir1arEtz0PtLptLQvjrbicX4CM2IXXnghLr74Ylx44YVIJpNYWFhYIdjj3AOm2tvttuxfiykpfKR4kq6EuvRB4yEdUJn54PvYoUHBJTMoJAt0e1wNfF2bTLHMQMEhMwV8TY/QpjcDyQQAuZ/stmA2oVaridBzNaGi3odlEQzbCWNDEFzXxaFDh/DII48Mvf7II4/gmmuuWfU9V1999YrtH374YVx55ZXSlrTWNtznmRyXYI3SYDiX0BkE7Wmguxa0S18URSsMeUgktK8BRxVTtc9aP82VstksSqWS9P+ThLD1r9lsShqemQvXdWXeAbUGtHzmdEcKBnkeXK3zGrkq12WTXq8nK3aaFlF7wPPSuoRR6M4F/R6tQ+C1kEBlMhkkk0kZfEVyxO1GjZSYWYmiCI1GY02CsNrv1mDYDhgbggAAt99+O/7oj/4In/70p/HMM8/gtttuw7Fjx3DzzTcDWErZv+Md75Dtb775ZvzoRz/C7bffjmeeeQaf/vSncf/99+M3f/M3ZZv3vve9ePjhh3H33Xfju9/9Lu6++2589atfxa233rrh40ZRhDvvvBN/9Vd/hR/96Ef41re+hXe96114/vnn8c/+2T87PzfHsGvAYK71BwxoXAlrS2Wu9PVqneUAigTb7TYqlQqq1aqUFphiZ8qeWQH6EzBw08dAayL4mud5mJqakpX47OyslAf0salFYICl7wHbDJlZ4Cqf2zBA8zzZ0aD1A2thVIfAL14bV/38P8dL876Q1LB8oDMNLBlwPHSlUhkiQWsRFyMIhu2Ec6pBOFscPnwY8/Pz+PCHP4wTJ07giiuuwEMPPYSLL74YAHDixIkhb4JLL70UDz30EG677TZ84hOfwP79+/Gxj30Mb33rW2Wba665Bp///OfxgQ98AB/84Adx2WWX4YEHHsBVV1214eOmUil897vfxX/5L/8Fc3NzmJycxGte8xo89thjeMUrXnGe7o5ht4BBiSluBn+m3SnWoy0xRXMLCwsylIhpdeoIOK44m80il8tJKx5FeABkzkIul5OWR9d1UalUhDxEUSQrfSr2OR2SbZnlclmMnTj/QZcpqGHodruIogi5XE5skHO5HLLZrNgYcx9M6zP7wRkQ60G7ImrjJgo5SWL0iGlqMkgE2HlELQKFnDSrSiQS0orK8sF6ZQQrMRi2E8aKIADAe97zHrznPe9Z9Wef+cxnVrz2+te/Ht/61rfW3efb3vY2vO1tbzvj4/q+jy984Qvrvt9gOBeg2p3dCswC6PHOdABcXFyUVW2/30e1WpVWPabOtWVzOp1GqVTCxMSEbF8sFqVePzMzI2r9XC4nRktxHItTYxRFmJiYEILBdsZms4lCoYBGo4FyuYx8Pi8eAiyVsJuBkx5JAoIgwMTEBPL5vAyQGtUQaJMnPW1yPeh7wwyF7mjg/WbWQhOJXC4n5667EkguaNTE+0CPB/374v7179YyCIbthLEqMRgMux2jAkWmswGIE6FW1icSCbElZoDLZrPIZDLI5XKy8h4MBjLBkXoBZh8ymQzq9bocp1gsAlhS7U9OTiKfz0tA5/RDGiXR0KlWq0n5gAHz+eefx9zcnLQC6rHOTMcHQYBsNjtk50zNAIM2syW8PsdxxC75VND6DU0OqL3Qok0AUmIJw1DKJqPW1vq9FG1WKhWZ7TBKEHhca3U0bDcYQTAYxggMItQhUE2vgw6DsO/70olAQSDFeEzDs6URgHQs8GcM7uw6SKfTUn7gqpnBUrfq+b6PUqkkngkM+L1eD1NTUyL2W1xcxMzMjARY7iuTycjIZN/3EYYhgKVMnQ7EnFyptQc891PpDwhdZuA1pdNpKZPoMg4A6cxIpVJyHJZTeO9Hp2NSvzE/Py8ZDxISwsySDNsRRhAMhjGCVvEzcOnvAchoZwr5UqnUkMKfff80FaIi3/d9WflzFd5sNvH8889LSy6tjNmhMz8/L8SB2gfqEBgktdPg1NQULrzwQkxPTw8ZJrEDQncRcO4CV+raX4GrdGYjSHo8z0M6nd6wZbEe3sSAnUwmhYzoSZnM0JAgeZ6HbDY7RNg0yaAmIggCxHGMcrksmY5RH5XRzILBsB1gBMFgGCMwaOlVtA5cyWQSURRJdgGAKPCZHmdwYoBl9wFLA8BSsJycnES9Xsf8/Dy63S6y2awE8m63i9nZWczMzMhwI4r5WG9nkOT+6XDIIE4DJh6PpIAZAdoya/GgTuO3223UajV0Oh1kMpmhkdRrtRGuBp1FYKAOgmDFaGfef3aAeJ4n25GkMePA1sherzdUiqjVatL6rMsMmiAYSTBsFxhBMBjGCBQoMkhp/QFr8JydwJVrvV4f6vVnIAOWLZtZLw/DEI1GQ4YScRLj4uIi4jhGEARSV19cXES9XkepVMJFF10k5ka1Wk00C/V6HYuLi2i1WuIHMBgM0Gg0hER4niepes5fmJ+fR7vdFi0BTYqYSRgMBlhYWBCvBZIDiihPB6M6BP5LS2e2eZKcaPLFe8HuCbZkkhwx6LO7pFarDXU0rPU7Nhi2A4wgGAxjBK5UgWX/A2B5ZcsMA02QWEJot9tSV9dzFuiX4DiOEArXddFqtXDixAkhI8wkMJhzv0EQYP/+/bjwwgtljDtXzgym1WpVPBg4l4E+CUzhe56HTCaDfD4v4kiSoVarBWC5BOD7PqrVqpQ6OJSJZkqnam8cBTMxJAdcxdPZVBs4UUzI8+HxtIGSNrJKJpOSDeF96/V6ovtYDaZDMGwXGEEwGMYIXO0zG8B6tiYIow6AOmBrt0W2B7KDQc9q8DwPnU5HhI6DwQAzMzM4duwYXnzxRbzwwgvo9XrI5/MIgmCIIJDEsCOCq2sSBmDZy4EZBQr76F/AVkIGWGYc+L5KpYJutwvf9yV7QB3FmYDH1CJC2jXrSZKj4lA9x0FD20PrVkjqNDRBGG15NIJg2C4wgmAwjAmoNWCPvdYfaJU9gyVX53rKIwOoXs1SGOi6LqIoQrVaRaPRwMTEBDKZDC666CJ4nodWqyVlBfofUA8QhiEKhcKQpTKDZ7PZHHIo1G2UJDQUATK97zgOpqenRU+gJzXOz8+j0WhIyybvw5lkDwieGzsx9EwI7ZFA8qV9JGgkRX8G/k5I2PSMCJZQmJkBIPsxoaJhu8EIgsEwJtCBhzVxQs8joKMfvQUASA8+Ff7MRLBcQfc/lg2oNSgWi8jlcti/fz9yuRwGgwGq1ap4KVB81+/3kcvlkMlkpC2S4kI9sIieBXQm1OZADNAMtL7vS6fAxMQEisUiXNeVrAMzDPRXIFk5E5AgsB2TgkVqDBjA2f0RBIGQB5ZuOIuBWgR9D/h7AyD3S2cWgGWiYBkEw3aBEQSDYUxAfQFXrQwketXLoEvbY6bx+b4wDMWpkN0OAGQ8NNP8LB1wvPKePXuQSqUwMzMjjooXXnihlCpoq8xgTSdGqvypPyDJob8CsEwMdOuf67oiRuT45z179qBUKolegq6FqVRqaOrimYI2yfp+6pZJncWgoJPnoH0MWE5hhobXr82YOGNCwzIIhu0GIwgGw5hAT11kIAOGBYo056EYkUZIXNlypU0jInYm8H3sGODKvV6vo1qtyqwFtun1+31pbSRhYSBlq2W1Wl1hyLS4uIhutyvzH4Bl8SGFgiQK1EyQEHB17/u+iAV1uv9syAGAIRGinnjJTgu2TtIhkh4TnGnBL5I3kjOSIs7BoGiUJSDuU2sgDIbtgLGbxWAw7FYw6DBtTYIALDsBskbued7QlEZgeW4DU970JqCzIVsjSSK4Wu71epibm0MURRKMXddFrVaT0kQmkxHDpFqthsXFRWmVZLcFRZEMhBwuxZkOJC4sG2h9QiaTEfMnpvNpaMRzPRcEgSSF94cEgfeKnQrUFFBU2e/3UavV5D7z99VoNMQeularifMjPR8IPc+BotO1Jj4aDOMCyyAYDGMCrlBHBxXpn+saNv0AtGaB+gBtvUwfAa7GGYAZ/Obn5/Hiiy8CAC688ELs27dPzoH6AgrwisWiBPx6vS56AW2BrAOwnioJLDsWsrzAGQzUBDBrwO85vAnAWRMEiiOpmyBBIHHhPWKGhmZPhUJBuj5IqogoiqSkEkURKpWKeEs0m80VxyeszGDYDjCCYDCMCfSqVhMD9uizDZABjkGGLYwARByo+/X7/T6CIEAmkxHhHAM6Bw2xa+DCCy/E3r174bou0uk0KpUK5ubmMD8/D2BpkBPbG7lvBnMdfHUgZTaEx2Wg14HYcRzRA0RRJASGwftclBh4rziNUc9LYCaB5QaeNwDk83mZbsl7SqtpEgzdXUETJf6+NKzV0bCdYATBYBgTaIU/Awhr2kyBM6jpej4ti7lS73a7qNfrIphLp9MiuGMaPIoiWemy5x+AlA842wFYIi4nTpxAEATYu3cvcrkcwjAcque3Wi1Uq1UAGGoZZBaEWQP9cw5gomDR9320223RLpRKpXOWPSCY4eB58X6TYNHxEVh2YPQ8T1pCdQcHyQvnWvD3B0AyOKM6BP07MxjGHUYQDIYxAaceaiGfNvZhoOWKW08UZNDl/yk65HwG3YrHUsXs7KwEaQ5Uog6BLYZsmVxYWEC325VWR2oTqBXo9/uSXmf9na+TaARBIMdnGcT3fRSLRXieJ1bNdDDUo67PFUFgloBlEmY/eB3Ud2SzWRSLRcm87N+/H4VCYcUAJmpCSJjoCcFOBmZs9O/UWh0N2wVGEAyGMQHLBlyZMyPAzgauULnq5mqbwj4KHBm8tVEPSQJ9Bl544YWhVX82m5WWvn379uHHf/zHUSwWMTU1hcFggEqlgpmZGRHu6YmMdGMkGdD2ycxouK4rJIbkwXEcqe/rsc5hGApBIUE4U4OkUehhT5y8qEseWoDI4/b7fWQyGWkh1aSCRIxtpHo+Q6vVslZHw7aGdTEYDGMABn8SBGC4Ts3VLtsUdYCje5+efUDiQMMjHdDpowAAe/fuBQDs27cP1WpVbJlzuRx6vR4qlQqKxSJqtZqYMWlDIB6PhIaBj0p+fnEwUhRFAJYyAhwhzawCjYtYctDeCaczvfFUoMcCu0B06YPZFJ2poYAxn88jmUwOdWSw/KOFonydFs4a1upo2E6wDILBMAbQo4S1dz+7ABj8GbT02OdUKoV6vS4rVq7ePc/DhRdeiKmpKcRxjOPHj2NhYUHMlhi0S6USgiCQLAItlxkkwzAUT4RWqyX6AhIIkhSuoHnuuv7ObACvIZ/PyywJCgcpDuS5n+vyAkEBJFf5+nVmBhjY9ZTHQqEgBIKkhZ4HJFb8ObUKJES8J7psZDCMO4wgGAxjAK60tW+/XqFylcp5BLQ0pqMiDXvYPsi6eKFQQD6fR7VaFRMjZgiy2SwAiDaB+9biPWBJuOd5Hnq93pDCn0OWmHngOVUqFbFeJkngeVFbQPKRSCSQzWbFzIkEKJVKbRpBYJmBxItaCgByfAZ4ekjwPMMwlDZOdpTQ0VL7O3BWRqvVGvKz4O/VSgyG7QAjCAbDGEAL9wBIgOTrDCiskXOoku40YCDXpYhOpyOuhq7rIpvNYnp6Wmr6TN0zkDEA6oxCPp+XYE4RHw2QKpUKqtWqzIWYnZ0dsoEm2eE8A5YNdCnD933JJlAYyWsCzp3+QIPDq/r9vpRjeN9plkTjJAZ7Ld7kz/i7qdVqsh2zJBR+jhom6Q4Vg2GcYQTBYBgDaD8BkoTRrgMAsnqNomhIHU+BoXZR5PbsdMhmszK2OZVKoVwuy+AmigtTqRSCIJB0OOc05PN5hGGIIAgwOTmJfD4vq25aDLNNcWFhQdT8bAEk0QGWLY85B4LXzxZOXV441/oDgiZI2v0RgBCUZDKJer0+5DFBUSXJ22AwkHvHTA//5Xt0u+ioQNHKDIZxhxEEg2EMQDJAcqDnL7BdkTVuAPI9CQBLA/Q30EOfuB0nF+qpiPV6fciUKJvNyrnobgMGeQof8/m8aBe0wVMQBEJegGX7Z3ZVeJ4H3/cRhqE4L3KWAUWCeg7FuS4vELqbQZcBOLWSOgR2bfA9FCrq8g+NkVYTmtJpke9nWcI6GQzbAUYQDIYtBlsUmQkAll0VdQuj67pi5MP2OhooMe3N+QgMuBzZPBgMpD2Rq33W/Tl0ac+ePXL8hYUF0SwAEJ8CihJZEiBBIYmhTkGPdqaokZ4Cnuchk8kAgAgueQ3aswHYnPICocsMLAOMGh9FUSQtmhRssuxAm2m+L45jIUcUe3Y6nRWdDOaFYNguMIJgMGwxWJvXUw8ZQLia1wOM6vU6FhYWUC6X0Wg0hCxwoiJXx5OTk8hmsxKIOE6Zq3SKFDmEiLV3Cg9PnDiBubk5tNttyVCUy2V0u10RNDL4ccATBxhxZQ1AshMM/iwb8IuraWY5AGx6BgGAWDvrMdr8fbAFUwsY2eFAojPa0sjWR+14SQ2IzhZYBsGwXWAEwWDYYpAgAMtjgfXYYKalGVC4Wm+321IG0L37uVwOpVIJF198sYgDfd8Xm+QoijAYDESESPtltkpSrQ9Axj5zHgEFeDpIUuNAwySSGt/3paRAMkDdBEsdjuOIOHO0e2Gz9AcEz9lxHLRaraHZFey2oDhRZ3fCMBQ7bC281KSGDpb9fl8IE3+/zOgYQTCMO4wgGAxbDD2zgAFUdzD0ej0Jnr1eD9VqVSY16mmHHCCUyWQwNTUlbovdbhfZbBa5XE4CerPZlFq/4zhoNBqo1+syb2H//v1igVwoFLB//37kcjlJtzuOg3w+D9d10el00Gg0kEql5D25XA7A8uAiZj+ApRU0gyzLCUzL68mPm1leIHQmRE/LZKcGuzU0IaCtMn9P9IagqyTJAt+jhYrAshbBSgyGcYcRBINhi6EV/PzS7YtctbNtcX5+XlLf3C6OYwlcnCVAJ792uy0dAyxJsBMin89L14IWM3JlDSxZQNP+mMp/x3FkgBGzAMlkElNTU0ImeC3sWtCTENkGqEkDA/L5KC8QWviphYcshwBLRIXZEnY58H3aVpk2y1psypILtRyjQ7YMhnGGEQSDYYvBLMFqUxABSM0/lUoNCQX16pzGP5ogcKqj67oyaGhhYQFxHEtgpw8ByQB7+RkImV2I41gyBgx2HBmdSCRQq9UkI8EOAD3bgPumVoHnqkkEa/jnkyDo7g5aRzNws3sBgAgv6ZPAkgl/V8w86PkX/F1qgqBttC2DYBh3GEEwGLYQrGFzdcr0MzMHXI1yVVur1dBoNCQtz04Fx3HQbDYlgDFt3u124fs+JiYmxMQoCALs379fhiSx3u66LoDl3n16JDDI0W6ZK39Od9SKfXZWMOtBQqEnTbIUQu3EavoDBuDzAWY0GMTZfUHBZLvdRqlUGhoV7TiOZEH0zAkd+Jk14T0BMNTGalkEw7jDCILBsIXQAkWCLY4kCEyBDwYDLC4uolwuS1DPZrOSLaAwLgzDobkILDfUajXEcYzJyUkpY9ADgYZFDHj0VigUCgCARqMhLoq6Q8FxHBHx1ev1oWFEOsiT/HB7YClDwPIDV+csmZyP7AFBwgJA2jdpggQsEQTeaz0WmiUGdilQjMgSDvfZbrclCzM69tkIgmGcYQTBYNhCkCDo1TRf06OSU6kUms0mFhYWhsyKuPKlwM51XelAoL2y53mSdWBWoNFowHVd6UYAIGUOBvg4jkWPwPp8GIZynsxq+L6PTqeDer0u2QRqJnRNnmSABIHeAtrm+HwKFAm2fWqr5F6vN2QBzevhkCneGxIGZl34e+C/zIrw/gM2tMmwfWAEwWDYQugSAwMPsJxF4IwF13VlKBMtf5nqpuc/2/a0SRHT5FzRZzIZ6flPp9OYmpqS2j+DPNse+b58Pi/nxPKFblv0fR+9Xg9zc3NoNBoyJIrnT+0B9QckQzqrMOqHcD4JAgAJ9rz/nM/A8+h0OtK5oUsfFCiy1ZGtp8zQ8F9NEAAb2mTYHjCCYDBsIbTbIAkCXwOWx0BrvwIKBrkCpYJe1/cptmNWod/vS6aAwTmXy4kVMgcscSXMfZCQBEGARCIhRkwMenxPu93G/Pw8arUaSqWSdFToqZCj1s/UHbCNcCuyBwSJlDY7ovsjAMnk0GWRGO1AGS2pABACp0dhWwbBsB1gBMFg2EKslkHgypspfK5O2b1AMaEeKQxANALAsFWzFhcyADJ4M+AzSFPHwNT43Nwc5ubmpDOhXq+j2+3KtEaurPU0Rto763kS3IaBk2l93Uq4lQRh9Hxom8xOBpZN9Fhnkitmcvj70L9D3odGozHkOmkaBMN2gBEEg2GLwNUjgyiDU6/Xk7Q1A0+r1cLi4qLYAJMYMEizY4ABq9PpSJ2caXH2+FNER9DTgNoEdkPQxGhmZgZRFA1ZEVMMGYahGCP5vi+tju12W7ZlNkT/nEFWiwN5P86nQJGgYJImScCSMNP3ffT7fdRqNSFq9EWgUyQzDqNTNLlPahB0C6QmTwbDuMIIgsGwRWAw10I+DmZiFwIFfZ1ORwYBFQoFCUrssdf1fU5OdF0X+Xxe7I8pnkulUtLWmMlkEASBtFDqmjqV+jx+qVRCNpsVo6C9e/fKOdNAqdFoDLU66rkL7LygMyRFgMxmAEsreZKG8wneP2DZr6HT6aBSqaDdbqPVasl9m5iYEI8IZh1IyHjN2k8BWOpkaDabQ4JUG9hkGHcYQTAYtgh6SBMDJT0QdIqaRkRc2ReLxaESAevj2rCn0+mgUCigVCqtICCpVAqZTEY8CrgP3frIVfz09DQymYxkFKampkTQl81mRROhWym5H3ZFUOyna/Ss5wNb170wCj1qmmOgm82mlBPYARIEgZgrsQTR6XSG5i0Ay5mC0U4GbZZkGQTDOMMIgsGwRRj1QNAeBOw64L/lchmdTgdhGKJYLMr7tBgxnU5LN0MikUAul0OxWJQ5A0yRMzBHUSQ/q9Vq0vLICYee5yEMQ+zdu1cCYRiGko3Q9sG5XA79fh/VahXJZBKu6w7NkKCfA4/PYAxgRQZhq6BLAiRBAETD0el0hBiQMPFfEjqKRrUwk5kbne3R5RojCYZxxdZ9Gg2GXQ7dwaCtelnPZstit9tFpVJBHMcoFosilqPoTbcpcgLhxMSE6AKq1apoAvR8BZYymFKn5wHJAQkFzZRY1giCAOVyWYI9X0skEoiiSMiIrtmPChK5P2B5xc3z2CpwumQcxzIum6t+ln7YhZHJZOS66AlBkSfbSLVt9GAwkHsDLAsVdWunwTBusAyCwbBFGLVZBpbnMgCQ1HS325VZBxQosi0xjmNZ3dPgJ5VKIQxDGTCkWyY5u0H7JrAVMp/Po1gsihkSAMkwULPAVDuDJlfKFEoOBgPU63XpjiBBoOKf50vCoMWJW5k9AJZbE+n1EASBEAD+XmhaRTKh2zaZWaEeQesvVvNCsLHPhnGHEQSDYQvAoKhnD4z6+rPEEEWRtNkVCgXpcoiiCACkG0CbLOXzeckCsKuAIjkAIrJj0KeAkMFPT48kieHKn2JIPX2xUqmIVmFxcRHNZnPIEMlxHNFKsA1SB09g6wkCsNxBQTtp+kows6MJAssLul2RhIwlB2A5a1Ov11dMezShomGcYQTBYNgC6BZHbcHLFbtOv1cqFZnomMlk0Gg0RFioiQbFcwzgHNhEMsF9BEEA3/fF8Ee35DFAcugTSQLr6nQ9ZFtlLpdDrVZDFEUyq4ArZRIX+h6wsyKbza5YNZ/P4UzrQRMETZTocUDiwCyI1i1owyRd/iEpa7Va0u6ox0FbBsEwrtj6T+QIPvnJT+LSSy+F7/s4dOgQHnvssXW3f/TRR3Ho0CH4vo+XvvSluO+++1Zs8+CDD+LgwYPwPA8HDx7EF7/4xdM6brfbxfve9z688pWvRCaTwf79+/GOd7wDx48fP/sLNuxK6J54XWLgBEZmDwCgUqkgkUiIWI5dCroLAlgKsmxrdF1XpisuLi4iiiI4joPJyUlks1lp6WMg4/faAdB1Xck0NJtNRFE0NIlxcnJSSEa1WpVAqp0gqSugXoG+CQSD4zhkD4BhgsDyCAlXr9eTUgonQJI08T0kOq1WS4iA7logUbNWR8N2wFgRhAceeAC33nor3v/+9+Opp57CtddeixtvvBHHjh1bdftnn30Wb3rTm3Dttdfiqaeewp133olbbrkFDz74oGxz9OhRHD58GEeOHMHTTz+NI0eO4KabbsI3vvGNDR+30WjgW9/6Fj74wQ/iW9/6Fr7whS/g+9//Pn7xF39xc2+IYcdCtyQyyDONPRgMxKCn0+mg0WgAAEqlkpgm1Wo1yQi0Wi0RFzqOIxMeB4MB5ubmMD8/j1QqhYmJCUxMTAzpBoBl9T7BgMasBFf8tVoNnU5HMgv9fh+lUmloLDIA6W6gbwCDq54hoVPswHgRBAZvukQmk0nxbGAmhRbMeqoj9SK0tmZ2iNfb6/XQbreHxl9bBsEwzhgrgvB7v/d7+LVf+zW8613vwuWXX4577rkHBw4cwL333rvq9vfddx8uuugi3HPPPbj88svxrne9C+985zvx0Y9+VLa555578MY3vhF33HEHXv7yl+OOO+7AG97wBtxzzz0bPm6hUMAjjzyCm266CT/xEz+B1772tfiDP/gDPPnkk2uSF4NhPYzOYGAQpUkRuxdIBGiZHMcxFhcXJVXNlT9FcalUCrlcDrlcDs1mE/Pz84iiCGEYYt++fUNWwqPZA0KveBOJhJgpNZtNlMtlFAoFhGGIer2OIAjEl4FZDToM6jkLJC9BEKyYz8BtxgUkPNroiRMyqa1gJoXbMmPDzAOwLArVo6xrtZp4ITCDYATBMK4YG4LQ6XTw5JNP4rrrrht6/brrrsPjjz++6nuOHj26Yvvrr78eTzzxhKxi1tqG+zyT4wLLad9isbjmNu12G9VqdejLYACGPRAoXNPugxT3MaDQoIe2v1zJ6ymIrPkHQSBWzHxvGIZDRGCt7AFfA4YFlLlcDr1eT8ya6IgYxzH27NkjI5+5KtYiRKbqc7mc1Ov15MRxyR4Q7LDQWQT6H2gvCWoxmHXg74Gkh9oLnS2o1+tDra26FdJgGDeMDUGYm5tDv9/H9PT00OvT09M4efLkqu85efLkqttz9Ox623CfZ3LcVquF3/7t38a/+Bf/Qkbhroa77roLhUJBvg4cOLDmtobdAy0s1Op3veJkOprmOrlcDplMBrVaDZVKBclkUsipXoXr4UAU1E1NTSGbzYp3gs4eaD0AoTMIGpzpwFHIbPujuVK73ZZUOgCZ2EjCUCqVhtwcx6W9cTXwvnQ6naG2Ri0eDYJACBZLJvSwoAsmNQskHBSXau8D0yAYxhVjQxCIUcOQU5mIrLb96Osb2edGj9vtdvH2t78dg8EAn/zkJ9e5EuCOO+5ApVKRr+eee27d7Q27AzogaG9+3YbI1kSSiHw+D9d1MTs7K05/NFLSpkStVku0AFTb53I5TE5OAoCQDgBDlsoaoy6AzAzQW4GlEA4qyufzyGazQjporsQsAj9LLEXo4VRcZY8bdEcHSwK6bELyxXtE8sBSC4kSfy+aQJBEaCJmJMEwjhibT+bU1BRSqdSKVfvMzMyK1T2xb9++VbdPp9PyQFxrG+7zdI7b7XZx00034dlnn8Wf//mfr5s9ACC95QaDBoMB08sMlKxh68FHnAWQy+UAAOVyGd1uF2EYykClIAhEs0CCzPZE/r9YLEpWgsdf72+TgZymTCxd0M6Z58wShq7L0xiJI5x935cWTD1fYty0B6PwPE/GNNMUiWSGbaC6lML7ypHZ9I7QGZVut4tmsymZIsBaHQ3ji7HJILiui0OHDuGRRx4Zev2RRx7BNddcs+p7rr766hXbP/zww7jyyiul9WitbbjPjR6X5OAHP/gBvvrVrwoBMRhOF1p7oAf8UKAIQFoUO50OMpkMstkser2emO1QfwBA3BD5PVsha7WaeBVwPgJJgV4hrwbuq9lsAli2Ie52u8hms8jn89JlMapxoJkQV8bpdFrKEyQIxDhmDwidYeF18NxpMsXsgC4j6MFXdLfUjowsG5lQ0TDuGBuCAAC33347/uiP/gif/vSn8cwzz+C2227DsWPHcPPNNwNYStm/4x3vkO1vvvlm/OhHP8Ltt9+OZ555Bp/+9Kdx//334zd/8zdlm/e+9714+OGHcffdd+O73/0u7r77bnz1q1/FrbfeuuHj9no9vO1tb8MTTzyBP/7jP0a/38fJkydx8uRJWaUZDBuFXjFqx0RORgSWCAK7AsIwRDabRbVaRavVErti3Y7I1rvJyUmkUilUq1U0Gg04jjMkpKVREdv01gJV9/z79n1fhL9hGMpxms2mjHvWHQs6uNKUSZsG8WfjTBCA5SyLHuDU7/clK6LFoRResvwADJcueU+r1eqQGNVKDIZxxVh9Og8fPoz5+Xl8+MMfxokTJ3DFFVfgoYcewsUXXwwAOHHixFBb4aWXXoqHHnoIt912Gz7xiU9g//79+NjHPoa3vvWtss0111yDz3/+8/jABz6AD37wg7jsssvwwAMP4KqrrtrwcZ9//nl8+ctfBgC86lWvGjrnv/iLv8DP/MzPbNIdMexEaILAYEpCwIDBLgSuvtPpNF588UVZyTIQk0Sk02nxOQiCAMePH0ez2cT+/ftlVgOxkcFA7PnnbAKdJmeGIJvNYn5+XgKm53lSjqA2gqvrXC43JM7kNYz7kCKKEKkZYBaAw5oAyPWyrEDHRc6w4BCt0U4G7s8yCIZxxVgRBAB4z3veg/e85z2r/uwzn/nMitde//rX41vf+ta6+3zb296Gt73tbWd83EsuucQ+wIZzAq0/0KDzHrUEzWZTFPD5fB69Xg+Li4vo9/uS2uaKNJlMiqFRqVQa6ijQpkSnAy2uS6fTaDQa0t4IQAhJtVoVl0bd1siSB10H+T6tPxj37AGhCRIzH67rSkmFRIfW1slkEo1GA67rSneKtpGuVqvSImoZBMM4Y6xKDAbDTocOBHTZ06tOthFqgSHT+xS3MSCFYSipat/3ZZASg5XrugiCAIuLi6dFcHk+NALSXQ/MRrB7gZ0MJAGstfMcM5mMeAgwKOqxz9sBo62MzCgEQSDjrrXnQTqdHhIqshOE18vBWbpl0hYghnGEEQSD4TxCD2nSBjlUyzO1z/9zbkK9Xker1ZIOBgYfXV5g90C1WoXjONizZw+CIECr1UKlUtlwEGq1WgAgmQpNQrQTI8WJzGRQLMlsAn0QSFx02n1chjNtFMyAsFRAbwp+r2c38OcsswCQ79kGSbJHmFmSYRyxfT6hBsMOgA4EuuVPK951nzxr+7Ozs+j1eiJG5CqWgZs1fQoU0+k09u7di6mpKSQSCTQaDdRqtXVT2f1+H1EUiXaApYrBYCBBfVTVzxkFdBtkiUGbC1HASL8GjpjeTqDGgNkcdm/k83khe7w/eoQ1Sw783QGQTgb+zNwUDeMKIwgGw3nEah4I/X5fugEYbNipEIYhBoMByuWyiN3YUsc6N4NzOp1Gt9uV7oWJiQn4vo9CoYBEIoEoihBF0QqSwBZLPYrY9/2hsdMM6Lo1kgTGcZyhAUZhGA6JGcMwHJpayGC73UDdAX93evw1ACFWetQ2yxLdbleyC9pRkYOezAvBMI4wgmAwnEfoEgODMf0OksmkTPtjEGWNm61xDLqc9qj1Bul0WrwUstmsDBgKggC5XE4yCbRhBpZWuBxBDCwRgUwmMxSs9AwHPQ6aZQbW1j3Pg+u6YthEXQLJAP0A2Ba43UAvCU7OHAwGyGQykjngPaUGQxOG0aFN5XJ5aCaDEQTDOGJ7qIQMhh0AnT3QHQa03wUgwVWL/LR/v3ZVZBukJg2Li4tDg5EAiKCRMxo4xIk1c2B5NDN7+dvt9pA7IjssAEgtvdvtDo1DZtqdK21mN2hD3O125efbFSQIbFVkeYe/M+2OSL0FM0LMGABArVYbmuZJkrCddBmGnQ/7azQYzhNIEBhwGTiazabUqDudjqw2WTYol8toNBpDmgTqFvRMBpYRUqnUCqdPtkJqotBsNtFut6WUwfIBzZh014IuS5C8aHdBro4p5qPTIN/P1TUJzXYFx26zNMDMDX8f1F50u10hgNSTcBImSzpRFA21OloGwTBuMIJgMJwn6CDLgEC7YrY18nUKAAeDAarVqox3zuVycF0XtVoNAER/EMexOB9ms1lkMpkVx2dwJslgENczHDqdjgjsfN8fEiUSfI3EgNux9XFqakoGM5FMbPfyggZNkii45LWzLVQP3NKZmm63K0LOTqcjmg9NEgyGcYKVGAyG84TRDgZgqaTA1Sb/z7Sz53my0hwMBlJeoNaA23CIENsTC4XCmiJAlhGoT+AEySiK4LqulDpGWxH1uetpj9yW3Q7UOySTSZkFAUB8AJj92M7wPA9hGKLRaAiRo78DBYrA0j3j1EtgeSokCVO9Xl9BDA2GcYJlEAyG8wS9QiQpYLpf+w3oIUzNZhP1eh3AktiwUCgglUqJRiCdTktAiqII6XQapVJp3Vq2bokMw1A6Kebn50VXoF0CR8+dBIYtemx1ZICjcJHnx2tlvX67EwROttTlBe2DoAdp6WFctMXm941GQ4ii3tZgGBcYQTAYzhN0cGBg4FhnrioZaLjSZNcBNQRcjXY6HQnyDFIUCRYKhQ2fE/fLMoM27+HPeZ56hat1CPo8qK0g0SBxYFfGdnFPPBU8z0Mmk0EQBDIXg34QJFe9Xg+9Xk/uA4WdvE+VSkV0C6PGWQbDOMAIgsFwHqAFisDyFEe2NVLRTuEbJwXWajVJU7N0EEWR+Aww4NK2me5+p4N2uy1iR5IF7YnAcx7VIWhTJK6aSTL0WGduoz0DtjtYWmArZ7/fFxJFcSkJX6fTkd8vO0/ohcCyg81jMIwjdsan1WAYc2iCwGACQIYyMYMAQIJMv99HuVwWJ8OJiQkAEE2Ctv1lAOLkx41CixILhYKYHPX7fUmBryVUJKEBMNQOSdEeMxskM9vNXnk98HoymYz4RpAUaa8EnRliacjzPPR6PURRhGazKVkWZo8MhnHBzvi0GgxjDp0+pmK91+vJ0B7aEAOQLEKj0ZBWOJ3ObjabACD6A76fEx03WuOnrTOw3LGQTqel5ZEtmCw76GvQwT6OY/E90CtmPc6ZQ6S2u/6AIAkLw3DIl4JaC4o8acvMjAtHXfNnlUoFwPLAJiMIhnGCEQSD4TxgtMWRhEC3unEFylR8s9mUwUuZTEbcEwGIaZIWAWr3xI2cjx7KpLsekskkwjAcqqWPCuroFsg5A3rVTNtotjbq8sJOySBQd+G6LorFokxw1GZW1IXojBFbH+mVwPtqY58N44id8Wk1GMYcoyUGAEOrbZIEivkYPDh/YWJiAoPBQJTwuhuAK3OOfD4VmBmgNmAtzYLnedKR0O/3pWZOcCVMB0Dth6Bb/yjS20kZBGB5PsXevXulRZQag3w+L6UDloB4n2irDSw5KjJDY62OhnGDEQSD4TxAEwTWpOlkqIf19Pt9qedzRHMmkxFvAc5aYIBptVrieJjJZDbkUshUODsY1kM6nUY2mxWlfRRFUpbgKprnQ3MmejPQPIhZDT3HYSeAZYZSqYQgCDAYDCSL4HkecrmcZFLod6CdFalD0N0tRhAM4wQjCAbDJkOTA64omQ1gSyADA3UA3W4Xc3NziOMYhUJBMgMsC3BVzmxCNpuVqYrrnUcURVLK4BjmUyGZTIqDI8+brZnMIADLQkXtDMnyAq9/JxEEkrFMJoNsNiteB81mE2EYIpvNAsBQCymJAVsdoyiS36m1OhrGDUYQDIZNhh5zzBUlV5t6kA+DZyqVkvHLjuOIOZIWMuqVO4P9etkATm3U45xPRw/A2RAUG9IlUF8jbZ85fIq+DdoLYScRBD3oig6XFJWSIHDsM4WKwFJbqW51ZCeDaRAM4wYjCAbDJoNBfZQgsEOA6XtgOfCzvZHGR2xnZKBlnz3nG6ylP6BjH8sC6XRaZgmcDvQkR93lwOBHoSLHU1PN7ziOlDN2kkgRWPaCSCaTmJiYQDqdFlOrdruNQqEgWReSQT1hk5M8oygCsDwB0mAYF+ycT6thLDAYDIY85g3DHQxUq7fb7aHJjXqgURzHqFarACC+BkztJxIJ+Z4ufblcbiiVT7DGTYJCI6QzWcVrLwTd5eA4Dnq9HqrVqkw6BDA0J4JahJ1EDgDI7yKZTKJUKg1lVrrdLrLZrGRqmFWhT0S73Zbta7Xa0Mhng2FcsLM+sYYtR6fTkZWlYQmjBIH+A9Qg6C4GBlTOX5iYmJA0PVP6zB7QfyCXyw3pDzhOWHcqZDKZNQc4bQSrWS5TiEfdAQdIsbWRxIXv30nlBYKGSYVCQQyQ9O8yk8lI5wJ/Z7x/LD/oVkfTIBjGCUYQDOcU2g3QVkNLGO1goHkOa866KyGVSolwLZ1OS/cCW+UY8GlERFtmBip6K7B1znVdGch0NtAZAP17DYJAnAQBiN0yDZcASAZhJxIEtpuGYSg+EGxjjONYxJ26pZUZBeoOarWa/D3Y58YwTjCCYDhn4CqIsNXQyhkMLA0wi6BbHAFIeSGRSCCbzYookBkZrkb7/b4EJQoI9QwFlgFOdy7Delht9DP1EPRLyGazyGazUn/XxGGnlRiAZS8ElhMIksBSqQTHcaStVVtRA5CBXFqoaK2OhnHBzhitZhgLjAqsWCPfzRjtYOBKkgFktPZM18LBYIDJyUkJqhzvzJo/BYzstef0RADSTXCuV+yrZRAAiElQIpFAqVSSbRgId6JJEkENAjUZdMDkz5hJYVmo3W6LXwSw3HpKESMJ43rtqgbD+cLOo/SGLQMJAletlkFY2cHQ7XZFsEa9BrMCACQ7kE6nZXojfRNob8z3sXOBmRu2O/q+vynBeLWhTcCyHwDHTedyOcls6AzCTiQI/J3QdRJY8qqgsyRbSult0Wg0hlpV4zhGu90emslhGQTDuMAIguGcQAcppsWtnroyg0AXQ11zpjaBwR9YWn2yS4D6A929wFHP9B9wXfeM2hdPB6uVGAAMzWzg+GPP84YGEO3UDAIAmUNBIShbHdkGyeFNo22MzDRw5obWpBgM4wAjCIZzAj74ksnkkH3sbu/rHtUgcAVJHQLJAVedNEzKZDLyHo5yZnscBYwcgJTP54e23yzoLIAmfiQltBAmeSEx4Ht3ogYBWC4z8LopEuXviAZTAIaEiswU9Pv9IdMsIwiGccHO/MQazjtGuxf4/W5/2I0ShG63OzRmWa+yWafudDrSHsdtaKZEgsEOh1wud17IAbFaFoEBkr97rpj1Njs9gwAAxWJRJm62Wi0pAbHEACz9/mmMxK6Tfr+PKIqkdLTbPzOG8YERBMNZQ5cX9EwBbQ28GzE6g4ElBuoQCPoHNJtNqUvTQ6DZbEpJgaY6HDHMgATgvK3OVxMqjpo3MbVO3QQzDzuVIHBoFUsMFB4CkDHduuRAcSoAyRpEUSRdDrv5M2MYLxhBMJw1mC3QBIGro928IhoVKHY6nSGBIrDc5qZb35iaZpug1ilEUQTP81AsFmU7HuN8YDWhIlsdR0V2PHee204lCOwuyWQy4mjZ6XRQqVTgOI4IRylU5DRPEihgaewzX9+tnxfD+MEIguGsocsLwMpV5m594GmBYhzHolTXgYD1Z3r2c7yzXmECEHdF6hPy+bz4H/AY5wOrlRioj9CTKvm3wJa9nUoOCMdxZDgTsGw5nkgkkMvlpNWR90jfP3okkDzY2GfDuMAIguGsoM2R+C/bu1hm2K1CxdEOBhIECtKYZWFant4IdCBkEGH6nivSqakpEb5RqHi+oHUR2uyHmQySHx3gduIchlGwi4TZBACoVCrodrvIZDIIw1A6UgBIFws/I2yBJHnY7d0/68EI1PnDzv7UGjYdo8Gf9Vh+rRYwdgv0hEbqD7ha5LwKTRZIGDKZjGQUWN+nXz+nO6bT6fOePQDWtlzm75uEZ7QEsdMzCJ7nSQbBcZyhOQsAMDU1JfMy6IfBrg92sdTrdelu2Y2fl42Aeg3eV8PmwgiC4awwShCYYuXKdjeXGbRIkRkEOilyFdRut2VlyeDLAKMzM7VaDXEcI5/PSz2bxjzne3W+WpmBBIHlhVH/g51OEFKpFHzfl44G/i75O89ms0Pulrw/LMmwJKENkwwrwc8O75lhc2EEwXDGWK1eyvQqxWwMjrvtgTfa3shMgR7UBCz5IjiOI10NDDJa8Edho+M4mJ6eBgBx7wPOP0FYS6jI1TCwPKCJIsXdQhCCIJAA5nkeoihCt9uVEoTrukICmGVgpogdLrvx87JRsEQz+n/D5sAIguGMsVr2gIFAj/0dFWXtBox2MIwShG63K1P9eN96vR5yuZwEGJIvlml83xdxIp0WgfPfHbCeFwJJw6hGYadrEAAIQQAgxkkkeYlEQtpSWV4geQaWgl2tVpOf2ep4JUZLL7tV23Q+sfM/tYZNw2j3wuhgJg6r2Y06hFGBYrvdlk4E/oxWu9onga1yDLAsSSSTSZmYyBHPxFaVGFbLIOjuBe2iuNMzCMDS6OtisTg0nhuAlI/0xEf+XvUAL+pM2u22Bb9VwNZgPmeszLD5MIJgOCPo8gIDwOgcAJ1R2G1pU00QmDXo9XpikqSNpHQrI0119GudTgeO46BQKMiEzEKhIMfaCoIwarnMsgNJAgV4O90DQcNxHCkRMUMALAU2GimR5PHzoAlks9kUjwwLfMPQzw/P8+TvzYjU5sIIguGMwPqfNvcZBUmDNojZLdCBk+SAGQRmVPQsBtd1EYahBFiKsRKJhAQYtj9SMQ+cf3JAjJYZRknDqCfGbiAI/B1ywiaAob99tqWGYShuiiSDdMxstVqWQVgFfN5w0aHnfxg2D0YQDKeN1cbSjpYXCOoQGBR3A/QUy2QyKe2NTCNT1R9FkSj/ORZYB1w+/BzHEUe+ZDIpYjdutxUYFSoy2I12MuwmgkASF4ah6E2YTWFQC8MQrusKAeTUS34+2MlgOoRlsNsDWH7OkCDsttLl+YYRBMNpgx/KwWAgaWQGjFGQINCnfzd8mNfqYGg0GlJeYK2ZhlKdTge+76+YZ6BT9YlEAmEYIp/Pr1ihn2+s1+rouq50Yuz0OQwaqVQK2Wx2qIzAcgE9LCYmJuSecEqn9kKgDoEEwrBczqQ4FxieDmpZhM3D2BGET37yk7j00kvh+z4OHTqExx57bN3tH330URw6dAi+7+OlL30p7rvvvhXbPPjggzh48CA8z8PBgwfxxS9+8bSP+4UvfAHXX389pqamkEgk8O1vf/usrnM7Y7S9aK3sAbDssseguBs+zKP6A9ZP6/U6+v2+dHZwSBM7AJgp6Ha70sbI93N4UzabRRiGQ8fYCqwlVNTgFMrdQA4AiBCRY585nhtYEqSm02n5ObA8xpueF7VaTUpQu7HzZy2MZg8IKzNsPsaKIDzwwAO49dZb8f73vx9PPfUUrr32Wtx44404duzYqts/++yzeNOb3oRrr70WTz31FO68807ccsstePDBB2Wbo0eP4vDhwzhy5AiefvppHDlyBDfddBO+8Y1vnNZxoyjCP/7H/xgf+chHNu8GbAMwHapXN6vpDzR2W7vjKEGgELFaraLf78PzPLHVjeMYrutK5wKDqc4iAEsKec/zZHzwVhMEZox0O6MWjuksym4iCLlcTkoJVNmzvNTv91EoFMSSud1uYzAYIJvNyqyOSqUiBMECH4ZEvKMEQdt7W7ZlczBWBOH3fu/38Gu/9mt417vehcsvvxz33HMPDhw4gHvvvXfV7e+77z5cdNFFuOeee3D55ZfjXe96F975znfiox/9qGxzzz334I1vfCPuuOMOvPzlL8cdd9yBN7zhDbjnnntO67hHjhzBv/t3/w4///M/v2nXvx3ADytXwjqIrQVdZmCr0lZisx8mWqCoywu8dm3Bm0ql5P4AS+UIz/PknjKbQA0Cg8toGWMrMFpm0ARhtMNltyCfz8tgJsdx4HmeEMNutyslItd1JaNE4tfpdDA/P49erycOjLsdOnsw+nekywx2rzYHY0MQOp0OnnzySVx33XVDr1933XV4/PHHV33P0aNHV2x//fXX44knnpA/rLW24T7P5Li7GafyPlgNiURCXP+YMt8qMNUfRdGmPVR08KYinY56HAUcRZF4GnS73aHWt3Q6jUKhIPVrz/OQyWSkvr1eWv98YlSoOEoQmD3YDSZJRBiGyGaz6Pf7Q1oEDmNyXRf79+9HGIZot9uIokgyD9xmfn4erVZrLMj0VmI1ceIorMywuRibT+7c3Bz6/b5YyRLT09M4efLkqu85efLkqtv3ej3Mzc2tuw33eSbH3Sja7Taq1erQ13bH6Bz7U5UXCK1D2Eq2zwfOYDAQ0eC5hO5g0EN5Go2GZF0ajYZYLJNE6GFNzCDwXFleYAvdVpcXiNVaHQGsKC/spgxCJpPB1NSUWGTz8xFFkXgclEollEolJJNJ+VtwXVd+5/Pz84iiCK1Wa4uvZmvBv/9TiaABIwibhbEhCMTow0TXZTe6/ejrG9nn6R53I7jrrrtQKBTk68CBA2e1v60Ga6pMe2sjpFOBfgisx24FqJ8Alle7XM2fK9IyOqCJHgi85lQqhWq1isFgIKRJGyaFYYhCoSDTHx3HEYMd3/elVAOMD0Hg+YySRW27vVuQTCaxd+9eBEGAVquFTCYD3/dlnka320Uul5PX+XmgWJFjvZvNJur1+q6urZMgUNS5GiiCtQFXm4OxIQhTU1NIpVIrVu0zMzMrVvfEvn37Vt0+nU5jcnJy3W24zzM57kZxxx13oFKpyNdzzz13VvvbavADyAzCRsoLRCKRkA/6uV61bxRsz0wmkwjDEEEQSCA/V9kEvZpmpwKd8phNYFpZP9yICy64QKYADgYDpNNp+L4/ZNO71S2OhC4xaM8DYjcShEQigampKeTzeSkRZbPZoTZGACgWi8hms0NaA93pw46G3Rr0dKZyIyJowLIIm4GxIQiu6+LQoUN45JFHhl5/5JFHcM0116z6nquvvnrF9g8//DCuvPJKCV5rbcN9nslxNwrP85DP54e+tjPo/reWtfKp4Ps+EonElnUzaDc2/pvJZORv5VxkE3gMehvQWploNpvS3qjb4FKpFHK5HIrFIuI4FkMlCtiCIJD5C+OSQdDlAz7M9Tnx/1t9nucTNLKamJiQGjoFptQcsKRJPws9k4OCVjoqViqVXZlFYMZtI1lKIwibh9N7wm8ybr/9dhw5cgRXXnklrr76anzqU5/CsWPHcPPNNwNYWpG/8MIL+OxnPwsAuPnmm/Hxj38ct99+O9797nfj6NGjuP/++/G5z31O9vne974Xr3vd63D33XfjzW9+M/70T/8UX/3qV/G1r31tw8cFgIWFBRw7dgzHjx8HAHzve98DsJSh2Ldv36bfm3EAVzeO45w2OQCGXRXZxne+oMsLOvNBB8N0Oi2r/UajAd/3TytDAiy39zFwNhoNIQGc3litVmW2Akf8ep6HIAgwOTkJz/Nw4sQJ9Ho9pNNpBEGAfD4vgjdgfAgCsLzqHQwG0tEyen67LYOQTCYxPT2NF154AY1GA4VCAb7vo1qtig4hl8uJDkHrFZhlSKfTUmpot9uSPdoN0J/V9coLhM5k0bzNcG4wVgTh8OHDmJ+fx4c//GGcOHECV1xxBR566CFcfPHFAIATJ04MeRNceumleOihh3DbbbfhE5/4BPbv34+PfexjeOtb3yrbXHPNNfj85z+PD3zgA/jgBz+Iyy67DA888ACuuuqqDR8XAL785S/jX/2rfyXfv/3tbwcAfOhDH8Lv/M7vbNYtGRswjcyxw2dCEFhmYLqVnQ3nA3zg6NYoDWYTGMz1GOaNQiuuqUjnKpIDm6IoQq/XQzablZJDsVhEPp/H5OQk2u22pKEzmYyclw4Q40QQtFCRxFE73wG7jyAAQKFQQD6fx+zsLAaDAYIgQKVSkbHOpVIJmUwGYRii1WrBdV14nodyuSx/K/xbZJfLmXzmtiN0Fm4jf+PMZnLhsRFSYdgYEvFuzF9tEarVKgqFAiqVyrYrN3Q6HUmPs5XrTB78rVYLCwsLSKfT2Lt37yac6epgF4Hnead8gHBbPrQ3gsFggCiKACwF9oWFBbz44osYDAb4+7//e/zd3/0dZmdn8d3vfhfz8/OYmJgQkdrLX/5yXH755bjsssvw/PPPo1wuy8qzVCrhiiuuwIUXXgjP84aOk8vlzu6mnANQZ8E5BDx3jq52HEcGS+0W1Ot1dLtd/O3f/i2+853vIJfLIZlMYnZ2Ful0GsViEcViEc8++yyeeOIJvPDCC5iYmEAikcBzzz2HCy64AD/90z+Nl7zkJXjlK1+JAwcOiM32OJDCzQbFmaeTxRv9O9wO2A7xYOf/tRnOCag/4ErmTFeFnufJBMPzVTPUo2I38sAhgTgdP3y96un3+2i32/JedjG0223U63V5D+cvUJ/ClDIA8TtgeYFEZZyyB8DaXghM9e6m7AHBTAqzBK1WSz437Gphx0omk5G/F2a3ut2u+GYwmxTH8a5oe6SQ+HRF0Hp4kw25OncYj6eMYexBgkD3xDOF7mY4Xw883dq4kYClnQ032pKpW7JarZaQKaaIu90u6vW62OtSq5DP5zExMSHah16vJyUcBhmKE/VxxiXdTKKih3fpn40LkTmfYGDL5/PI5XLy9+f7PrrdrogRwzAcIn4s07TbbREpVqtVCZgkEjsZZ/r3TdEvYGLFc4nd9+k1nDbIyilEO9vgxHr6+SIIp3JjWw18cG8ki6CdA2mExBkLrVZLWtlqtZqULuI4FsdEDvdhLZrfO44jsxeAtYWWWw3th8Dz4sN6N2YQaOwTBAFKpZJ07vi+Ly2sTIXTHZOdC47jiLFWIpFArVZDuVwe+nvcya2P/Ps+UxG03ofh7GEEwXBK0MSHoqGzXRXqh91mpwNJbIDTe+joTMmpVm2agPABTjLFuQtMG7P0wPkKFCLqFD1Xi7lcDp7nDdlUc5txWpnzPnEFnM1mkclkAOxOggBA5jAUCgVpcWTbarvdRrPZhOd52LNnDwqFghgpARiyZW42m1hcXJR9AkutsjtROqbLC2dDELgfw9ljfJ4yhrGFLi+ci9Q2V8fA5psm6ZTl6QarjcyPGAwGQ6seCgi5Emw2m+h0OqjVaqjVagCWBzS5riuDe5hiZvklnU4jn88jk8nIeZ9JJuR8QGcQWDbhvdutBIGfk3w+j2w2K5moIAjEH6Pf70sHi3bIZDah1+shkUgISaAF907VI5xN9gAYLmlZFuHcwAiC4ZSgoFDX5s8WDCDniyDooLrR8bA6i7CWFkETEG2K5HkeWq2WfFWrVUktMxgEQYAwDGVwD50TuT8OaALOPBNyPjAqVATGx+1xq0CRXRiGKBaLEtj5d99sNtFoNBCGIXK5HFzXFQ8F2i2TFHS7XczNzYk+BRgeqb1TcC70NVZmOLfYnZ9ew4ahVcHnKoMALBOEVqu1aenA1VKWTO9u1DHxVFkEnfaPoki0B8lkUkoKzWYT5XJZSBawFDhzuRxyuRwGg4GkjVm/9jxPSgz6OGfTQbJZ0BkE/i5Xm4my28AyA0dAkzxmMhlpy2NJJggC+Xv0PA+dTgcnT56UjBJJgv4M7iTB4tmWFwhdZjCcPYwgGNaFdj08l86HDKIc/rQZGF2R6KFJtDM+1UpDP5BHswjdbndIYd7pdKR0QKEZPfXZvggsd3Ls3bsX6XRa/CU8z5P7zOwBg++4lheAlZbLgBEEYDkDVSgUkMlkpIwUhqFkm9rtthAIGpGxHZKeEpwXUq/X0Wg0hDTupCzC6BC1M4Web2JZhLOHEQTDuhj1P9gINvLQomAL2LyVkFb8czoiv+e1UCOwHvQqTl+bJiDsXAiCQMb41ut1VCoVaW/kwz+dTiObzYqBDskDa8yJREKCCq/jXKyuNhOjg5uMICxhtMzA3yH9MqIoEkdFtorSiZPlKX7+er3eikzUVk1GPdc4l905VmY4dzCCYFgTZOHsYNgIu6danwYv60G3O57rMoMOqgzC7B7g8CM9XXI90ddqWQRtvsTsAVPKcRxjcXERi4uLaLVa6Pf7MouBAk0OX+r1eqjX63Bdd0i8yJHAwHhnDwhtuax/l0YQllpVwzAU50waYFGsSC0K7yFbXpvNpszuyGQyYtVNLQuwnMXaztD6mnORpeTnxAjC2cMIgmFNsL2Rge1UgjOONeZ7T7W6cRwHyWRSshTnEjqoUgCYSCSGTIdGWwjXax8bzSJw/xy4RGtYbjM/Py8Pd318ahQKhQIcxxEjnCAIpPOB2oRUKjW23gejGM0gALtXoKiRTCbhui6KxSJ835dyHW2z+cXftx56Va/XUS6XRcDI0kO9Xken0xHytd2zCOdaX6PLDKZFODvYJ9iwJk63vZGBkoGBafW1wP2eax3CaP2R+w6CYMUDyHVdIQ1sS1yNJIyKw7hPEiEaHLF2XC6X5fo5lIkPwEQiMSRUoyaBWYlSqYRSqTR07uPmfTCK1TIIuz17QOgyg57ISULYarUko8RMk+M4aDQaOHnypHwGwzBEOp1GuVwWvw0OA9vOWYSzbW9cDVZmODcY3yeOYcuhBYqn+vDygcVV+kZMXThqGTi3ZQY+FOI4ltUVBYCrIZ1OIwxDERty2NAodIsaU8XaRpdE58UXX0S9XhdnRd4DtjGGYYh8Po9Wq4VutysCtjiOkcvlMDExsa3KC8BwtoCk0AjCEji2m2UGksVsNisEs1gsDmVhaK60uLgof28TExOSzSuXy+LQqP/Otxs2q33XCMK5gREEw6rQKxPHcdatDerSAoV2GzV12YwyA8+bgYp1fZ5ro9FYIYzkCo2dFbrrgODDmQp0nT1IpVJCDhYWFtButxGGodSN9X2kOJG+/DwmAHHWo3J9XL0PVsOoF74RhCWQNNNVkaTbcRyx3GbnSiKRQLvdFhFjrVbD/Pw8Wq0WkskkJiYm5GfNZhPJZFIyWueKYJ/tfnSG7VTQ2YNz+feiydZO6fTYChhBMKyKUf3BemAw1Q6Jut6v2wtHQVX/uZruyDQ9R78mk0nJUvBcGdhHsxvJZFIyCYPBYNVzTqfT8nDWA5r6/T7q9TpmZmZQqVSQyWTg+760srG0QJLATAVLC6lUCqVSCVNTU0NaBh5zOwRb7YegvzdAbLVzuZyIFfv9vjgrMouQTCbR6/WE0FarVczMzIiOxfM8ZDKZIeLNz9fpBGUKc2nYFEUR6vW6tOVuRGS8GtrtNjqdjgybOhU2a/iY7vixLMKZwz7BhlWh3RPX+/BqAZ4OxAAkk6C3G4VeSZ3OeOX1zpv7IUlhcNXnym1Hywm6/XK182GrIlvU2LVQr9fxd3/3dyiXy9L7ztf5gBoMBnBdV0b8AsurtTAMsXfvXuRyubG3Vl4Lo1mm7UBqzhc4vEmPePY8TwZ3AUu2zCxz8XPR6XTwwgsvSMYqjmMZ8EVi4TgOWq3WhoK6tv+mNoblMv23Tu3M6WCUVFOgu972m5khM4Jw9jCCYFgVur1xrQ+v7lTwfV9qorVaTVY3nEwIrK1H0GWGs1UdN5tNtNttaS/T3uz6XHWmoNFoDB2Xq/w4jocecCy78FzpyFir1fAP//APqFarSKVS2LNnDzKZjKzE9MOXrZBaJ5HJZDAxMYHJycmhFq1x9z4YxWjGwAjCMLLZLLLZrAT/0aCcy+XEUZGBnw6Kc3Nzsi1neCQSCTQaDZlBwL/99cCfs+zmeZ4IJGnOpUn96RB2fubT6fQQyV7rnM60vDB639aCDW86exhB2IbY7D92LXpyHGfVD28cx1JaoPEQU/sAZHUCLJMHrVXQ0GWG9VYt1BWsNQWSGQEAQ0JJnY4lYWHNlzoJTlwk9AOOq616vY4oilCpVKTNrNFoYGFhAdVqFclkEpdeein27t2LRqMhD2xmY5LJJIIgkD53KtkLhQL27NkjJku8f7y32wVGENYHbZULhQLCMBwi4BzMxAwSpz0OBgPUajUpMwBLAS+fz8P3fdHDMAtXqVTWfD6MZvuYweDnj0ZO1NSczlAoLVL2fV/IB3+22uf+TLoX6LNCXc96oEhYH8twejCCsM3AD8hmqpZ198JaAYqrC5YRtLCPgYGdCVqP0O12V5AAPiSZQdB+/qyXNhoNVKtVaSGs1WorHhB8jasiQrdf8qHF82TrGLdrtVpCCthzvrCwgFarJZbJg8FAHoL9fl8U5dPT0+JvQAdF3fHAhzIFjYlEAsViEYVCQdLG+rqB7UUQKLgkTIMwjGQyiUwmI9Mbfd8fIghxHKNYLIpQkfcviiKcPHlS3DpZ+iuVSnAcB7VaTQJ8r9dDtVpdcWyd/idhXw/azvlUwXVUpMx9u64rZcdRkqCNxjZKEPQCRC9Q1oOVGc4O9gnehmDqe7PUuQzUa5UX9EqfDwA+vEZX5vxA0xwGWKlH4HFYohgVTdVqNVSrVSFGrP/r1Q2DO1dhRKfTkYeDJg0EyQtX9QsLCyiXy+h2u5I94f2m6DEIApRKJaTTadRqNSwuLsL3fUxOTsqDiw9qjvWlkVIQBDIDwvM8lEolTExMSLAAto/3wWrQ52sZhJWgSJEtjwBkQNdgMECxWBRdAsWt3W4XCwsLkuViij2TyUg7bKVSEb0NZ3toMDhv1NMklUoNOY2uB11aGCW0LPUBwyRBz17YyN+JXoDo0sGpFkqaIFiZ4fSxvZ4+hqGWw82aYcDswGrjnUfT9Zw7wBU60556BaLV/kxdjrJ/PrgajQYqlYrU9nkuFPcVi8WhhyK9B5gl0BbK/X5f7pHWI2hwRgMzJrzGOI4RhiEmJyeRzWbloew4DhzHQb1eBwAsLCzAdV1ks1m4riuOjMCyOyPLC7Sr1i1rk5OTyOfzQ5mN7VheIHiPjRysDk7p5Bhv/t45wTGZTMqQrna7Ddd10W63UalUMD8/P1RmAIBSqSSjxbk9gymDp84CjAqJ1wMdHNcqDQLDpQX9N6yxGkk4nfICS4BcgARBIPs71UKJ+gzAsghnAiMI2xB6Jvy5noSoXQ0ZaDVGSwtMubP2yLo7R9nq9wDLboajDx2uJGq1GqIoEiMZDjXK5/PI5/MIggC5XE5EXpx3QFLCe6OJzGorGy0y1E6LU1NTQ774fEi2221EUQRg2W6Z43gp8tKlCeoW2BNOUVgikUCn0xFyQGFaOp1ekRnaLuJEDZIsIwhrY2JiAkEQIJ/Pi3EWSSl1CuxmYEkhiiI8//zzMsGRBMFxHBSLRSk1AMtkg4GYnzMS+o1CdyatpvvRZQvte8IMhl6xa5LAkiFfXw+aHDB7x/dp8fN6sDLDmcMIwjbFmSqNT4X19AeaPPi+L4OImKan8A5YFhSOlhpGHzo61aiJhed5QhB83x9SOrN2D0Cc5oClB6AmJau1X/KBo0c9p9NpZDIZyT6MplYZ1NnjTQ+FZrMJ3/exZ88eAJAuBm6rH5TMMnQ6Hbm26elpZLNZaVOjxz6vZTsGWa2ON6wOx3EkM6XbiJl9KxQKQhiZGq/X65idnZW0uhYBk2TqNDw7barVqgggWbogMaaQltkHvV8+U/T5jZYt+LetnxXMxrFUONodxGvk3/mp/sb5TNEtyyzbnUr8TOiShOH0YARhm4EiRTLq0Va8c7F/WgKPrmD1ilxnL5ji5AdZOxLyQaO3186GfB896R3HkZXOeqsdriAGgwHK5bLoBVKp1NCxRucvUDTIfZAY6GONplbZscAgHscx5ubmxO8gm82KZoLljk6ng0ajMTRimg/efD6P6elphGEIAEMmN0yhbucA63netsx+nE/w72ZychL9fl+yCIlEAvl8Xv6e+XcRRZGIZRkgtdaA2gWWFljuIlHl543EmFkIflZIammepLsE+LeovRF4DpqAM1vGc2BXkdYJ6K6oU63oSTYArNBXkHzoxcZaBEAPb7IswunBCMI2g57gxocwP6wbxVoZB002tBoZWPZFAJZWJzq1yPQjyQGDHD+UPJ5On1PNH8exBFcAyGQyEkzXqy12Op2hzEKlUpGyg9ZIaA2FznjQ6XA1EqIfeuxE6Ha7Qj4WFhbE9CibzaJer6PVasHzPPE9aLfbqNfrkiZmOxkJgu/7klKm10EYhkNdFYadi2QyiampKSmZBUEgfyecxcBul8FggGq1ikajgXK5vEKvwpIcuyOYGeD8Dy3+HQwGkqpnLZ/tjiTd/NxyH6sZno2WLegz0mw2paRHksxsBZ8FPIZ+joxCk2YSeOp5CGp5dPZirWfbRssMzJJatmEJRhC2GXQ9nbVtYGX6bzWQANDAZ/TDxNWEVjATWgXNDzXnEvCho2v3ul6o66n6PJkiZKeC7/vI5/Oyj7WuieLDRCKBffv2yXUxC8G05+iDVJdHTlWLpUAziiIsLi5KV0ccx5ifnwew5H7I9st8Pi+EptfriVkUuyF4H2iVSz0FlegMCIbdg0wmI/bavV5PxLCDwUD+nhisW60WarWazPnQI9gZzFmaGwwGiKIIzWZTPge1Wk1MlRhw+UWBMJ8t/HvVbYUkAtprgc8JknLam5Ns+L4v5TO2KDcajaEs42pupcx8AMufVWYM9CKE5UKe23qlhtUIAjOX1ETQ54RfRhKMIGxLsCVOrxDWmh1AjKb72CqoPzBM042K+kgCgGWffbZl6RXJaNBlrzewTBJ0a5J2gONUQ65iqGEYZfy6zsqHGVXfc3NzUg7QugP9oOPKhtmE9ZBOp6WjAliq9dKwpt/vw3VdITZsY6xUKvLgq9VqUmbh/IVisYjJyUmUSiXs3bt31ftm2B1IJBKYmpqS7hxOeuTMBmbw+LmpVCo4fvz4EBHVAV0PBCMhYPBlSYHmXgyC1OMw68DyAD/bWuRI/QDLdPy7Z9qfsyKYESP55RCqZrOJkydPSkvmam6lo6SE56sXIcxQanLExYDWZmjozAgzlpoM8IvZQH6/2wc92ZNpm0ILdIjVWn64+mC3AVsRdbshP9z8YOrygv4A63IBzX9GMwej0JoCPqR4ngz2TGFyoBFXNbwmgrbIoy2VuVxuqB2MimqesxZusVTClCt7y1dLTS4uLgpR6ff7OH78uJAbWilTB8EHIO8bh+CwdY3TIqempnDgwAEUCoXTajkz7Ez4vo+pqSns3bsXiURCsgiO40gGjqn0arWKEydOyN8UsPT5YHmKnwmmyRn0u90uwjBEEASoVCqSSdOfN92Gy+/5eWe6X08d5WeQAsdutytlEj5LWG7I5XLiG0LtRLlcXlEiHe084uKBBFs/Z7RokYsjrWta7fPMFmOSfpIBZgd930c2mxUbdj4fdrN/ghU7tyH4YWBbIT/IbMfTroW6y4GpP5YRuELgB5OpS52aZwqQZEBP6tPTD4k4jodMhgBI2hOAmBmRlHQ6HWQyGXEl5GqdqUsem+l+rvo5DIkPllwuJ8RDp/X1/dHZD45bZvDnqkd7O/BhSo3D7OwsgiBAsVhEKpVCuVyWWi4f1MxQVCoVuVb+riYmJmScs2UODMTk5CQqlYr8W6vVEIYhcrkcZmdn0e124bqurHpnZ2exZ88e+Sw3m00ZBEWhbzKZRL1elxp9qVRCtVoVwp/L5dbUujB1D0A6mvTfMkXMWpRLkSWzZyyBNBoNmc2gbaR7vR4qlYqQ5FarNUS2+YwAhlskNZi5ZEaDJIdZiFFjNGYPer0eJicnh7QQmhzxNbZc8zm3G2EEYZuBbn908+NUN2C5psY0G1NtXFmQFY8yYqYa6/W61D75QSVB4Fe/35fgT6W0TkVy+3Q6jYmJiaEWrkajId4J7O1mYOYDjUInlho6nQ4WFxflQ0t/BGoKKMDiABs6GHqeJwRAT3DUAkpuw2vg/zudDubn51Gr1STl+3d/93dIp9MoFouYmprCD37wAxGVcUVGtbhWcgNLq6EgCDA5OYl9+/aJo6LBACwFwD179mBhYUFS8IPBQBxBqb5nRur48eO45JJLxEeBExpJ1rPZrATfarWKXC6HarUKx3GkNMYAupruhatzBnd+zkgECoUCms2mCIs1OahWq0LotZaJXQ2+76NQKIhbqc5itFotacXUHVKr+bEQXPkzU8Jr5HNQDz/j/aMV+3q+EJyVwUzDqKZpt8AIwjYD2TGDeKlUklUwv6IokocFP2D9fn8oPU+2TsZcLpflg8WHC/unmfKMokhEilytaEKiz5GtgBMTE1JLDMNQ2gRfeOEF9Ho9ITk6YLNdkelSqrQ5KpcrARIdri4mJydRLpfR6XQwOzsrH3K9StBtjyQ5vD+tVguLi4uo1WpDbYzValXqra7r4u///u/l3nC1xDQoMxV6jDRXT3v27BHlunUqGDT497F3716x+2a3C4m94zhiOV6v1+F5nmQLBoOBdM10u13s379fSO7s7CwajQYuuugilEol0RrRx2O1v0WuzhuNBlKpFCqVipQIaEuua//JZBKLi4viv8DsHz8nXNmzQ6NYLKJarUo3Fj9jJBYAROR4KqTTafFl0aUQiibjOEatVkOn05FMy6naqOloyTJotVoVQ6rdBHtKbTOkUinkcjlREg8GAxQKBWkzYoqx3++jUChI3Z11+FGzI7ZSUVXPlS0fNixRxHEsD6QgCIQUMPiOpswXFxcxGAwwNzcng4hY/2fGIpFIDI1l5geb+2Rqnj/nrANqBjgCl1kFtnrNzs6KQQxXClzFrwaWOpjRaLfbom+gSQ23+/73v49kMolSqSSlhSiKpFWtUCjg6aeflvQrCQizByQ5BoMGzZOmp6cxOzsrWhqu8knGq9WqZLYWFhZQKBQkSFN8yL/FAwcO4Pjx43juueeQSCRQr9dFi8D9kSSsFvhI0svlspQkHceRzzY/r91uF5VKRRYPNP/ieXJ4WSqVwuTkpGgTstmslPK4MGEL8nokWpch9P3j51h3f7D7QeshgKWMwlqZCV4bn7XsjqhUKiiVSruq28gIwjaD53lot9uYmJiQDyrr3zq1x04AGqAwsDKdTqUu589zyFEul5O2QwobdW2QKwFmJvgaMxpEqVTC3NycjElmax9XFplMRh6ALFFoFfTi4iLK5bJoDVzXHVrJk+RQQKXtiUmKWMtdixxoIyQt4iyVSlhYWEAikcB3vvOdoYdhp9PB5OQkpqam5Dzot8AVF4VQui1rz549MtJ5t61CDBtDLpfD9PQ05ufnMT8/jxMnToitOB08+XfVbDaRzWZRLpflb5zCP3bUDAZLE0SLxaIQWZb3mJnQc0xWC5gk6+wM4nOB7om9Xg8zMzPIZrPo9XooFosiEnYcB+12W+zQmQFhqy8/N9QqkMSspY+gfoJZxtHsB7VO1FUx+0jPlGw2iyAIUK/XZUHFDKn+4nVz//l8HouLi+h0OqhWq7Lw2g0wgrDNwME/3W4X2WxWVtFc/fODSnMVBnct1qPQiCuSubk59Pt97N27Vx4S/LCwrYi1Tt27zAeTbq/Uc+SDIBBvAj5oHMeRVTRroXzYMU3PY7BVcO/evUJ0+HM+KLgaZ/mEqxwSl3a7LbbMBFstmdHgA4+1zEajgXa7jdnZWfEzKBaLCIIAExMTyOVyQ452JCTVahX9fh+zs7NSBnJdFxMTE3jJS16CQqFg2QPDmkin05icnMT+/ftFj8BgxDJDrVYTASwzZFEUoVwuyxRVvgYszxdhCZE6oyiKhkTLXEToOjs/x8zA6dZoipmZXet0OpienpYMIwm1FjXyM9tut1Gr1TA1NSXlSGYlKX7Ubpwk4nzuMHOpvR+YTSBJZ0m1Xq8jkUhgYmICYRgKyafD5FriQ90+6bqu6CbYdZXP57elFfrpwgjCNgPr78wCsG7PD2Gn05GUnu79JWlgvZ3agUqlgpmZGQBLrDmKIumt1g8I3/eRy+WEvff7fczPz0vWgqJCfuCpGaDTIkc360FF9IrnKp6GMVEUiRBxMBhI6pE/SyaTWFhYQC6XQyaTkRQs2wwTiQT27NkjD8lmsynaBT6kgOUuD17P4uIiqtUqZmZm0Gg08MILL8h9Zckjm82iWq0KqSkWi2JNS9KgXeBc18X+/fuxb98+ZLPZXSl0MmwcuVwOU1NT2L9/P5577jnUajXRGTCw1ut1WYkzo8gFwWWXXTY0nTSXy8nKmm6MJPEAhHxQN8PPLbOC1CyFYYjnn39+KGNJUS7LAiQH1EKxq4dZM9d1heS0Wi388Ic/lI4gLm6oj6hUKtL1oDOgFEnz+UXhtB6XHgQBFhYWhMzQfI3EgOfO95JgaF0CS6j0PKGJW7lcxvz8PLrdLqamprbs7+R8wQjCNoNuS2T/LllwFEXwfV/SatQdkNGnUiksLCzIip+BlTVITiQsl8tSO2T7UbPZFJEOgyDPhSlCEgU+EPjB54rj2WefldQdgzIfAIlEAvPz85L6o2qYq3nWGKl2BpayBswO8KESxzH27NkjQ55oGAMsD5CiVoMPI2YlyuUyFhYW0Ov1MDc3J4rqPXv2yIOEhIbCRHollMtlJBKJIfEVAGSzWbzkJS/B5OSkGMYYDGshlUphz549KJfLuOyyy3Ds2DHRIbBzgKLdZrOJSqUiKfT9+/djcXFRNEie50lWIJvNYnZ2VtLq+Xx+aH6KbpVuNBoIw1C8DeifQI0BtyEBoOaAAVwPHCPJYOcO2zefe+45DAYD/OhHP8L+/fuHpprS2VB7iLD7goJkvsYsAhc/nufJMySOYxnDzpIqs68UGFNwrTu1AAy5PXJhwudavV4XEel6HRY7AUYQthkYzJhOJJPmKpyCHwZWrsT1B4ue7dQo0PXs/2/v3sOjqO/9gb9zYTchZDcEcoUlBBDERBSSigkiVTE2tbbYi3mkInqgNQ/eYg5YKKflUjRqLaLVpNCDUhSQo5TWc4yXnOdIBBGrMZyDYEVuJoRNQhLIJgE2ZDO/P/h9x9lssjMhk51J9v16nn2UndnZ7052Zj/z+X6/nwEuTaMUU5DCw8PlwXjiSkU5y0BZS0FkKJRXGFFRUXIWw+12IyoqSp6zfOTIEXkAot1uR11dnXxVLmrEKwu1iOmRyjrpdrtdns0gghblTAgR8Ig7Poqb2YjARjnzQFyViZMBcOkkIQrYREdHy0WVxGvE4C0x+ErsJ+X4DdG9IPYjkZrIyEgkJSWhubkZSUlJqKqqwjfffCPPVKitrZVnIjU1NclXvmL2UVtbm5waF/VNRHdETU2NPJNIpPVFpk5c+YeGhqKmpgZ2u13uphP3fBBBghhcPGzYMHkdkSFU1hVRdmmKNotut5aWFkRFRcHlcnmVfxbBgfjxt1gsiI6OlgcgiuymCArEOVAMqhbZAXFB43K55K4GcUt4Zfl3cQGiDBBEplYEQeHh4WhsbJTPvaI422DHAGGAEQOLRNSuvA2xSKuJA1ik4keMGOFVLQ2AfIApuwREN4C40rbb7YiJiUFcXJycblPObRYjmMUURzEQSkT+YiS2iLqBS3edczqd8kwBUeCoqalJ7voQwYgILkRRopCQEDQ1NQG4lIoVtQbEjAExhbGtrQ0nT56Up2I2NTXJXS5iHZEWDQ0NRVtbG5qbm+XttbS0yClHUYRGDGwS3TUiwyKu3CIjI1FXV4d//vOfqK2tla94Ro0aheTkZLkcNJGakJAQ+R4NV199Nb7++muv+6/U1dWhuroaycnJ8rEo0u1iLIJI54urZhHIix/g06dPy110yqBaDHYEIBdtEuOYxA3WRFeZyCSIQmLiuI+NjZUHHIofWXFuEEHLxYsXMWLECPkeEzU1NXLWTtREUWY+PR6P18wGcXyKoEFMZRTZQpFBFN2ByoGVYnqzuPgQ3aTAt1lG0W0jpnuLrlYx/TFYxhIxQBhgxFX06dOn5QJIIo0vpvWIiFrMDxap+5iYGHmZ+PETXQziBCNmFogfUo/HA6fTKf/QK2cLiH5GMWBIZAeU7yFOABaLBTExMTh37hyioqLkKZC1tbXyYCmRmqypqZFnN4gZASKgESnO1tZWDBs2TL5CEl0aIg2rLJJ0/vx5ObiJiYlBbGys/JlFl4u46j99+jSAS8FOcnKyHFiJMQjKeg/iKu3EiRNwuVxobm6Wb0ojbr4zYcIExMXFBc0JhfQxZMgQjB49Gi6XC+PGjcOBAwfQ2NgoZwlFzYGYmBjY7Xb5nCCyeqILQFm6WAw2FjU/RCZM/PCLMUFiZoPIHIggQZSEFuOHxNgbkbEQt08XAYTISABAS0sLGhsbvWZRJCUlIT4+HlFRUaiurpbPacOGDcPIkSPlwYDK+7mIIEY51VF5QyhRLVL8yIuuQOUFhbKKqpjO3bVsung/Md5L1FmIjo5GW1sb3G63fOE1mDFAGGAiIiLkqwaPxyP/sIkiIImJiaitrZUHyrW2tso/bOLKJDY2FgBQVVUlXw2fOXNG7ooYOnSoHIGLEfkulwvApQpjIjsBwCsoUBZhEpkOUaRF/HgrZx2IucURERGIi4vD0KFDcfr0abnPUlytK6dbAt+m/5qamuR+SXGSEOlFMatB9JGK6ZJipoKyu0LUZm9oaJBPrrGxsTh79ixiY2Pl7IcYUyFOsrW1tairq5NLQIv+VVHBLTo6GpMmTUJsbGxQzZ0mfURHRyM+Ph7p6enYs2cPjh07JncBigqJDQ0N8o/6kCFDcP78ea8bOonjWIxDEF1iHo9HvruimDGgzCiKwmgNDQ1yUC9ucy4GR4tBgGJ7ISEhaGhoQH19vRz0ixkAom6DOD7FuUlc1cfHx8vdk2L6o8jwiXONOKaVBc9E0COqsAKXftjr6urksRYjRoyQA/vTp097jZsAvs2EivOqGJ8gsi5iXJboshTn0WDAAGGAEV9aMRCppaVFPkEoI3MxRU8cdOIHV9Q6ENGwKCTU0tICAHLEff78efk5AHLRE6fTKQ/+Ef2J4qBVVhIUV+6NjY1yel5ZzVEUbBEpvFOnTsmpO3Ewix9cUaZZjMoOCQmRU5IiYwJA7spwuVywWCzyneTE9Kbm5macPHlSznwAlzIFFy5ckO8ECUDOdNhsNjQ0NHhVpBQBlcgWiC4Z0R0jAqGQkBAkJCQgJSVFLs5C1BshISFITk7GuHHjkJaWhv3798s3YBLfQ/FDL/5fjBEQqf2GhgbExMQgOjpaziJ2LbEcFhbm1T8fEREBp9MJp9MpD7wVgfP58+dRX1+PqKgouZS6csCyGIMgggxxrhHZPNGtIaonHjt2DOHh4bDb7XA4HHI27+zZs3LmQtRQEQMzld2dAOSZHSJLqfxxP3PmDBoaGuQBhyLbKbKvolS9CFrEOCHRzSEuvkTXiJgueu7cOSQlJTGDQOZSV1eHiooKeQCQGGQkBgOJaUQjRoxAbGysvFz8EFZVVSEqKkoOKJSFhMSgHnEvgra2Nnk9cVCIg+nMmTPyqGRld4Q4OZw7dw719fVyhkO8RkwbGjp0KGw2mzwoUfRpWq1WJCYmyoODRKU4UUtB1IEXJwgxOLGhoQHNzc0AIKcDXS4XTpw4Ib+fCEiio6PlLITL5cLJkyflwGXYsGGor6+XByWJedZi6qdIO4ornbi4OABAY2OjXE9CdO9cccUVSExMDIrBTNQ/IiIiMGrUKFx33XV4++230dzcjHPnzqGhoQFJSUlyd4H4kRb98aKrQYxDUg40tNvtcjeAmLkguhpEyeT6+nr5gkNcYYsuBTEOqbm5GXFxcXIXgPiBFdMQxfggMR1aVE8Uffpi+qLoDjh79qxcnEhUWwUuXSicO3cOycnJ8vEvsoWtra1y8Sgxi0GMqRKzlZSZVHHBII5ncQ4TmQERPInppcrBnqLgk9gfYsrlYMYAYYARI5JPnz6NpqYmObUYFRUl//iJ6YHK26G63W7U19cjNDRUToOLLgEA8pWDMgUvirKIUc6iT08QU6nECUNss7OzU04nij5QcdtmkXYUhYjETWRE9kAEF6Ir4vjx4/IgIjGFSQwWEsVKxKBAMQCrvr7e6/OJWRTh4eFISEiA3W6XB3eKTIvyKkHZZQJ8O3NEWSAmLCxMHmshHqIbRwyomjJlSlDMlab+lZiYiLS0NIwbNw7V1dW4cOECqqur5Wyb6E4Q90FQ/rAB344Xampqkn+8xQ80AK8pzqIrUfTJi6yg8n4mImtx5swZnDx5EjExMRg+fDji4+PlCwRlul+8Rtwh0el0ym0Wt4iur6+XxxOIqYkA5OxiS0sLmpqaEBMTI18ciZkTYsyE6DZU1jRQ1nsQs5WUReIiIyNhs9nkdcSsKJGhEbOSxCBpAPKMrGDoNjRdgFBcXIzf//73cDqdSEtLw7p16zBz5swe1y8vL0dhYSEOHjyI5ORkPP7448jPz/daZ8eOHfjNb36Do0ePYvz48XjiiSdw55139up9JUnCqlWrsGHDBpw5cwbTp0/HSy+9hLS0NH13gApRvlTMtRcFhJRTg8QXV1kkqb29Xb6BkIh6RYSuHMCkvMmKmPZz9uxZufiK2Jb4QRRjDsQVurhyEVccYlCR6I4QNRvEICYR3Z8/fx5OpxNfffUVIiIi5MIr4kAXgY448Yn3EZ9ZpB6VxY/EiUQM4jxz5oxcSc7tduPYsWNoamryul2tslKlGGClHGchrsoE8fmV/Zmi0My0adM4tZH6LCwsDOPGjcPMmTOxb98+uN1uOJ1O2O12r8GGYlCymLUgfvhFgCxqpoiSzGJwnvgxF9P5AMj3LRDZPdGNJy4EREZSBOSiKFpMTIx8JQ9APl8AkCupinOM8m6q4gdfdJ+KwEF8LqfTKf+Yi2mKYmCwyNiJrkNxXhHjLkTmTxzD4iIAgNwVorzhmuiOFedWcf4SrxGzMgZ79wJgsgBh+/btKCgoQHFxMWbMmIH169cjNzcXhw4dwpgxY3zWP378OL7//e/jF7/4BV577TV89NFHWLRoEeLi4vCTn/wEAPDxxx8jLy8Pv/vd73DnnXdi586duOuuu7Bnzx5Mnz5d8/s+88wzWLt2LTZt2oSJEydizZo1uPXWW/HVV18FtI/5yy+/xCeffCIf7Mo7NYofcWWNceXIX/EDCEA+UMQPsChOIg5W5e2KxcHT9X4LIj2ojPzFCUp5ZzUxPkE5uFEZxChHTQPfVjET7yf6CsWVkeiLFCcX5Y+0GJAFQM48iNK0IqMguhHE82LWhmif2Gei31RckQCQ+3lFACXmeIuTh9vths1mQ3x8PCZNmsTCSKSL4cOHIycnB3/6059w8eJFeSCgciqw8nsLfHvvAmUxMJHqFz/UysHFogtv5MiRcppfOa1ZeZ8XkUkDIGcnxeDA6OhoOWugnD4psggiwBcXGuK4Fxcgogop8O1FjghebDYbYmJicObMGa9Bi+Hh4XJ7RLbRYrHI06fFD74IQsR4IuV5R7RPEOc6EcyI7g8RiAWDEEnkYExg+vTpmDZtGkpKSuTnJk+ejDlz5qCoqMhn/V/96ld466238OWXX8rP5efn43//93/x8ccfAwDy8vLgcrnwzjvvyOt873vfw/Dhw7Ft2zZN7ytJEpKTk1FQUIBf/epXAC4dFAkJCXj66afxwAMPaPp84kYfzc3Nclqrt/7whz/gP/7jP3yeFz+G4uQAQD4oxAGkLJ8sBhyJH1kAXicWZVpR/ACL/4oThTh4xYFksVi8RvkrTzxiHIMIKpQ3RxHBjHhenFiUYxqU0yuVsxmUgYayjeK9xTbFOmJ7IgMjrmqUB78IasSJTJSTFYGKMu0qiH0sPn9aWhoWL14cFGlICozW1lbk5uaisrISNpsNo0aNkr+DIpsmvu9dix8pjztxPInXiu+9OA7E3RTFa5QZRmWRNOVFhzJTKY4N8b4AvI4VZR++eJ2yreJ4FcuV21DOQBA/7MruBOV9WJQXI+L4FT/uYjaG2G/KrhpxvIvnxblLzNgALmVbPv744z4d33r8HvQ302QQ2tvbUVFRgaVLl3o9n5OTg71793b7mo8//hg5OTlez912223YuHGj3Df/8ccf47HHHvNZZ926dZrf9/jx46itrfV6L6vVilmzZmHv3r09Bghut1v+EgOQ+/f64s0338Q//vEPr+fElYPy34B3BKyF2I44sMSPrvJHGIBXwSWx/a4nA3FQdj14lRkIkX0Qr1e+h3J7IoBRBgqiDcr2KgMB5TbFa8WgTmWqUKQTlcGR8oQopn2KqzVxIhVp0NjYWHnut8igDB06FGlpaQwOSFfDhg1DTk4OTp06JY8DUGbxugYEYpnyB7xrYC4of+iVdQAAeJ0PumbExL/Fsan8b9f1THQtqotgOL5NEyCIEeAJCQlezyckJKC2trbb19TW1na7vqiln5SU1OM6Ypta3lf8t7t1vvnmmx4/U1FREVatWtXj8ssh7rgoDkzxI6kkDnLlwSsOfnESUQ62E6l1MfhPXCkouwfEdpQngK4HvZhRAHzb36i8JbR4KMcViKt88XplACFeK9a9ePGiXD9BtE25HeVVi3JWhfKqSlRIE3OvRREjMbq565WUxWKRuzfE5xHTt+Lj42G32+W7NA4dOlTuHw2GkwcF3vz587Fv3z558K84BsRxqLziBiBf/Yr7DojBucpsnbIrQlncSGy3p26y7n7wRfChPAf5Cyy6CxzEOB/xWZQBvPLOscptdX2PrpkH5Xt0125/AYzywkk5cDkYmCZAEHr6sevN+l2f17JNvdZRWrZsGQoLC+V/u1wuOByOHtfXYsmSJZgyZYr8A9+137zrgSEONvEDeeHCBVy4cAEpKSmIi4uT662L9UX/uiAOCvEe4v+7XqGLKxW3243a2lp5RoT4QRUDIMX7iLaJ58RJRWxTDI5SpvzFyU7UHlAGMsqDV7RTDGQU+0T0OV64cAFTpkxBUlKSVxCiHL0sPm/XLIX4fxFMcYwBBdKYMWOwceNGNDQ0eH3/lcelchyCMghQ9vGL773olxfB99mzZ+VS6OI7rzz2lQF8d8ev2L7VapVH+nc9PpU3iFK2Ffj2Ykb5GmWw397ejlOnTsnjAsQ+UB7nYvvKmUgAvLIrynFL4nMqB3OLdUTmsOtFTbBURjVNgDBy5EiEhYX5ZAvq6+t9rtwFUTWw6/rh4Zfuq+5vHbFNLe+bmJgI4FImISkpSVPbAMi3Y9XTDTfcgBtuuEHXbRLRwJGYmCifk4j6k2nmaVgsFmRkZKCsrMzr+bKyMmRnZ3f7mqysLJ/133//fWRmZsrTznpaR2xTy/umpqYiMTHRa5329naUl5f32DYiIqIBTTKR119/XRoyZIi0ceNG6dChQ1JBQYEUFRUlnThxQpIkSVq6dKk0b948ef1jx45JQ4cOlR577DHp0KFD0saNG6UhQ4ZIb775przORx99JIWFhUlPPfWU9OWXX0pPPfWUFB4eLu3bt0/z+0qSJD311FOS3W6X/vrXv0oHDhyQ7r77bikpKUlyuVyaP19zc7MEQGpubu7LbiIiogFuIPwemCpAkCRJeumll6SUlBTJYrFI06ZNk8rLy+Vl8+fPl2bNmuW1/q5du6SpU6dKFotFGjt2rFRSUuKzzTfeeEOaNGmSNGTIEOnKK6+UduzY0av3lSRJ6uzslFasWCElJiZKVqtVuvHGG6UDBw706rMNhC8EERH1v4Hwe2CqOgiD3UCY90pERP1vIPwemGYMAhEREZkHAwQiIiLywQCBiIiIfDBAICIiIh8MEIiIiLrx4Ycf4o477kBycjJCQkLwt7/9rV/fr6WlBQUFBUhJSUFkZCSys7Px6aef9ut7+sMAgYiIqBttbW245ppr8OKLLwbk/RYuXIiysjK8+uqrOHDgAHJycjB79mzU1NQE5P27YoBARETUjdzcXKxZswY//vGPu13e3t6Oxx9/HKNGjUJUVBSmT5+OXbt2XdZ7nT9/Hjt27MAzzzyDG2+8ERMmTMDKlSuRmpqKkpKSPnyKy2eaezEQERENJPfffz9OnDiB119/HcnJydi5cye+973v4cCBA7jiiit6tS1xM7qIiAiv5yMjI7Fnzx49m60ZMwhERES9dPToUWzbtg1vvPEGZs6cifHjx2Px4sW44YYb8Morr/R6e9HR0cjKysLvfvc7nDp1Ch6PB6+99ho++eQTOJ3OfvgE6hggEBER9dLnn38OSZIwceJEDBs2TH6Ul5fj6NGjAIATJ07It9Xu+rDb7QCAxYsXy9t89dVXIUkSRo0aBavVihdeeAFz585FWFiYIZ+RXQwBJKpau1wug1tCRES9de7cOfn83drairCwMJSXlyM01Ptae9iwYXC5XIiOju5xFkJraytuuukmLFmyRH5u/PjxKC8vR1tbG1wuF5KSkpCXl4fU1NT++1B+8F4MAXTy5Ek4HA6jm0FERCZRXV2N0aNHd7vszJkzSE1NxTPPPINf/vKXAW4ZA4SA6uzsxKlTpxAdHY2QkBDNr3O5XHA4HKiurjbtTT3Mivuub7j/+ob7r2+M3n+tra04duwYAGDmzJl48sknMXPmTAwfPhwOhwO/+MUvsG/fPjzxxBOYMmUKGhsb8eGHHyItLQ05OTl+ty1JElpaWpCcnCxnIN577z1IkoRJkybhyJEjWLJkCaxWK/bs2YMhQ4b0++ftil0MARQaGtpjpKiFzWbjSeYycd/1Dfdf33D/9Y1R++/zzz/HTTfdJP/717/+NQBg/vz52LRpE1577TWsWbMGv/nNb1BTU4MRI0YgKysLP/7xjzW1V4xDEJqbm7Fs2TKcPHkSsbGx+MlPfoInnnjCkOAAYAYhoJhBCDzuu77h/usb7r++Gcz7r7sMgtkwQAggjkEgIiIlf2MQjGbOsGWQio6ONroJRERkImb+XWCAEEC96VYg6que5l8rH0R0ebQcX1qOvZCQEFy4cAEul0v1ceHChV61saamBvfccw9GjBiBoUOH4tprr0VFRYXm13OQIhERkUEuXLiASZMmoba2VnXdxMREHD9+3Kccc3fOnDmDGTNm4KabbsI777yD+Ph4HD16FDExMZrbxgCBiIjIIO3t7aitrUVVVZXfgZgulwtjxoxBe3u7pgDh6aefhsPh8Cr7PHbs2F61jV0MREREBhNTOf09APh0O7jd7m6399ZbbyEzMxM/+9nPEB8fj6lTp+LPf/5zr9rEAIGIiMhgkiSpPgDA4XDAbrfLj6Kiom63d+zYMZSUlOCKK67Ae++9h/z8fDzyyCPYvHmz5jaxi4GIiMhgyiCgp+UAfGpCWK3Wbtfv7OxEZmYmnnzySQDA1KlTcfDgQZSUlODee+/V1CYGCEQDlB6zENS2wTIpFIy0HFtGHTtaq0omJSXhqquu8npu8uTJ2LFjh+b3YoBARERkMK0ZBK1mzJiBr776yuu5w4cPIyUlRfM2OAaBiIjIYFrHIGj12GOPYd++fXjyySdx5MgRbN26FRs2bMCDDz6oeRsMEIiIiAaZ73znO9i5cye2bduG9PR0/O53v8O6devw85//XPM22MVARERkML27GADgBz/4AX7wgx9cdpsYIBARERmsPwKEvmIXAxEREflgBoGIiMhgZswgMEAgGqQG0t0aA3Xy02OfaGmrlvdhjYneC0TtD63U/n69/fuaMUBgFwMRERH5YAaBiIjIYGbMIDBAICIiMpgZAwR2MRAREZEPZhCIiIgMZsYMAgMEIiIig5kxQGAXAxEREflgBoGIiMhgZswgMEAgCmJqRWMCVWxJy8lPjxNkWFhYn9/H4/H0uR2A+r4NxkJKavskNFQ96a22Tmdnp+o2AvV97Lo9BghERETkxYwBAscgEBERkQ9mEIiIiAxmxgwCAwQiIiKDmTFAYBcDERER+WAGgYiIyATMNnOFAQIREZHBzNjFwACBeqRlDrzZIl76lpa/30Cqg6Bl/roaLfPo1dqipR1m2m8Didp+01LHQsvfWE1HR0eftzEYBPUYhOLiYqSmpiIiIgIZGRnYvXt3j+s6nU7MnTsXkyZNQmhoKAoKCgLXUCIiGtREBsHfI9CCNkDYvn07CgoKsHz5clRWVmLmzJnIzc1FVVVVt+u73W7ExcVh+fLluOaaawLcWiIiGswYIJjI2rVrsWDBAixcuBCTJ0/GunXr4HA4UFJS0u36Y8eOxfPPP497770Xdrs9wK0lIiIKrKAMENrb21FRUYGcnByv53NycrB3716DWkVERMHKjBmEoByk2NDQAI/Hg4SEBK/nExISUFtbq9v7uN1uuN1u+d8ul0u3bRMR0eBhxlkMQZlBELqOmJUkSdfRx0VFRbDb7fLD4XDotm0iIqL+FJQBwsiRIxEWFuaTLaivr/fJKvTFsmXL0NzcLD+qq6t12zYREQ0eZuxiCMoAwWKxICMjA2VlZV7Pl5WVITs7W7f3sVqtsNlsXg8iIqKuzBggBOUYBAAoLCzEvHnzkJmZiaysLGzYsAFVVVXIz88HcOnqv6amBps3b5Zfs3//fgBAa2srTp8+jf3798NiseCqq64y4iP0u8FWhMUsBlsRHS2fR624kMfj0eV91NbRUuRIbb9p2a+B+hsPJIH6+6nRYxvBImgDhLy8PDQ2NmL16tVwOp1IT09HaWkpUlJSAFwqjNS1JsLUqVPl/6+oqMDWrVuRkpKCEydOBLLpREQ0yJhxkGKIxMvEgHG5XKyhQAG7ugxUqeWBlEHQo9SylrbqUe5Xy6l5IJ2+tfz91PabHtvQ8vfTI9OkVXV1NRwOBw4dOoTo6Oge12tpacFVV12F5ubmgHVXB+UYBCIiIvIvaLsYiIiIzMKMXQwMEIiIiAxmxgCBXQxERETkgxkEIiIig5kxg8AAgUhneoyk10KP+fpq6+g1i0Ft5LiWfRIWFqa6jh6zJfTYJ8FGy99Pj/2m5Tvd0dHR520Y8WNsxgCBXQxERETkgxkEIiIig5kxg8AAgYiIyGBmDBDYxUBEREQ+mEEgIiIymBkzCAwQiIiIDGbGAIFdDEREROSDGQQiIiITMNvdORkgEOlMj1soa6FHoaRAUfvMWoogaSnGo1YoScs+0auQlRoz/X3U6PGd1uPvF8jbMAcauxiIiIhoQGAGgYiIyGBmzCAwQCAiIjKYGQMEdjEQERGRDwYIREREBhMZBH+P3li5ciVCQkK8HomJib3aBrsYiIiIDNYfXQxpaWn47//+b/nfWmYLKTFAICIiGoTCw8N7nTXwer2ObSEiqEf6WuZy61UrwSz02Cd6vE+gtqGHQLVDy3dNbR0tbdWjhoFZ/jb9oT8yCF9//TWSk5NhtVoxffp0PPnkkxg3bpzm1zNAICIiMpjWAMHlcnk9b7VaYbVafdafPn06Nm/ejIkTJ6Kurg5r1qxBdnY2Dh48iBEjRmhqEwcpEhERDRAOhwN2u11+FBUVdbtebm4ufvKTn+Dqq6/G7Nmz8fbbbwMA/vKXv2h+L2YQiIiIDKY1g1BdXQ2bzSY/3132oDtRUVG4+uqr8fXXX2tuEwMEIiIig2kNEGw2m1eAoJXb7caXX36JmTNnan4NuxiIiIgMpncdhMWLF6O8vBzHjx/HJ598gp/+9KdwuVyYP3++5m0wg0BERDTInDx5EnfffTcaGhoQFxeH66+/Hvv27UNKSormbTBAICIiMpje0xxff/31vjaJAQIREZHRzHizJgYIRDoL1IGsx/uYpSCTHkV0tK4TiG2YidrfODS070PRAlUoiQKLAQIREZHBzJhBCOpZDMXFxUhNTUVERAQyMjKwe/fuHtf961//iltvvRVxcXGw2WzIysrCe++9F8DWEhHRYKX3LAY9BG2AsH37dhQUFGD58uWorKzEzJkzkZubi6qqqm7X//DDD3HrrbeitLQUFRUVuOmmm3DHHXegsrIywC0nIiLqfyFSkHb6TJ8+HdOmTUNJSYn83OTJkzFnzpweS1d2lZaWhry8PPz2t7/VtL7L5YLdbr+s9tLgocfNcQB9bmyjxxgELdtQ63820z4ZbMwyBiFQY0gGmurqajgcDnzwwQcYNmxYj+u1trbipptuQnNz82UVSrocQZlBaG9vR0VFBXJycryez8nJwd69ezVto7OzEy0tLYiNje1xHbfbDZfL5fUgIiLqil0MJtHQ0ACPx4OEhASv5xMSElBbW6tpG3/4wx/Q1taGu+66q8d1ioqKvG6q4XA4+tRuIiKiQAnKAEHomnqTJElTGnPbtm1YuXIltm/fjvj4+B7XW7ZsGZqbm+VHdXV1n9tMRESDjxkzCEE5zXHkyJEICwvzyRbU19f7ZBW62r59OxYsWIA33ngDs2fP9rtuT/fppoErUP3gA6mWghZ6jHXQMo9e7X3MUvcBUN/3eo3LCMRnNtN3eiAz2z4KygyCxWJBRkYGysrKvJ4vKytDdnZ2j6/btm0b7rvvPmzduhW33357fzeTiIjIMEGZQQCAwsJCzJs3D5mZmcjKysKGDRtQVVWF/Px8AJe6B2pqarB582YAl4KDe++9F88//zyuv/56OfsQGRnJmQlERNQnZiyUFLQBQl5eHhobG7F69Wo4nU6kp6ejtLRUvtOV0+n0qomwfv16dHR04MEHH8SDDz4oPz9//nxs2rQp0M0nIqJBxIwBQtDWQTAC6yAMfHqMQRhsAtWvH6i6DoEymMYg8D4Ll0/UQSgrK0NUVFSP67W1teHWW28NaB2EoM0gEBERmYUZMwgMEIiIiAxmxgAhKGcxEBERkX/MIBARERnMjBkEBghEOlMbFKbXgR6IokB6FcDR44ZBZhmAGKgbE4WFhaluQ8t+UxtAqKWtemyD/DNjgMAuBiIiIvLBDAIREZHBzJhBYIBARERkMDMGCOxiICIiIh/MIBARERnMjBkEBghEREQGM2OAwC4GIiIi8sEMAhnOTDf7CYRA3YRHyxx5NXrMkdeyHS1t1VIXQA+BqBsA6PP3Cw9XP4V3dHT0aTlgnmNnMDNjBoEBAhERkcHMGCCwi4GIiIh8MINARERkMDNmEBggEBERGcyMAQK7GIiIiMgHMwhEREQGM2MGgQECERGRwcwYILCLgYiIiHwwgxCk9CpOpEdUa5YiLHoVMFIrkqNXUSCLxdKn5QBw8eJFv8vPnTvX53YAQHt7u+o6aoYMGdLntlitVtVtuFwuv8u1/G0cDofqOmr7trm5WXUbLS0tquvoUfhJD4EqiKbGLOebrsyYQWCAQEREZAJmC17YxUBEREQ+mEEgIiIyGLsYiIiIyIcZAwR2MRAREZEPZhCIiIgMZsYMAgMEIiIigzFAoIBRm3OsZS6+HnP+1ZabiV51ENTW0TKfPzIyUnUdu93ep+UA0NbW5nf5qVOnVLehpQ6CHt+T8HD101V0dLTf5Vr2idvt9rs8Li5OdRvZ2dmq61RXV/td/tVXX6luo6mpSXWdQPyw6FXjgLUSzIUBAhERkcGYQSAiIiIfZgwQgnoWQ3FxMVJTUxEREYGMjAzs3r27x3X37NmDGTNmYMSIEYiMjMSVV16J5557LoCtJSKiwUoECP4egRa0GYTt27ejoKAAxcXFmDFjBtavX4/c3FwcOnQIY8aM8Vk/KioKDz30EKZMmYKoqCjs2bMHDzzwAKKiovDLX/7SgE9ARETUf4I2g7B27VosWLAACxcuxOTJk7Fu3To4HA6UlJR0u/7UqVNx9913Iy0tDWPHjsU999yD2267zW/WgYiISAszZhCCMkBob29HRUUFcnJyvJ7PycnB3r17NW2jsrISe/fuxaxZs3pcx+12w+VyeT2IiIi6YoBgEg0NDfB4PEhISPB6PiEhAbW1tX5fO3r0aFitVmRmZuLBBx/EwoULe1y3qKgIdrtdfmi5BSwREZEZBGWAIHSdcytJkuo83N27d+Ozzz7Dn/70J6xbtw7btm3rcd1ly5ahublZfqjNeyYiouBkxgxCUA5SHDlyJMLCwnyyBfX19T5Zha5SU1MBAFdffTXq6uqwcuVK3H333d2ua7VaYbVa9Wm0AfQoCqRlG4OtKElYWJjf5XoVSho+fLjf5fHx8arbOHv2rN/lZ86cUd2Glr+f2jpa9omWgkxqxZS0fB/Pnz/vd/moUaNUt3HVVVeprqNGywWFloJnavtej7+fFmYpgqSFEeet/pzmWFRUhF//+td49NFHsW7dOs2vC8oMgsViQUZGBsrKyryeLysr01QBTZAkSbXqGhERkVE+/fRTbNiwAVOmTOn1a4MygwAAhYWFmDdvHjIzM5GVlYUNGzagqqoK+fn5AC51D9TU1GDz5s0AgJdeegljxozBlVdeCeBSXYRnn30WDz/8sGGfgYiIBof+yCC0trbi5z//Of785z9jzZo1vX590AYIeXl5aGxsxOrVq+F0OpGeno7S0lKkpKQAAJxOJ6qqquT1Ozs7sWzZMhw/fhzh4eEYP348nnrqKTzwwANGfQQiIhoktAYIXWfD+evKfvDBB3H77bdj9uzZDBB6a9GiRVi0aFG3yzZt2uT174cffpjZAiIiMlTX2XArVqzAypUrfdZ7/fXX8fnnn+PTTz+97PcK6gCBiIjIDLRmEKqrq2Gz2eTnu8seVFdX49FHH8X777+PiIiIy24TAwQiIiKDaQ0QbDabV4DQnYqKCtTX1yMjI0N+zuPx4MMPP8SLL74It9utOtsKYIBAREQ0qNxyyy04cOCA13P3338/rrzySvzqV7/SFBwADBCIiIgMp+cshujoaKSnp3s9FxUVhREjRvg87w8DBAOEhIT4LcTR2dnZ5/cwS3EUM1ErfqKl6IyWddSKHGnpE9RSYKujo8Pvci33/mhvb/e7PDo6WnUbTU1NquskJSX5XT5y5EjVbah9XgCoq6vzuzwrK0t1G/7urwJcKqim5j//8z9V16mpqfG73Ol0qm5Dy/dR7XxipuNcj/OW2nFups+r1J+Fki4XAwQiIqJBbteuXb1+DQMEIiIigzGDQERERN0yW/dHUN6LgYiIiPxjBoGIiMhg7GIgIiIiH2YMENjFQERERD6YQTCAWh0EPebxqlXKslgsqtsYMmSI6joXL170u1zL3HWPx6O6jh7zo/XYJ1rqE6jVOdCyDT3qILS0tKhuQ+27pqUOgpZ1EhIS/C5PTExU3YaW+gNXXHGF3+XPPfec6jbUvo9PPvmk6jb+/ve/q66jVi9Dy3Gh9vfTuo5ZqB3HWioAqtWG0FJnRss6el/RmzGDwACBiIjIYGYMENjFQERERD6YQSAiIjKYGTMIDBCIiIgMZsYAgV0MRERE5IMZBCIiIoOZMYPAAIGIiMhgZgwQ2MVAREREPphBGKTUiqNoKZ6iVnBE6zqBoEfBGL2KzqgVc9FSBElLkSq1KwothXbCw/2fAvRqq9vt9ru8urpadRtHjhxRXScvL8/v8hEjRqhuo7Gx0e/ypqYm1W1MnDhRdR21v9/p06dVt6GlLVqK/vSVlqtbLesE4hg1a+EoM2YQGCAQEREZzIwBgjku/4iIiMhUmEEgIiIymBkzCAwQiIiIDGbGAIFdDEREROSDGQQiIiKDmTGDwACBiIjIYAwQCMClecn9PRdXbe5ze3u76jY6OjpU11H70uo1B1uP/aXWFrW5+gBw8eJF1XW01AVQY7FYVNfRY763HrUUtKzzxRdf+F0+ffp01W3cfvvtquuofa8LCwtVt1FVVeV3+Z49e1S3ER0drbqO2vGl5fsYKIGqIaJGy/lEbR29ajYEAwYIREREBmMGgYiIiHyYMUDgLAYiIiLyEdQBQnFxMVJTUxEREYGMjAzs3r1b0+s++ugjhIeH49prr+3fBhIRUVAQGQR/j0AL2gBh+/btKCgowPLly1FZWYmZM2ciNzdXdYBSc3Mz7r33Xtxyyy0BaikREQUDMwUHQBAHCGvXrsWCBQuwcOFCTJ48GevWrYPD4UBJSYnf1z3wwAOYO3cusrKyAtRSIiIa7JhBMIn29nZUVFQgJyfH6/mcnBzs3bu3x9e98sorOHr0KFasWKHpfdxuN1wul9eDiIhoIAjKAKGhoQEejwcJCQlezyckJKC2trbb13z99ddYunQptmzZgvBwbZM/ioqKYLfb5YfD4ehz24mIaPAxYwYhqKc5di3cIUlSt8U8PB4P5s6di1WrVmHixImat79s2TKvwiwul0sOEvryxw4NVY/r9CgWokdREr0KqASqyIoetBShUqOl2JJaoKolkFUr/HTu3DnVbWhZ57vf/a7f5Y8++qjqNqZNm6a6zsqVK/0u37lzp+o20tLS/C7vemHRnbq6OtV11L4nWgqV6UHLuUDtnBMWFtbnbQDqx6iWfdLfRej6ixmnOQZlgDBy5EiEhYX5ZAvq6+u7PfhbWlrw2WefobKyEg899BCAS19kSZIQHh6O999/HzfffLPP66xWK6xWa/98CCIion4UlAGCxWJBRkYGysrKcOedd8rPl5WV4Uc/+pHP+jabDQcOHPB6rri4GP/zP/+DN998E6mpqf3eZiIiGryYQTCRwsJCzJs3D5mZmcjKysKGDRtQVVWF/Px8AJe6B2pqarB582aEhoYiPT3d6/Xx8fGIiIjweZ6IiKi3GCCYSF5eHhobG7F69Wo4nU6kp6ejtLQUKSkpAACn06laE4GIiGiwCtoAAQAWLVqERYsWdbts06ZNfl+7cuVK1QFRREREWjCDQERERD7MGCAEZR0EIiIi8o8ZBAOEhIT4naurRw0DLW1Qo2XecqDaYhZ6fF4t2/B4PKrrqO03Lfu1qanJ7/JvvvlGdRs2m011HbXaAY2Njarb+Pzzz1XXOXTokN/lEyZMUN1GfHy83+Va2qqlaqpaDQq9jgu175uW91Hbhl41RtS+91qOHbWaDFraasTVuhkzCAwQiIiIDGbGAIFdDEREROSDGQQiIiKDmTGDwACBiIjIYGYMENjFQERERD6YQSAiIjKYGTMIDBCIiIgMZsYAgV0MRERE5IMZBAOEhob2qQiKHkVJtESjehQU0VJsKVDU9rle+0TtfbRso6OjQ3UdPYrX1NbW+l0+btw41W3ccMMNquu0t7f7XV5WVqa6jbq6OtV1PvnkE7/Lr7/+etVtqO2ThoYG1W1o+fupHRt6fAf0ovY+Wgp76XE+USuCBOhTQEyP4lG9ZcYMAgMEIiIig5kxQDDP5R0RERGZBgMEIiIig4kMgr9Hb5SUlGDKlCmw2Wyw2WzIysrCO++806ttMEAgIiIymN4BwujRo/HUU0/hs88+w2effYabb74ZP/rRj3Dw4EHN2+AYBCIiokHmjjvu8Pr3E088gZKSEuzbtw9paWmatsEAgYiIyAS0ZAm63krcarXCarX6fY3H48Ebb7yBtrY2ZGVlaW4PuxiIiIgMprWLweFwwG63y4+ioqIet3ngwAEMGzYMVqsV+fn52LlzJ6666irNbWIGwQBqdRACMZ1Fr/cYSHOO1d5HS80GLW1V246Wz6JlDvzFixf7/D5q9QmmTZumuo3c3FzVddQGR5WWlqpuw263q66Tnp7ud7mW/Xr27Fm/y8+cOaO6jWHDhqmuo1YXwO12q25D7e+n5X30+E7rRe19zFRXxSjV1dWw2Wzyv/1lDyZNmoT9+/fj7Nmz2LFjB+bPn4/y8nLNQQIDBCIiIoNprYMgZiVoYbFYMGHCBABAZmYmPv30Uzz//PNYv369ptczQCAiIjJYIAolSZKkKTMlMEAgIiIaZH79618jNzcXDocDLS0teP3117Fr1y68++67mrfBAIGIiMhgemcQ6urqMG/ePDidTtjtdkyZMgXvvvsubr31Vs3bYIBARERkML0DhI0bN/a1SZzmSERERL6YQSAiIjKYGe/myACBiIjIYAwQCMClspf+ipOoFTbRQ6AKGGn5LHq0Ra/Po8c21D6zWoEjAGhtbVVdx+Px+F2uVjQIACZPnux3uZa27tixQ3Wdzz//3O/yruVju5OUlKS6jhotn0dNbGys6jotLS2q66gVOdJSBElL4SC1Y9SIH57LpaWtehzndAkDBCIiIoMxg0BEREQ+zBggcBYDERER+QjqAKG4uBipqamIiIhARkYGdu/e3eO6u3btQkhIiM/jn//8ZwBbTEREg5HWuzkGUtB2MWzfvh0FBQUoLi7GjBkzsH79euTm5uLQoUMYM2ZMj6/76quvvG6UERcXF4jmEhHRIMYuBhNZu3YtFixYgIULF2Ly5MlYt24dHA4HSkpK/L4uPj4eiYmJ8iMsLCxALSYiIgqcoAwQ2tvbUVFRgZycHK/nc3JysHfvXr+vnTp1KpKSknDLLbfggw8+8Luu2+2Gy+XyehAREXXFLgaTaGhogMfjQUJCgtfzCQkJqK2t7fY1SUlJ2LBhAzIyMuB2u/Hqq6/illtuwa5du3DjjTd2+5qioiKsWrXK5/nOzk6/c3X1+CKozY/WMldYyxxrtbn4WuogaPm8am3R0tZA1UFQ+zwdHR2q22hoaFBd58477/S7PC8vT3UbZ8+e9btcy53f3nrrLdV1LBaL3+UpKSmq2xg6dKjqOmq3su3NrW57Mnz4cNV1up5butPY2Oh3eV1dneo2tHwete+sXrcRDoRAvY8e54rettWMXQxBGSAIXb8EkiT1+MWYNGkSJk2aJP87KysL1dXVePbZZ3sMEJYtW4bCwkL53y6XCw6HQ4eWExER9a+g7GIYOXIkwsLCfLIF9fX1miJ/4frrr8fXX3/d43Kr1Qqbzeb1ICIi6sqMXQxBGSBYLBZkZGSgrKzM6/mysjJkZ2dr3k5lZaUu5V+JiCi4mTFACNouhsLCQsybNw+ZmZnIysrChg0bUFVVhfz8fACXugdqamqwefNmAMC6deswduxYpKWlob29Ha+99hp27NihqQ49ERGRPxyDYCJ5eXlobGzE6tWr4XQ6kZ6ejtLSUnmwlNPpRFVVlbx+e3s7Fi9ejJqaGkRGRiItLQ1vv/02vv/97xv1EYiIiPpN0AYIALBo0SIsWrSo22WbNm3y+vfjjz+Oxx9/PACtIiKiYMMMAhEREXXLbLfeDspBikREROQfMwgGMTpS1FJYSMs6WgohqdGj+FCgaGlHS0uL3+VqxYkAaKqXMWHCBL/LJ06cqLqNw4cP+12uVswHAMaOHau6zrBhw/wuVyukBEBTWfP29na/y7UUqVJ7n4iICNVtaJnSfOHCBb/LhwwZoroNPQo/aTGQjr9AbEOL3haoYhcDERER+TBjgMAuBiIiIvLBDAIREZHBzJhBYIBARERkMDMGCOxiICIiIh/MIBARERnMjBkEBghEREQGY4BAAC7Nj/U3R1aP2gJqXyYtXzY91tFS40DLOmr7RMv8drX30asew6hRo/wuT01N7fM2APV6Ctu2bVPdxpEjR/wu/+KLL1S3oeUW6R6Px+9yLX8/Pb6PWmopqLW1tbVVdRtqNQ4AoLm52e9ytZoOgLZzhR4/LHocO3rQ67wVCGZpR18wQCAiIjIYMwhERETkw4wBAmcxEBERkQ9mEIiIiAxmxgwCAwQiIiKDmTFAYBcDERER+WAGgYiIyGBmzCAwQCAiIjIYAwQCoF4oSY+iI3oUSgoULZ9XrcCNHgVU9ChQBQDjxo3zu3zWrFmq24iLi1NdZ+/evX6Xl5aWqm6jpqbG7/KRI0eqbkPL30+t+JBeRar0KNyltg0thZLcbrfqOufPn/e7XEuhpEAVDtKjUJIe+34gFUoaDBggEBERGYwZBCIiIvJhxgCBsxiIiIjIBzMIREREBjNjBoEBAhERkcHMGCCwi4GIiIh8MINARERkMDNmEBggmJAec7n7+h6AtroAZpm3rMc8bC3bCA1VT7p1dHT4Xe5yuVS3oYVaDYPq6mrVbSQlJfldHh6ufopQm88PqO9bLftVj++9Fmo1DLR83ra2NtV1Ll686He5Wu0IIHA/GoE6RoOd2Wo4sIuBiIiIfDCDQEREZDB2MRAREZEPMwYI7GIgIiIiH0EdIBQXFyM1NRURERHIyMjA7t27/a7vdruxfPlypKSkwGq1Yvz48Xj55ZcD1FoiIhqsRAbB3yPQgraLYfv27SgoKEBxcTFmzJiB9evXIzc3F4cOHcKYMWO6fc1dd92Furo6bNy4ERMmTEB9fb3qiHUiIiI17GIwkbVr12LBggVYuHAhJk+ejHXr1sHhcKCkpKTb9d99912Ul5ejtLQUs2fPxtixY3HdddchOzs7wC0nIiLyr6ioCN/5zncQHR2N+Ph4zJkzB1999VWvthGUAUJ7ezsqKiqQk5Pj9XxOTg727t3b7WveeustZGZm4plnnsGoUaMwceJELF68WNOcaCIiIn/07mIoLy/Hgw8+iH379qGsrAwdHR3IycnRVKNDCMouhoaGBng8HiQkJHg9n5CQgNra2m5fc+zYMezZswcRERHYuXMnGhoasGjRIjQ1NfU4DsHtdnsVXREFcjo7Ow0vGqJHESSt6+jRFrX9paUdYWFhfpdrKQqkZZ26ujq/yz/99FNd3uf48eN+l6t9XkC96I9exaPU/sZ6pU8tFovf5UOGDFHdhlqBogsXLqhuQ8s6au+jZZ/oUSDMTMe5HoXXBiq9uxjeffddr3+/8soriI+PR0VFBW688UZN2wjKDILQ9cCRJKnHg0n8qG/ZsgXXXXcdvv/972Pt2rXYtGlTjyfZoqIi2O12+eFwOHT/DEREFDxcLpfXQ63yp9Dc3AwAiI2N1fxeQRkgjBw5EmFhYT7Zgvr6ep+sgpCUlIRRo0bBbrfLz02ePBmSJOHkyZPdvmbZsmVobm6WH1pK3xIRUfDR2sXgcDi8LjyLioo0bbuwsBA33HAD0tPTNbcpKLsYLBYLMjIyUFZWhjvvvFN+vqysDD/60Y+6fc2MGTPwxhtvoLW1FcOGDQMAHD58GKGhoRg9enS3r7FarbBarfp/ACIiGlS0djFUV1fDZrPJz2v5jXnooYfwf//3f9izZ0+v2hSUGQQAKCwsxL//+7/j5ZdfxpdffonHHnsMVVVVyM/PB3Dp6v/ee++V1587dy5GjBiB+++/H4cOHcKHH36IJUuW4F/+5V8QGRlp1McgIqIgYrPZvB5qAcLDDz+Mt956Cx988EGPF7M9CcoMAgDk5eWhsbERq1evhtPpRHp6OkpLS5GSkgIAcDqdqKqqktcfNmwYysrK8PDDDyMzMxMjRozAXXfdhTVr1hj1EYiIaJDQe5CiJEl4+OGHsXPnTuzatQupqam9blPQBggAsGjRIixatKjbZZs2bfJ57sorr0RZWVk/t4qIiIKN3gHCgw8+iK1bt+Lvf/87oqOj5TF3drtdc9Y7aLsYiIiIzELvOgglJSVobm7Gd7/7XSQlJcmP7du3a95GUGcQiIiIBiM9akYwQDBIX/54gSoWYqaiJHq0Ra1gjJbiRGqFeAD0WGxLUI5t6Ul7e7vqOmoFirR8nnPnzvldrlcRHbV7lmgptqRH0SYxA8kftc+jpXqqln2i1tZAFTDSsl/1KGBkpvOJGZnxXgwMEIiIiAxmxgCBYxCIiIjIBzMIREREBjNjBoEBAhERkcHMGCCwi4GIiIh8MINARERkMDNmEBggEBERGYwBAtFlUpszrsc8eo/Ho7oNLfUJ1Ob8d3Z2qm5DCy3z19WYZX67XvtEjdvtVl1H7fNoaase+4S1BchoDBCIiIgMxgwCERERdctsGSHOYiAiIiIfzCAQEREZjF0MRERE5MOMAQK7GIiIiMgHMwhEREQGM2MGgQECERGRwRggEHVDS8EftUJIYWFhfW6HlkJJakWQAH2KD2nZJ2aZEqXH59Hrs6htR0uhK7VtaPmemOVvQ9QXDBCIiIgMxgwCERER+TBjgMBZDEREROSDGQQiIiKDmTGDwACBiIjIYGYMENjFQERERD6YQSAiIjKYGTMIDBDIcFrm/Kuto1YnAQA6Ozv7tBzQVgdBj7bqUQdBjxOKXicltc+j5fNqodZePepYmMlAqpdB/pkxQGAXAxEREflgBoGIiMhgZswgMEAgIiIymBkDBHYxEBERkQ9mEIiIiAzGDILJFBcXIzU1FREREcjIyMDu3bt7XPe+++5DSEiIzyMtLS2ALSYiosFIBAj+HoEWtAHC9u3bUVBQgOXLl6OyshIzZ85Ebm4uqqqqul3/+eefh9PplB/V1dWIjY3Fz372swC3nIiIqP8FbYCwdu1aLFiwAAsXLsTkyZOxbt06OBwOlJSUdLu+3W5HYmKi/Pjss89w5swZ3H///QFuORERDTZmzCAE5RiE9vZ2VFRUYOnSpV7P5+TkYO/evZq2sXHjRsyePRspKSk9ruN2u+F2u+V/u1yuy2vwABaookB6FMDRUihJD1oOdC37RK29ehR10quA0UCi9plZeIj6A8cgmERDQwM8Hg8SEhK8nk9ISEBtba3q651OJ9555x0sXLjQ73pFRUWw2+3yw+Fw9KndREREgRKUAYLQ9UpBkiRNV0ybNm1CTEwM5syZ43e9ZcuWobm5WX5UV1f3pblERDRIsYvBJEaOHImwsDCfbEF9fb1PVqErSZLw8ssvY968ebBYLH7XtVqtsFqtfW4vERENfmbrvgrKDILFYkFGRgbKysq8ni8rK0N2drbf15aXl+PIkSNYsGBBfzaRiIjIUEGZQQCAwsJCzJs3D5mZmcjKysKGDRtQVVWF/Px8AJe6B2pqarB582av123cuBHTp09Henq6Ec0mIqJByIyDFIM2QMjLy0NjYyNWr14Np9OJ9PR0lJaWyrMSnE6nT02E5uZm7NixA88//7wRTSYiokHKjAFCiGS2To9BzOVywW63G92MgNJrmqMe0/H0mOaoZR092qplHY/H0+/vM9CmOar9jfU43ZnplKnH956MVV1dDYfDgalTpyIsLKzH9TweDyorK9Hc3AybzRaQtgVtBoH0EagfQz1+3APx46FlO3r96KoFX1o+j9p+0xLgaVnHLD/Meux7/uBSfzBjBoEBAhERkcHMGCAE5SwGIiIi8o8ZBCIiIoOZMYPAAIGIiMhgDBCIiIjIhxkDBI5BICIiIh/MIBARERnMjBkEBghEREQGY4BAAaNWEEavCod60PLF16NQklnoUY1Ri0AVJ9JjHb1Ofmrfay3fezWBKqgVqG0Q9YRjEIiIiAwmMgj+Hr3x4Ycf4o477kBycjJCQkLwt7/9rddtYoBARERkML0DhLa2NlxzzTV48cUXL7tN7GIgIiIaZHJzc5Gbm9unbTBAICIiMpjWQYoul8vreavVCqvV2i9tYhcDERGRwbR2MTgcDtjtdvlRVFTUb21iBoGIiGiAqK6uhs1mk//dX9kDgAECERGR4bR2MdhsNq8AoT8xQBik1OZ7DxkyRHUb4eHqX4+Ojo4+LQe01QUYTPO9tdQ40KMOgpY5/3rUJ9Dj76fl82ppi9pntlgsqttQ+zx61dwYTLU9qO9YKImIiIj6XWtrK44cOSL/+/jx49i/fz9iY2MxZswYTdtggEBERGQwvTMIn332GW666Sb534WFhQCA+fPnY9OmTZq2wQCBiIjIYHoHCN/97nf73C3BaY5ERETkgxkEIiIiEzDbYGwGCERERAYz4ywGdjEQERGRD2YQiIiIDGbGDAIDhEEqLCzM73ItBWO0rHPhwgW/y7UUSjJbv1tfqRX9UfvbANqKHPW1HYB6MR6Px6O6DT0KGGn5vFoKB6l9Zi0FwtTe5+LFi31uB6BPkarBduzoQW3fm3WfmTFAYBcDERER+WAGgYiIyGBmzCAwQCAiIjKYGQMEdjEQERGRD2YQiIiIDMYMgskUFxcjNTUVERERyMjIwO7du/2uv2XLFlxzzTUYOnQokpKScP/996OxsTFArSUiosFKBAj+HoEWtAHC9u3bUVBQgOXLl6OyshIzZ85Ebm4uqqqqul1/z549uPfee7FgwQIcPHgQb7zxBj799FMsXLgwwC0nIiLqfyGSWSeF9rPp06dj2rRpKCkpkZ+bPHky5syZg6KiIp/1n332WZSUlODo0aPyc3/84x/xzDPPoLq6WtN7ulwu2O32vjdeg/Bw/71HWmocqG0DANrb2/0u1zJnXMtc+8FEy5x/LfPo1dbRow6CltoDWk4herRVy/voUf9D7X3cbrfqNrR8HjV67Xsyt+rqajgcDiQnJ/s9N3R2duLUqVNobm6GzWYLSNuCMoPQ3t6OiooK5OTkeD2fk5ODvXv3dvua7OxsnDx5EqWlpZAkCXV1dXjzzTdx++239/g+brcbLpfL60FERNQVuxhMoqGhAR6PBwkJCV7PJyQkoLa2ttvXZGdnY8uWLcjLy4PFYkFiYiJiYmLwxz/+scf3KSoqgt1ulx8Oh0PXz0FERNRfgjJAELqmASVJ6jE1eOjQITzyyCP47W9/i4qKCrz77rs4fvw48vPze9z+smXL0NzcLD+0dkUQEVFwMWMGISinOY4cORJhYWE+2YL6+nqfrIJQVFSEGTNmYMmSJQCAKVOmICoqCjNnzsSaNWuQlJTk8xqr1Qqr1ar/ByAiokGF0xxNwmKxICMjA2VlZV7Pl5WVITs7u9vXnDt3zmcAiRgQxYFCREQ02ARlBgEACgsLMW/ePGRmZiIrKwsbNmxAVVWV3GWwbNky1NTUYPPmzQCAO+64A7/4xS9QUlKC2267DU6nEwUFBbjuuuuQnJxs5EchIqIBzowZhKANEPLy8tDY2IjVq1fD6XQiPT0dpaWlSElJAQA4nU6vmgj33XcfWlpa8OKLL+Jf//VfERMTg5tvvhlPP/20UR+BiIgGCTMGCEFbB8EIrIPQPdZB8MU6CJf3PqyDQAONqIMQFxenWgfh9OnTAa2DELQZhIFMj5Op2g87AHR0dKiuo/bjruUkF2z02id6/Oiq0esHSG07er2P2r7V8r1Xa4uWv5+Z9j0NDGbMIDBAICIiMpgZA4SgnMVARERE/jGDQEREZDAzZhAYIBARERnMjAECuxiIiIjIBzMIREREJmC2mSsMEIiIiAwWqKnAvcEAwYQCUQDHbJHqYKLHHHgtzHhCuVx6FIYC9Cn8pIeBtO/JHMx4PHMMAhEREflgBoGIiMhgZswgMEAgIiIymBkDBHYxEBERkQ9mEIiIiAxmxgwCAwQiIiKDmTFAYBcDERER+WAGgYiIyGBmzCAwQDBASEiI36IvenxRWKjFOHrs+0AVW1KjpR2hoeqJSLV9oqWAkZb9Goj9xmOL+oMZAwR2MRAREZEPZhCIiIgMZsYMAgMEIiIig5kxQGAXAxEREflgBoGIiMhgZswgMEAgIiIymBkDBHYxEBERkQ9mEAygVgdBjZY542Qctb+tlroBWuhRW0CPtoaFhamuo8d3Vo9t6LHvtVzJ8Ril3jJjBoEBAhERkcHMGCCwi4GIiIh8MINARERkMDNmEBggEBERGcyMAQK7GIiIiMgHMwhEREQGM2MGgQECERGRCZjtVuIMEAJI/PHNGCmSfgL199VjO3q0VY91ArVPArHPiHrDzN8nBggB1NLSAuDSF8LMXwrqXwOpiI6Wtg62z0MUSG63G4mJiaitrVVdNzExERaLJQCtuiRE4i9VwHR2duLUqVOIjo7uUyXF/uJyueBwOFBdXQ2bzWZ0c/waSG0F2N7+xvb2L7ZXf5IkoaWlBcnJyWhvb0d7e7vqaywWCyIiIgLQukuYQQig0NBQjB492uhmqLLZbKY9qLoaSG0F2N7+xvb2L7ZXX3a7HQAQERER0B9+rTjNkYiIiHwwQCAiIiIfDBBIZrVasWLFClitVqObomogtRVge/sb29u/2N7gxEGKRERE5IMZBCIiIvLBAIGIiIh8MEAgIiIiHwwQiIiIyAcDhCBSXFyM1NRUREREICMjA7t37+5xXafTiblz52LSpEkIDQ1FQUFB4Br6//WmvX/9619x6623Ii4uDjabDVlZWXjvvfcC2NretXfPnj2YMWMGRowYgcjISFx55ZV47rnnAtja3rVX6aOPPkJ4eDiuvfba/m1gF71p765duxASEuLz+Oc//2nK9gKXSu4uX74cKSkpsFqtGD9+PF5++eUAtbZ37b3vvvu63b9paWmmaysAbNmyBddccw2GDh2KpKQk3H///WhsbAxIWwc0iYLC66+/Lg0ZMkT685//LB06dEh69NFHpaioKOmbb77pdv3jx49LjzzyiPSXv/xFuvbaa6VHH33U1O199NFHpaefflr6xz/+IR0+fFhatmyZNGTIEOnzzz83ZXs///xzaevWrdIXX3whHT9+XHr11VeloUOHSuvXrzdle4WzZ89K48aNk3JycqRrrrkmIG2VpN6394MPPpAASF999ZXkdDrlR0dHhynbK0mS9MMf/lCaPn26VFZWJh0/flz65JNPpI8++siU7T179qzXfq2urpZiY2OlFStWmK6tu3fvlkJDQ6Xnn39eOnbsmLR7924pLS1NmjNnTr+3daBjgBAkrrvuOik/P9/ruSuvvFJaunSp6mtnzZoV8AChL+0VrrrqKmnVqlV6N61berT3zjvvlO655x69m9aty21vXl6e9G//9m/SihUrAhog9La9IkA4c+ZMAFrnq7ftfeeddyS73S41NjYGonk++vr93blzpxQSEiKdOHGiP5rnpbdt/f3vfy+NGzfO67kXXnhBGj16dL+1cbBgF0MQaG9vR0VFBXJycryez8nJwd69ew1qVc/0aG9nZydaWloQGxvbH030okd7KysrsXfvXsyaNas/mujlctv7yiuv4OjRo1ixYkV/N9FLX/bv1KlTkZSUhFtuuQUffPBBfzZTdjntfeutt5CZmYlnnnkGo0aNwsSJE7F48WKcP3/elO3tauPGjZg9ezZSUlL6o4myy2lrdnY2Tp48idLSUkiShLq6Orz55pu4/fbb+7WtgwFv1hQEGhoa4PF4kJCQ4PV8QkKCpluMBpoe7f3DH/6AtrY23HXXXf3RRC99ae/o0aNx+vRpdHR0YOXKlVi4cGF/NhXA5bX366+/xtKlS7F7926Ehwf2tHE57U1KSsKGDRuQkZEBt9uNV199Fbfccgt27dqFG2+80XTtPXbsGPbs2YOIiAjs3LkTDQ0NWLRoEZqamvp9HEJfjzen04l33nkHW7du7a8myi6nrdnZ2diyZQvy8vJw4cIFdHR04Ic//CH++Mc/9nt7BzoGCEGk6y2mJUky5W2nhctt77Zt27By5Ur8/e9/R3x8fH81z8fltHf37t1obW3Fvn37sHTpUkyYMAF33313fzZTprW9Ho8Hc+fOxapVqzBx4sSAtK07vdm/kyZNwqRJk+R/Z2Vlobq6Gs8++2y/BwhCb9rb2dmJkJAQbNmyRb7D39q1a/HTn/4UL730EiIjI03VXqVNmzYhJiYGc+bM6aeW+epNWw8dOoRHHnkEv/3tb3HbbbfB6XRiyZIlyM/Px8aNGwPR3AGLAUIQGDlyJMLCwnwi7Pr6ep9I3Az60t7t27djwYIFeOONNzB79uz+bKasL+1NTU0FAFx99dWoq6vDypUr+z1A6G17W1pa8Nlnn6GyshIPPfQQgEs/aJIkITw8HO+//z5uvvlm07S3J9dffz1ee+01vZvn43Lam5SUhFGjRsnBAQBMnjwZkiTh5MmTuOKKK0zVXkGSJLz88suYN28eLBZLv7VRuJy2FhUVYcaMGViyZAkAYMqUKYiKisLMmTOxZs0aJCUl9Xu7ByqOQQgCFosFGRkZKCsr83q+rKwM2dnZBrWqZ5fb3m3btuG+++7D1q1bA9q/qNf+lSQJbrdb7+b56G17bTYbDhw4gP3798uP/Px8TJo0Cfv378f06dNN1d6eVFZWBuTH4HLaO2PGDJw6dQqtra3yc4cPH0ZoaChGjx5tuvYK5eXlOHLkCBYsWNCfTZRdTlvPnTuH0FDvn7qwsDAAl4458sOIkZEUeGJq0MaNG6VDhw5JBQUFUlRUlDzqeOnSpdK8efO8XlNZWSlVVlZKGRkZ0ty5c6XKykrp4MGDpmzv1q1bpfDwcOmll17ymn519uxZU7b3xRdflN566y3p8OHD0uHDh6WXX35Zstls0vLly03Z3q4CPYuht+197rnnpJ07d0qHhd/YbwAAApRJREFUDx+WvvjiC2np0qUSAGnHjh2mbG9LS4s0evRo6ac//al08OBBqby8XLriiiukhQsXmrK9wj333CNNnz49IG283La+8sorUnh4uFRcXCwdPXpU2rNnj5SZmSldd911AW33QMQAIYi89NJLUkpKimSxWKRp06ZJ5eXl8rL58+dLs2bN8lofgM8jJSXFlO2dNWtWt+2dP3++Kdv7wgsvSGlpadLQoUMlm80mTZ06VSouLpY8Ho8p29tVoAMESepde59++mlp/PjxUkREhDR8+HDphhtukN5++23TtleSJOnLL7+UZs+eLUVGRkqjR4+WCgsLpXPnzpm2vWfPnpUiIyOlDRs2BKyNQm/b+sILL0hXXXWVFBkZKSUlJUk///nPpZMnTwa41QMPb/dMREREPjgGgYiIiHwwQCAiIiIfDBCIiIjIBwMEIiIi8sEAgYiIiHwwQCAiIiIfDBCIiIjIBwMEIiIi8sEAgYiIiHwwQCAiIiIfDBCIKCCefPJJhISE+DzWrl1rdNOIqBu8FwMRBURLSwva2trkf69evRqlpaXYs2dPv9/SmIh6L9zoBhBRcIiOjkZ0dDQAYNWqVSgtLUV5eTmDAyKTYhcDEQXUqlWr8Morr6C8vBwpKSlGN4eIesAAgYgChsEB0cDBAIGIAoLBAdHAwjEIRNTv1qxZgxdffBH/9V//BavVitraWgDA8OHDYbVaDW4dEXWHsxiIqF9JkoSYmBi4XC6fZfv27cP06dMNaBURqWGAQERERD44BoGIiIh8MEAgIiIiHwwQiIiIyAcDBCIiIvLBAIGIiIh8MEAgIiIiHwwQiIiIyAcDBCIiIvLBAIGIiIh8MEAgIiIiHwwQiIiIyAcDBCIiIvLx/wAU0UT4OiddDQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -59,9 +81,9 @@ "figure, axis = plt.subplots(2, 1, figsize=(5,10))\n", "figure.subplots_adjust(wspace=0, hspace=0.01)\n", "for i in range(100):\n", - " axis[0].plot(zs, pzs[i], 'k-', alpha=0.05)\n", + " axis[0].plot(base.z, base.nzs[i], 'k-', alpha=0.05)\n", "axis[0].set_ylabel(r'$p(z)$')\n", - "im = axis[1].imshow(abs(cov), aspect='auto',\n", + "im = axis[1].imshow(abs(base.nz_cov), aspect='auto',\n", " origin='lower', cmap='gray',\n", " extent=[min(zs), max(zs), max(zs), min(zs)])\n", "axis[1].set_xlabel(r'$z$')\n", @@ -79,33 +101,25 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "45 (100, 45)\n" - ] - } - ], + "outputs": [], "source": [ "shifts = qp.projectors.ProjectorShifts(q)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "pz_fid = [shifts.z, shifts.pz_mean]" + "pz_fid = [shifts.z, shifts.nz_mean]" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -114,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -123,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -143,7 +157,7 @@ "for i in range(100):\n", " pz = shifted_pzs[i]\n", " axis[0].plot(shifts.z, pz, 'k-', alpha=0.05)\n", - "axis[0].errorbar(shifts.z, shifts.pz_mean, yerr=np.sqrt(np.diag(shifted_cov)), fmt='k-')\n", + "axis[0].errorbar(shifts.z, shifts.nz_mean, yerr=np.sqrt(np.diag(shifted_cov)), fmt='k-')\n", "axis[0].set_ylabel(r'$p(z)$')\n", "im = axis[1].imshow(abs(shifted_cov), aspect='auto',\n", " origin='lower', cmap='gray',\n", @@ -155,6 +169,82 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Shifts & Widths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "SnW = qp.projectors.ProjectorShiftsWidths(q)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "SnW_pzs = []\n", + "for i in range(100):\n", + " shift_p = SnW._get_shift_prior()\n", + " width_p = SnW._get_width_prior()\n", + " shift = shift_p.rvs()\n", + " width = width_p.rvs()\n", + " pz = SnW.evaluate_model(pz_fid, shift, width)[1]\n", + " SnW_pzs.append(pz)\n", + "SnW_pzs = np.array(SnW_pzs)\n", + "#SnW_pzs = base._normalize(SnW_pzs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "SnW_cov = np.cov(SnW_pzs.T)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure, axis = plt.subplots(2, 1, figsize=(5,10))\n", + "figure.subplots_adjust(wspace=0, hspace=0.01)\n", + "for i in range(100):\n", + " axis[0].plot(SnW.z, SnW_pzs[i], 'k-', alpha=0.05)\n", + "axis[0].errorbar(SnW.z, SnW.nz_mean, yerr=np.sqrt(np.diag(SnW_cov)), fmt='k-')\n", + "axis[0].set_ylabel(r'$p(z)$')\n", + "im = axis[1].imshow(abs(SnW_cov), aspect='auto',\n", + " origin='lower', cmap='gray',\n", + " extent=[min(zs), max(zs), max(zs), min(zs)])\n", + "axis[1].set_xlabel(r'$z$')\n", + "cbar_ax = figure.add_axes([0.905, 0.11, 0.02, 0.38])\n", + "figure.colorbar(im, cax=cbar_ax)\n", + "#plt.savefig('docs/source/assets/moments.png')\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -164,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -184,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -193,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -202,12 +292,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -221,7 +311,7 @@ "figure.subplots_adjust(wspace=0, hspace=0.01)\n", "for i in range(100):\n", " axis[0].plot(moments.z, moments_pzs[i], 'k-', alpha=0.05)\n", - "axis[0].errorbar(moments.z, moments.pz_mean, yerr=np.sqrt(np.diag(moments_cov)), fmt='k-')\n", + "axis[0].errorbar(moments.z, moments.nz_mean, yerr=np.sqrt(np.diag(moments_cov)), fmt='k-')\n", "axis[0].set_ylabel(r'$p(z)$')\n", "im = axis[1].imshow(abs(moments_cov), aspect='auto',\n", " origin='lower', cmap='gray',\n", diff --git a/src/qp/projectors/__init__.py b/src/qp/projectors/__init__.py index 17d9ce79..1b758cb9 100644 --- a/src/qp/projectors/__init__.py +++ b/src/qp/projectors/__init__.py @@ -1,3 +1,4 @@ from .projector_base import ProjectorBase from .projector_shifts import ProjectorShifts +from .projector_shifts_widths import ProjectorShiftsWidths from .projector_moments import ProjectorMoments diff --git a/src/qp/projectors/projector_base.py b/src/qp/projectors/projector_base.py index 71df24b9..325a4909 100644 --- a/src/qp/projectors/projector_base.py +++ b/src/qp/projectors/projector_base.py @@ -1,6 +1,5 @@ from ..ensemble import Ensemble import numpy as np -from multipledispatch import dispatch class ProjectorBase(object): @@ -15,45 +14,25 @@ class ProjectorBase(object): - get_prior: return the prior distribution of the model given the meadured photometric distributions. """ - @dispatch() - def __init__(self): - self._project_base() - self._project() - - @dispatch(np.ndarray, np.ndarray) - def __init__(self, zs, pzs): - self._project_base(zs, pzs) - - @dispatch(Ensemble) def __init__(self, ens): self._project_base(ens) - @dispatch() - def _project_base(self): - raise NotImplementedError - - @dispatch(np.ndarray, np.ndarray) - def _project_base(self, zs, pzs): - self.pzs = self._normalize(pzs) - self.z = zs - self.pz_mean = np.mean(self.pzs, axis=0) - self.prior = None - - @dispatch(Ensemble) def _project_base(self, ens, z=None): if z is None: z = np.linspace(0, 1.5, 45) self.z = z - pzs = ens.pdf(z) - pzs = ens.objdata()['pdfs'] - self.pzs = self._normalize(pzs) - self.pz_mean = np.mean(self.pzs, axis=0) + nzs = ens.pdf(z) + nzs = ens.objdata()['pdfs'] + self.ens = ens + self.nzs = self._normalize(nzs) + self.nz_mean = np.mean(self.nzs, axis=0) + self.nz_cov = np.cov(self.nzs, rowvar=False) self.prior = None - def _normalize(self, pzs): - norms = np.sum(pzs, axis=1) - pzs /= norms[:, None] - return pzs + def _normalize(self, nzs): + norms = np.sum(nzs, axis=1) + nzs /= norms[:, None] + return nzs def evaluate_model(self, *args): """ @@ -77,8 +56,16 @@ def sample_prior(self): prior = self.get_prior() return prior.rvs() - def save_prior(self): + def save_prior(self, mode="dist"): """ Saves the prior distribution to a file. """ - raise NotImplementedError + prior = self.get_prior() + if mode == "dist": + return prior + if mode == "file": + prior = self.get_prior() + np.save("prior_mean.npy", prior.mean) + np.save("prior_cov.npy", prior.cov) + else: + raise NotImplementedError diff --git a/src/qp/projectors/projector_moments.py b/src/qp/projectors/projector_moments.py index 5e59b6b9..29357a73 100644 --- a/src/qp/projectors/projector_moments.py +++ b/src/qp/projectors/projector_moments.py @@ -27,8 +27,8 @@ def __init__(self): self._project() @dispatch(np.ndarray, np.ndarray) - def __init__(self, zs, pzs): - self._project_base(zs, pzs) + def __init__(self, zs, nzs): + self._project_base(zs, nzs) self._project() @dispatch(Ensemble) @@ -37,11 +37,10 @@ def __init__(self, ens): self._project() def _project(self): - self.pz_cov = self._get_cov() - self.pz_chol = cholesky(self.pz_cov) + self.nz_chol = self._get_chol() - def _get_cov(self): - cov = np.cov(self.pzs, rowvar=False) + def _get_chol(self): + cov = self.nz_cov if not self._is_pos_def(cov): print('Warning: Covariance matrix is not positive definite') print('The covariance matrix will be regularized') @@ -55,22 +54,23 @@ def _get_cov(self): print('Warning: regularization failed') print('The covariance matrix will be diagonalized') cov = np.diag(np.diag(cov)) - return cov + chol = cholesky(cov) + return chol def _is_pos_def(self, A): return np.all(np.linalg.eigvals(A) > 0) - def evaluate_model(self, pz, alpha): + def evaluate_model(self, nz, alpha): """ Samples a photometric distribution from a Gaussian distribution with mean and covariance measured from the data. """ - z = pz[0] - pz = pz[1] - return [z, pz + self.pz_chol @ alpha] + z = nz[0] + nz = nz[1] + return [z, nz + self.nz_chol @ alpha] def _get_prior(self): - return mvn(np.zeros_like(self.pz_mean), - np.ones_like(self.pz_mean)) + return mvn(np.zeros_like(self.nz_mean), + np.ones_like(self.nz_mean)) diff --git a/src/qp/projectors/projector_shifts.py b/src/qp/projectors/projector_shifts.py index f5514d02..b4c10f61 100644 --- a/src/qp/projectors/projector_shifts.py +++ b/src/qp/projectors/projector_shifts.py @@ -1,23 +1,23 @@ import numpy as np from ..ensemble import Ensemble -from multipledispatch import dispatch from .projector_base import ProjectorBase from scipy.interpolate import interp1d -from scipy.stats import multivariate_normal +from scipy.stats import multivariate_normal as mvn class ProjectorShifts(ProjectorBase): - @dispatch() - def __init__(self): - self._project_base() - self._project() - - @dispatch(np.ndarray, np.ndarray) - def __init__(self, zs, pzs): - self._project_base(zs, pzs) - self._project() - - @dispatch(Ensemble) + """ + Projector for the shifts model. + The shift model assumes that all the variation in the measured + photometric distributions can be described by a single shift in + the position of the mean of a fiducial n(z) distribution. + + This shift is calibrated by computing the standard deviations + of the measured photometric distributions over redshift. + The shift prior is then given by a Gaussian distribution with + mean 0 and variance equal to the ratio of the standard deviation + of the standard deviations to the mean of the standard deviations. + """ def __init__(self, ens): self._project_base(ens) self._project() @@ -25,26 +25,26 @@ def __init__(self, ens): def _project(self): self.shift = self._find_shift() - def evaluate_model(self, pz, shift): + def evaluate_model(self, nz, shift): """ Aplies a shift to the given p(z) distribution. This is done by interpolating the p(z) distribution at the shifted z values and then evaluating it at the original z values. """ - z = pz[0] - pz = pz[1] + z = nz[0] + nz = nz[1] z_shift = z + shift - pz_shift = interp1d(z_shift, pz, + pz_shift = interp1d(z_shift, nz, kind='linear', fill_value='extrapolate')(z) return [z, pz_shift] def _find_shift(self): - stds = np.std(self.pzs, axis=1) # std of each pz + stds = np.std(self.nzs, axis=1) # std of each pz s_stds = np.std(stds) # std of the z-std m_stds = np.mean(stds) # mean of the z-std return s_stds / m_stds def _get_prior(self): - return multivariate_normal([0], [self.shift**2]) + return mvn([0], [self.shift**2]) From 02d03304cdb5625ebd880d0f7c0a40dc4e3495c0 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:16:39 +0100 Subject: [PATCH 06/13] tests --- tests/qp/test_projector_base.py | 26 +++++++------------------- tests/qp/test_projector_moments.py | 12 ++++++------ tests/qp/test_projector_shifts.py | 8 ++++---- 3 files changed, 17 insertions(+), 29 deletions(-) diff --git a/tests/qp/test_projector_base.py b/tests/qp/test_projector_base.py index cc10427e..b3faf9e5 100644 --- a/tests/qp/test_projector_base.py +++ b/tests/qp/test_projector_base.py @@ -5,31 +5,19 @@ def make_qp_ens(file): zs = file['zs'] - pzs = file['pzs'] + nzs = file['pzs'] dz = np.mean(np.diff(zs)) zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) - q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":pzs}) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":nzs}) return q -def test_base_from_qp(): +def test_base(): file = np.load('tests/qp/dummy.npz') ens = make_qp_ens(file) projector = proj.ProjectorBase(ens) - m, n = projector.pzs.shape + m, n = projector.nzs.shape k, = projector.z.shape - pzs = file['pzs'] - pzs /= np.sum(pzs, axis=1)[:, None] + nzs = file['pzs'] + nzs /= np.sum(nzs, axis=1)[:, None] assert n == k - assert np.allclose(projector.pz_mean, np.mean(pzs, axis=0)) - -def test_base_from_arrs(): - file = np.load('tests/qp/dummy.npz') - zs = file['zs'] - pzs = file['pzs'] - projector = proj.ProjectorBase(zs, pzs) - m, n = projector.pzs.shape - k, = projector.z.shape - pzs = file['pzs'] - pzs /= np.sum(pzs, axis=1)[:, None] - assert n == k - assert np.allclose(projector.pz_mean, np.mean(pzs, axis=0)) \ No newline at end of file + assert np.allclose(projector.nz_mean, np.mean(nzs, axis=0)) diff --git a/tests/qp/test_projector_moments.py b/tests/qp/test_projector_moments.py index 60dbe880..6ac7283c 100644 --- a/tests/qp/test_projector_moments.py +++ b/tests/qp/test_projector_moments.py @@ -5,10 +5,10 @@ def make_qp_ens(file): zs = file['zs'] - pzs = file['pzs'] + nzs = file['pzs'] dz = np.mean(np.diff(zs)) zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) - q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":pzs}) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":nzs}) return q @@ -26,14 +26,14 @@ def test_prior(): def test_sample_prior(): projector = make_projector() - pz = projector.sample_prior() - assert len(pz) == len(projector.pz_mean) + nz = projector.sample_prior() + assert len(nz) == len(projector.nz_mean) def test_model(): projector = make_projector() shift = projector.sample_prior() - input = np.array([projector.z, projector.pz_mean]) + input = np.array([projector.z, projector.nz_mean]) output = projector.evaluate_model(input, shift) assert (projector.z == output[0]).all() - assert len(output[1]) == len(projector.pz_mean) + assert len(output[1]) == len(projector.nz_mean) diff --git a/tests/qp/test_projector_shifts.py b/tests/qp/test_projector_shifts.py index 7007a49a..67aae272 100644 --- a/tests/qp/test_projector_shifts.py +++ b/tests/qp/test_projector_shifts.py @@ -5,10 +5,10 @@ def make_qp_ens(file): zs = file['zs'] - pzs = file['pzs'] + nzs = file['pzs'] dz = np.mean(np.diff(zs)) zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) - q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":pzs}) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":nzs}) return q @@ -33,7 +33,7 @@ def test_sample_prior(): def test_model(): projector = make_projector() shift = projector.sample_prior() - input = np.array([projector.z, projector.pz_mean]) + input = np.array([projector.z, projector.nz_mean]) output = projector.evaluate_model(input, shift) assert (projector.z == output[0]).all() - assert len(output[1]) == len(projector.pz_mean) + assert len(output[1]) == len(projector.nz_mean) From 3fd92a58f8558c0015fe9f8e85ae82d532b14045 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:17:01 +0100 Subject: [PATCH 07/13] tests --- tests/qp/test_projector_shifts_widths.py | 39 ++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 tests/qp/test_projector_shifts_widths.py diff --git a/tests/qp/test_projector_shifts_widths.py b/tests/qp/test_projector_shifts_widths.py new file mode 100644 index 00000000..05f8c8b3 --- /dev/null +++ b/tests/qp/test_projector_shifts_widths.py @@ -0,0 +1,39 @@ +import qp +import numpy as np +import qp.projectors as proj + + +def make_qp_ens(file): + zs = file['zs'] + nzs = file['pzs'] + dz = np.mean(np.diff(zs)) + zs_edges = np.append(zs - dz/2, zs[-1] + dz/2) + q = qp.Ensemble(qp.hist, data={"bins":zs_edges, "pdfs":nzs}) + return q + + +def make_projector(): + file = np.load('tests/qp/dummy.npz') + ens = make_qp_ens(file) + return proj.ProjectorShiftsWidths(ens) + + +def test_prior(): + projector = make_projector() + prior = projector.get_prior() + assert prior is not None + + +def test_sample_prior(): + projector = make_projector() + prior_sample = projector.sample_prior() + assert len([prior_sample]) == len([projector.shift, projector.width]) + + +def test_model(): + projector = make_projector() + shift, width = projector.sample_prior() + input = np.array([projector.z, projector.nz_mean]) + output = projector.evaluate_model(input, shift, width) + assert (projector.z == output[0]).all() + assert len(output[1]) == len(projector.nz_mean) From 75395df180dfb987d9958cf72f5e282d88c153cc Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:21:54 +0100 Subject: [PATCH 08/13] forgot to commit --- src/qp/projectors/projector_shifts_widths.py | 72 ++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 src/qp/projectors/projector_shifts_widths.py diff --git a/src/qp/projectors/projector_shifts_widths.py b/src/qp/projectors/projector_shifts_widths.py new file mode 100644 index 00000000..dfa82242 --- /dev/null +++ b/src/qp/projectors/projector_shifts_widths.py @@ -0,0 +1,72 @@ +import numpy as np +from ..ensemble import Ensemble +from ..interp_pdf import interp +from .projector_base import ProjectorBase +from scipy.interpolate import interp1d +from scipy.stats import multivariate_normal as mvn + + +class ProjectorShiftsWidths(ProjectorBase): + """ + Projector for the shifts and widths model. + The shifts and widths model assumes that the variation in the measured + photometric distributions can be captured by varying the mean and the + standard deviation of a fiducial n(z) distribution. + + The calibration method was written by Tilman Tröster. + The shift prior is given by a Gaussian distributiob with zero mean + standard deviation the standard deviation in the mean of + the measured photometric distributions. + The width is calibrated by computing the standard deviations + of the measured photometric distributions over redshift. + The width prior is then given by a Gaussian distribution with + mean 0 and variance equal to the ratio of the standard deviation + of the standard deviations to the mean of the standard deviations. + This is similar to how the shift prior is calibrated in the shift model. + """ + def __init__(self, ens): + self._project_base(ens) + self._project() + + def _project(self): + self.shift = self._find_shift() + self.width = self._find_width() + + def evaluate_model(self, nz, shift, width): + """ + Aplies a shift and a width to the given p(z) distribution. + This is done by evluating the n(z) distribution at + p((z-mu)/width + mu + shift) where mu is the mean redshift + of the fiducial n(z) distribution and the rescaling by the width. + Finally the distribution is normalized. + """ + z = nz[0] + nz = nz[1] + nz_i = interp(xvals=z, yvals=nz) + mu = nz_i.mean().squeeze() + + pdf = nz_i.pdf((z-mu)/width + mu + shift)/width + norm = np.sum(pdf) + return [z, pdf/norm] + + def _find_shift(self): + ms = np.mean(self.nzs, axis=1) # mean of each nz + ms_std = np.std(ms) # std of the means + return ms_std + + def _find_width(self): + stds = np.std(self.nzs, axis=1) + std_std = np.std(stds) + std_mean = np.mean(stds) + width = std_std / std_mean + return width + + def _get_prior(self): + return mvn([0, 1], [self.shift**2, self.width**2], + allow_singular=True) + + def _get_shift_prior(self): + return mvn([0], [self.shift**2]) + + def _get_width_prior(self): + return mvn([1], [self.width**2]) \ No newline at end of file From e70599fb2fcbf130457628c413c69b07ee215086 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:29:50 +0100 Subject: [PATCH 09/13] bug --- nb/priors_example.ipynb | 60 +++++++++--------------- tests/qp/test_projector_shifts_widths.py | 2 +- 2 files changed, 22 insertions(+), 40 deletions(-) diff --git a/nb/priors_example.ipynb b/nb/priors_example.ipynb index b1c018f7..28c6238d 100644 --- a/nb/priors_example.ipynb +++ b/nb/priors_example.ipynb @@ -4,21 +4,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "ename": "SyntaxError", - "evalue": "invalid syntax (projector_shifts_widths.py, line 71)", - "output_type": "error", - "traceback": [ - "Traceback \u001b[0;36m(most recent call last)\u001b[0m:\n", - "\u001b[0m File \u001b[1;32m~/anaconda3/envs/tutorials/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3508\u001b[0m in \u001b[1;35mrun_code\u001b[0m\n exec(code_obj, self.user_global_ns, self.user_ns)\u001b[0m\n", - "\u001b[0m Cell \u001b[1;32mIn[1], line 9\u001b[0m\n import qp\u001b[0m\n", - "\u001b[0m File \u001b[1;32m~/Documents/UCL/qp/src/qp/__init__.py:38\u001b[0m\n from . import projectors\u001b[0m\n", - "\u001b[0;36m File \u001b[0;32m~/Documents/UCL/qp/src/qp/projectors/__init__.py:3\u001b[0;36m\n\u001b[0;31m from .projector_shifts_widths import ProjectorShiftsWidths\u001b[0;36m\n", - "\u001b[0;36m File \u001b[0;32m~/Documents/UCL/qp/src/qp/projectors/projector_shifts_widths.py:71\u001b[0;36m\u001b[0m\n\u001b[0;31m return mvn([1], [self.width**2])S\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "from numpy.linalg import cholesky\n", @@ -40,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -54,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -101,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -110,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -128,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -137,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -178,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -187,25 +173,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "SnW_pzs = []\n", "for i in range(100):\n", - " shift_p = SnW._get_shift_prior()\n", - " width_p = SnW._get_width_prior()\n", - " shift = shift_p.rvs()\n", - " width = width_p.rvs()\n", + " shift, width = SnW.sample_prior()\n", " pz = SnW.evaluate_model(pz_fid, shift, width)[1]\n", " SnW_pzs.append(pz)\n", - "SnW_pzs = np.array(SnW_pzs)\n", - "#SnW_pzs = base._normalize(SnW_pzs)" + "SnW_pzs = np.array(SnW_pzs)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -214,12 +196,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -254,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -274,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -283,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -292,12 +274,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/tests/qp/test_projector_shifts_widths.py b/tests/qp/test_projector_shifts_widths.py index 05f8c8b3..644cc862 100644 --- a/tests/qp/test_projector_shifts_widths.py +++ b/tests/qp/test_projector_shifts_widths.py @@ -27,7 +27,7 @@ def test_prior(): def test_sample_prior(): projector = make_projector() prior_sample = projector.sample_prior() - assert len([prior_sample]) == len([projector.shift, projector.width]) + assert len(prior_sample) == len([projector.shift, projector.width]) def test_model(): From 8e8b2e7f9513dcfd2199c3022418ff3db16e3e81 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:45:18 +0100 Subject: [PATCH 10/13] no reqs --- requirements.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/requirements.txt b/requirements.txt index ee5280c7..773f4b85 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,5 +4,4 @@ scipy>=1.9.0 scikit-learn setuptools_scm tables-io[full] -deprecated -multipledispatch +deprecated \ No newline at end of file From d3601bfecab8563e3b9d1a63395c4a8139d368c3 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:46:35 +0100 Subject: [PATCH 11/13] no reqs --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 773f4b85..25bd9b93 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,4 @@ scipy>=1.9.0 scikit-learn setuptools_scm tables-io[full] -deprecated \ No newline at end of file +deprecated From e979fdba297c559e41916ece341c76f946171e84 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:48:41 +0100 Subject: [PATCH 12/13] no multiple dispatch --- src/qp/projectors/projector_moments.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qp/projectors/projector_moments.py b/src/qp/projectors/projector_moments.py index 29357a73..e8030bb4 100644 --- a/src/qp/projectors/projector_moments.py +++ b/src/qp/projectors/projector_moments.py @@ -1,6 +1,5 @@ import numpy as np from ..ensemble import Ensemble -from multipledispatch import dispatch from .projector_base import ProjectorBase from numpy.linalg import eig, cholesky from scipy.stats import multivariate_normal as mvn From be1856193e49370434cc52d95642a71596647b90 Mon Sep 17 00:00:00 2001 From: jaimerzp Date: Mon, 17 Jun 2024 17:53:31 +0100 Subject: [PATCH 13/13] dispatch still present --- src/qp/projectors/projector_moments.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/qp/projectors/projector_moments.py b/src/qp/projectors/projector_moments.py index e8030bb4..7ce0fb23 100644 --- a/src/qp/projectors/projector_moments.py +++ b/src/qp/projectors/projector_moments.py @@ -20,17 +20,6 @@ class ProjectorMoments(ProjectorBase): to its eigen-values. If this fails, the covariance matrix will be diagonalized. """ - @dispatch() - def __init__(self): - self._project_base() - self._project() - - @dispatch(np.ndarray, np.ndarray) - def __init__(self, zs, nzs): - self._project_base(zs, nzs) - self._project() - - @dispatch(Ensemble) def __init__(self, ens): self._project_base(ens) self._project() @@ -72,4 +61,3 @@ def evaluate_model(self, nz, alpha): def _get_prior(self): return mvn(np.zeros_like(self.nz_mean), np.ones_like(self.nz_mean)) -