├── 1. Hermite polynomials.ipynb ├── 10. Quantum Hadrodynamics.ipynb ├── 11.1 The Semi-Empirical mass formula.ipynb ├── 12. Alpha decay.ipynb ├── 2. Schrödinger equation.ipynb ├── 3. Rutherford Scattering.ipynb ├── 4. Legendre polynomials.py ├── 5. Associated Legendre polynomials.py ├── 6. Spherical harmonics Q2.py ├── 6. Spherical harmonics.py ├── 7.2 Anisotropic harmonic oscillator Fig 6.py ├── 7.2 Anisotropic harmonic oscillator Fig 7.py ├── 7.3 Nilsson Model - Cranking Model.ipynb ├── 7.3 Nilsson model.ipynb ├── 8. Pairing correlations.ipynb ├── 9. Hot Nuclei.ipynb ├── Hot and rotating nuclei.pdf ├── Notes.pdf ├── PHN-624 ETE Manish Prasad 18122012.ipynb ├── README.md ├── Time Dependent Schrödinger Equation Notes.pdf ├── Time Dependent Schrödinger Equation.py └── nuclear_data.csv /1. Hermite polynomials.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Exercise 1" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import numpy as np\n", 17 | "import math" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "# Constants\n", 27 | "pi=4*math.atan(1.0)" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 3, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "# Integration subroutines\n", 37 | "# Simpson's rule\n", 38 | "def simpInt(h, fnc):\n", 39 | "\tI = (fnc[0] + fnc[len(fnc)-1])\n", 40 | "\tfor i in range(1,len(fnc)-2,2):\n", 41 | "\t\tI = I + 4*fnc[i] + 2*fnc[i+1]\n", 42 | "\tI = I + 4*fnc[i+2]\n", 43 | "\tI = I*h/3\n", 44 | "\treturn I" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 4, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "# Hermite Subroutine calculates till Hn(x)\n", 54 | "def hermite(x,n):\n", 55 | " H=[1,2*x]\n", 56 | " for i in range(1,n):\n", 57 | " H.append(2*x*H[i]-2*i*H[i-1])\n", 58 | " return H" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 5, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "# Coefficient subroutine calculates till N_n\n", 68 | "def N_coeff(n): \n", 69 | " factorial=fact(n)\n", 70 | " N_c=[]\n", 71 | " a=math.sqrt(math.sqrt(pi))\n", 72 | " for i in range(len(factorial)):\n", 73 | " N_c.append(1/(a*math.sqrt((math.pow(2,i))*factorial[i])))\n", 74 | " return N_c" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 6, 80 | "metadata": {}, 81 | "outputs": [ 82 | { 83 | "name": "stdout", 84 | "output_type": "stream", 85 | "text": [ 86 | "[1, 1, 2, 6, 24, 120]\n" 87 | ] 88 | } 89 | ], 90 | "source": [ 91 | "# Q2. Factorial Subroutine\n", 92 | "# On input \"N\" gives an array of factorials till factorial of N\n", 93 | "def fact(N):\n", 94 | " fct=[1,1]\n", 95 | " for i in range(1,N):\n", 96 | " fct.append((i+1)*fct[i])\n", 97 | " return fct \n", 98 | "print(fact(5))" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 7, 104 | "metadata": {}, 105 | "outputs": [ 106 | { 107 | "name": "stdout", 108 | "output_type": "stream", 109 | "text": [ 110 | "LHS:\n", 111 | "5.70028543785625e-17\n", 112 | "RHS:\n", 113 | "-0.8862269254527579\n" 114 | ] 115 | } 116 | ], 117 | "source": [ 118 | "# Q3.\n", 119 | "def func(x):\n", 120 | "\treturn ((x*x-1)*np.exp(-(x*x)/2))\n", 121 | "vfunc = np.vectorize(func)\n", 122 | "x= np.linspace(-20,20,2001)\n", 123 | "h = x[1]-x[0]\n", 124 | "I=simpInt(h,vfunc(x))\n", 125 | "print(\"LHS:\")\n", 126 | "print(I)\n", 127 | "print(\"RHS:\")\n", 128 | "print(-np.sqrt(pi)/2)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 8, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "-7.670429459684071e-17\n", 141 | "0.24999999999999448\n", 142 | "1.2499999999999727\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "# Q4).\n", 148 | "x=np.linspace(-20,20,2001)\n", 149 | "h=x[1]-x[0]\n", 150 | "\n", 151 | "# subroutine for calculating psi\n", 152 | "def psi(x,N):\n", 153 | " N_c=N_coeff(N)\n", 154 | " psi=[]\n", 155 | " for i in x:\n", 156 | " psi_i=[]\n", 157 | " H=hermite(i,N)\n", 158 | " for j in range(N+1):\n", 159 | " psi_i.append(N_c[j]*(np.exp(-(i*i)/2))*H[j])\n", 160 | " psi.append(psi_i)\n", 161 | " return np.reshape(np.array(psi),(len(x),N+1))\n", 162 | "\n", 163 | "# subroutine for calculating psi_2\n", 164 | "def psi_2(Psi,x):\n", 165 | " rt_8=np.sqrt(8)\n", 166 | " Psi_2=np.zeros(Psi.shape,dtype=float)\n", 167 | " Psi_2[:,0]=np.multiply((np.multiply(x,x)-1),Psi[:,0])\n", 168 | " Psi_2[:,1]=-(rt_8)*np.multiply(x,Psi[:,0])+np.multiply((np.multiply(x,x)-1),Psi[:,1])\n", 169 | " for i in range(2,Psi.shape[1]):\n", 170 | " Psi_2[:,i]=(2*(np.sqrt(i*(i-1)))*Psi[:,i-2])-(rt_8)*(np.sqrt(i))*(np.multiply(x,Psi[:,i-1]))+(np.multiply((np.multiply(x,x)-1),Psi[:,i]))\n", 171 | " return Psi_2\n", 172 | " \n", 173 | "# Calculating psi\n", 174 | "Psi=psi(x,4)\n", 175 | "\n", 176 | "# A)\n", 177 | "m=3\n", 178 | "n=2\n", 179 | "psi_m=Psi[:,m]\n", 180 | "psi_n=Psi[:,n]\n", 181 | "y=np.multiply(psi_m,psi_n)\n", 182 | "print(simpInt(h,y))\n", 183 | "\n", 184 | "\n", 185 | "# B)\n", 186 | "m=0\n", 187 | "Psi_m=Psi[:,m]\n", 188 | "VPsi_m=0.5*np.multiply(np.multiply(x,x),Psi_m)\n", 189 | "y=np.multiply(Psi_m,VPsi_m)\n", 190 | "print(simpInt(h,y))\n", 191 | "\n", 192 | "\n", 193 | "# C)\n", 194 | "m=2\n", 195 | "KPsi=-(0.5)*psi_2(Psi,x)\n", 196 | "KPsi_m=KPsi[:,m]\n", 197 | "Psi_m=Psi[:,m]\n", 198 | "y=np.multiply(Psi_m,KPsi_m)\n", 199 | "print(simpInt(h,y))" 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": 9, 205 | "metadata": {}, 206 | "outputs": [ 207 | { 208 | "name": "stdout", 209 | "output_type": "stream", 210 | "text": [ 211 | "Expectation value matrix of V:\n", 212 | "[[ 2.50000000e-01 2.73174209e-17 3.53553391e-01 -3.71459292e-17\n", 213 | " -2.43299468e-17]\n", 214 | " [ 2.73405435e-17 7.50000000e-01 -7.77797477e-17 6.12372436e-01\n", 215 | " -4.97486634e-17]\n", 216 | " [ 3.53553391e-01 -7.78261032e-17 1.25000000e+00 -7.19797751e-17\n", 217 | " 8.66025404e-01]\n", 218 | " [-3.85806800e-17 6.12372436e-01 -7.19723212e-17 1.75000000e+00\n", 219 | " -1.71793537e-16]\n", 220 | " [-2.26125798e-17 -2.36227477e-18 8.66025404e-01 -2.30704824e-16\n", 221 | " 2.25000000e+00]]\n", 222 | "Expectation value matrix of K:\n", 223 | "[[ 2.50000000e-01 -3.61962315e-17 -3.53553391e-01 -6.82632663e-17\n", 224 | " -3.43595056e-16]\n", 225 | " [-2.39612026e-17 7.50000000e-01 1.91299491e-17 -6.12372436e-01\n", 226 | " -1.19963032e-16]\n", 227 | " [-3.53553391e-01 -4.01103687e-18 1.25000000e+00 -8.05526355e-17\n", 228 | " -8.66025404e-01]\n", 229 | " [ 1.97456739e-17 -6.12372436e-01 1.99311702e-18 1.75000000e+00\n", 230 | " -6.72878423e-17]\n", 231 | " [-4.62817730e-17 1.39735262e-16 -8.66025404e-01 3.87768503e-17\n", 232 | " 2.25000000e+00]]\n", 233 | "Expectation value matrix of Hamiltonian:\n", 234 | "[[ 5.00000000e-01 1.04210471e-16 -4.46275480e-17 5.43388915e-17\n", 235 | " -3.18558223e-16]\n", 236 | " [-6.16663095e-17 1.50000000e+00 -4.83451748e-17 3.28393768e-16\n", 237 | " 7.30549588e-17]\n", 238 | " [-5.07559283e-17 7.13623714e-17 2.50000000e+00 -3.90411885e-17\n", 239 | " 9.53161955e-16]\n", 240 | " [-3.21645478e-17 -1.17304807e-16 -1.32659874e-16 3.50000000e+00\n", 241 | " 3.38780956e-16]\n", 242 | " [-1.34034360e-17 2.16678257e-17 1.50010233e-16 -4.06106350e-16\n", 243 | " 4.50000000e+00]]\n" 244 | ] 245 | } 246 | ], 247 | "source": [ 248 | "# Q5).\n", 249 | "# Potential Expectation\n", 250 | "V_ev=np.zeros((Psi.shape[1],Psi.shape[1]),dtype=float)\n", 251 | "for i in range(Psi.shape[1]):\n", 252 | " for j in range(Psi.shape[1]):\n", 253 | " VPsi_j=0.5*np.multiply(np.multiply(x,x),Psi[:,j])\n", 254 | " V_ev[i,j]=simpInt(h,np.multiply(Psi[:,i],VPsi_j))\n", 255 | "print(\"Expectation value matrix of V:\")\n", 256 | "print(V_ev)\n", 257 | " \n", 258 | " \n", 259 | "# Kinetic Expectation \n", 260 | "KPsi=-0.5*psi_2(Psi,x)\n", 261 | "K_ev=np.zeros((Psi.shape[1],Psi.shape[1]),dtype=float)\n", 262 | "for i in range(Psi.shape[1]):\n", 263 | " for j in range(Psi.shape[1]):\n", 264 | " K_ev[i,j]=simpInt(h,np.multiply(Psi[:,i],KPsi[:,j]))\n", 265 | "print(\"Expectation value matrix of K:\")\n", 266 | "print(K_ev)\n", 267 | "\n", 268 | "\n", 269 | "# Total Energy Expectation\n", 270 | "Hamil_ev=np.zeros((Psi.shape[1],Psi.shape[1]),dtype=float)\n", 271 | "for i in range(Psi.shape[1]):\n", 272 | " for j in range(Psi.shape[1]):\n", 273 | " VPsi_j = 0.5*np.multiply(np.multiply(x,x),Psi[:,j])\n", 274 | " Hamil_ev[i,j]=simpInt(h,np.multiply(Psi[:,i],KPsi[:,j]+VPsi_j))\n", 275 | "print(\"Expectation value matrix of Hamiltonian:\")\n", 276 | "print(Hamil_ev)" 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": 10, 282 | "metadata": {}, 283 | "outputs": [ 284 | { 285 | "name": "stdout", 286 | "output_type": "stream", 287 | "text": [ 288 | "2.2494875537468713\n", 289 | "Expectation value matrix of K:\n", 290 | "[[ 2.49987500e-01 9.41436603e-15 -3.53518037e-01 8.31547064e-16\n", 291 | " -2.04103734e-05]\n", 292 | " [ 6.75902226e-16 7.49937503e-01 5.30034312e-15 -6.12270381e-01\n", 293 | " -3.28313325e-15]\n", 294 | " [-3.53518037e-01 6.31501405e-15 1.24983751e+00 -1.35697318e-15\n", 295 | " -8.65823350e-01]\n", 296 | " [-1.77681685e-15 -6.12270381e-01 7.26374436e-17 1.74968753e+00\n", 297 | " 1.80573026e-14]\n", 298 | " [-2.04103734e-05 -3.71106428e-15 -8.65823350e-01 2.14324234e-14\n", 299 | " 2.24948755e+00]]\n" 300 | ] 301 | } 302 | ], 303 | "source": [ 304 | "# Q6.\n", 305 | "# subroutine for calculating double derivative numerically\n", 306 | "def psi_2num(Psi,h):\n", 307 | " Psi_2=np.zeros(Psi.shape,dtype=float)\n", 308 | " h2=h*h\n", 309 | " for i in range(Psi.shape[1]):\n", 310 | " for j in range(1,Psi.shape[0]-1):\n", 311 | " d=(Psi[j+1,i]-2*Psi[j,i]+Psi[j-1,i])/h2\n", 312 | " Psi_2[j,i]=d\n", 313 | " Psi_2[0,i]=Psi_2[1,i]\n", 314 | " Psi_2[Psi.shape[0]-1,i]=Psi_2[Psi.shape[0]-2,i]\n", 315 | " return Psi_2\n", 316 | "\n", 317 | "# Calculating K*Psi\n", 318 | "KPsi_num=-(0.5)*psi_2num(Psi,h)\n", 319 | "\n", 320 | "\n", 321 | "# 4)B\n", 322 | "m=4\n", 323 | "KPsi_m=KPsi_num[:,m]\n", 324 | "Psi_m=Psi[:,m]\n", 325 | "y=np.multiply(Psi_m,KPsi_m)\n", 326 | "print(simpInt(h,y))\n", 327 | "\n", 328 | "\n", 329 | "# 5)\n", 330 | "K_ev=np.zeros((Psi.shape[1],Psi.shape[1]),dtype=float)\n", 331 | "for i in range(Psi.shape[1]):\n", 332 | " for j in range(Psi.shape[1]):\n", 333 | " K_ev[i,j]=simpInt(h,np.multiply(Psi[:,i],KPsi_num[:,j]))\n", 334 | "print(\"Expectation value matrix of K:\")\n", 335 | "print(K_ev)\n" 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": 11, 341 | "metadata": {}, 342 | "outputs": [ 343 | { 344 | "name": "stdout", 345 | "output_type": "stream", 346 | "text": [ 347 | "Expectation value matrix of Hamiltonian:\n", 348 | "[[-2.86287694e+00 5.42369166e-04 -3.53011994e-01 4.40474868e-04\n", 349 | " 3.09266068e-04]\n", 350 | " [ 5.42369166e-04 -2.36211129e+00 1.52995068e-03 -6.10816177e-01\n", 351 | " 1.31222162e-03]\n", 352 | " [-3.53011994e-01 1.52995068e-03 -1.86058810e+00 3.41809810e-03\n", 353 | " -8.62530376e-01]\n", 354 | " [ 4.40474868e-04 -6.10816177e-01 3.41809810e-03 -1.35782307e+00\n", 355 | " 6.75817028e-03]\n", 356 | " [ 3.09266068e-04 1.31222162e-03 -8.62530376e-01 6.75817028e-03\n", 357 | " -8.53127817e-01]]\n" 358 | ] 359 | } 360 | ], 361 | "source": [ 362 | "# Q7). Wood-Saxon Potential\n", 363 | "Hamil_ev2=np.zeros((Psi.shape[1],Psi.shape[1]),dtype=float)\n", 364 | "A=100\n", 365 | "# 41A^(-1/3) MeV = 1 natural unit\n", 366 | "# -55 MeV = -(55/41)*A^(1/3) natural unit\n", 367 | "V0=-(55/41)*(math.pow(A,1/3))\n", 368 | "for i in range(Psi.shape[1]):\n", 369 | " for j in range(Psi.shape[1]):\n", 370 | " VwPsi_j = 0.5*np.multiply(V0/(1+np.exp(2*(x-5))),Psi[:,j])\n", 371 | " Hamil_ev2[i,j]=simpInt(h,np.multiply(Psi[:,i],KPsi[:,j]+VwPsi_j))\n", 372 | "print(\"Expectation value matrix of Hamiltonian:\")\n", 373 | "print(Hamil_ev2)" 374 | ] 375 | } 376 | ], 377 | "metadata": { 378 | "interpreter": { 379 | "hash": "31e9a9fdb727f4cab00c9bb2df7901a2e872a4cc83935cdcfda541b216adb23e" 380 | }, 381 | "kernelspec": { 382 | "display_name": "Python 3.9.7 64-bit", 383 | "language": "python", 384 | "name": "python3" 385 | }, 386 | "language_info": { 387 | "codemirror_mode": { 388 | "name": "ipython", 389 | "version": 3 390 | }, 391 | "file_extension": ".py", 392 | "mimetype": "text/x-python", 393 | "name": "python", 394 | "nbconvert_exporter": "python", 395 | "pygments_lexer": "ipython3", 396 | "version": "3.9.7" 397 | } 398 | }, 399 | "nbformat": 4, 400 | "nbformat_minor": 2 401 | } 402 | -------------------------------------------------------------------------------- /11.1 The Semi-Empirical mass formula.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "95d93c22", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import matplotlib.pyplot as plt\n", 11 | "import pandas as pd\n", 12 | "import numpy as np" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 2, 18 | "id": "c8e2fac2", 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "def secant(f, x0):\n", 23 | " flag = 1\n", 24 | " h = 0.01\n", 25 | " x1 = x0\n", 26 | " f1 = f(x1)\n", 27 | " x2 = x1 + x1*h\n", 28 | " f2 = f(x2)\n", 29 | " for i in range(1000):\n", 30 | " x = x2 - f2*(x2-x1)/(f2-f1)\n", 31 | " if abs(x-x2)<0.001:\n", 32 | " flag = 0\n", 33 | " break\n", 34 | " x1 = x2\n", 35 | " if(x<0):\n", 36 | " x = 0.1\n", 37 | " x2 = x\n", 38 | " f1 = f(x1)\n", 39 | " f2 = f(x2)\n", 40 | " if abs(flag-1)<0.001:\n", 41 | " print('No Convergence')\n", 42 | " x = 0\n", 43 | " return x" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "id": "6436fa67", 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "data = pd.read_csv('nuclear_data.csv')\n", 54 | "data['a'] = data['n']+data['z']\n", 55 | "data['be/a(keV)'] = data['bindingEnergy(keV)']\n", 56 | "data['be(MeV)'] = data['be/a(keV)']*data['a']*(10**(-3))\n", 57 | "data.drop('bindingEnergy(keV)',axis = 1,inplace = True)\n", 58 | "data = data[(data.a%2!=0)]\n", 59 | "\n", 60 | "A = data['a']\n", 61 | "N = data['n']\n", 62 | "Z = data['z']\n", 63 | "y = data['be(MeV)']" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 4, 69 | "id": "1b8411da", 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "name": "stdout", 74 | "output_type": "stream", 75 | "text": [ 76 | "15.170737926298017 15.656162687069349 0.6830801465619543 44.37887392399462\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "a11 = (-A**2).sum() \n", 82 | "a12 = (A**(5/3)).sum() \n", 83 | "a13 = ((Z**2)*(A**(2/3))).sum() \n", 84 | "a14 = (((N-Z)**2)/2).sum() \n", 85 | "a21 = (-A**(5/3)).sum() \n", 86 | "a22 = (A**(4/3)).sum() \n", 87 | "a23 = ((Z**2)*(A**(1/3))).sum() \n", 88 | "a24 = (((N-Z)**2)/(2*(A**(1/3)))).sum() \n", 89 | "a31 = (-(Z**2)*(A**(2/3))).sum() \n", 90 | "a32 = ((Z**2)*(A**(1/3))).sum() \n", 91 | "a33 = ((Z**4)/(A**(2/3))).sum() \n", 92 | "a34 = ((Z**2)*((N-Z)**2)/(2*(A**(4/3)))).sum() \n", 93 | "a41 = (-((N-Z)**2)).sum() \n", 94 | "a42 = (((N-Z)**2)/(A**(1/3))).sum() \n", 95 | "a43 = ((Z**2)*((N-Z)**2)/(A**(4/3))).sum() \n", 96 | "a44 = (((N-Z)**4)/(2*(A**2))).sum() \n", 97 | "\n", 98 | "b1 = (-y*A).sum()\n", 99 | "b2 = (-y*(A**(2/3))).sum()\n", 100 | "b3 = (-y*(Z**2)/(A**(1/3))).sum()\n", 101 | "b4 = (-y*((N-Z)**2)/A).sum()\n", 102 | "\n", 103 | "arr1 = np.array([[a11, a12, a13, a14], [a21, a22, a23, a24], [a31, a32, a33, a34], [a41, a42, a43, a44]])\n", 104 | "arr2 = np.array([b1, b2, b3, b4])\n", 105 | "[av, ass, ac, asym] = np.linalg.solve(arr1, arr2)\n", 106 | "print(av, ass, ac, asym)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 5, 112 | "id": "9c6c0c22", 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "av = 15.8\n", 117 | "ass = 18.3\n", 118 | "ac = 0.714\n", 119 | "asym = 2*23.2\n", 120 | "Mn = 939.565420\n", 121 | "Mh = 938.272088\n", 122 | "N_list = range(1,201)\n", 123 | "Zproton = []\n", 124 | "Zbeta = []\n", 125 | "Zneutron = []\n", 126 | "for N in N_list:\n", 127 | " def f(Z):\n", 128 | " A = N+Z\n", 129 | " return N-Z-(ac*(A**(2/3))-(Mn-Mh))/(2*asym/A+ac/(A**(1/3)))\n", 130 | " Zbeta.append(int(secant(f,N)))\n", 131 | " def g(Z):\n", 132 | " A = N+Z\n", 133 | " beta = 2*ac*(A**(2/3))/(ac*(A**(2/3))+6*asym)\n", 134 | " gamma = (av+3*asym/2-2*ass*(A**(-1/3))/3)/(ac*(A**(2/3))/3+2*asym)\n", 135 | " return Z**2-2*Z*A*(1+beta)+gamma*(A**2)\n", 136 | " Zproton.append(int(secant(g,N)))\n", 137 | " def h(Z):\n", 138 | " A = N+Z\n", 139 | " alpha = (av+3*asym/2-2*ass/(3*(A**(1/3)))+ac*(A**(2/3))/3)/(ac*(A**(2/3))/3+2*asym)\n", 140 | " return N**2-2*N*A+alpha*(A**2)\n", 141 | " Zneutron.append(int(secant(h,N)))" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": 6, 147 | "id": "cce9b3e5", 148 | "metadata": {}, 149 | "outputs": [ 150 | { 151 | "data": { 152 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfQAAAFzCAYAAADIY/vqAAAAO3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMGIxLCBodHRwczovL21hdHBsb3RsaWIub3JnLwiMSToAAAAJcEhZcwAACxMAAAsTAQCanBgAAGMzSURBVHic7d13eBTV28bx74EEErpUEQQEKSIg8EOqIIhi6L2odBSkKUUQUAEVBaSqNCnSe0dK6An9pUlv0nsLJbT08/5xNiSUQAjZnd3N87muXGQmm51nWcidmTnnOUprjRBCCCFcWyKrCxBCCCHEy5NAF0IIIdyABLoQQgjhBiTQhRBCCDcggS6EEEK4AQl0IYQQwg14WF3Ay0ifPr3OkSOH1WUIIYQQDrNr167rWusMj+936UDPkSMHO3futLoMIYQQwmGUUmeetl8uuQshhBBuQAJdCCGEcAMS6EIIIYQbcOl76E8TGhrK+fPnCQoKsroUEc+8vLzImjUrnp6eVpcihBBOx+0C/fz586RMmZIcOXKglLK6HBFPtNYEBARw/vx53njjDavLEUIIp+N2l9yDgoJIly6dhLmbUUqRLl06ufIihBAxcLtAByTM3ZS8r0IIETO3DHSrJU6cmMKFC1OgQAHq16/P/fv3Y/29e/bsYfny5Xapa9KkSXTo0OGpX1uyZAkDBgyI9XOdPn2aAgUKALBz506++uqreKlRCCFE3Eig24G3tzd79uzhwIEDJEmShDFjxjzy9bCwsBi/156BHpOwsDBq1KhBjx494vT9xYoV448//ojnqoQQQrwICXQ7K1u2LMePH8fPz4+yZctSo0YN8ufPT1BQEC1atKBgwYIUKVKE9evXExISQu/evZk9ezaFCxdm9uzZ3Lhxg1q1alGoUCFKlizJvn37AOjbty8tW7akfPny5MyZM8ZAnThxInny5KF48eJs3rz54f7mzZvz5ZdfUqJECbp37/7I2Xvk14oVK0aePHlYunTpM1+jn58f1apVe25d06ZNo3jx4hQuXJg2bdoQHh7+Un+3QgghorjdKPfoOnWCPXvi9zkLF4bhw2P32LCwMFasWIGPjw8Au3fv5sCBA7zxxhsMGTIEpRT79+/nyJEjVKpUiWPHjvHTTz+xc+dORowYAUDHjh0pUqQIixYtYt26dTRt2pQ9thd15MgR1q9fz507d8ibNy9t27Z9ZErXpUuX6NOnD7t27SJ16tRUqFCBIkWKPPz6+fPn2bJlC4kTJ2bSpEmP1H769Gm2b9/OiRMnqFChAsePH8fLyytWr/tpdR0/fpzZs2ezefNmPD09adeuHdOnT6dp06ax+8sUQgjxTG4d6FZ58OABhQsXBswZeqtWrdiyZQvFixd/OOVq06ZNdOzYEYB8+fKRPXt2jh079sRzbdq0ifnz5wPwwQcfEBAQQGBgIABVq1YladKkJE2alIwZM3LlyhWyZs368Hv/7//+j/Lly5Mhg+nh37Bhw0eOUb9+fRInTvzU19CgQQMSJUpE7ty5yZkzJ0eOHHn4mp7naXWtXbuWXbt28e677z78O8qYMWOsnk8IIVxJUBBs3AiRd1c//BAc0T7DrQM9tmfS8S3yHvrjkidPHq/HSZo06cPPEydO/Mx780/zrHoeH1H+IiPMn1aX1ppmzZrRv3//F6pRCCFcSXAwVK4Mfn5R+27dgtSp7X9suYdukbJlyzJ9+nQAjh07xtmzZ8mbNy8pU6bkzp07T32cn58f6dOnJ1WqVLE6RokSJfD39ycgIIDQ0FDmzp0b6/rmzp1LREQEJ06c4OTJk+TNm/cFXt2TKlasyLx587h69SoAN27c4MyZpy4YJIQQLikiAlq0MGH+55+wbZv5iOdzuRi59Rm6M2vXrh1t27alYMGCeHh4MGnSJJImTUqFChUYMGAAhQsXpmfPng8HmRUqVIhkyZIxefLkWB8jc+bM9O3bl1KlSpEmTZpYXzIHyJYtG8WLFycwMJAxY8bE+v55TPLnz0+/fv2oVKkSEREReHp6MnLkSLJnz/5SzyuEEFbSGrp1gz/+gPBwE+r9+0MMM4TtSmmtHX/UeFKsWDH9+Hrohw8f5q233rKoIvfQvHlzqlWrRr169awu5Qny/gohnMmAAdCzJ9SrB3nzQp480KQJ2LMPllJql9a62OP75QxdCCGEeAHz5sG0aRAaCsuXwyefmO1EFt/ElkAXT3h8CpsQQghj6VJo2BCyZIG0aaFZM/jrL+vDHCTQhRBCiKc6fBii9ePi3j1zeb1IETPwLUUKy0p7Kgl0IYQQ4jH//gvlysHdu4/uz50bli1zvjAHCXQhhBACMPfEb9yAq1ehShV45RXYuhXSpIl6TMaMkCSJZSU+kwS6EEKIBO/KFXj/fTh61GynSQNr10L+/JaW9UKc4Da++1FK0bVr14fbgwcPpm/fvnF6rlu3bjFq1Kh4quzZoi+y8ri4LJGawnZN6uLFi045BU4IIcBcVq9WDc6ehcGDYdQo0xDGlcIcJNDtImnSpCxYsIDr16+/9HM9K9BftNVrXIWFhb3UEqmvvfYa8+bNi+eqhBAi7kJC4PPP4d13oWBB2L0bZs+Grl2hbVszp9zVSKDbgYeHB61bt2bYsGFPfO3atWvUrVuXd999l3fffffhkqZ9+/Zl8ODBDx9XoEABTp8+TY8ePThx4gSFCxemW7dusVqGFczUszp16uDj40Pu3Lnp3r37U2v19fUlX758FC1alAULFjzc37dvX5o0aUKZMmVo0qTJE0ukNmnShFKlSpE7d27GjRv3zL+P06dPU6BAgefWtWrVKkqVKkXRokWpX78+dx8fjSKEEPEgskXrhAnmPnn+/DBzJlSvbnVlL8e976FbuH5q+/btKVSo0BNB+vXXX9O5c2fee+89zp49y8cff8zhw4djfJ4BAwZw4MCBh4u9+Pn5xWoZVoA9e/bw77//kjRpUvLmzUvHjh15/fXXHz53UFAQX3zxBevWrePNN9+kYcOGjxz70KFDbNq0CW9vb/yirzQA7Nu3j23btnHv3j2KFClC1apVee2115779xJTXd7e3vTr1481a9aQPHlyBg4cyNChQ+ndu3esnlMIIZ5FaxPax4+b6WizZsGvv5ppaO7CvQPdQqlSpaJp06b88ccfeHt7P9y/Zs0aDh069HA7MDDwhc9EY7sMa8WKFUltW+Inf/78nDlz5pFAP3LkCG+88Qa5c+cGoHHjxowdO/bh12vUqPFI7dHVrFkTb29vvL29qVChAtu3b6dWrVqxqv9pdd26dYtDhw5RpkwZAEJCQihVqlRs/0qEEOKZfvsNevQwnysFXbpEbbsL9w50q9ZPtenUqRNFixalRYsWD/dFRESwbdu2JxY78fDwICIi4uF2UFBQjM8b22VYXW151Y8++oiZM2e+UI1CCPG4c+fg2rWo7W3bTHg3bBjVotUZOrvFNzd8Sc4jbdq0NGjQgAkTJjzcV6lSJf7888+H25GX0nPkyMHu3bsB2L17N6dOnQJ4YjnVx8W0DGts5MuXj9OnT3PixAmAFwrTxYsXExQUREBAAH5+frz77rux/t6nKVmyJJs3b+b48eMA3Lt37+GVBiGEiK358yFHDvjf/6I+2reH8uVh8mTw8HDPMAcJdLvr2rXrI6Pd//jjD3bu3EmhQoXInz8/Y8aMAaBu3brcuHGDt99+mxEjRpAnTx4A0qVLR5kyZShQoADdunV74vnbtWtHREQEBQsWpGHDhg+XYY0NLy8vxo4dS9WqVSlatCgZM2aM9esqVKgQFSpUoGTJkvzwww+xvn8ekwwZMjBp0iQ++eQTChUqRKlSpThy5MhLPacQImHZtAk++wxKloTFi6M+li0zi6jE8kejy7Lb8qlKqb+BasBVrXUB275BQHUgBDgBtNBa37J9rSfQCggHvtJar3zeMWT5VGv07duXFClS8M033zj82PL+CiGi27PHLFd64wYEBJiz882bIV06qyuzn5iWT7XnGfokwOexfauBAlrrQsAxoKetuPxAI+Bt2/eMUkoltmNtQgghXNyZM6ZF682b5s/WrWHlSvcO82ex26A4rfUGpVSOx/atira5DYhsH1YTmKW1DgZOKaWOA8WBrfaqT8RdXLveCSHEy7p2DQYOhDt3YN06uH/fnJG//bbVlVnPylHuLYHZts+zYAI+0nnbvicopVoDrQGyZctmz/qEEEI4kXv3oGpVsxJa+vSQMqW5Ry5hblgS6Eqp74AwYPqLfq/WeiwwFsw99HguTQghhBMJCzNrjz94AKNHw65dsGiR63d1sweHB7pSqjlmsFxFHTUi7wLwerSHZbXtE0IIkUBFREDz5jA92qnfmDES5jFxaKArpXyA7sD7Wuv70b60BJihlBoKvAbkBrY7sjYhhBDOpVcvE+bffw+1apm+6zlzWl2V87LbKHel1EzMoLa8SqnzSqlWwAggJbBaKbVHKTUGQGt9EJgDHAJ8gfZa63B71WZviRMnpnDhwrzzzjsULVqULVu2PPPx8blE6qRJk7h48eJzH1e+fHken/IHsGTJEgYMGAA8umBM7969WbNmDQDDhw/n/v37T3yvEELEVf/+pumLUlEfAwealc9++sk0iHH2MO/ZsyeJEiVCKfXIx+3btx1yfHuOcv/kKbsnPGVf5ON/AX6xVz2O5O3t/bAD3MqVK+nZsyf+/v4xPj4y0Nu1a/fSx540aRIFChSIc6OXGjVqUKNGjSf2//TTTw8/Hz58OI0bNyZZsmRxrlMIISKNH2/OxqtWhWLRZldnymSmor1AZ2nLDBs2jAEDBlC3bt2Hq0tGim2zr5fl3r3cnUBgYCCvvPLKw+1BgwYxZ84cgoODqV27Nj/++OMjS6R+9NFH9OnTh5o1a3Lz5k1CQ0Pp168fNWvWfOR5w8PDadWqFTt37kQpRcuWLXn99dfZuXMnn332Gd7e3mzdupVBgwbxzz//8ODBA0qXLs1ff/31sO/61KlT+fzzzwkLC+Pvv/+mePHiTJo0iZ07dzJixIhHjte8eXOqVavGxYsXuXjxIhUqVCB9+vQ0adKEffv2MdzWN3/cuHEcOnToqUvHCiFEpJUrYeRIM+ht1Sr4+GNYuBA8Pa2uLPYWLVrEhAkTCA0NZeXKldStW5fZs2eTOLE1bVTcOtA7der08Ew5vhQuXPhheMXkwYMHFC5cmKCgIC5dusS6desAs973f//9x/bt29FaU6NGDTZs2PDEEqlhYWEsXLiQVKlScf36dUqWLEmNGjUeWQBlz549XLhwgQMHDgDmLD9NmjSMGDGCwYMHU8z2a26HDh0eLkHapEkTli5dSnXbiJL79++zZ88eNmzYQMuWLR8+17N89dVXDB06lPXr15M+fXru3r3LL7/8wqBBg/D09GTixIn89ddfL/R3KoRIWDZtgpo1zdSzV1+FunXNWborhfmqVauoX78+r732GhkyZKBJkyaMHTvWsjAHNw90q0S/5L5161aaNm3KgQMHWLVqFatWraJIkSIA3L17l//++++J+fRaa3r16sWGDRtIlCgRFy5c4MqVK7z66qsPH5MzZ05OnjxJx44dqVq1KpUqVXpqLevXr+e3337j/v37D3vFRwb6J5+YuyLlypUjMDCQW7duvfBrTZEiBR988AFLly7lrbfeIjQ0lIIFC77w8wgh3NuZM+DrC6Gh0Ls3ZM8OW7a4Vle348ePs3btWoKCgvj+++8pUKAA/v7+pEqVyurSADcP9OedSTtCqVKluH79OteuXUNrTc+ePWnTps0jjzl9+vQj29OnT+fatWvs2rULT09PcuTI8cRyqq+88gp79+5l5cqVjBkzhjlz5vD3338/8pigoCDatWvHzp07ef311+nbt+8jz/MyS6BG9/nnn/Prr7+SL1++R5aKFUIIgLNnoXRpiByvmyWLCXdXCvNjx45RunRpAgICAHNStWzZMqcJc5DV1uzuyJEjhIeHky5dOj7++GP+/vtv7t69C8CFCxe4evXqE0uk3r59m4wZM+Lp6cn69es5c+bME897/fp1IiIiqFu3Lv369Xu49Gr054oM78hL4/PmzXvkOWbPNo36Nm3aROrUqUmdOnWsXtPj9ZYoUYJz584xY8aMh2f9QoiELTwcLlyA48fBx8d0eduyxYT6iRPwxhtWV/h8YWFhXLhwgcOHD+Pj40OiRInYvXs3Fy9e5PDhwy+9ymR8c+szdKtE3kMHc/l88uTJJE6cmEqVKnH48GFKlSoFmMvV06ZNI1euXA+XSK1cuTLffvst1atXp2DBghQrVox8+fI9cYwLFy7QokULIiIiAOjfvz9gBq99+eWXDwfFffHFFxQoUIBXX331iTXLvby8KFKkCKGhoU+c3T9L69at8fHx4bXXXmP9+vUANGjQgD179jwyAFAIkTDduweVKpkAB0iSxAyCs/3ocwm3bt2iQoUKD2+fJkuWDD8/v4e3TJ2R3ZZPdQRZPtV5VKtWjc6dO1OxYkW7HkfeXyGcW1gY1K5t1h//6SfImNHMIS9a1OrKYi84OBgfHx82b97ML7/8Qpo0aShZsqTTjA+KaflUOUMXL+XWrVsUL16cd955x+5hLoRwTlrDt9/C6tVw9665zD5qlGkK4+xCQ0MfjjWKdPv2bU6dOsW0adP47LPPLKzuxUigi5eSJk0ajh07ZnUZQggL9eoFgwZB+fKQLRt07uwaYa615osvvmDy5Ml8/PHHjzSA6d27t0uFOUigCyGEeAELFkD09h6XL8O4cdCmjVkNzRW6us2cOZPDhw9z/PhxZs6cSd++fenTp4/VZb00twx0rXWcp2AJ5+XK4z2EcAcTJsDnn5vPo/+IbdQIRoxwjTAfPnw4nTt3BiBRokR07NjxYfMtV+d2ge7l5UVAQADp0qWTUHcjWmsCAgLw8vKyuhQhEpRLl+DcOThyxJyFV6oES5e6Vle38+fPc/HiRf7991+6dOlC7dq1mTt3rqVd3ezB7QI9a9asnD9/nmvXrlldiohnXl5eZM2a1eoyhEgwNm+GDz+EyH5URYrAvHmuFearV6+mSpUqhIWFAVCmTBmmT5/udmEObhjonp6evOEKHQuEEMKJHTkC1avD66/D0KGQODG89x6kTGl1ZbH377//UqdOHfLnz8+vv/6Kh4cHZcuWxdvb2+rS7MLtAl0IIUTcnD0LdeqYS+x37pjw9vV1/nXIo/vvv/+oV68ely9ffth1c8WKFU7X1c0eJNCFEEJw8yZUrgznz8Mnn5jL6m3auFaYX7lyBR8fHwIDA6lXrx5JkiShQ4cOCSLMQQJdCCESrPv34eef4epV2LXLNITx9YUKFayuLPZu375Nv379uHHjBtu2bePSpUusX7+eEiVKWF2aw0mgCyFEAhQWZqabLV1qVj9LkgSmTXOtMA8ODqZ27dps2LCBzJkz4+3tzdy5cxNkmIMEuhBCJBhag78/3LoFixbBP//AyJHQrp3VlT1fWFgY69ev5969ew/3zZgxg/Xr1zN16lQaN25sYXXOQQJdCCESiO++A9vCjAD07OkaYR7ZonXSpElPfK1///4S5jYS6EII4cbCw82Z+dixJsxbtYIOHSBZMsiTx+rqni08PBytNT/99BOTJk3i22+/pVGjRg+/niJFCt58800LK3QuEuhCCOGm5syB5s3hwQOzXa0ajBkDHi7wk3/kyJF07tyZ0NBQAFq2bEn//v2lA+gzuMDbKoQQ4kX5+UGTJqa7W7VqkCqV6cPuCmE+b948OnbsSMWKFXn//fdJnz49rVq1kjB/Dhd4a4UQQsTGnj3Qt69p1bp1K7z5JqxYAa+8YnVlz7dhwwZ+++03QkND8ff3p3Tp0ixZssRtu7rZgwS6EEK4gVOnwMfH3DPPlcu0aR092jXCfM+ePVSrVo0UKVKQLVs2qlSpwrhx4yTMX5AEuhBCuKiAAJg/H0JD4Y8/ICTELKjy1ltWV/Z8Fy9eZPHixYSFhdG/f3/SpEnD1q1byZIli9WluSwJdCGEcEF37sBHH8G//5rtFClMlzdXCPMrV65QtmxZTp48CUCGDBlYvXq1hPlLkkAXQggXobXptR4eDl9+Cfv2wYIF5vJ68uRmKpqzioiI4Ny5c4SGhvLJJ588bNH69ttvkzJlSry8vKwu0eVJoAshhAuIiIDGjWHmzKh948dD7drW1RRbISEhVKtWjdWrVwOQKFEiFi1aRPny5a0tzM1IoAshhAvo1s2EeadOUKgQ5MjhGn3XIyIiaNGiBatXr6Z3797kyJGD/PnzJ9h+6/YkgS6EEE5qxAgYN84Mejt8GDp2hKFDwdmnY0d2d5s/fz5BQUH8999//Prrr/Ts2dPq0txaIqsLEEII8aTJk02AJ0kC+fLB99/DsGHOH+YAgwYNom/fvqROnZoCBQowaNAgevToYXVZbk/O0IUQwkls3WpWQAsKgj//hIoVYflyE+rObvXq1axfv55bt24xevRoGjZsyIwZM0iUSM4bHUUCXQghnMC2bSbAg4MhcWIoUcLMMXeFMF++fDk1atQAzIC3atWqMXnyZAlzB5NAF0IIi9y+DYcOQWAgfPYZvPYabNkCGTNaXdnzXbt2jePHj3P58mUaN27MO++8g7+/PylSpLC6tARLAl0IISxw/jyUKmX+BMiQwTSGcYUwP3z4MGXKlOHmzZsA5MiRg2XLlkmYW0wCXQghHOzWLahc2Zyhz5oFadLAO+/Aq69aXdnzXbx4ER8fH5IkScKiRYvw8vLi3XffJW3atFaXluDZLdCVUn8D1YCrWusCtn1pgdlADuA00EBrfVOZNfF+B6oA94HmWuvd9qpNCCEc7cEDaNDAXFIPDjZ911esMPfNndXVq1epWbMmx44de7jvwYMHJE6cGH9/f4oWLWphdeJx9jxDnwSMAKZE29cDWKu1HqCU6mHb/haoDOS2fZQARtv+FEIIlxceDp9+CsuWQcuW4O0NNWo4d5jfu3ePatWqceDAAVq0aPFwgJtSik8//VTC3AnZLdC11huUUjke210TKG/7fDLghwn0msAUrbUGtiml0iilMmutL9mrPiGEsCetTROYffvg3DlYvx5+/x2++srqymIWEhLCTz/9xLlz5zh06BC7d+9m4cKFD0ewC+fm6HvomaKF9GUgk+3zLMC5aI87b9v3RKArpVoDrQGyZctmv0qFEOIl9OkDP/8MWbOCh4f53JnDPCIigpYtWzJ9+nSyZ8+Oh4cH48ePlzB3IZYNitNaa6WUjsP3jQXGAhQrVuyFv18IIexl1y44dQoOHjQB3qqVad3qrN3dtNZs3LiRq1evsm7dOqZPn84vv/xCr169rC5NxIGjA/1K5KV0pVRm4Kpt/wXg9WiPy2rbJ4QQLmHePDPoTdtOM6pUgdGjnTfMAQYPHkz37t0fbrdt21b6rbswR7fxWQI0s33eDFgcbX9TZZQEbsv9cyGEswsPN21a/fzM0qalSsHeveYM/Z9/wNPT6gqfFBYWRlBQENOnT6d79+40aNCA/fv3c/ToUUaOHIly5t9AxDPZc9raTMwAuPRKqfNAH2AAMEcp1Qo4AzSwPXw5Zsraccy0tRb2qksIIeLDnj1QqRJcu2a28+aFJUsgXTpLy3qmFStWUL9+fe7duwfA+++/z5QpU0iaNKnFlYn4YM9R7p/E8KUnJmrYRre3t1ctQggRn86cMY1hvLzg11/Nmfinnzp3mO/cuZN69eqRO3duGjVqRLJkyWjWrJmEuRuRTnFCCBELV6/C11/D9etmbfKgIFizBt5+2+rKYnbkyBF69OjBvXv32L17NxkzZsTX15dXXaElnXhhshSOEEI8x927ULUqLF4M9+9DnjywdKlzh/mlS5fw8fHB39+f+/fvU7x4cQlzNydn6EII8RQhITBjhum3/s8/sHu3CfRq1ayuLGaBgYHMnDmToKAgJk6cyPXr1/H39+d///uf1aUJB5BAF0KIx0REQIsWJtDBNIYZM8a5wzwoKIjq1auzYcMGALy9vVmwYIGEeQIigS6EEDaXLplL6qNHmzDv1w/atYMkSSB5cqure7qzZ88SGhpKz5492bBhA1OnTqVq1ap4eXnh7e1tdXnCgSTQhRACGDQIovVYoW1b6NXLeRvDaK1p3749o0ePfrhv8ODBNG7c2MKqhJUk0IUQCd706SbMa9c2H6lTm0FwzhrmAL/88gujR4+mTZs2lClThsyZM1PRmZdvE3YngS6ESJB8faFnT7M2+X//QYUKMHMmOPO07EmTJjF48GDCw8M5cuQITZo0YfTo0dLdTQAybU0IkQBt3w5168K9e1CgAHzxBSxY4NxhvmjRIlq2bEmSJEkoWLAg3bt3Z/z48RLm4iE5QxdCJAgnTsCECRAaCpMnQ6ZMsHGj+dNZ7d69m9mzZxMaGsro0aMpXrw469atI1myZFaXJpyQBLoQwu1dvAgffADnz5uz8CxZYNky5w7z/fv3U6FCBe7fv4+npycFChTgn3/+kTAXMZJAF0K4peBg2LkTwsJMy9YbN2DHDiha1OrKYnbnzh327NlDUFAQLVq0IEWKFBw4cIDXX3/9+d8sEjwJdCGE2wkKgo8+gk2bzLaHhzkjd+Ywv379OqVLl+a///4DIFWqVGzcuFHCXMSaBLoQwq2Eh5u1yTdtgt9/N/3Ws2eHN9+0urKY3b9/n2rVqnHu3DmmTZvGq6++Sr58+ciSJYvVpQkXIoEuhHB5WkPXrmbQW3i4Gb0+ZAh89ZXVlcUsNDSUxo0b4+vrS2hoKEFBQcyfP5/atWtbXZpwURLoQgiX9/PPMGyYaQqTPTsUKmR6sTsrrTWff/45c+bMoXnz5qRJk4YKFSpQo0YNq0sTLkwCXQjhkubNg0WLTO/1hQuhWTOYONG5u7uNGjWKLVu2cPXqVVavXs2PP/5I7969rS5LuAkJdCGEy1m4EBo0gIwZIUUKaNoUxo1z7jAfNmwYXbp0IWvWrCRNmpRvv/2WH374weqyhBuRQBdCuJTNm+HTT6F4cVi3Dpx5WvbevXs5fPgwp0+fpmfPntStW5fZs2eTOHFiq0sTbkgCXQjhMo4cgerV4fXXYelS5w7zlStXUq1aNcLCwgAoV64c06ZNkzAXdiOBLoRwahER5j759evg4wOenmZhlfTpra7sSWFhYQQFBXHw4EHq1q3L22+/zdSpU/H09CR37twS5sKuJNCFEE7r5k348EPYvdtsJ08Ofn6QM6elZT3VsWPHqFChAhcvXgQgW7ZsLF++nNdee83iykRCIYEuhHBKQUFQqxbs3w99+5owr1gRihSxurInXb58GR8fH0JDQxk4cCAeHh7UrVtXwlw4lAS6EMJphIVBt26wZw9cvQqHDpk1yhs1srqyJ926dYsOHTpw4cIFTp48yfXr1/Hz8+Pdd9+1ujSRQMl66EIIp6A1tG8Pw4ebs/P06WH8eOcM8+DgYGrXrs3s2bMJDw/nzTffZNGiRRLmwlJyhi6EsNQ//8CxY2YE+/jx0KMH9O9vdVVPCg8PZ9q0aVy/fp3169fj5+fH1KlTady4sdWlCQFIoAshLDR6NLRrF7XdqhX8+qt19cREa81XX33FqFGjAEiUKBGDBg2SMBdORQJdCOFQN26YKWg7dkCHDlCtGkybBokTm65vzuTSpUvcuXOHWbNmMWrUKLp168YPP/xA4sSJSebMk+CFtbSGU6fMoBCAXLnMP3A7k0AXQjjM+vVQuTIEB5vt4sVh1iwzgt3ZjB07ljZt2jzc/vTTTxkwYACJEsnQI/EMERFmYYFp06L23boFqVPb/dAS6EIIh9i/30xDy5ULevUyDWJ8fJwzzP/55x/atm1LpUqVaNasGcmTJ6dKlSoS5uL5evY0Yd6pE0QOkvT2dsihJdCFEHZz6hQ0aWKmoF2+DClTwooVkC2b1ZU9aePGjXz11Vfcu3ePM2fOUKRIEebPn08KZ7sPIJzPqFHwxx/mEvuJE/DllzB0qMNXC5JfN4UQdhHZqvXQIShWDOrUgVWrnDPMDx48SI0aNbh9+zbFihWjZcuWLFu2TMJcPN+MGWa+ZZo05h5S794wYoQlS//JGboQIt7dv28WUTl7FtasgTJlrK7oSefOnWP06NEEBwczd+5cvL29Wb9+PdmzZ7e6NOGsNmyAxYujtkNDYcwYKF/eLDCQNKllpYEEuhAinoWHm+VN/+//YP585wzzgIAAPvroI44fP463tzfp06dnyZIlEuYiZhs3QqVKZgR7kiRR+0uUgIULLQ9zkEAXQsQDrc0CKoGB5grk4sXw559Qu7bVlT3pwYMH1KhRg1OnTrFu3TrKlStndUnC2Vy9CgcPRm0HBkKLFpAjB2zeDOnSWVbas0igCyFeWp8+8PPPUdvdu5s55s4mPDyczz77jK1btzJ79mwJc/Gk48ehdGm4du3R/ZkymRGdThrmIIEuhHhJf/1lwrxZM3MSkyIFFC1qdVVP0lrz9ddfs3DhQoYPH079+vWtLkk4m6tXzUjOiAjTkzhlyqivvf22WWDAiVkS6EqpzsDngAb2Ay2AzMAsIB2wC2iitQ6xoj4hxLPNn29m5ty/bz6qVDF92D2c8BRhwIAB/Prrr4SFhfHgwQO6du3K119/bXVZwlkEBkKNGqZ1YWio+Ue8bh2ULGl1ZS/M4f/9lFJZgK+A/FrrB0qpOUAjoAowTGs9Syk1BmgFjHZ0fUKIZ9uwwQx6K1gQKlQws3W+/to5w3z8+PH07NmTjz/+mIIFC5I9e3baRW8eLxK2kBAzn3LzZmjb1gxsq1XLJcMcnhPoSikFZNVan7PDcb2VUqFAMuAS8AHwqe3rk4G+SKAL4RT274dBg8zPv5UrIWdOM6c8bVqrK3vS6tWr+fvvvwkLC2PhwoX4+PiwZMkSPD09rS5NWCksDPr2NffII505A9u2weTJ0LSpZaXFl2cGutZaK6WWAwXj64Ba6wtKqcHAWeABsApzif2W1trWyZ7zQJanfb9SqjXQGiCbM3aoEMLNnD5tZuvcvw+ZM5sz86lTnTPMN27cSPXq1UmVKhVp06alevXqTJ06VcI8odPa3COaMAFy54bIFr5KmQ5vbhDmELtL7ruVUu9qrXfExwGVUq8ANYE3gFvAXMAntt+vtR4LjAUoVqyYjo+ahBBPFxBgxggFBcHWrZA/v9UVPen8+fP4+fkRHBxMt27dyJ49O1u2bCGdE49GFg7i5wfnz5umCBMmwHffQb9+VldlN7EJ9BLAZ0qpM8A9QGFO3gvF8ZgfAqe01tcAlFILgDJAGqWUh+0sPStwIY7PL4SIBw8emLFCp07B6tXOGeZnzpyhVKlSXLp0CYDMmTPj6+srYS5M+9WOHaO2W7R4dG6lG4pNoH8cz8c8C5RUSiXDXHKvCOwE1gP1MCPdmwGLY3wGIYTd3Lljur21bGnOymfPBmearq21JjAwkDt37lC5cmXu37+Pv78/r732GpkzZya5My7fJuwrKChqTV4wAz2++gpq1jSDPzw9IXt2S/qrO9JzA11rfUYp9R6QW2s9USmVAYjzigVa6/9TSs0DdgNhwL+YS+jLgFlKqX62fRPiegwhxIvTGtq1M62pIw0fDs40XfvevXv4+PiwadMmAJIkScKqVaukQUxCtmyZ+Uf64MGj+0uWNG0LkyWzpi4LPDfQlVJ9gGJAXmAi4AlMw1wmjxOtdR+gz2O7TwLF4/qcQoiX8+OPJsxbtDAD33LmNCc4ziIsLIyGDRuyZcsWvv/+e9KmTUvp0qUpUaKE1aUJq+zYAQ0aQN68jw5sS5oUPvkkQYU5xO6Se22gCOaMGq31RaVUymd/ixDCFUyebMYKhYaa2TstWphtZ7kyqbXmu+++Y+PGjdy6dYsDBw4wevRovvzyS6tLE1Y5cgS6dDH3hg4cgIwZTUvWV1+1ujLLxWY99BCttcZ0dUMpJTeohHAD8+ebAL9+3ZzIfPWVaePqLGEO0KtXL/r3709oaCgZM2bkjz/+kDBPyC5ehI8/NqPWkySB998398slzIHYnaHPUUr9hRmF/gXQEhhn37KEEPawd69ZtjkoCPr3h1KlzHrl3t5WVxbF19eXvXv3cu7cOUaOHEmbNm0YPXo0ypl+0xD2d+MGTJny6GC3GTPMfn9/51wwwGKxGRQ3WCn1ERAI5AF6a61X270yIUS82rPHjFa/c8dsFyoES5Y4V5jPmDGDzz777OF2/fr1GTFihIR5QnPvnmmAsOOx9icpUsC8eRLmMYht9+X9gDdRi6kIIVzImTNQubLpu753r7lCmTRpVMMsK924cYPLly9z5MgRmjdvzvvvv8/ixYtJkiQJ3s7024awL63hv//MgI5vv4Vdu2DBAhPskTw8zBQ08VSxGeX+OdAbWIdpKvOnUuonrfXf9i5OCPHybtyI6va2Zg288YbVFUXZsWMHH3zwAXfv3gXg7bffZtGiRaROndriyoRDRURA8+amp3CkMWOgdm3LSnJFsTlD7wYU0VoHACil0gFbAAl0IZxcUJCZenbypFlM5e23ra4oyokTJ6hatSrp06dn3LhxeHh4ULFiRdKkSWN1acLRevUyYd6pkxnYkSULlInzzOgEKzaBHgDcibZ9x7ZPCOGEwsKgdWvTxvr+fbhyxXR7e/99qyuLcu3aNXx8fAgPD8fX15e8efNaXZJwlKFDYeRIc4kdzNn5mTNm8ZShQ51rmoWLiTHQlVJdbJ8eB/5PKbUYcw+9JrDPAbUJIV6Q1mZZ54kTzdXKFCmgShXTe8NZ3L9/n+rVq3P+/HnWrVsnYZ6QTJgAXbvCe+89eu8nVy6zcIqE+Ut51hl6ZPOYE7aPSNJjXQgnM2WKGUN04YKZX+5si0qFhIQwdOhQLl26xO7du9mxYwfz58+nVKlSVpcm7GXNGvjnn6jt4GAYP97MI//nHxncZgcxBrrW+kdHFiKEiJuRI6FDB0iZEhInNgtMOdOiUlprPv/8c6ZOnUqaNGnw9PRkzJgx1KpVy+rShL2sXWsuDXl4mOkUkSpUgLlzJcztJDaj3IsB3wHZoz/+JZZPFULEk4ULTYDXqGFm+CRObHVFUXbv3k1AQADLli1j6tSp/PTTT/zwww9WlyXs5coV2LcPbt2CVq1Mf/WNG81cSeEQsRkUNx0z0n0/EGHfcoQQsbVlC3z6KZQoATNnOleYDx06lK5duz7c/uKLL/j+++8trEjY1YkTZnT6tWtmO0sWWL5cwtzBYhPo17TWS+xeiRAi1o4eherV4fXXze1IZ1pUavbs2XTt2pW6devSuXNnvLy8KFq0qHR7c1fXrplGBxERJsRTpTLzIyXMHS42gd5HKTUeWAs8bKqrtV5gt6qEEE84e9Z0eztxwjTTSp/e9GVPn97qymDlypU0adKEwMBAgoODKVu2LNOmTcPLy8vq0kR8unEDqlaFf/+N2hcWZu6Jr1tnztKFZWIT6C2AfJh10CMvuWtAAl0IB7l504T5+fNmVTQPD2jSxKxZbrVdu3ZRt25dcuTIQcuWLUmRIgXt27eXMHc3QUFQqxbs3g3t25vVziLVqCFh7gRiE+jvaq1loqgQDnb/PvTsaaaiHT5s2lyvXGkGClvtv//+4+eff+b+/fts2LCB9OnTs2rVKl577TWrSxPxKSwMeveGY8fg9GkzN3LWLGjY0OrKxFPEJtC3KKXya60P2b0aIQRgfo5+8om5P/7WW+aK5qxZzhHmly9fplKlSgQEBJAtWzby5s3L2LFjJczdTWSXovHjzT9CDw/46y8JcycWm0AvCexRSp3C3ENXgJZpa0LYh9ZmXvmSJWaOebt2VlcEd+/eZcmSJYSEhPDnn39y9epV/Pz8ePfdd60uTcQHrU2z/0uXovbt3GnC3Nm6FIkYxSbQfZ7/ECFEfPn1V3Mi1KOHc4R5cHAw1apVw9/fHwBPT08WLVokYe5OBg+G7t2f3N+ihXN1KRLPFJtA13avQogE7t49M+Zo0SL4/nto3NgEu9UiIiJo1qwZ/v7+jB8/nooVK5I6dWpeeeUVq0sTL+v+fXjwAJYtM2HeoAEMHBj1dQ8PM59cphu6jNgE+jJMqCvAC3gDOAo40UKMQriuxYvNbclg26TQDz80a1g4w8/R7t27M3v2bAYOHEirVq2sLkfEl+XLoW5d81skmKX4pkx5tE2rcDnPDXStdcHo20qpooATXAgUwvVt3QqNGkHBgtC0KXh7m+3oM4KsMnz4cIYMGUKHDh3o1q2b1eWI+LJjB9SvD/nyQcuW4OVlfqOUMHd5sTlDf4TWerdSqoQ9ihEiITl2zHR7y5rVnDBlyGB1RTB//nyGDh1KeHg427dvp3bt2gwfPly6vLmq/fuhSxe4ezdq35EjkDEjrFgBr75qXW0i3sVmcZYu0TYTAUWBi3arSIgE4PJl0y0zUSLT7c0Zwnz16tU0atSIXLlykT17dlq3bs2wYcNI7ExN4kXsnT1r/pGFhUHhwlH7P/jADNCQMHc7sTlDTxnt8zDMPfX59ilHCPd1+zZMnGjGIs2daxan8vODXLmsq+nw4cMsWrSI0NBQBg0aRP78+dmwYQOpU6e2rigRdzduwKRJ5t74tGlmtOWmTVCggNWVCQeIzT10WRddiJcUHAw1a4Jt5hfJk8OcOWDlzK9jx45RtmxZAgICAMiTJw/Lly+XMHdV9+6Z/sDbt5vt1KnNtAkJ8wQjxkBXSk0k5ilrWmstQ16FeAatzX3y4GDo39+E+dSpZnZQokRmVpCjBQcHc/ToUYKCgvjkk09QSnH48GFy5syJh4cHiRIlcnxR4sVFRJh+wOHhUfu++840g5k/H6pVM+vpyu2SBOVZP1KWPmXf60BnQP6VCPEMkd3eRo2K2jdggJlfbpXbt29Trlw59u3bB4C3tzfr168nX7581hUlXlxEhJkKMXfuk18bNQrq1HF8TcIpxBjoWuuH98mVUjmBXkA5YAAwwf6lCeG6BgwwP1u//BI++sgscVq2rHX1BAcHU7t2bQ4dOsTIkSN59dVXKVCgAHny5LGuKPHitDaj1ufONSv3FCsW9bXMmWXFswTumRf9lFL5gO+BIsAg4EutdZgjChPCVU2dCr16wWefmV7sVl/FjoiIoEWLFqxfv56pU6fS2MrLBCJuhg6FP/4wl9jPn4fOnZ2jlaBwKs+6hz4X+B8wBHOZPRxIFTkfVWt9wxEFCuFKVq82vTo++AD+/tv6MAfo0aMHM2fOpH///hLmrujvv6FrV3OJJ1cuyJMHvv3W6qqEE3rWGfq7mEFx3wBdbfsiu0toIKcd6xLCZezbZxalCgszZ+f588OCBdZ2e5szZw7+/v4EBAQwe/Zs2rdvz7cSAs5vzRpYuDBqOyTEzHWsVAmWLjXr6AoRg2fdQ8/hwDqEcEn//QcVK5pGXClSmG6aixaZGUNWmTZtGk2aNCFVqlQkSZKEFi1a8Pvvv0u3N2e3bh1UqWJasHp5Re3/4AOYN0/CXDyXBRNnhHAPV66YRlxgztJz57aullOnTnHkyBEuXLhA27ZtqVChAitWrCCp9Od2bpcvw7//QmAgtG5tLqdv2gRp0lhdmXBBEuhCxMHdu2aq76VLsH69tWG+fft2KlSowP379wEoWLAgCxYskDB3didOmFHp166Z7SxZTH91CXMRRxLoQrygsDCzONXu3Wbp0xIWLlV0/PhxqlatSqZMmZg0aRJJkyalUKFCeHt7W1eUeL5r18zlnfBw08w/TRpzv0a69ImXEKtAV0olBjJFf7zW+mxcD6qUSgOMBwpgBti1xKyxPhvIAZwGGmitb8b1GELEp4gIM6f877/NVOCICPjrL3OW7mgXL16kUqVKHDlyhPDwcNKlS4evr6/MKXdWN2+alqw7d0bti4gw98rXrZO54yLexGa1tY5AH+AKEGHbrYFCL3Hc3wFfrXU9pVQSIBmmcc1arfUApVQPoAcgw3KFU+jZE8aNM53esmeHd94xS0o7WmBgIJUrV+bMmTN069YNDw8PGjVqJGHurIKCTBP/f/81c8ej3wapUkXCXMSr2Jyhfw3k1VoHxMcBlVKpMR3nmgNorUOAEKVUTaC87WGTAT8k0IUTGDECfvsN2rY1jWKsGiweEhJCnTp1OHToEMuWLaNSpUrWFCKeLSwMfvjB9Fo/e9aE+cyZpl2rEHYUm7YX54Db8XjMN4BrwESl1L9KqfFKqeRAJq31JdtjLmMu8T9BKdVaKbVTKbXzWuRgEiHsZMEC+Oorc5L155/WhbnWmlatWrF27VrGjx8vYe6stIb27U3v3xMnzPZff0mYC4eIzRn6ScBPKbUMCI7cqbUe+hLHLAp01Fr/n1Lqd8zl9Ye01lop9dSV3rTWY4GxAMWKFYtpNTgh4uzIEdi8Ge7cMZfaS5SAGTMcv3CV1hpfX18uXrzItm3bmDZtGv369aNZs2aOLUQ8ndawciVcuBC1799/YexY8w9HWrMKB4tNoJ+1fSSxfbys88B5rfX/2bbnYQL9ilIqs9b6klIqM3A1Ho4lxAvZu9d02Lxzx2y/9Rb88w8kS+b4WgYPHkz37t0fbrdv355evXo5vhDxdEOGQLduT+5v3hx++cXh5Qjx3EDXWv8IoJRKYdu++zIH1FpfVkqdU0rl1VofBSoCh2wfzTCruTUDFr/McYR4UWfPmnFKqVKZ3h6vvAKvvurYBl13797l3r17+Pr60r17dxo0aMCgQYPw9PQkc+bMjitEPN3du3Dvnjkz79bNjIwcPDjqXkzixPDaa9bWKBKs2IxyLwBMBdLatq8DTbXWB1/iuB2B6bYR7ieBFpj7+XOUUq2AM0CDl3h+IV7IzZtmWvDduybMCxZ0fA0rVqygTp06BAUFAfD+++8zefJkvKK3ARXW8fWF2rXNyHWAcuVgypRH27QKYaHYXHIfC3TRWq8HUEqVB8YBpeN6UK31HqDYU75UMa7PKURcRc4sOnHC/My2Isx37txJ/fr1yZcvH61btyZp0qTUr19fwtxZ7NwJ9eqZ5i+tW5vpZ/XrS5gLpxKbQE8eGeYAWms/26h0IVxWWBh8/TVs327Ozk+cMDOLKlRwfC0nT56katWqZMiQgRUrVvDqq686vgjxpCNHoEMHuH3brMKTPj0sXw5y60M4qdhMWzuplPpBKZXD9vE95jK5EC4pcmbRqFHmfnnevDBpkjUzi65du4aPjw9hYWH4+vpKmDuLy5fNPZg9eyBjRrN86cqVEubCqcXmDL0l8COwANMhbiPmnrcQLumXX6ydWXTnzh3GjRvH3bt3WbJkCefOnWPt2rXkzZvX8cUICAgwPX0fPIjaN38+XL8O/v7wv/9ZV5sQLyA2gf6h1vqr6DuUUvWBufYpSQj7mTTJNPFq0sSamUUhISHUrVuX1atXA5A8eXJmzpxJ6dJxHpIiXsa9e2Zqw/btj+5PmRLmzpUwFy4lNoHekyfD+2n7hHBKV66Y3h+HD8Pnn8OHH8L48Y7r+qa15vDhwwQFBTF8+HBWr17NhAkTaN68OQCJEsXmzpeIN1rDgQMQGgp9+5oBbwsWmJGRkZSyri2gEHEUY6ArpSoDVYAsSqk/on0pFRBm78KEiA9btpgAj7yaWriwuZqaJD5aJMVS165dGTZs2MPtH3/8kZYtWzquABFFa9P4ZcqUqH0jR5rpaEK4uGedoV8EdgI1gF3R9t8BOtuzKCHiw9GjUL06ZMkCgwaBh4eZOpwqleNqGDp0KMOGDeOLL76gWrVqpE2bljJlyjiuAPGo7783Yd6lC7z/PmTKZO2C9kLEoxgDXWu9F9irlJoBKCByfcajWutQRxQnRFxFDlL28DBzy3PlcnwNs2bNomvXrtSrV48xY8bIpXVHGzoUhg0za4+DOTu/dMnMI4/e3U0INxGbe+ilgSnAaUywv66Uaqa13mDPwoSIqzt3oGpVuHYN/PysCXM/Pz+aNWtG2bJlmTp1qoS5o02cCF27mksy0deKz54devSQMBduKTaBPhSoZOu7jlIqDzATkOGfwumEhpoGXnv3mkVVij2tH6GdHDx4kFGjRhEaGsqcOXPIlSsXixYtkm5vjuLvb5bFCw01l9U//BCWLXPsgAkhLBSbQPeMDHMArfUxpZQDl6sQIna0NldTV66ECROgcmXHHfvUqVNUrFiRwMBAUqdOzZtvvsn8+fNJmzat44pIyLZsMfdYPD0heXKoWNFMO5MwFwlIbAJ9l1JqPDDNtv0ZZrCcEE7h//7PXF5fs8bMM+/bFxwxiPzu3bts2LCBsLAwunXrRkhICLt27eKtt96y/8ETskuXYFe0cbr370PbtpA1qwn2DBmsq00IC8Um0L8E2gORzWU2AqPsVpEQL2D4cOgcbc7F559D7972P+6dO3coX748u3fvBsDLy4vVq1dLmNvbyZNQqhRcvfro/owZzehHCXORgD0z0JVSiYG9Wut8mHvpQjiNOXPM7KPataFXL7MAVoEC9h/vFBoaSv369dm7dy+TJ08mf/78ZMmSRdYrt7fr181l9bAwc18l+u2MXLnMAvZCJGDPDHStdbhS6qhSKpvW+qyjihLiefz9TfvW0qVh+nTw9nbMcbXWfPHFF6xcuZLx48fTtGlTxxw4obpzx7Rm3bTJbHt5mXsrMpdfiCfE5pL7K8BBpdR24F7kTq11DbtVJcQzHDwItWpBzpywZInjwhygd+/eTJ48mT59+tCqVSvHHTghCg01a5Bv3QrffGMGu338sbnkLoR4QmwC/Qe7VyHEc5w+bS6rBwaa1tteXrBixaNXXe1l2rRpzJo1i+DgYNasWUOrVq3o06eP/Q+ckISFwXffmd/WIl2+bAa/TZjgmFGOQri4Z/Vy98IMiHsT2A9M0FpLD3fhcAEB5tbphQtm7fJ8+cxguBw57H/suXPn0rRpU3LkyEHatGlp06YNf/75J0oak8QfraFDB/jrL3jnHdPeL9Iff0iYCxFLzzpDnwyEYka1VwbyA187oighIj14ADVqmDP01auhbFnHHXvDhg00btyY0qVLs3r1arwdeW0/IVi1Ck6dgn37TJhbtUC9EG7iWYGeX2tdEEApNQHY/ozHChHvwsPhs8/MLdQ5cxwb5gcPHqRmzZrkzJmTJUuWSJjHt9GjoV27qO3mza1ZoF4IN/KsQH+4AIvWOkwuMQpH0ho6dYKFC83l9Xr17H/M0NBQrl69yq1bt6hcuTJeXl6sWLFCur3Flzt3zCCITZvMJfZq1cyZeeLEZtUzIcRLeVagv6OUCrR9rgBv27YCtNbagYtQioRm0CAYMcKsr/G1A2703Lhxg/fff58DBw4AkCJFCjZu3EgOR9yoTwj8/MyKOffvm+3ixWHWLDNyXQgRL561fGpiRxYiRKQZM+Dbb6FRI/jtN/sf78GDB9SoUYNjx44xePBgUqVKRZkyZcifP7/9D54Q7N9v5hlmz27a+nl6mm0JcyHiVWymrQlhd6tWmZatISFw4ACUL2/6sttr1dGwsDA6dOjA9u3buXnzJmfOnGH27NnUr1/fPgdMKI4eNX3Vb92K2nf6tAlvX1/Ils2qyoRwe7JIs7Dcjh2mfeu1a2Z9jaZNzb3zpEntczytNV9++SV//fUX6dOnp2DBgkydOlXC/GVdvmzmF+7bZ97IyI8PPzStWiXMhbArOUMXljp+3NxazZgRNm+GV1+1/zF/+uknJkyYwPfff8/PP/9s/wO6s9u3zcC2u3dh8WKzaIqfH7z7rtWVCZHgSKALy1y7ZtYsj4gwV2MdEeYTJkygb9++NG/enJ9++sn+B3RnwcFQs6ZprK8UpEpl1iCXMBfCEhLowhL37plZS+fPw7p1pgOcvVy6dInz589z+PBh2rRpw8cff8zYsWOl29uL0NpcSg8Jido3ZIgJ8+nT4dNPratNCAFIoAsLhIWZEew7d8L8+fZda2PTpk18+OGHBAcHA1C0aFHmzp2Lp6en/Q7qbrSGFi1g8uQnv/bbbxLmQjgJCXThUFpD+/awdCmMGmVmL9nL4cOHqVGjBtmzZ2fw4MF4eHhQtmxZUqRIYb+DuqMffjBh3rkzVKwYtT9dOihRwrq6hBCPkEAXDvHrr2adjfBwuH7dtO1u29Z+x7t48SI+Pj4kSZIEX19f3njjDfsdzB2NHg0//2wup1y7Bp9/bi6xy20KIZyWBLqwu9GjzcqYH30EuXKZ++X27P4WGBhIlSpVCAgIwN/fX8L8Rc2ZY/qsv/ceFCgAr78O3btLmAvh5CTQhV0tXmzadlevDgsWPLoyZnwKCgqiX79+XLp0ib1793LgwAGWLl3K//73P/sc0F34+cG0aeZeCJgpBzNmmDBfvdosPC+EcAkS6MJutm41g9/efde07bZXmEdERNCkSRPmzZtH1qxZ8fT0ZPLkyfj4+NjngO5i61YzbzBpUkiZMmr/e++Z6WcS5kK4FAl0YRdHj5qz8qxZ4Z9/IFky+xxHa03nzp2ZN28eQ4YMoUuXLvY5kLu4csUEeVCQuXSSNSts2QIZMlhdmRDiJUmgi3gX2QE0USLTMMaeWTFkyBD++OMPOnXqJGH+POfPQ8mScOGC2c6Y0f5vkBDCYSTQRbzQ2oxgv3fPtHKN7ACaK1f8HysiIoKIiAjmzp1Lt27dqF+/PkOGDIn/A7mDyDcmMNBcXg8MhBUrTFu+N96A1KmtrlAIEU8sC3SlVGJgJ3BBa11NKfUGMAtIB+wCmmitQ571HMI5BAebxVVWrDDbiRObwXD26ADq6+tLgwYNuHPnDgDlypVjypQpJLLXsmyu7P59qFED1q41256e5k2KPpdcCOE2rDxD/xo4DKSybQ8EhmmtZymlxgCtgNFWFSdiJyLCrI62YgV06mR6jZQuDR98EP/H2rlzJ/Xq1SNXrlzUr1+fZMmS0bJlS7xk8NaTwsNNB7d16+Cbb8yZ+PvvQ9myVlcmhLATSwJdKZUVqAr8AnRRpqn2B0BkD8nJQF8k0J1et25m2vJvv5nP7eXkyZNUrVqV9OnT4+vrS+bMme13MFcTEWEWk9+1K2rf9eumt+6ff5rBb0IIt2fVGfpwoDsQOVcmHXBLax1m2z4PZHnaNyqlWgOtAbLJ+sqWGj4chg6Fjh3NSaC9XL9+HR8fH8LCwiTMn6ZbN/NGvPNO1CLyiRLBoEES5kIkIA4PdKVUNeCq1nqXUqr8i36/1nosMBagWLFiOn6rE7E1dy506QJ16sCwYfHfROzevXvMnj2bBw8eMGXKFM6dO8eaNWvIly9f/B7IVa1ZY+YGHjtmeup27Ai//y7d3IRIwKw4Qy8D1FBKVQG8MPfQfwfSKKU8bGfpWYELFtQmYmHDBmjc2NwrnzbNDIKLT6GhodStW5eVK1cCkCRJEmbOnEmZMmXi90CuasoUaNYsarthQ/v8ViWEcCkOHxqste6ptc6qtc4BNALWaa0/A9YD9WwPawYsdnRt4vkOHoSaNSFnTliyBLy94/f5tdZ88cUXrFy5kjFjxnD16lUCAgKoU6dO/B7I1QQGwpkzsHAhtGplRqpfumQWTpk5M/5/qxJCuBxnmof+LTBLKdUP+BeYYHE94jEXLpiGMV5eZlR72rTxf4zevXszefJk+vbtS5s2beL/AK5o2zazss3du2a7UCGzkLzMIRdCRGNpoGut/QA/2+cngeJW1iNidvu26Uty6xZs3Ag5csT/Mf766y/69evH559/Tu/eveP/AK7o2DGoVg0yZTL3yD08zLaEuRDiMc50hi6cVEiIGfx2+DAsXw6FC8ffcy9atIiff/6Z0NBQDh48SNWqVRk9ejQqId4PPnXKXE6/fj1q34UL5nK6ry+8+aZ1tQkhnJ4EunimiAho0cL0J5k82Vz5jS/+/v40bNiQnDlz8tZbb1GuXDkGDhyIh72WZXNmAQHmEsiVK1ChQtT+/PnNWuQS5kKI50iAPznF82gNU6fCkSPw338wbx78+qvpCBdfDh48SK1atciZMyebN28mrT1uyDu7u3dh5EhzP2PVKjh92qxBLt3chBBxIIEunjBoEHz7rbldmygRdO0KPXrE3/NfuHABHx8fvL298fX1TZhhHhoK9eubS+menpA8OUyfLmEuhIgzCXTxiBkzTJg3amTyJb7WPAkJCWH37t2Eh4fTrl07bt++zYYNG8iePXv8HMAVaA379plFU/76y4T5uHHw+edWVyaEcAMS6OKhtWuheXMoXx4mTYq/MH/w4AEfffQRmzdvBsDDw4Ply5dTOD5H17mCbt0g+jKvvXtLmAsh4o0EugDMiWOdOpA3r+ldEtkS/GWFh4fz2WefsWXLFn7//Xfy5s3LG2+8QZ48eeLnAK7i999NmH/+OdSrZ6adlShhdVVCCDcigS44e9YMsE6Z0kxLS5Mmfp5Xa02nTp1YuHAhv//+O1999VX8PLGzmzgRevY098kj3bhhFo0fM0a6ugkh7EICPYG7edOE+d27sGkTvP56/D33oEGDGDFiBN98803CCfN//jFn4SVKwP/+F7U/fXoz/UzCXAhhJxLoCVhQENSqBcePm/FZBQu+/HMuXryYhQsXEhQUxOzZs2nUqBEDBw58+Sd2Zjt2mDPvsDCzDF3RomYaWooUVlcmhEhAJNATqIgIM698wwaztkf0XiZxtXTpUurUqUPatGlJnjw5DRs2ZNKkSSSKr9F1zujgQahUyfyFvvIKFC8Oc+ZImAshHE4CPYHq2tWcTA4ebKaovazt27fTsGFDihQpgp+fHyncMdCuXQN//6jt8HAzct3bG7ZuhYQ0BU8I4XQk0BOgoUNh+HD4+mvo0uXln+/48eNUrVqVTJkysWzZMvcM8ytXzALwJ08+uj9VKhPyEuZCCItJoCcws2ebs/N69Uywv+waKFevXsXHxwetNb6+vmTKlCl+CnUGWkNwsGkEU7UqXL4MS5c+Gt6vvWafdWSFEOIFSaAnIH5+5r552bKmV/vL3tq+d+8e1apV4+LFi6xbt8695pYHB5uJ+cuXm+1EiWDxYhPsQgjhhCTQE4gDB8yI9ly5YNEi8PJ6uecLCwujYcOG7Nq1i4ULF1KyZMn4KNM5RC4xt3w5dO4MGTOaaWjxMXJQCCHsRALdjZ06Bd98A4GBphNcsmRmelpcrxBHRETQp08ftm3bxvXr19mzZw+jR4+mRo0a8Vu4FbSGgQNN/9vbt81UtP7943dVGiGEsCM3nk+UsF2/Dj4+sGaNuQX8zjsmzLNli/tz9urVi379+hEQEECyZMkYNmwYX375ZfwVbaWBA013t6tXzepnP/9sVqkRQggXIWfobuj+fahRA86cMSecZcq8/HOOHDmSgQMH0qZNG0aPHo162dF0zmDjRti9Gy5dMoEe30vMCSGEA0mgu5nwcPjsM9i2DebNi58wX7hwIR07dqR69eqMGDHCPcJ82TKoWdP8hYFpDhOfS8wJIYSDSaC7Ea3hq6/MoLc//jCDtOPqzp07XLt2jaNHj/Lpp59SvHhxZs2ahYeHC/6TuXPHNIWJdOIENGgAhQub3uteXmZFGnf4RUUIkWC54E9nEZOBA2HUKNO8rGPHuD/P/v37ef/997l58yYAuXPnZunSpSRLliyeKnWgf/81o9Nv3350f86c5izdnebNCyESNAl0NzF1qhnT9cknMGBA3J/n3LlzVK5cGW9vb4YMGYKHhwcff/wx6dOnj79iHeXMGahSxXRzGz486nK6UuYSu4S5EMKNSKC7gTVroGVLcyI6cWLcbwPfunWLypUrc+fOHTZu3EihQoXit1BHuHoVmjSBc+dMu9aICPMX9PbbVlcmhBB2JSOAXNyePeZe+VtvwcKFkDRp3J4nODiYWrVqcezYMRYtWuSaYX7vHlSrZkavv/02fPwxrFghYS6ESBDkDN2FnTkDlSub8VwrVkDq1HF7noiICJo2bYq/vz8zZsyggit1RAsJMSMAr10zK57t2mVatFarZnVlQgjhUBLoLurGDdM4JijIXFHOkiXuz9WtWzfmzJnDb7/9xieffBJ/RdpbZIvWGTPMSPWkSWHsWAlzIUSCJIHugoKCzBTqkydh1aq4XVE+evQoV69eZf369QwdOpSOHTvyzTffxH+x8UVr2LvXTEGLNG+eCfNffzUjAoUQIgGTQHcx4eHQuDFs2mSWQn3//Rd/jilTptCsWbOH23Xr1mXYsGHO3TDmxx/Nx+PatZN+60IIgQS6S9EaunSB+fPNWuYNGrz4c6xatYpWrVrxwQcf0KtXL5IkSUKpUqVInDhx/BccX8aNM2HeuDE0bx61P1kyswqaM/8iIoQQDiKB7kKGDDHjvzp3Nh8v6t9//6Vu3brkz5+fBQsWkDquo+gcYeFCaNsWHjwwl9l9fODvv83CKUIIIZ4gge4iZs40HeAaNIDBg1/8+0+fPk2VKlV45ZVXWLFihXOH+caNpkNO/vzmnsIrr5jfYCTMhRAiRhLoLmDdOmjWDMqVg8mTX7xxTEBAAD4+PgQFBbF27Vpee+01+xT6Mg4eNJcgQkJg+XLIkQNWr4Z06ayuTAghXIIEupPbtw9q14Y8ecyiK15eL/b9Dx48oEaNGpw+fZrVq1eTP39+u9T5Us6cgY8+MpfWM2WCfPnMMqYS5kIIEWsS6E7s3DnTijxlStM45pVXYvd9YWFh+Pr6cvfuXWbMmMHWrVuZM2cOZcuWtW/BLyIwEFauhLAw+Plns4j71q1QoIDVlQkhhEuSQHdSt26ZLnB37pgpaq+/Hrvv01rTunVrJk6c+HDf8OHDqVevnn0KjYt79+DDD2HHDrOdNCn4+kqYCyHES5BAd0LBwVCrFhw7Zk5iCxaM/ff27duXiRMn0rNnT5o2bUqKFCnImjWr3WqNlfv3zZw7MN3dPv3UtGidOhWKFYMMGeTyuhBCvCSHB7pS6nVgCpAJ0MBYrfXvSqm0wGwgB3AaaKC1vuno+qwWEQFNm4K/v2mC9iJt1ceNG8dPP/1Ey5Yt+eWXX6xvFBMeblY+mznzya+NHm3mlQshhIgXVpyhhwFdtda7lVIpgV1KqdVAc2Ct1nqAUqoH0AP41oL6LNWtG8yZA7/9ZmZuxdayZcto27YtPj4+jBkzxvow19pMNZs508wnf+ONqK/lzQs1alhXmxBCuCGHB7rW+hJwyfb5HaXUYSALUBMob3vYZMCPBBbow4ebDnAdO8KLtFXfsWMHDRo0oHDhwsydOxdPK+drjxoFc+eahvPbtpnWdkOGWFePEEIkEJauh66UygEUAf4PyGQLe4DLmEvyT/ue1kqpnUqpndeuXXNMoQ4wZ47Jvjp1YNiw2HczPX78OFWrViVTpkwsW7aMFClS2LfQZ5kwAdq3N0uZJkkC3bvDoEHW1SOEEAmIZYPilFIpgPlAJ611YPRLxFprrZTST/s+rfVYYCxAsWLFnvoYV+Pvb241ly4N06bB89qqX7t2jZkzZxIaGsqYMWOIiIjA19eXTJme+juQfe3YARs2wO3bZtWzjz+Gf/6Rrm5CCOFglgS6UsoTE+bTtdYLbLuvKKUya60vKaUyA1etqM3RDh40I9pz5oQlS8Db+9mPDwwM5MMPP2Tfvn0ApE6dmhUrVpAnTx77F/u4TZvM9LPgYLNdsqS53C5hLoQQDmfFKHcFTAAOa62HRvvSEqAZMMD252JH1+ZoFy6YNUe8vEzjmLRpn/34kJAQ6tSpw6FDh1i2bBlly5YladKkJEmSxDEFg5mCdv48XLliFmXPnh3WroXUqSF58hfvSyuEECJeWHGGXgZoAuxXSu2x7euFCfI5SqlWwBkgDouDuo7bt03jmNu3zRXrHDme/XitNa1atWLt2rVMmjSJKlWqOKTOR5w5A2XKmN9EwLRp9fUFq+e5CyGEsGSU+yYgpiFfFR1Zi1VCQszgt8OHzTokhQs//3t69erFtGnT6NevH82aNbN7jU+4ccP8BnL3Lowfb+4NlC0b+xZ2Qggh7Eo6xTlYRAS0aGFWUJsyxaxJ8jwjR45kwIABtGnThl69etm/yMBA0/TlyJGofbdumcsJK1dC+fL2r0EIIcQLkUB3sJ49TQe4X381I9ufZ+HChXTs2JHq1aszYsQI+zeMCQmBunXBz89cRogccq+UKVjCXAghnJIEugP9+afpANe2LfTo8fzHb9myhU8//ZTixYsza9YsPDzs9HaFh8OIEXD2LOzfD2vWwKRJZhF2IYQQLkEC3UHmz4evvzYDw//88/mNY44ePUr16tXJmjUr//zzD8mSJbNPYVqbjjZ//GFGqXt4wODBEuZCCOFiJNAdYNMm+OwzKFHCXG6PqXHM3bt32bFjB6GhobRp0wYPDw98fX3JkCFD/Bd18CBcvQrr15sw79TJtKgTQgjhkiTQ7ezwYbMOSbZspoFaTCfat27d4r333uPgwYMAJEuWDD8/P3LlyhX/RU2cCC1bRm3Xry/91oUQwsVJoNvRpUtmppenp5munT790x8XHBxMrVq1OHbsGFOmTCFbtmzkypXLPuuYr1gBX3xhhtd/953puV68uDSEEUIIFyeBbidaQ716cP266dWeM+fTHxcREUHTpk3x9/dnxowZfPIia6bG1pYt0LAh3LwJDx7AO++Ym/opU8b/sYQQQlhCAt1O/P1Njo4ZA//7X8yP69atG3PmzOG3336zT5gfPQrVq8Mrr8CXX5qGMB06SJgLIYSbkUC3k6FDzSX2pk1jfszw4cMZOnQoHTt25JsXWQD9ec6dgx9/NF3dNm0yI9dXrYr5MoEQQgiXJ4FuB8eOwdKl8MMPMa+eNmfOHLp06UKdOnUYNmxY/DWMuXnTrPhy6pQZiZc5M4weLWEuhBBuTgLdDn7/3QyEa9fu6V/39/enSZMmlC5dmmnTppH4eQugP09QkPkNIigIxo6F48fNKLwKFV7ueYUQQrgMCfR4tnKlydRmzcxiZI87ePAgtWrVImfOnCxZsgTv5y2A/jxhYdCggZkTB2a0+rRpEuZCCJHASKDHo927TRv0t98299Afd+HCBXx8fPDy8mLFihWkfd4C6M9y965p2frttybMhw41g99SpYKMGeP+vEIIIVySBHo8OXUKqlSBdOnMkqipUj369du3b1O5cmVu3brFxo0byfG8BdCfpU8f+OmnqO0ePaBz57g/nxBCCJcngR4PAgJMA5mQENNJ9bXXHv16SEgIderU4fDhwyxfvpzCsVkAPSajR5swr1cPSpeGV1+FRo1eqn4hhBCuTwL9JT14YK50nz5tFil76y2zPzw8nO7du7N9+3YCAgI4fPgwU6ZM4aPYLIAeae5cswpaRITZ1hq2boVq1WDmTDMdTQghhACk3+dLCA+HTz+Fbdtg+nR47z2zX2tNp06dGDp0KBEREWTOnJmxY8fSJDYLoEfy9YVPPjH9Y5MkMR9Jk0Lz5jBrloS5EEKIR0gqxJHW8NVXsGiRWaysbt2orw0aNIgRI0bQtWtXBg8eHPsnPXzYDHALDYX+/aFgQdiwQbq6CSGEeC4J9DgaOBBGjYJu3aBjx6j9M2bM4Ntvv6VRo0b89ttvsX/Co0fNKf6NG2Y7Tx4zuk7CXAghRCxIoMfB1KnQs6e5Ij5gQNT+tWvX0rx5c8qXL8+kSZNI9LwVzIKD4cQJuH/fLGGaOLE5S8+WzVxef9mGM0IIIRIMCfQXdPYstGpl+rZMnBi16ujevXupXbs2efPmZeHChSRNmvTZT3TrFpQrB/v3m+1kycDPD/Lls2f5Qggh3JQE+gv6808z6HzSJHMSDXD27FmqVKlC6tSpWbFiBWnSpHn2kwQHQ61acOSIGcWeIYNZ0jRvXjtXL4QQwl1JoL+AO3dMW9d69cxVcYCbN2/i4+PDvXv32LRpE1mzZn36N4eFQdu2sG6ducR++bIZGv/pp457AUIIIdyWBPoLmDgRAgOhSxezHRQURM2aNTlx4gQrV66kQIECT/9Grc3IufHjoWZNM9CtcmUJcyGEEPFGAj2WQkLMKmqlS0Px4hAREUHTpk3ZuHEjM2fOpHz58k9+07RpsGOHmUs+d67pux59FJ0QQggRTyTQY0FrMxDu5Ekz51xrTZcuXZg7dy5Dhgyh0dNar/71F3z5JaRIYZrAtGsHv/7q+OKFEEIkCBLosdCrlznZ/vlnqFoVhgwZyu+//06nTp3oEnn9HUzinzhhPtq3Nw9etEi6ugkhhLA7SZrnGDXKXCVv0wa++w5mzZrFN998Q/369RkyZEjUA/39oVIlc20e4N13YfZsCXMhhBAOIWnzDAsXQocOZvGVESPA39+PZs2aUa5cOaZMmRLVOObgQTMNLVcuGDPGhHjRouDlZWn9QgghEg4J9BicOGEGoRcvbtZCOXx4P7Vq1eLNN99k0aJFeF26ZEaqnz5teq9nymQWVImczyaEEEI4kAR6DIYPN6upzZ8PN26cp3LlyiRPnpwVK1bwSkSECfOrV+Hrr80ZebNmEuZCCCEsI4H+FDdvmjnnn34KyZPfomzZyty5c4eNlSuTrUsXc4k9cgH0yDVThRBCCAvJeuhPMW4c3LsH7dsHU6tWLY4ePcrCvHkpNG+eadfq5WUGvEmYCyGEcBJyhv6Y0FDTr71ChQiGDGmGv78/08uV44MNG0ynt1atrC5RCCGEeIKcoUejtbklfv48vPJKd2bPns3AihX5dMMG6NNHwlwIIYTTkjN0m9DQUH76KZDRo+HDcuNYsGAIHd5/n25r15og79PH6hKFEEKIGDndGbpSykcpdVQpdVwp1cNRxx00aCP9+qUH0rNmQ09qA8P9/VGVK8Po0aCUo0oRQgghXphTnaErpRIDI4GPgPPADqXUEq31IXsfu3793Bz652uK7xxJymzZ+KR9exKnTg2ffAKenvY+vBBCCPFSnCrQgeLAca31SQCl1CygJmD3QM8deodpRyabbm+bN0O6dPY+pBBCCBFvnO2SexbgXLTt87Z9DymlWiuldiqldl67di3+jqw15Mljur1JmAshhHAxzhboz6W1Hqu1Lqa1LpYhQ4b4e+K334Zt2yBHjvh7TiGEEMJBnC3QLwCvR9vOatvnGDLwTQghhItytkDfAeRWSr2hlEoCNAKWWFyTEEII4fScalCc1jpMKdUBWAkkBv7WWh+0uCwhhBDC6TlVoANorZcDy62uQwghhHAlznbJXQghhBBxIIEuhBBCuAEJdCGEEMINSKALIYQQbkACXQghhHADEuhCCCGEG5BAF0IIIdyABLoQQgjhBiTQhRBCCDegtNZW1xBnSqlrwJl4eKr0wPV4eB5nIK/FOclrcU7yWpyTvJZny661fmK5UZcO9PiilNqptS5mdR3xQV6Lc5LX4pzktTgneS1xI5fchRBCCDcggS6EEEK4AQl0Y6zVBcQjeS3OSV6Lc5LX4pzktcSB3EMXQggh3ICcoQshhBBuIMEHulLKRyl1VCl1XCnVw+p6XoRS6nWl1Hql1CGl1EGl1Ne2/X2VUheUUntsH1WsrjU2lFKnlVL7bTXvtO1Lq5RarZT6z/bnK1bX+TxKqbzR/u73KKUClVKdXOV9UUr9rZS6qpQ6EG3fU98HZfxh+/+zTylV1LrKnxTDaxmklDpiq3ehUiqNbX8OpdSDaO/PGMsKf4oYXkuM/6aUUj1t78tRpdTH1lT9dDG8ltnRXsdppdQe235nf19i+jns+P8zWusE+wEkBk4AOYEkwF4gv9V1vUD9mYGits9TAseA/EBf4Bur64vD6zkNpH9s329AD9vnPYCBVtf5gq8pMXAZyO4q7wtQDigKHHje+wBUAVYACigJ/J/V9cfitVQCPGyfD4z2WnJEf5yzfcTwWp76b8r2c2AvkBR4w/ZzLrHVr+FZr+Wxrw8BervI+xLTz2GH/59J6GfoxYHjWuuTWusQYBZQ0+KaYk1rfUlrvdv2+R3gMJDF2qriXU1gsu3zyUAt60qJk4rACa11fDRAcgit9QbgxmO7Y3ofagJTtLENSKOUyuyQQmPhaa9Fa71Kax1m29wGZHV4YXEQw/sSk5rALK11sNb6FHAc8/POKTzrtSilFNAAmOnQouLoGT+HHf5/JqEHehbgXLTt87hoICqlcgBFgP+z7epgu5zztytcprbRwCql1C6lVGvbvkxa60u2zy8DmawpLc4a8egPJld8XyDm98HV/w+1xJwtRXpDKfWvUspfKVXWqqJe0NP+Tbny+1IWuKK1/i/aPpd4Xx77Oezw/zMJPdDdglIqBTAf6KS1DgRGA7mAwsAlzOUrV/Ce1rooUBlor5QqF/2L2lyvcplpGUqpJEANYK5tl6u+L49wtfchJkqp74AwYLpt1yUgm9a6CNAFmKGUSmVVfbHkFv+mHvMJj/4S7BLvy1N+Dj/kqP8zCT3QLwCvR9vOatvnMpRSnph/RNO11gsAtNZXtNbhWusIYBxOdKntWbTWF2x/XgUWYuq+Enk5yvbnVesqfGGVgd1a6yvguu+LTUzvg0v+H1JKNQeqAZ/ZfthiuzwdYPt8F+a+cx7LioyFZ/ybctX3xQOoA8yO3OcK78vTfg5jwf+ZhB7oO4DcSqk3bGdTjYAlFtcUa7Z7TROAw1rrodH2R78fUxs48Pj3OhulVHKlVMrIzzEDlw5g3o9mtoc1AxZbU2GcPHKm4YrvSzQxvQ9LgKa2kbslgdvRLjM6JaWUD9AdqKG1vh9tfwalVGLb5zmB3MBJa6qMnWf8m1oCNFJKJVVKvYF5LdsdXV8cfAgc0Vqfj9zh7O9LTD+HseL/jNUjBK3+wIw4PIb5re87q+t5wdrfw1zG2QfssX1UAaYC+237lwCZra41Fq8lJ2ZU7l7gYOR7AaQD1gL/AWuAtFbXGsvXkxwIAFJH2+cS7wvml5BLQCjm/l6rmN4HzEjdkbb/P/uBYlbXH4vXchxzDzPy/8wY22Pr2v7t7QF2A9Wtrj8WryXGf1PAd7b35ShQ2er6n/dabPsnAV8+9lhnf19i+jns8P8z0ilOCCGEcAMJ/ZK7EEII4RYk0IUQQgg3IIEuhBBCuAEJdCGEEMINSKALIYQQbkACXQgnpJTSSqkh0ba/UUr1jeNzpVFKtYu34p58fj9lWx3Ptl1MKeUXT8/dXCk1Ij6eSwh3J4EuhHMKBuoopdLHw3OlAZ4a6LbOXPEho1Kqcjw9V7yJbEgiREIggS6EcwoDxgKdH/+CrXPWfKXUDttHGdv+vkqpb6I97oBtsYgBQC7bWtKDlFLllVIblVJLgENKKS+l1ERl1qL/VylVwfb9zZVSC5RSvrY1nX97Rr2DMI1MHq/1kTNspdRSpVR52+d3bfUcVEqtUUoVt53tn1RK1Yj2NK/b9v+nlOoT7bkaK6W2217XX9G6id1VSg1RSu0FSj3vL1oIdyGBLoTzGgl8ppRK/dj+34FhWut3MV20xj/neXpglnAtrLXuZttXFPhaa50HaI9ZP6Igpl3tZKWUl+1xhYGGQEGgoVLqdZ5uKxAS+ctALCUH1mmt3wbuAP2AjzAtTH+K9rjimNdZCKhvu6T/lq2uMlrrwkA48Fm05/0/rfU7WutNL1CPEC4tvi63CSHimdY6UCk1BfgKeBDtSx8C+U0LaQBS2VZ6ehHbtVknG0zryj9txzyilDpD1OIXa7XWtwGUUoeA7Dy69GN0/YDvgW9jWUMI4Gv7fD8QrLUOVUrtB3JEe9xqbVucQym1wFZvGPA/YIft78GbqMUvwjELZQiRoEigC+HchmP6V0+Mti8RUFJrHRT9gUqpMB696uZFzO7F8vjB0T4P5xk/M7TW65RS/YCS0XY/q6ZQHdV7OiLyWFrriMfu7T/en1pj+mFP1lr3fEopQVrr8JjqFMJdySV3IZyY1voGMAezEEekVUDHyA2lVGHbp6cxl9JRShUF3rDtvwOkfMZhNmK7XK2UygNkwyzoERf9MCuZRToNFFZKJbJdro/LkrEfKaXSKqW8gVrAZsyiF/WUUhltdadVSmWPY81CuAUJdCGc3xAg+mj3r4BiSql9tsvgX9r2zwfSKqUOAh0wqwhiu1y92TZIbtBTnn8UkMh2qXs20FxrHfyUxz2X1no5cC3ars3AKeAQ8AfmasOL2o55bfuA+VrrnVrrQ5jL+6uUUvuA1UDmZzyHEG5PVlsTQggh3ICcoQshhBBuQAJdCCGEcAMS6EIIIYQbkEAXQggh3IAEuhBCCOEGJNCFEEIINyCBLoQQQrgBCXQhhBDCDfw/pphLvf8PR6cAAAAASUVORK5CYII=", 153 | "text/plain": [ 154 | "
" 155 | ] 156 | }, 157 | "metadata": { 158 | "needs_background": "light" 159 | }, 160 | "output_type": "display_data" 161 | } 162 | ], 163 | "source": [ 164 | "plt.figure(figsize=(8,6))\n", 165 | "plt.plot(N_list,Zproton,label='Proton drip line',color='b')\n", 166 | "plt.plot(N_list,Zneutron,label='Neutron drip line',color='r')\n", 167 | "plt.plot(N_list,Zbeta,label='Beta stability',color='k')\n", 168 | "plt.xlabel('Neutron Number')\n", 169 | "plt.ylabel('Proton Number')\n", 170 | "plt.legend()\n", 171 | "plt.show()" 172 | ] 173 | } 174 | ], 175 | "metadata": { 176 | "interpreter": { 177 | "hash": "31e9a9fdb727f4cab00c9bb2df7901a2e872a4cc83935cdcfda541b216adb23e" 178 | }, 179 | "kernelspec": { 180 | "display_name": "Python 3.9.7 64-bit", 181 | "language": "python", 182 | "name": "python3" 183 | }, 184 | "language_info": { 185 | "codemirror_mode": { 186 | "name": "ipython", 187 | "version": 3 188 | }, 189 | "file_extension": ".py", 190 | "mimetype": "text/x-python", 191 | "name": "python", 192 | "nbconvert_exporter": "python", 193 | "pygments_lexer": "ipython3", 194 | "version": "3.9.7" 195 | } 196 | }, 197 | "nbformat": 4, 198 | "nbformat_minor": 5 199 | } 200 | -------------------------------------------------------------------------------- /12. Alpha decay.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "90f8311e", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import math\n", 11 | "import matplotlib.pyplot as plt\n", 12 | "import numpy as np" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 2, 18 | "id": "eb1ed5c8", 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "def integration_two_point_gauss(function, x1, x2, h):\n", 23 | " n = int((x2-x1)/h)\n", 24 | " x_values = [x1+h*i for i in range(n)] \n", 25 | " integral = 0\n", 26 | " \n", 27 | " for x in x_values:\n", 28 | " x1 = x\n", 29 | " x2 = x1 + h\n", 30 | "\n", 31 | " a = (x1+x2)/2.0 - (x2-x1)/(2.0*math.sqrt(3.0))\n", 32 | " b = (x1+x2)/2.0 + (x2-x1)/(2.0*math.sqrt(3.0))\n", 33 | "\n", 34 | " f_a = function(a)\n", 35 | " f_b = function(b)\n", 36 | "\n", 37 | " integral_gauss = h*(f_a+f_b)/2.0\n", 38 | " integral = integral + integral_gauss\n", 39 | "\n", 40 | " return integral" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 3, 46 | "id": "96eac782", 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [ 50 | "A3 = 143.910092 #mass of parent nucleus\n", 51 | "Z = 60 #atomic number of parent nucleus\n", 52 | "A1 = 139.905448 #mass of daughter nucleus\n", 53 | "A2 = 4.002603\n", 54 | "hc = 197\n", 55 | "fs = 1/137\n", 56 | "R = 1.2*((A1**(1/3))+(A2**(1/3)))\n", 57 | "malpha = A2*A1*931.49/A3\n", 58 | "Q = (A3-A1-A2)*931.49\n", 59 | "pi = math.pi\n", 60 | "c = 3*(10**23)\n", 61 | "b = 2*(Z-2)*hc*fs/Q\n", 62 | "v = c*math.sqrt(2*Q/malpha)\n", 63 | "vc = v/(2*R)\n", 64 | "h = 0.0001" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "id": "212acc49", 70 | "metadata": {}, 71 | "source": [ 72 | "Square Well" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 4, 78 | "id": "36a84d9f", 79 | "metadata": {}, 80 | "outputs": [ 81 | { 82 | "name": "stdout", 83 | "output_type": "stream", 84 | "text": [ 85 | "5.542827137248644e+22\n" 86 | ] 87 | } 88 | ], 89 | "source": [ 90 | "\n", 91 | "G = math.sqrt(2*malpha*Q)*b*(pi/2 - 2*math.sqrt(R/b))/hc\n", 92 | "T = math.exp(-2*G)\n", 93 | "lam = vc*T\n", 94 | "T_half = math.log(2)/lam\n", 95 | "print(T_half)" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 5, 101 | "id": "ea030524", 102 | "metadata": {}, 103 | "outputs": [ 104 | { 105 | "name": "stdout", 106 | "output_type": "stream", 107 | "text": [ 108 | "1.7798055958427078e+22\n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "V0 = 50\n", 114 | "a = 0.5\n", 115 | "E = Q\n", 116 | "def Vws(r):\n", 117 | " return -V0/(1+math.exp((r-R)/a))\n", 118 | "def Vc(r):\n", 119 | " if r<=R:\n", 120 | " return 2*(Z-2)*hc*fs*(3-((r/R)**2))/(2*R)\n", 121 | " if r>R:\n", 122 | " return 2*(Z-2)*hc*fs/r\n", 123 | "def k(r):\n", 124 | " V = Vc(r)+Vws(r)\n", 125 | " return math.sqrt(2*malpha*abs(V-E))/hc\n", 126 | "G = integration_two_point_gauss(k, R, b, h)\n", 127 | "T = np.exp(-2*G)\n", 128 | "lam = vc*T\n", 129 | "T_half = math.log(2)/lam\n", 130 | "print(T_half)" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "id": "4ef03584", 136 | "metadata": {}, 137 | "source": [ 138 | "Wood-Saxon Potential" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 6, 144 | "id": "1bd83fed", 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "data": { 149 | "text/plain": [ 150 | "[]" 151 | ] 152 | }, 153 | "execution_count": 6, 154 | "metadata": {}, 155 | "output_type": "execute_result" 156 | }, 157 | { 158 | "data": { 159 | "image/png": "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", 160 | "text/plain": [ 161 | "
" 162 | ] 163 | }, 164 | "metadata": { 165 | "needs_background": "light" 166 | }, 167 | "output_type": "display_data" 168 | } 169 | ], 170 | "source": [ 171 | "r=np.linspace(0,25)\n", 172 | "lol=[]\n", 173 | "for ra in r:\n", 174 | " lol.append(Vc(ra)+Vws(ra))\n", 175 | "plt.plot(r,lol)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": 7, 181 | "id": "26de9540", 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "name": "stdout", 186 | "output_type": "stream", 187 | "text": [ 188 | "1.5040683311346897e+23\n", 189 | "4.608481983242248e-24 50.78647942849438 5.972187527060387e+20\n" 190 | ] 191 | } 192 | ], 193 | "source": [ 194 | "V0 = 50\n", 195 | "a = 0.5\n", 196 | "E = Q\n", 197 | "def Vws(r):\n", 198 | " return -V0/(1+math.exp((r-R)/a))\n", 199 | "def Vc(r):\n", 200 | " if r<=R:\n", 201 | " return 2*(Z-2)*hc*fs*(3-((r/R)**2))/(2*R)+Vws(r)\n", 202 | " if r>R:\n", 203 | " return 2*(Z-2)*hc*fs/r\n", 204 | "def k(r):\n", 205 | " V = Vc(r)\n", 206 | " return math.sqrt(2*malpha*abs(V-E))/hc\n", 207 | "G = integration_two_point_gauss(k, R, b, h)\n", 208 | "T = np.exp(-2*G)\n", 209 | "lam = vc*T\n", 210 | "T_half = math.log(2)/lam\n", 211 | "print(T_half)\n", 212 | "print(lam,G,vc)" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 8, 218 | "id": "9adebfa3", 219 | "metadata": {}, 220 | "outputs": [ 221 | { 222 | "data": { 223 | "text/plain": [ 224 | "[]" 225 | ] 226 | }, 227 | "execution_count": 8, 228 | "metadata": {}, 229 | "output_type": "execute_result" 230 | }, 231 | { 232 | "data": { 233 | "image/png": "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", 234 | "text/plain": [ 235 | "
" 236 | ] 237 | }, 238 | "metadata": { 239 | "needs_background": "light" 240 | }, 241 | "output_type": "display_data" 242 | } 243 | ], 244 | "source": [ 245 | "# The function written in the notes.pdf is incorrect\n", 246 | "r=np.linspace(0,25)\n", 247 | "lol=[]\n", 248 | "for ra in r:\n", 249 | " lol.append(Vc(ra))\n", 250 | "plt.plot(r,lol)" 251 | ] 252 | } 253 | ], 254 | "metadata": { 255 | "interpreter": { 256 | "hash": "31e9a9fdb727f4cab00c9bb2df7901a2e872a4cc83935cdcfda541b216adb23e" 257 | }, 258 | "kernelspec": { 259 | "display_name": "Python 3.9.7 64-bit", 260 | "language": "python", 261 | "name": "python3" 262 | }, 263 | "language_info": { 264 | "codemirror_mode": { 265 | "name": "ipython", 266 | "version": 3 267 | }, 268 | "file_extension": ".py", 269 | "mimetype": "text/x-python", 270 | "name": "python", 271 | "nbconvert_exporter": "python", 272 | "pygments_lexer": "ipython3", 273 | "version": "3.9.7" 274 | } 275 | }, 276 | "nbformat": 4, 277 | "nbformat_minor": 5 278 | } 279 | -------------------------------------------------------------------------------- /3. Rutherford Scattering.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 6, 6 | "id": "16cf4fbf", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import matplotlib.pyplot as plt\n", 11 | "import numpy as np\n", 12 | "import math" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 7, 18 | "id": "200c1828", 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "def rk4_vector(f,t0,x0,h):\n", 23 | " k1 = h*f(t0, x0)\n", 24 | "\n", 25 | " k2 = h*f(t0+h/2, x0+k1/2)\n", 26 | " \n", 27 | " k3 = h*f(t0+h/2, x0+k2/2)\n", 28 | " \n", 29 | " k4 = h*f(t0+h, x0+k3)\n", 30 | "\n", 31 | " x1 = x0 + (k1+2*k2+2*k3+k4)/6\n", 32 | " \n", 33 | " return x1" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 8, 39 | "id": "55e3e024", 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "data": { 44 | "image/png": "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", 45 | "text/plain": [ 46 | "
" 47 | ] 48 | }, 49 | "metadata": { 50 | "needs_background": "light" 51 | }, 52 | "output_type": "display_data" 53 | } 54 | ], 55 | "source": [ 56 | "# Nuclear radius equal to Rt\n", 57 | "h = 1\n", 58 | "t_min = 0\n", 59 | "t_max = 10000\n", 60 | "b_min = -10\n", 61 | "b_max = 10\n", 62 | "x_min = -10\n", 63 | "E = 5\n", 64 | "m = 3727.379378\n", 65 | "A = 197\n", 66 | "Rt = 1.2*(A**(1/3))\n", 67 | "q = 2\n", 68 | "Q = 79\n", 69 | "e2 = 1.44\n", 70 | "\n", 71 | "b_list = range(b_min,b_max+1,2)\n", 72 | "t_list = range(t_min,t_max+1,h)\n", 73 | "ax = plt.gca()\n", 74 | "ax.set_xlim([-10, 1])\n", 75 | "ax.set_ylim([-20, 20])\n", 76 | "\n", 77 | "def f(t,x):\n", 78 | " z1 = x[0][0]\n", 79 | " z2 = x[1][0]\n", 80 | " z3 = x[2][0]\n", 81 | " z4 = x[3][0]\n", 82 | " \n", 83 | " r = (z1**2+z3**2)**0.5\n", 84 | " r = max(r,Rt)\n", 85 | " \n", 86 | " a = z2\n", 87 | " b = q*Q*e2*z1/(m*(r**3))\n", 88 | " c = z4\n", 89 | " d = q*Q*e2*z3/(m*(r**3))\n", 90 | " \n", 91 | " return np.array([[a],[b],[c],[d]])\n", 92 | "\n", 93 | "for b in b_list:\n", 94 | " x_list = []\n", 95 | " y_list = []\n", 96 | " x1 = np.array([[x_min],[(2*E/m)**0.5],[b],[0]])\n", 97 | "\n", 98 | " for t in t_list:\n", 99 | " x0 = x1\n", 100 | " x1 = rk4_vector(f,t,x0,h)\n", 101 | " x_list.append(x1[0][0])\n", 102 | " y_list.append(x1[2][0])\n", 103 | "\n", 104 | " plt.plot(x_list,y_list)\n", 105 | "plt.show()" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 9, 111 | "id": "f778d7ea", 112 | "metadata": {}, 113 | "outputs": [ 114 | { 115 | "data": { 116 | "image/png": "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", 117 | "text/plain": [ 118 | "
" 119 | ] 120 | }, 121 | "metadata": { 122 | "needs_background": "light" 123 | }, 124 | "output_type": "display_data" 125 | } 126 | ], 127 | "source": [ 128 | "# Nuclear radius order of magnitude bigger\n", 129 | "h = 1\n", 130 | "t_min = 0\n", 131 | "t_max = 10000\n", 132 | "b_min = -10\n", 133 | "b_max = 10\n", 134 | "x_min = -10\n", 135 | "E = 5\n", 136 | "m = 3727.379378\n", 137 | "A = 197\n", 138 | "Rt = 1.2*(A**(1/3))*10 # Previous radius*10\n", 139 | "q = 2\n", 140 | "Q = 79\n", 141 | "e2 = 1.44\n", 142 | "\n", 143 | "b_list = range(b_min,b_max+1,2)\n", 144 | "t_list = range(t_min,t_max+1,h)\n", 145 | "ax = plt.gca()\n", 146 | "ax.set_xlim([-10, 1])\n", 147 | "ax.set_ylim([-20, 20])\n", 148 | "\n", 149 | "def f(t,x):\n", 150 | " z1 = x[0][0]\n", 151 | " z2 = x[1][0]\n", 152 | " z3 = x[2][0]\n", 153 | " z4 = x[3][0]\n", 154 | " \n", 155 | " r = (z1**2+z3**2)**0.5\n", 156 | " r = max(r,Rt)\n", 157 | " \n", 158 | " a = z2\n", 159 | " b = q*Q*e2*z1/(m*(r**3))\n", 160 | " c = z4\n", 161 | " d = q*Q*e2*z3/(m*(r**3))\n", 162 | " \n", 163 | " return np.array([[a],[b],[c],[d]])\n", 164 | "\n", 165 | "for b in b_list:\n", 166 | " x_list = []\n", 167 | " y_list = []\n", 168 | " x1 = np.array([[x_min],[(2*E/m)**0.5],[b],[0]])\n", 169 | "\n", 170 | " for t in t_list:\n", 171 | " x0 = x1\n", 172 | " x1 = rk4_vector(f,t,x0,h)\n", 173 | " x_list.append(x1[0][0])\n", 174 | " y_list.append(x1[2][0])\n", 175 | "\n", 176 | " plt.plot(x_list,y_list)\n", 177 | "plt.show()\n", 178 | "# At a higher nuclear radius, there is no scattering" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 10, 184 | "id": "0fc9bf41", 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "data": { 189 | "image/png": "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", 190 | "text/plain": [ 191 | "
" 192 | ] 193 | }, 194 | "metadata": { 195 | "needs_background": "light" 196 | }, 197 | "output_type": "display_data" 198 | } 199 | ], 200 | "source": [ 201 | "# cylindrical coordinates\n", 202 | "h = 0.001\n", 203 | "b_min = -20\n", 204 | "b_max = 20\n", 205 | "x0 = 20\n", 206 | "E = 5\n", 207 | "m = 3727.379378\n", 208 | "v = (2*E/m)**0.5\n", 209 | "\n", 210 | "A = 197\n", 211 | "q = 2\n", 212 | "Q = 79\n", 213 | "e2 = 1.44\n", 214 | "\n", 215 | "b_list = range(b_min,b_max+1,3)\n", 216 | "ax = plt.gca()\n", 217 | "ax.set_xlim([-20, -15])\n", 218 | "ax.set_ylim([-25, 25])\n", 219 | "\n", 220 | "for b in b_list:\n", 221 | " x_list = []\n", 222 | " y_list = []\n", 223 | " if b<0:\n", 224 | " factor = -1\n", 225 | " else:\n", 226 | " factor = 1\n", 227 | " k = q*Q*e2/(m*(v**2)*(b**2))\n", 228 | " ui = 1/((x0**2+b**2)**(0.5))\n", 229 | " thetai = math.pi - math.atan(b/x0)\n", 230 | " theta0 = math.atan(-(1+math.cos(thetai)+ui/k)/math.sin(thetai))\n", 231 | " u0 = -k/math.cos(theta0)\n", 232 | " theta = thetai\n", 233 | " u = ui\n", 234 | " while (u>0.001):\n", 235 | " r = 1/u\n", 236 | " x_list.append(r*math.cos(theta))\n", 237 | " y_list.append(r*math.sin(theta))\n", 238 | " theta = theta - factor*h\n", 239 | " u = u0*math.cos(theta-theta0)-k\n", 240 | " plt.plot(x_list,y_list)\n", 241 | "plt.show()" 242 | ] 243 | } 244 | ], 245 | "metadata": { 246 | "interpreter": { 247 | "hash": "31e9a9fdb727f4cab00c9bb2df7901a2e872a4cc83935cdcfda541b216adb23e" 248 | }, 249 | "kernelspec": { 250 | "display_name": "Python 3.9.7 64-bit", 251 | "language": "python", 252 | "name": "python3" 253 | }, 254 | "language_info": { 255 | "codemirror_mode": { 256 | "name": "ipython", 257 | "version": 3 258 | }, 259 | "file_extension": ".py", 260 | "mimetype": "text/x-python", 261 | "name": "python", 262 | "nbconvert_exporter": "python", 263 | "pygments_lexer": "ipython3", 264 | "version": "3.9.7" 265 | } 266 | }, 267 | "nbformat": 4, 268 | "nbformat_minor": 5 269 | } 270 | -------------------------------------------------------------------------------- /4. Legendre polynomials.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import numpy as np 3 | x=np.linspace(-1,1,1000) 4 | p0 = np.ones(np.size(x)) 5 | p1 = x 6 | plt.plot(x,p0, label='$P_{0}(x)$') 7 | plt.plot(x,p1, label='$P_{1}(x)$') 8 | n=5 9 | for l in range(2,n+1): 10 | p2 = ((2*l+1)*x*p1 - l*p0)/(l+1) 11 | plt.plot(x,p2, label='$P_{{{}}}(x)$'.format(l)) 12 | p0=p1 13 | p1=p2 14 | plt.legend(loc='lower right') 15 | plt.xlabel('x') 16 | plt.ylabel('$P_{n}(x)$') 17 | plt.title('Legendre polynomials') 18 | plt.show() -------------------------------------------------------------------------------- /5. Associated Legendre polynomials.py: -------------------------------------------------------------------------------- 1 | from matplotlib import pyplot as plt 2 | import numpy as np 3 | 4 | def dblfact(n): 5 | if n==0 or n==1: 6 | return 1 7 | if n%2==1: 8 | return n*dblfact(n-2) 9 | if n%2==0: 10 | return (n-1)*dblfact(n-3) 11 | 12 | def legendre_polynomial(l, m, x): 13 | pmm = 1.0 14 | if m > 0: 15 | sign = 1.0 if m % 2 == 0 else -1.0 16 | pmm = sign * dblfact(2*m - 1)*pow((1.0 - x * x), ((m / 2)) ) 17 | 18 | if l == m: 19 | return pmm 20 | 21 | pmm1 = x * (2 * m + 1) * pmm 22 | if l == m + 1: 23 | return pmm1 24 | 25 | for n in range(m + 2, l + 1): 26 | pmn = (x * (2 * n - 1) * pmm1 - (n + m - 1) * pmm) / (n - m) 27 | pmm = pmm1 28 | pmm1 = pmn 29 | return pmm1 30 | 31 | x=np.linspace(-1,1,1000) 32 | L=5 33 | M=3 34 | Plm = legendre_polynomial(L,M,x) 35 | plt.plot(x,Plm) 36 | plt.show() -------------------------------------------------------------------------------- /6. Spherical harmonics Q2.py: -------------------------------------------------------------------------------- 1 | from math import atan 2 | import numpy as np 3 | 4 | def factorial(n): 5 | fct=[1.0] 6 | for i in range(n+1): 7 | fct.append((i+1)*fct[i]) 8 | return fct[n] 9 | 10 | def dblfact(n): 11 | if n==0 or n==1: 12 | return 1 13 | if n%2==1: 14 | return n*dblfact(n-2) 15 | if n%2==0: 16 | return (n-1)*dblfact(n-3) 17 | 18 | 19 | def legendre_polynomial(l, m, x): 20 | pmm = 1.0 21 | if m > 0: 22 | sign = 1.0 if m % 2 == 0 else -1.0 23 | pmm = sign * dblfact(2 * m - 1)*pow((1.0 - x * x), ((m / 2)) ) 24 | if l == m: 25 | return pmm 26 | pmm1 = x * (2 * m + 1) * pmm 27 | if l == m + 1: 28 | return pmm1 29 | for n in range(m + 2, l + 1): 30 | pmn = (x * (2 * n - 1) * pmm1 - (n + m - 1) * pmm) / (n - m) 31 | pmm = pmm1 32 | pmm1 = pmn 33 | return pmm1 34 | 35 | def simpInt(h, fnc): 36 | I = (fnc[0] + fnc[len(fnc)-1]) 37 | for i in range(1,len(fnc)-2,2): 38 | I = I + 4*fnc[i] + 2*fnc[i+1] 39 | I = I + 4*fnc[i+2] 40 | I = I*h/3 41 | return I 42 | 43 | pi= 4*atan(1.0) 44 | L=2 45 | M=0 46 | R=1 47 | theta = np.linspace(0, pi, 1000) 48 | phi = np.linspace(0, 2* pi, 181) 49 | r=np.linspace(0,R,1000) 50 | 51 | #The Integral is: 52 | # Qlm = Integral(r^l Ylm(theta,phi) Rho(r) dTau) 53 | # = Integral((r^l Rho(r) 4*pi*r^2 dr) (Ylm_theta sin(theta) d_theta) (Ylm_phi d_phi)) 54 | # = R(r) * THETA(theta) * PHI(phi) Using Separation of Variables 55 | 56 | K = np.sqrt( ((2*L + 1)* factorial(L - abs(M)))/ (4* pi* factorial(L + abs(M))) ) 57 | Ylm_theta = np.sin(theta)*np.sin(theta)*legendre_polynomial(L,M,np.cos(theta)) 58 | Qlm_theta = simpInt(theta[1]-theta[0],Ylm_theta) 59 | Ylm_r = r*r*r*r 60 | Qlm_r = simpInt(r[1]-r[0],Ylm_r) 61 | Ylm_phi=np.cos(M*phi) 62 | Qlm_phi = simpInt(phi[1]-phi[0],Ylm_phi) 63 | print(Qlm_r*Qlm_theta*Qlm_phi*K) 64 | 65 | #Hence we can evaluate the integrals separately. And we can see below that the THETA(theta) Integral evaluates to zero. Hence Q20 = 0 -------------------------------------------------------------------------------- /6. Spherical harmonics.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from math import atan 3 | import matplotlib.pyplot as plt 4 | 5 | def Spherical2Cartesian(r, theta, phi): 6 | x = r* np.sin(theta)* np.cos(phi) 7 | y = r* np.sin(theta)* np.sin(phi) 8 | z = r* np.cos(theta) 9 | 10 | return x, y, z 11 | 12 | def factorial(n): 13 | fct=[1.0] 14 | for i in range(n+1): 15 | fct.append((i+1)*fct[i]) 16 | return fct[n] 17 | 18 | # Double Factorial: Product of all odd integers less than or equal to n 19 | def dblfact(n): 20 | if n==0 or n==1: 21 | return 1 22 | if n%2==1: 23 | return n*dblfact(n-2) 24 | if n%2==0: 25 | return (n-1)*dblfact(n-3) 26 | 27 | #Associated Legendre Polynomials 28 | def legendre_polynomial(l, m, x): 29 | pmm = 1.0 30 | if m > 0: 31 | sign = 1.0 if m % 2 == 0 else -1.0 32 | pmm = sign * dblfact(2 * m - 1)*pow((1.0 - x * x), ((m / 2)) ) 33 | 34 | if l == m: 35 | return pmm 36 | 37 | pmm1 = x * (2 * m + 1) * pmm 38 | if l == m + 1: 39 | return pmm1 40 | 41 | for n in range(m + 2, l + 1): 42 | pmn = (x * (2 * n - 1) * pmm1 - (n + m - 1) * pmm) / (n - m) 43 | pmm = pmm1 44 | pmm1 = pmn 45 | 46 | return pmm1 47 | 48 | #Azimuthal and Magnetic quantum nubers 49 | l = int(input('Azimuthal quantum number "l": ')) 50 | if l < 0: 51 | print('"l" can not be a negative number') 52 | 53 | m = int(input('Magnetic quantum number "m": ')) 54 | if m > l or m < (-l): 55 | print('quntum number "m" belong to "[-l,l]"') 56 | 57 | pi=4*atan(1.0) 58 | 59 | #Normalization constant 60 | K = np.sqrt( ((2*l + 1)* factorial(l - abs(m)))/ (4* pi* factorial(l + abs(m))) ) 61 | 62 | #Value of Phi and Theta 63 | phi = np.linspace(0, 2* pi, 181) 64 | tht = np.linspace(0, pi, 91) 65 | Phi, Tht = np.meshgrid(phi, tht) 66 | 67 | #Value of Y 68 | p, q = np.shape(Phi) 69 | Y = np.zeros([p, q],dtype=np.complex_) 70 | 71 | for i in range(0, p): 72 | for j in range(0, q): 73 | 74 | if m > 0: 75 | #Y[i, j] = np.sqrt(2) * K * np.exp(1j*m * Phi[i, j]) * legendre_polynomial(l, m, np.cos(Tht[i, j])) 76 | Y[i, j] = np.sqrt(2) * K * np.cos(m * Phi[i, j]) * legendre_polynomial(l, m, np.cos(Tht[i, j])) 77 | elif m < 0: 78 | Y[i, j] = np.sqrt(2) * K * np.sin(abs(m) * Phi[i, j]) * legendre_polynomial(l, abs(m), np.cos(Tht[i, j])) 79 | 80 | else: 81 | Y[i, j] = K * legendre_polynomial(l, 0, np.cos(Tht[i, j])) 82 | 83 | #Convert data to cartesian form 84 | x, y, z = Spherical2Cartesian(abs((Y)), Tht, Phi) 85 | 86 | #Plotting 87 | fig = plt.figure('Harmonics') 88 | ax = fig.add_subplot( 111 , projection='3d') 89 | 90 | surf=ax.plot_surface(x, y, z, cmap = 'jet', edgecolor = 'k') 91 | fig.colorbar(surf) 92 | #plt.axis('auto') 93 | plt.title('Spherical Harmonics', fontsize = 14, fontweight = 'bold') 94 | #ax.view_init(azim=0, elev=0) 95 | ax.set_xlabel('X', fontsize = 12, fontweight = 'bold') 96 | ax.set_ylabel('Y', fontsize = 12, fontweight = 'bold') 97 | ax.set_zlabel('Z', fontsize = 12, fontweight = 'bold') 98 | plt.show() 99 | -------------------------------------------------------------------------------- /7.2 Anisotropic harmonic oscillator Fig 6.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | from fractions import Fraction 3 | Ntotal=6 4 | x = [-4,0,2,8] 5 | lname=['s','p','d','f','g','h','i','j'] 6 | for N in range(Ntotal): 7 | E1=N+1.5 8 | for l in range(N+1): 9 | n=((N-l)/2)+1 10 | if float(n).is_integer(): 11 | j=[l-0.5,l+0.5] 12 | if j[0]>0: 13 | E2=N+1.5+0.05*(l+1)-0.0225*l*(l+1) 14 | plt.plot(x,[E1,E1,E2,E2]) 15 | plt.text(8.7, E2,"{}{}{}".format(int(n),lname[l],str(Fraction(j[0]))),fontsize = 6) 16 | E2=N+1.5-0.05*(l)-0.0225*l*(l+1) 17 | plt.plot(x,[E1,E1,E2,E2]) 18 | plt.text(8.7, E2,"{}{}{}".format(int(n),lname[l],str(Fraction(j[1]))),fontsize = 6) 19 | plt.text(-3,E1+0.1,"N={}".format(int(N)),fontsize = 8) 20 | plt.title('The Single-Particle Energy Level Positions for the Spherical Shell Model') 21 | plt.show() -------------------------------------------------------------------------------- /7.2 Anisotropic harmonic oscillator Fig 7.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import numpy as np 3 | 4 | N=8 5 | x = np.linspace(-0.8,1, 100) 6 | for n in range(N): 7 | for nz in range(n+1): 8 | plt.plot(x,(n+1.5-(x*(3*nz-n)/3))) 9 | 10 | plt.ylim((0,7.5)) 11 | plt.axvline(x=0, color='k') 12 | plt.xlabel(r'$delta$') 13 | plt.ylabel(r'E/$\hbar\omega$') 14 | plt.title('Single-particle level spectrum') 15 | plt.show() -------------------------------------------------------------------------------- /7.3 Nilsson Model - Cranking Model.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "e4164260", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import math\n", 11 | "import matplotlib.pyplot as plt\n", 12 | "import numpy as np\n", 13 | "from sympy import Matrix" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 2, 19 | "id": "f8b2ebe1", 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "def factorial(n):\n", 24 | " F = [1]\n", 25 | " for i in range (1,int(n+1)):\n", 26 | " F.append(i*F[i-1])\n", 27 | " return F" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 3, 33 | "id": "85c9c4a9", 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "def cg_coeff1(j1, j2, m1, m2, j):\n", 38 | " F = factorial(20)\n", 39 | " m = m1 + m2 \n", 40 | " a = math.sqrt((2*j+1)*F[int(j+j1-j2)]*F[int(j-j1+j2)]*F[int(j1+j2-j)]*F[int(j+m)]*F[int(j-m)]*F[int(j1-m1)]*F[int(j1+m1)]*F[int(j2-m2)]*F[int(j2+m2)]/F[int(j1+j2+j+1)])\n", 41 | " k_max = min((j1+j2-j),(j1-m1),(j2+m2))\n", 42 | " k_min = -min(0,(j-j2+m1),(j-j1-m2))\n", 43 | " b = 0\n", 44 | " for k in range(int(k_min), int(k_max+1)):\n", 45 | " b = b + ((-1)**k)/(F[int(k)]*F[int(j1+j2-j-k)]*F[int(j1-m1-k)]*F[int(j2+m2-k)]*F[int(j-j2+m1+k)]*F[int(j-j1-m2+k)])\n", 46 | " return (a*b)\n" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 4, 52 | "id": "4b32a55b", 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "data": { 57 | "text/plain": [ 58 | "(0.0, 0.9)" 59 | ] 60 | }, 61 | "execution_count": 4, 62 | "metadata": {}, 63 | "output_type": "execute_result" 64 | }, 65 | { 66 | "data": { 67 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAG7CAYAAAAsU4mVAAAAO3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMGIxLCBodHRwczovL21hdHBsb3RsaWIub3JnLwiMSToAAAAJcEhZcwAACxMAAAsTAQCanBgAAHtRSURBVHic7d13eFRV+sDx75mS3jslVKkiRVBQFAQCCoq9K6CuP7Drrr1gwV7WXpB13VVAXdvqqiAERIqKSlOkl9BJJ71NOb8/7k0ImJAEkml5P88zT2bu3HvPe2cm884959xzlNYaIYQQAsDi7QCEEEL4DkkKQgghakhSEEIIUUOSghBCiBqSFIQQQtSQpCCEEKKGJAUhhBA1JCkIIYSoccxJQSm1Til1xrGHAkqpHUqptObYV3Nr7HH68jG0FE8cc2t8XY9VQ59ZeU3/TCn1b6XUE96Ow5salRSUUqcppX5UShUqpfKVUj8opU4C0Fofr7X+vkWj9ILD/2EC9ThF0/nLl+nhn9ljjdvcPlspFV5r2fVKqe+PsNnRlnWLUmqFUqpSKfXv5t6/P2rqa6KU+l4pVaGUKjFvmxpTToNJQSkVBXwNvAbEAe2Ax4DKxhTgb5RSNm/H0JIC/fh8QYC/xlbgdg+Usw94AnjXA2X5i6N5TW7RWkeYtx6N2aAxZwrdAbTWH2qtXVrrcq31fK3173Dorw/z/l1Kqd/Ns4r/KKVCqneklDpRKbVaKVWslPrEfL7OUzWlVFul1GdKqRylVIZS6rYjBWmWfb9Sar1S6oBS6l/VZSul7lNKbTPLXa+UuqCObe9VSv0OlCqlPgQ6AF+ZGfaew39lKaVSlVKfm/HlKaVeP9bjONK6jXhtG9q29vHZjvReKKXuVkp9dlhsryqlXjnSe3CkOMzyPz1s3VeUUq829XWqo8x7lVJ7zWPZpJQaVeu46/xMNOI1q/P9VUrN5LDPRj2vsVZKHVdrf4dUS5jr322+n6VKqX8qpZKVUnPN41iglIqt53ivVUp9VevxFqXUJ7Ue71ZK9VeH/m/WGTfQv77PVD2eB+5SSsU0sN4x0Vp/rrX+AshraN0j/X834v9mgFJqlbntf4B6j18pFamU2qMOq5JTSrU33+/4ozjURmvKa3KsBR3xBkSZQbwHjAViD3t+B5BW6/4vQFuMs4oNwA3mc0HAToxfGXbgQqAKeOLwfWEkq5XAw+Z2XYDtwJlHiHMH8AeQapb9Q/W+gUvMmCzAZUAp0OawbdeY24Yeflx1HKcV+A14CQjH+CCdVsd6jT6OhtZt4LVtzLY1x9fQewG0MV+jGPOxDcgGBh7htT/i+wZ0BMqAyFqv4X5gSGNep8Pfj1rLewC7gbbm405A10Z8Jo4Ua73vb32x1PEaa+C4Ws//mz9/1pcDyRhn39nAKmCAWd53wCP1vN5dgALzGNqa7+WeWs8dMJ87JM56Htf5mWrgff681ut4PfD9Ebb52oy1rtvXjfj+eQL4dwPr1Pv/faRj5OD/wV8x/g8uBhy136fDynkUmFfHcgWUAGe0xGtwNK+Jud73QA6Qi/HZrzO+P23XyCB6mR/qPYAT+B+QXMeX4A7g6lrbPQdMN+8PA/YCqtbzy6g7KQwGdh0Ww/3Avxr4wN5Q6/E4YFs9664Bzjts2+vq+geo6zFwivli2+r7xzHvN/o4Glq3gde2MdteV+u5xrwXc4H/M++fA6xv4LVv8H0zy5ho3h9d/f405nU6/P2otfw4jC/UNMDe2M/Ekco80vtbXyx1vMaNSQpX1Xr8GfBWrce3Al8c4TXfDZwIXA7MwPji6wlcC/yvoc9wQ5+pBt7nPkAhkEgDSeFYbzTyC/CwbdZg/n8f6Rgx/g/2cej/wY/UkRQwfihkAZeYjxOBLrWeLwDGttTrcDSvifkZjwSCgUlAMeYPpiPdGtXQrLXeoLW+Rmvd3vxAtAVermf1zFr3y4AI835bYK82ozXtrmcfHYG2SqmC6hvwAJCslLpKHWw4mXvYdrX3t9MsE6XURKXUmlr76gMkHGHbhqQCO7XWzgbWq/c4jnLd+l7bxmxb+/ga8168B1xt3r8amHnEI21cHB8AV5j3rzQfNzb+OmmttwJ3YPyKy1ZKfaSUalvPcdV8Jhoos7Hv7+Ga8hkC40umWnkdjyOo32LgDIwvtsUYvwqHm7fFTYihvs9UvbTWf2D8+r2vCeW0mEb8fzflO2lnPcX0AZKAeebjvwGTzfJDMb58s4/lOGpr4HuuUbTWP2uti7XWlVrr9zDOFsY1tF2TG8S01huV0fI9pYmb7gfaKaVUrTchFdhWx7q7gQytdbd69jW7nuWpte53APYppToC/wBGAT9prV1KqTUYp3y16QYeHx5fB6WUrYEvjoaO42jXPZptax9PY96LL4C3lFJ9MM4U7qFhDcXxCfB3pVR74AKMX+SNjb9eWusPgA+U0SnibeBZYIL59J8+Ew2VqZQ6hSO/v/V9NmovLwPCaj1OwTjTbi6LgfFAZ+ApjF+qV2G8pnW2b3Hkz3RTPYJR3fX3I61kfqGdXs/TS7XWY48liCb8f9elrv+DDtT9ndQOOKC1LjIfn8XBH0rDMarsVtcTY5NfA631bOr/njtamka8Lo3pfdRTKXWn+Y+MUioV49fe8iYG9BPgAm5RRkPnecDJ9az7C1BsNtyFKqWsSqk+yuwGewQ3m40+ccCDwH8w6oQ1RnUASqlrMbJ+Q7Iw6mfri28/8IxSKlwpFaKUGnqMx3G0x3w02zb4XmitK4BPMX7N/6K13nWscWitczB+0f4L4wt5w7Eeu1Kqh1JqpFIqGKjA+IXtrrVKXZ+Jhsps6P090mej2hrgSnO/Z2F8cTSnxcAIjDawPcBSjC+qeOr5cqJxcTeKeYb2H+CIHQK01mP1wd4vh9/qTQjm5zIEo9rGar4Hdf2IPdr/bzD+D5zAbUopu1LqQur/TsoHopRSnZVSV2C0R/RWRoP7o8DLWmt3XRse7WtwuCa8JiilYpRSZ1avo5S6CuOs8tuGymlM9VExRt3Uz0qpUoxk8AdwZ2MPBkBrXYXRoPkXjF81V2Ocgv6pa6vW2oXx67Q/kIHRUPIOEN1AMR8A8zEaDLdh1A2ux/g18xPGP8UJGKdRDXkaeMg8Jb2rjvjGY9Rn78L4BXjZsRzHMRxzk7dtwnvxHsbr1Ziqo8bG8QFGvfQHTdyuPsHAM+Y2mRin+PcfVt4hn4mGymzE+1vvZ6OW2819FGD8gv+iEcfSaFrrzRiNm0vNx0UYx/iDGX9dGhN3U0zD+FJuCQ9hJPj7MD6f5eayQxzD/3ft/4NrML70L8NoRK/Lr8BHGMn+L8C5wKnAFuBnjLPTlnbE10QZPdceMB/aMT7r1Q3NtwLnm5+bI1KHVqd5llLqZ4xGn381w752ANdrrRccc2CtUF3vhVKqA7ARSKl12uw35DMhRNN5dOwjpdRwpVSKeTozCehLI05nRPNr6L1QSlkwGtM+8seEIIQ4Op4eEO94jAa+SowGwf9qrffXXkEpFayMC0y2KqV+Vkp1qvXc/ebyTUqpMz0aeeDpgdEXvwCjKvDi6vdCGcMYFGF0G33EWwEKITzPo9VHSikFhGutS5RSdox+67drrZfXWucmoK/W+gal1OXABVrry5RSvYEPMRqC2gILgO5HqD8VQgjRRB49U9CGEvOh3bwdnpXOw2jgBKP3yygzmZyHUZVRqbXOALZSf08BIYQQR8HjA3cppawYwwscB7yhtf75sFXaYV4EpLV2KqUKMbrZtePQbrB7zGWH738y5kUl4eHhA3v27NnsxyCaT0lJCUVFRQQHBxMXF4eR/1sBrXEVVeEqcaCUwhodhCXc7u2oRCOtXLkyV2ud6O04WoLHk4JZ3dPf7N/7X6VUH/MKyeba/wyMy/4ZNGiQXrFiRXPtWjQjrTXp6en8+OOP9OnTh/PPPx+bLZAHFzVorSlbnU3hnAzcpQ7CT0oh6sxOWCUh+BWlVH1XPvs9r/0Xaq0LlFKLMC64qZ0U9mJchbrHvDAjGmNAvurl1dqby4SfcblcfPXVV6xZs4aTTjqJsWPHYrEE/iSAVftKKPhyG1U7i7CnRpIw6XiCUiO9HZYQh/BoUlBKJQIOMyGEYvRuOfyij/9hDN70E8aohd9prbVS6n8YQxm8iNHQ3A3jylPhRxwOB59++imbNm1i+PDhnHHGGQFfZeQuc1CYvpPS5fuxhNmIvagbYQOTUZbAPm7hnzx9ptAGeM9sV7AAH2utv1ZKTQNWaK3/B/wTmKmU2opxleHlAFrrdUqpj4H1GJem3yw9j/xLRUUFH374ITt37mTs2LEMHjzY2yG1KO3WlK3IonBeBu4yJ+FD2hA9uiOWMKkqEr7Lq1c0tzRpU/AdJSUlzJo1i+zsbM4//3z69u3r7ZBaVNXuYg58uRXHnhKCOkURc25Xgto2OACp8BNKqZVa60HejqMlBH7LnvC6AwcOMHPmTIqKirjiiivo1u2oBkP1C65SB0Xf7qB0RSaWCDuxl/UgrH9iwFeRicAhSUG0qOzsbGbOnInD4WDixIl06NDB2yG1CO3WlP68n8L5O9GVLiJOa0fUqA5YQuRfTPgX+cSKFrN7925mz56NzWbj2muvJTm5wTlz/FLljkIKvtyGY38pwV2jiTm3K/bklho8VIiWJUlBtIitW7fyn//8h4iICCZOnEhsbJ1z0Ps1Z2ElhXMyKP8tB2t0EHFX9iT0hASpKhJ+TZKCaHZr167lv//9L4mJiUyYMIGIiMBqYNUON8VL91C8aDdaayJHphJ5RiqWIKu3QxPimElSEM3ql19+Yc6cOXTs2JErrriCkJAQb4fUbLTWVKzLo2BOBq78CkKPjyf67C7Y4gLnGIWQpCCahdaaxYsX8/3339OjRw8uvvhi7PbA6Y/vyCql4KvtVG4twJYcRsL1JxByXIy3wxKi2UlSEMfM7Xbz7bff8ssvv9CvXz/OPfdcrNbAqEpxlzkoWrCLkuX7UME2Ys7tSvjgNiirtBuIwCRJQRwTl8vFF198wdq1aznllFMYPXp0QIxjpN2a0l8yKZq/A3e5k/DBbYga3VEGrhMBT5KCOGpVVVV8/PHHbN26lbS0NIYOHRoQPW8qtxdS8JXRxTSocxQx4+VqZNF6SFIQR6W8vJwPPviAPXv2MH78eAYOHOjtkI6Zs6DC6GL6ey7W6GDpYipaJUkKosmKioqYNWsWeXl5XHLJJfTu3dvbIR0T7XBRvHgPxYv3oDVEjupA5PD20sVUtEqSFEST5OXlMXPmTMrKyrjqqqvo0qWLt0M6alpryv/IpfCbDFwFlYSekED0uM7YYqWLqWi9JCmIRtu/fz+zZs1Ca82kSZNo1+5Ps6H6jar9pRR+tY3K7YXYU8KJ/b/uhHSN8XZYQnidJAXRKDt27ODDDz8kODiYCRMmkJjon9PTukodFKXvpPTn/VhCbcSc35Xwk6SLqRDVJCmIBm3cuJFPP/2UmJgYJkyYQHR0tLdDajLt0pT+sp+i9J1GF1OZ8EaIOklSEEe0Zs0avvzyS9q0acNVV11FeLj/jf5Zsa2Awq+24cgsI7iLOYppiv8dhxCeIElB1OvHH39k/vz5dOnShcsuu4zg4GBvh9QkzgNmF9O1uVhjgom7qhehfeKli6kQRyBJQfyJ1pqFCxeybNkyevfuzYUXXojN5j8fFXeVi+Lvd1O8ZC9KQdTojkQOa4eySxdTIRriP//pwiPcbjdff/01q1atYuDAgZx99tl+M2yF1pry33MpnJOBq7CS0H6JRI/tjC3Gv85whPAmSQqihtPp5LPPPmPDhg0MGzaMESNG+E1VS9XeEgq+3kZVRhH2NuHEXd6D4M7+1yAuhLdJUhAAVFZW8tFHH5GRkcGZZ57JKaec4u2QGsVZUEnR/B2Urc42uphecBzhJ6WgLP6RzITwNZIUBKWlpcyePZv9+/dzwQUX0K9fP2+H1CB3hdMYmmLpXkATMaw9UWekYgmVj7QQx0L+g1q5goICZs6cSWFhIZdffjk9evTwdkhHpF2a0l/3U5S+C3epg9D+iUSP6SSznwnRTCQptGI5OTnMnDmTyspKJkyYQMeOHb0dUr201lRsyKdwbgbOnHJjSOtxxxOUGunt0IQIKJIUWqm9e/cya9YsLBYL1157LSkpKd4OqV5Ve4opnJNB5fZCbAmhxE/oTUjvOL9pBBfCn0hSaIW2bdvGRx99RHh4OBMnTiQuLs7bIdXJWVBB0bydRiNyuI2Y87oSfnIKyuofXWSF8EeSFFqZdevW8fnnnxMfH8+ECROIjPS96hd3hdO4+GzZXgAiz2hP5BmpWELk4ypES5P/slZkxYoVfP3116SmpnLllVcSGhrq7ZAOoV1uY17kBTtxlzoJG5BE1JkdscVII7IQniJJoRXQWrN06VK+++47unXrxiWXXEJQUJC3w6qhtaZivdmInFtOcJdoosd1Jqi9753FCBHoJCkEOLfbzfz581m+fDl9+/blvPPOw2r1nTGAqnYXUzBnO1UZRdgSQ4mf2JuQXtKILIS3SFIIYC6Xiy+//JLff/+dwYMHc+aZZ/rMOEbOAxUUzttB+ZocLOF2mexGCB8hSSFAORwOPvnkEzZv3szIkSM5/fTTfeLXt7vcSdH3uyn5YS+giByRSuTw9tKILISPkP/EAFReXs6HH37Irl27OPvssznppJO8HRLa6ab05/0ULdyFu9xsRB7TSUYwFcLHSFIIMMXFxcyaNYucnBwuvvhi+vTp49V4tNZUrMuj8NsdRiNy12iix3UhqF2EV+MSQtRNkkIAyc/PZ+bMmZSUlHDVVVfRtWtXr8ZTuauIwjkZVO0owpYURvw1xxPSI9YnqrGEEHWTpBAgMjMzmTVrFi6Xi0mTJtG+fXuvxeLMNxuRf8vBEmE3hrMelCKNyEL4AUkKAWDXrl188MEH2O12rr32WpKSkrwSh7vMYTYi70NZFJEjzUbkYPmYCeEv5L/Vz23evJmPP/6Y6OhoJkyYQExMjMdjcJVUUbJsLyU/7UdXuQg7MZnoMR2xRksjshD+xqNJQSmVCrwPJAMamKG1fuWwde4GrqoVXy8gUWudr5TaARQDLsCptR7kqdh90e+//84XX3xBcnIyV199NeHh4R4t31VYSfGSPZT+kol2ugk9IYGokR2wp3g2DiFE8/H0mYITuFNrvUopFQmsVEqla63XV6+gtX4eeB5AKTUe+KvWOr/WPkZorXM9GrUPWr58Od9++y2dOnXi8ssvJyTEc+MDOfMrKF68m9IVWaA1Yf2TiByRij0xzGMxCCFahkeTgtZ6P7DfvF+slNoAtAPW17PJFcCHHgrPL2itWbRoEUuWLKFnz55cdNFF2O12j5TtyC6j+PvdlK3JBqUIH5RM5PBUmfVMiADitTYFpVQnYADwcz3PhwFnAbfUWqyB+UopDbyttZ5Rx3aTgckAHTp0aOaovcvtdjNnzhxWrFjBgAEDOOecczwyjlHVvhKKF+2m/I9clM1CxKntiDy9nbQZCBGAvJIUlFIRwGfAHVrronpWGw/8cFjV0Wla671KqSQgXSm1UWu9pPZGZqKYATBo0CDdAuF7hdPp5L///S/r1q1j6NChpKWltXh//8pdRRQv2k3FhnxUsJXIM1KJGNoWa4TvjLAqhGheHk8KSik7RkKYrbX+/AirXs5hVUda673m32yl1H+Bk4EldWwbUCorK/n444/Ztm0bo0ePZujQoS1WltaaqoxCir7bTeXWAixhNqJGdyTi1LZYQqWzmhCBztO9jxTwT2CD1vrFI6wXDQwHrq61LBywmG0R4cAYYFoLh+x1ZWVlzJ49m3379nHeeecxYMCAFilHa03l5gMUfbebqp1FWCLsRI/rTPjgNliCfWeobSFEy/L0T7+hwARgrVJqjbnsAaADgNZ6urnsAmC+1rq01rbJwH/NKhMb8IHW+ltPBO0thYWFzJw5kwMHDnDZZZfRs2fPZi9DuzUV6/MoWrQbx94SrNHBxlzIg5JRdkkGQrQ2nu59tAxosCJca/1v4N+HLdsO9GuRwHxQbm4uM2fOpLy8nAkTJtCpU6dm3b92acrX5lC0aDfOrDJs8SHEXtSNsAFJKJtvzLkghPA8qST2Qfv27WPWrFkopbj22mtp06ZNs+1bO92Urc6m+PvdOPMqsCWHEXd5D0JPSJSxiYQQkhR8TUZGBh9++CGhoaFMnDiR+Pj4ZtmvdrgoXZFF8fd7cBVWYm8XQfzVvQjpHY+ySDIQQhgkKfiQDRs28OmnnxIXF8eECROIioo65n26K12U/ryf4qV7cBc7COoYReyFxxHcXYawFkL8mSQFH7Fq1Sq++uor2rVrx5VXXklY2LENGeEud1Ly4z5KftiLu8xJ8HExRF2RSlDnaEkGQoh6SVLwAcuWLWPBggUcd9xxXHrppQQFHf3FYa6iSkp+2k/Jj/vQlS5CesUROSKV4A7HftYhhAh8khS8SGtNeno6P/74I3369OH888/HZmv6W+LMr6B8XS7lf+RRtbMIFISekEDkGakEtZVpL4UQjSdJwUtcLhdfffUVa9as4aSTTmLs2LFYLI3vCurIKaP8DyMROPaWAGBvE07U6I6E9kvEnhDaUqELIQKYJAUvcDgcfPrpp2zatInhw4dzxhlnNFjPr7XGkVmdCHJxZpUBEJQaSfTYzoT2iccWL4lACHFsJCl4WEVFBR9++CE7d+5k7NixDB48uN51tdY49pQcTAR5FaAgqFMU0eO7EHp8ArYYGalUCNF8JCl4UElJCbNmzSI7O5sLL7yQvn37/mkd7dZU7SqifG0u5evycBVUgkUR3DWaiGHtCe0djzVSRikVQrQMSQoecuDAAWbOnElRURFXXHEF3bp1q3lOuzSVGQWU/5FH+bpc3MUOsCpCusUSldaR0N5xWMI8M5GOEKJ1k6TgAdnZ2cycOROHw8GkSZNITU1FO91UbC2g/I9cKtbn4S5zouwWQnrEEtongZCecVhC5O0RQniWfOu0sN27dzN79mxsNhvXXD2J6AI7+T9spHxDPrrShQq2EtIrjrA+CQR3j8USJCOTCiG8R5JCC9q6dSv/+c9/CA8K49yE03C9vZ08hxtLmI3QExKMM4LjYmRUUiGEz5Ck0My0W+MqqGTNshXMWbWQWB3OmcUnEFLlInRgMqF94gnuHCMjkgohfJIkhaPkLnfiyCnDmVOOM7ccZ04ZjpxynHnlrNe7+dG2iTaWOM7vP5qY/m0J6hAlo5EKIXyeJIUj0C43zvwK44s/p9xIArlGEnCXOA6uaAFbXCjW+BDWhO9i+b5NdOvQlUuuvuyYxjESQghPa/VJQWuNu9Rx8Is/t6zmvjO/Aty6Zl1LuA1bQhghPeOwJ4ZiSwjDlhiKLS4EbYFvv/2WX375jX79+nHuueditUqjsRDCv7SapKAdbpx55UYVT60vfkdOObrCeXBFq8KWEIo9OYzQPgnGl35CKPbE0HqvFXA6nXz53y9Zu3Ytp5xyCqNHj27SOEZCCOErAjopVGSXkfHCCqxlTlSZ45DJoS1RQdgTQgnrl4At0fjFb08IxRob0qS6/6qqKj7++GO2bt1KWloaQ4cOlfkKhBB+K6CTgqXKTWlmGSVubdxcxt9SFzgLHATlVBK8s4TgMBsh4XaCw2wEh9kbeGwjKMSGsijKysr44IMP2Lt3L+PHj2fgwIHePmQhhDgmAZ0U7O3C6Tx1MJWlTirLHFSUGX//9LjMSWWpk9KC0pplbqeud79KgTXcRV74bzhUGZ3CB5G7OpjvN22qSRzBoTZsdgtWuxVbkAWr3YLNbsVmtxz6OMiCzW7BYpXqJiGE9wV0UlBKER4dTHh000YS1VrjrHIfTBhlDipKDyaQ/Px8ftmSjtNZyXGRpxDsiCVnV7G5rhPtrj+h1BurRdWbMKzVycRuwRp0eHKxmutYzGVWrDYLFquq+WvcLFht5n2LBYt532o116m9rkVJFZgQrVRAJ4WjpZTCHmzFHmwlIvbQ5/bv30/6rHQsds1frrmWdu3aHfK81hpHpYuqcidOhxuXw42zyo3T4TIe175fz3Muhxtn9a3KeFxW7sRZVWs7h7Hukc5ojsWfkonFuG8kEzPpWA/er05CymLcV8r8a8FIMhZV87f2feNvrXVqb6tqL8Pc3+Hb1t6vkVyVMtavuW+h3mUWiwJFnctqkqN5/5BlFrCog9sKESgkKTTBjh07+PDDDwkODmbixIkkJCT8aR2lFEEhRruDJ7jd2kwSLpxVRsJwOd24XRqXy43bqXG7qh8fvO926Zr13Icsd+NyHrrskO2ctZcdXO6sclFZ5sTt0mit0W6N213rr0vj1saIsFob22q3xq21ucwjL1eLUNWJoTr5AFhUzXKlOJh4qtet8zE1ibA6z9TcV4fvr/rxwe2NWA59vmYf1FpWK5EdXj4c3O8h63PYttVF1i4PDll+8L6xPZZa21Qvr7XRwWV17J/D1q11vNQuo9Zzf3q+1vHVfu+o9VrUbHP4OrWP/wifhUAgSaGRNm7cyKeffkpMTAwTJkwgOjra2yEBxi9Xi3lW48+qE4l2c2gyqeOvdlOTfNyHJRmta+1Lc9jfhpYZ+z5k+1rL3G4NGvOv8fyhy6jZX/XzBx8fvK+1BrfGXM24r0FjlFV7W2O7I+1X43ZjFsDBmKr3RfX6B7eteb1rxQV1rGPGSF3r1jzHn9epWVhrn9TavmabWuvW3o/5nPAOSQqNsGbNGr788kvatm3LVVddRVhYmLdDCjhKKWM8KCv4d3oTzeXQBFIrWdRKJockm+r7B3dw8Ay09jb6sDJq9mHc+dPztROc+fwtbzf30foOSQoN+PHHH5k/fz5dunThsssuIzhYpr8U3mWcGblwu5zmXxfa7Tbuu91o82bcP2xZzTqug+u4XLi1+9DHh+2nuoz69mucedS679ZGGbr6DKyO9dzm/cOed5t/OeSx2zwrOrgeunoftW9u8yxM1+zf+MI/WA5wcB+11qu9H9xuI/+4Dy6nJvbAPo2RpFAPrTULFy5k2bJl9O7dmwsvvBCbTV6uQGV80TpxVjlwOapwOqoOue+qchjLHOayqipcDgfOqkpzmaPmS9pV/YXtPPSL2+Vy4XY6ay1zGm04f1rXicvpwu2uXv/g/lwuZ80Xm89S1Y39FrMDgMW4r4yeb1gO3jfaYmo/NrdRFnO76o4B1lqdBIz1qN6fAovFWvMccMi2VMdSE5dZZn3rWYzGg4OdFiwHj8mijLaL9z7x6kvckuRbrg5ut5uvv/6aVatWMXDgQM4++2wZtsLLtNtNZXkZVWVlVJaVmrcyqspKqSgrpaqsjKqKcvML2/gCN760q8wvdschX+7Vy1xVB59rjtZui9WGxWbFarVhsVqx2My/VisWqw2r+ddiM/9aLdiDQ7CG1V7XWE9Zzf3UrGvFarOhLFZjP7X2rSwW44vRYjG+XC2WWsvNL1iL1egtpizml6xxfYyyWI+wTQP7VQfXq/kybw29sa6d4u0IWowkhcM4HA4+//xzNmzYwLBhwxgxYkTr+JC3IO12U1VRUevLvLTWl3uZ+bj0kMfVX/g1z5eXNViOsliwBQVjs9uxBgVhs9ux2YOw2oOwBdmxB4cQGhGJzR6ELSjIXCcIq92OrfZ9exDWIONv7ftWu7nPoIP3q8ux2u1YLNIaIvyfJIVaKisr+eijj8jIyOCss85iyJAh3g7JZ2mtKS8uoig7i4LsTAqzsyjMzqT0QP5hX/ZlVJaXNfgr3GK1ERwWRnBYOEHm35iUNgSHhZvLwmueDw4Lq/U4oma5TYYpF+KYSVIwlZaWMnv2bPbv388FF1xAv379vB2S1zmqKinKzqYwO7PWLYvCrEwKc7KoKi8/ZP3QyCgi4uIJCY8gOimlji/x8JrHtb/8g8PCsAUFyxmZED5AkgJQUFDAzJkzKSws5IorrqB79+7eDskj3G4XJfl55q/8rD996ZceyD9kfVtQMNFJyUQnJdO+9wlEJ6UYj5NTiE5MIihUuuoK4e9afVLIyclh5syZVFZWMmHCBDp27OjtkJqN1pqK0hKjiifrsF/72ZkU5eTgdh2cS0IpCxHx8cQkpdCp34nE1P7ST0ohLDpGfs0LEeBadVLYs2cPs2fPxmq1cu2115KSkuLtkI6a1prcXTvYvnoFWdu2UJCdSVF2FpVlpYesFxIZRXRiMkmdj6Pb4KFEJ1Z/6ScTlZCI1Vb3REJCiNah1SaFbdu28dFHHxEREcGECROIi4vzdkhNVlVRzq61v5GxegXb16ygJC8XgNg27YhJaUO7Hr0OVvEkpdTU8wshRH1aZVJYt24dn332GYmJiVx99dVERkZ6O6RG0VpzYP9eIwmsXsHeDX/gcjoJCg2lY98BdL7kSjr3G0hEXLy3QxVC+CmPJgWlVCrwPpCMMaLIDK31K4etcwbwJZBhLvpcaz3NfO4s4BWM4XHe0Vo/09QYVqxYwddff02HDh244oorCA0NPdrD8QhHVSV71v/B9lW/krFmBYVZmQDEt+/AgLHn0rn/INr17CXVPkKIZuHpMwUncKfWepVSKhJYqZRK11qvP2y9pVrrc2ovUEpZgTeA0cAe4Fel1P/q2LZOWmuWLl3Kd999R7du3bjkkksI8tF+7YXZWWSsXkHGmhXs+uN3nFWV2IKC6dCnL4POuZDO/QcSnZTs7TCFEAHIo0lBa70f2G/eL1ZKbQDaAY35Yj8Z2Kq13g6glPoIOK8x27rdbubPn8/y5cvp27cv5513Hlar71x96nI62LtxA9tX/0rG6hXk790NQHRyCieMHEPnAYNo37sP9iAZjE8I0bK81qaglOoEDAB+ruPpU5RSvwH7gLu01uswksfuWuvsAQbXsd/JwGSADh064HK5+PLLL/n9998ZMmQIY8aM8YlxjEry88hYs5KM1SvYuXY1VeXlWG022vc+gb6jzqLzgEHEtmkrXUCFEB7llaSglIoAPgPu0FoXHfb0KqCj1rpEKTUO+ALo1th9a61nADMABg4cqD/66CO2bNnCyJEjOf300732Jet2udi/ZRMZa4xG4pwd2wGIiE+g56nD6TxgEB1O6EdQiG+3cQghApvHk4JSyo6REGZrrT8//PnaSUJrPUcp9aZSKgHYC6TWWrW9uaxeObk5bNmyhXPOOYdBgwY1zwE0QVlRITt+W8X2Vb+y87dVVJSWoCwW2vXozelXXkPnAYNISO0oZwNCCJ/h6d5HCvgnsEFr/WI966QAWVprrZQ6GbAAeUAB0E0p1RkjGVwOXHmk8pwOJyeOPtGjCcFRUcHaRelsXPY9+7dtBq0Ji46h66DBdB4wiI59BxASHuGxeIQQoik8faYwFJgArFVKrTGXPQB0ANBaTwcuBm5USjmBcuBybUyR5FRK3QLMw+iS+q7Z1lCvyuBKpmVMIzI1khEdRrTIAVUrKypk9bdfs2be11SUFJPUuSunXnwlnQcMIrlz15rJP4QQwpcp3QwTi/iqAQMH6F7TerE+bz2PnfoY5x13XrOXUZCVyYqv/8u6Rek4HVV0HTSEk8ZfSLuevZu9LCGEb1BKrdRae75O2gMC+opmq7Lyzph3uGPRHTz0w0MUVBYw6fhJzbLvrO1b+fV/n7F5+Q8oi4Xew0Yy6JwLiG+f2vDGQgjhowI6KQCE2cN4fdTr3L/0fl5Y8QIFlQXcNuC2o2rc1Vqz8/fV/Pq/z9j1x28EhYYxaPwFnDj2XBlaQggREAI+KQAEWYN4bthzRP8czTtr3+FAxQGmDpmKtZHTJ7pdLjYtX8av//uMnB3bCY+NY9hV19I37SyCw8JbOHohhPCcVpEUAKwWK1OHTCU2JJYZv8+gqKqIZ05/hiBr/UNdVPckWvnNFxTlZBHXtj1jbriNXqeNwGaXsYaEEIGn1SQFAKUUtw64lZjgGJ779TmKqop4ZcQrhNsP/bV/eE+itj16M+KayXQ98STpRSSECGitKilUm9B7AjHBMUz9YSp/mfcX3kp7i9iQ2Dp6Eg3mpPEXSU8iIUSr0SqTAsD4ruOJCorizsV3ctPsCVx44CR2r1hp9iQawaBzLpSeREKIVqfVJgWtNR0PRHHTplM5sHk722y/0Ht0GiMvmCg9iYQQrVarSwp19STqdcE5vOT6D99YP6ezK40TkKQghGidWk1SaKgn0QlFZzM5fTJ/mf8XXhnxCqe0PcXbIQshhMcF9DAXgwYN0ku+W8iaeV+zet43VBQX0bZ7L0467+I6exLllOVww4Ib2F64nWdPf5YxncZ4KXIhhC8L5GEuAjopdG/fVt884hScVZWN7klUVFXErQtvZXX2ah4a8hCX9rjUQ9EKIfxFICeFgK4+Ki8rJVXZOOWOv9HmlKGN2iYqKIrpo6dz1+K7eHz54xRWFnL9CdfLnAdCiFYhoK/Eio2I5vj12yn4y2T2T30YR1Z2o7YLtYXy8oiXOafLOby6+lWeX/E8bu1u4WiFEML7AjopBCUl0TV9PnETrqbgiy/YdtZZ5Lz6Kq6S0ga3tVvsPHnak1zd62pmrp/JQ8sewuF2eCBqIYTwnoBOCgC22FiS77+frnO+IXLECHLffIttY8aQP3s22nHkL3mLsnDPSfdw64Bb+Wr7V/x10V+pcFZ4KHIhhPC8gE8K1YJSU2n34t/p9MnHBHftStbjT7D9nPEUzZvPkRrblVJM7juZqUOmsmTPEqakT6Goqqje9YUQwp+1mqRQLfSEE+jw/nu0n/4WKsjO3ttvZ+flV1C2cuURt7u0x6U8N/w5fs/9nWu/vZbc8lwPRSyEEJ7T6pICGL/+I884g85ffEGbJx7HsX8/O6+6mt233ELl9u31bndWp7N4Y9Qb7C7ezYQ5E9hdvNuDUQshRMtrlUmhmrJaibn4YrrO+5bEO+6g7KflbB9/LvsfeRRnTk6d25za9lT+OeafFDuKmTh3IpvyN3k4aiGEaDmtOilUs4SGknDDFLqmzyf2iiso+Owztp55FjmvvY679M89lU5IPIH3z3ofq7Jy7bfXsiprlReiFkKI5idJoRZbXBwpDz1I12++JmLYMHLfeIOtZ57FgY8++lNPpS4xXZg5dibxofFMSZ/Ckj1LvBS1EEI0H0kKdQjq2JH2L79Ep/98RFCnjmQ++hjbx59LUXr6IT2V2kS04b2x79Elpgu3fXcbX237yotRCyHEsZOkcASh/frRceZM2r/5Jlit7L31NnZeeRVlq1bXrBMXEse7Z77LoORBPLDsAWZvmO3FiIUQ4thIUmiAUorIkSPo8uUXpEx7jKo9u9l55ZXsufU2KjMyAAi3h/NG2hukdUjjmV+e4fXVrx/x2gchhPBVkhQaSdlsxF56KcfNm0fCbbdS+sMPbD9nPJnTpuHMzSXYGswLw1/gom4X8fbvb/PE8idwuV3eDlsIIZpEkkITWcLCSLzpJqOn0mWXceDjT9g25kxy3ngDVV7BI6c8wl/6/IWPN3/MPUvuocpV5e2QhRCi0SQpHCVbfDwpD0+ly1f/I/y008h97XW2nnUWBR9/wu39buGuQXcxf+d8bll4C2WOMm+HK4QQjSJJ4RgFd+5M+1dfoeOHHxCU2oHMRx5h+7nncWFWKo+fOo1fMn/h+vnXU1BR4O1QhRCiQZIUmknYgAF0nD2L9q+/Blqz56abOfHpr3m1011syt/EpG8nkVma6e0whRDiiCQpNCOlFJFpaXT535ckP/AA5X/8QeKNz/DuhqGU5mUyce5EMgozvB2mEELUS5JCC1B2O3ETJ9B13rfEXHoJQV8s5LUZmsE/HeDaryeyLm+dt0MUQog6HVVSUEqFK6WszR1MoLHFxtLmkUfo/N/PCevRiyu/KWHqjEKemz6RX/b/4u3whBDiTxqVFJRSFqXUlUqpb5RS2cBGYL9Sar1S6nml1HEtG6Z/C+nRgw7v/Zt2r7xCe0s8980sY8MN17Lo54+8HZoQQhyisWcKi4CuwP1AitY6VWudBJwGLAeeVUpd3UIxBgSlFFFnjqHb3LlE3jyZ/hkQd91jLH34xjpHYhVCCG9QjRmOQSll11ofcULjxqzjaYMGDdIrVqzwdhh1KtqdwcIHrqHnr9lUxUXQ6b6pRI0fj1LK26EJIRqglFqptR7k7ThaQqPOFBrzZe9rCcHXRaV25px/L+Cbe4eyK6iEfffcy84rrqR87VpvhyaEaMWOuveRUupxpdQnSql/K6VOaM6gWgu71c7frpnB2qev5o2zLeRv38COSy5l3/0P1DvzmxBCtKRj6ZIaqrW+BJgM3NRM8bQ6FmXh/iEPcPyEW7jheierR3ei8Kuv2HbmWeS98w7uKhk7SQjhOceSFEKUUidqrauARlWEK6VSlVKLzF5L65RSt9exzlVKqd+VUmuVUj8qpfrVem6HuXyNUso3GwuOglKKG/vfyF+HPcgzg/byj3uPJ+jkQWS/8He2nzOe4u++k6G4hRAecSxJ4W5gpFLqXeDLRm7jBO7UWvcGhgA3K6V6H7ZOBjBca30C8Dgw47DnR2it+wdiI88VPa/gmdOfYZHexD1n5xP9xgsou509N93M7r9cT+XWrd4OUQgR4JqUFJRSryql5iul5gGPAQu01tdprec2Znut9X6t9SrzfjGwAWh32Do/aq0PmA+XA+2bEqO/G9dlHK+Neo0dhTv4v8I3CZ79Rs2QGdvPO5/MJ5/CVVjo7TCFEAGqqWcK64HngVeAbGCWUuqWoylYKdUJGAD8fITV/gLUTjgamK+UWqmUmlzPficrpVYopVbk+Glj7WntTuMfY/5BQWUBk+ZfR974IXT9di4xl1zMgdmz2XbmWRz48EO00+ntUIUQAaZR1ynUu7FSIcCvZlVPU7aLABYDT2qtP69nnRHAm8BpWus8c1k7rfVepVQSkA7cqrVeUl85vnydQmNsObCFG9JvoMJVwRuj3qB/Un8qNm4k68mnKPv1V4J79CD5/vsJHzLY26EK0aq0+usUDqeUukEp9QLGGUNRE7e1A58Bs4+QEPoC7wDnVScEAK31XvNvNvBf4OSjid9fdIvtxvvj3icmOIbJ6ZNZtncZIT170uH992j38su4i4vZdc017Lntdqr27PF2uEKIAHC0Dc1zMNoD2gNPN3YjZVyu+09gg9b6xXrW6QB8DkzQWm+utTxcKRVZfR8YA/xxlPH7jXYR7Xhv7Ht0iurErQtvZc72OcaQGWedSZc535B4+22ULF3K9nFnk/3yy7jLZJY3IcTRa1L1kVLqE+BhrfUG87EFWK217nfkLWu2Pw1YCqwF3ObiB4AOAFrr6Uqpd4CLgJ3m806t9SClVBeMswMAG/CB1vrJI5Xn79VHtRVXFXPbd7exMmsl9w++nyt6XlHznCMzk+wX/k7R119jS04m6a47iTrnHBkyQ4gWEsjVR01NCucCT2Bcl7ASiAC6aq0HtEx4xyaQkgJApauSuxffzaLdi7ip303c0O+GQ774y1atIuvJp6hYt47QgQNJmfoQIT17ejFiIQKTJIXDNzLq/PtjVD/NMev4fU6gJQUAp9vJoz8+ypfbvuSKnldw38n3YVEHawG1203BZ5+R8/cXcRUVEXv55STefhvW6GgvRi1EYJGk4KcCMSkAaK15ceWL/HvdvxnbeSxPDn0Su9V+yDquggJyXn2NAx99hDU6msS//ZWYiy5CWWSyPSGOlSSF6pWVugyYAJRiNPL+DvyutfbJiYcDNSlUe/ePd3lp5UsMbTeUF4e/SJg97E/rVGzcSObjT1C+ciUhJ5xAytSHCO3b1wvRChE4AjkpNHbmtbPNu88BLwOvYly8dibwfotEJhp0XZ/rePSUR/lp309MTp9MYeWfr3QO6dmTjrNm0vb553Bk7mfHpZex76GHcObl1bFHIURr19hJdtZrrXsrpRZqrUd5IK5mEehnCtUW7FzAPUvuoWNUR6anTSc5PLnO9VwlJeS++Rb577+PJTSUxNtuI/aKy1E2m4cjFsK/tfozBaCdUup+YINS6iml1J/rKYTXpHVM4620t9hXso9J305iZ9HOOtezRkSQfM/ddPnyC0JP6EPWk0+SceFFlP36q4cjFkL4qsYmhTVACWAHhgM7lFKrlFL/Ukr9taWCE403uM1g3j3zXcocZUycO5ENeRvqXTe4a1dS//lP2r3yCq6SYnZOmMjeu+7GkeWTnciEEB501L2PlFKpQB+gj9b6+WaNqpm0luqj2jIKM5iSPoXiqmJeHfkqJ6WcdMT13eXl5P3jH+S980+UzUbCzTcRN2ECKijIQxEL4X+k+qgOWuvdWuu5vpoQWqvO0Z15f+z7JIUlcUP6DSzateiI61e3LXT5+ivCBg8m+/kX2H7e+ZQs+8FDEQshfIl0Wg9AKeEpvHfWe/SM68lfv/8rX2z9osFtgjp0IPWtN0l9ezra7WL39dez59Zbqdqzt+UDFkL4DEkKASomJIZ/jPkHJ6eczNQfpvLeuvcatV3E8OF0+eorEv/6V0qW/cD2s88m5403cFdUtHDEQghf0NjrFGaaf/80p7LwXWH2MF4f9TpndjqTF1a8wMsrX27UXM+WoCASpkym65xviBg5gtzXXpe5ooVoJRp7pjBQKdUWuE4pFauUiqt9a8kAxbEJsgbx7OnPcmn3S/nnH//ksZ8ew+V2NWpbe5s2tH/pJTr8+1+okGBjrujJU6jM8MkL2IUQzaCxVy1NBxYCXTBGR609JrM2lwsfZbVYeWjIQ8SGxPL2729TWFnIM8OeIdga3Kjtw4cMoct//8uBDz4g57XX2X7uecRfcw0JN0zBEh7ewtELITypqWMfvaW1vrEF42lWrbFLakNmrZ/Fs78+y+CUwbwy8hXC7U37Unfm5JD99xcp/OILbMnJJN97D5Fjx8rcDaJVCeQuqU2+TkEp1Q843Xy4RGv9e7NH1UwkKdTtq21fMfWHqfSM68mbaW8SF9L0GsCyVavJfOJxKtdvIOzkk0l+6EFCundvgWiF8D2BnBSa1PtIKXUbMBtIMm+zlVK3tkRgouWM7zqeV0e+ytaCrUyaO4n9JfubvI+wEwfQ+ZNPSHn0ESo3bSLjggvJfOopXEVNmrJbCOFjmlp99Dtwita61HwcDvyktfbJsZjlTOHIVmWt4paFtxBmD2PG6Bl0iTm6piHngQPkvPIKBf/5GGtcHEl330X0eedJlZIIWHKmcJACanddcXFoo7PwIycmn8i/zvoXLu1i4rcT+T3n6GoCbbGxtHn0UTp98glB7duz/7772XnV1VRs3NjMEQshWlpTk8K/gJ+VUo8qpR4FlgP/bPaohMf0iOvB+2e9T6Q9kuvnX8+P+3486n2F9jmejh9+QJsnn6AqI4OMCy8i80mpUhLCnzQpKWitXwSuBfLN27Va65dbIC7hQalRqbw/9n1SI1O5eeHNzNsx76j3pSwWYi66iK5z5xBz2aUcmDWLbWPHUfDFF3LhmxB+QOZoFjWKqoq4deGtrM5ezUNDHuLSHpce8z7L/1hH5uPTqPjtd0IHDiRl6kOE9OzZDNEK4T3SpiBahaigKKaPns7p7U/n8eWPM+P3Gcf86z60z/F0+vBD2jzxOFXbt0uVkhA+TpKCOESoLZSXR7zM+C7jeW31azz363O4tfuY9qksFmIuvliqlITwA5IUxJ/YLXaeOO0Jru51NbM2zOLBZQ/icDuOeb/WmBjaPPIInT75BHv7dkYvpasnSC8lIXxIUy9eu0QpFWnef0gp9blS6sSWCU14k0VZuOeke7htwG18vf1r7lh0B+XO8mbZd71VSsXFzbJ/IcTRa+qZwlStdbFS6jQgDaM76lvNH5bwBUop/q/v/zF1yFSW7lnKDek3UFTVPG0BUqUkhG9qalKorlw+G5ihtf4GkMl8A9ylPS7l+eHP83vu71z77bXkluc2274PqVJq1/ZgldKmTc1WhhCi8ZqaFPYopd4GLgPmKKWCkSuaW4UzO53JG6PeYHfxbibMmcDu4t3Nuv9DqpS2bZMqJSG8pKlJYT0wDzhTa10AxHHosBcigJ3a9lT+OeafFDuKmTh3Ipvym/fXfE2V0rdzibn0kpoqpcIvv5QqJSE8pKlJIU1r/bnWeguA1no/YG/+sISvOiHxBN4/632sysq1317LqqxVzV7G4VVK++69T6qUhPCQxs7RfKNSai3QUyn1e61bBuCz8ymIltElpgszx84kPjSeyemTWbJnSYuUU2eV0lNSpSRES2rUMBdKqWggFngauK/WU8Va6/wWiu2YyTAXLSu/Ip8bF9zIpvxNPD70ccZ3Hd9iZbkKCsh+5RUKPvoP1vh4ku++i6hzz5XhuYVXBPIwFzL2kTgmpY5Sbv/udn7O/Jl7T7qXq3tf3aLlla/9g8zHH6fid3MspYenEtKjR4uWKcThAjkpNLb6aJn5t1gpVVTrVqyUkkFsWrFwezhvpL1BWoc0nv31WV5d9WqLNgqHntCHTh9JlZIQLaVRSUFrfZr5N1JrHVXrFqm1jmrZEIWvC7YG88LwF7io20X8Y+0/eHz547jcLdcp7ZBeSpdczIGZ0ktJiOYiYx+JZmG1WHnklEe4/oTr+WTzJ9yz5B6qXFUtW2ZMjDHj28cfY29r9FLaNWEiFZs3t2i5QgSyps7RHAxcBHQCbNXLtdbTmj2yZiBtCt7x3rr3eGHFC5zS5hReHvEyYfawFi9Tu90UfPopOX9/EVdJCXETJpBwyy1YI8JbvGzR+rT6NoVavgTOA5xAaa1boyilUpVSi5RS65VS65RSt9exjlJKvaqU2mp2ez2x1nOTlFJbzNukJsYuPGTS8ZN4YugT/JL5C9fPv56CioIWL1NZLMReeildvp1LzIUXkv/ee2wfN46iOXOkSkmIJmjqmcIfWus+R12YUm2ANlrrVeZoqyuB87XW62utMw64FRgHDAZe0VoPVkrFASuAQYA2tx2otT5QX3lypuBdi3Yt4q7Fd9E+sj1vj36blPAUj5Vd/ttvZD42jYr16wk7ZQgpU6cS3KWLx8oXgU3OFA76USl1wtEWprXer7VeZd4vBjYA7Q5b7TzgfW1YDsSYyeRMIF1rnW8mgnTgrKONRbS8ER1GMH30dLLLspk4dyIZhRkeKzu0Xz86ffIxyQ9PpWLderafdz7Zf38Rd1mZx2IQwh81NSmcBqxSSm0yq3bWKqWO6opmpVQnYADw82FPtQNqj7a2x1xW33Lhw05KOYl3z3yXSlclk+ZOYl3eOo+VraxW4q68kq5z5xB9zjnk/eMfbDv7HIrmz5cqJSHq0dSkMBY4DhgDjAfOMf82iVIqAvgMuENr3azXOSilJiulViilVuTk5DTnrsVR6hXfi/fHvk+YPYzrvr2OX/b/4tHybfHxtH36KTrOnoU1Koq9t93O7slTqNq506NxCOEPmpoUJtVzazSllB0jIczWWn9exyp7gdRaj9uby+pbfgit9Qyt9SCt9aDExMSmhCZaUMeojrw/9n3aRrTlhgU3sGDnAo/HEDZwIJ0/+5TkB+6nfNUqto8/l5xXX8NdUeHxWITwVU1NCrV7HLkwzhw6NXZjZQxU809gg9b6xXpW+x8w0eyFNAQoNEdjnQeMUUrFKqViMc5W5jUxfuFFSWFJ/Pusf9M7vjd3Lr6TzzZ/5vEYlM1G3MSJdJk7h8gxY8h98022nzOe4kWLPB6LEL7omMY+Mq9bmKe1PqOR658GLAXWcnAWtweADgBa6+lm4ngdoxG5DLhWa73C3P46c32AJ7XW/zpSedL7yDeVOcr42+K/8cPeH7jjxDu4rs91XhvYrnT5z2Q+bgyZETFiBMkPPkBQ+/ZeiUX4j0DufXSsSSEW+FVrfVzzhdR8JCn4LofLwYM/PMjcjLlM6j2JOwfd6bXEoKuqyJ85k5w33gSXi4QbphD3l79gCZKZZkXdAjkpNKn6qLq3kXlbB2wCXm6RyERAs1vtPHP6M1zR8wreW/8eU3+YitPt9EosKiiI+L/8ha5zviHijDPIeeVVto8fT8nSZV6JRwhvaurFax1rPXQCWVpr7/wnN4KcKfg+rTXTf5vOm7+9yRmpZ/D8sOcJsYV4NaaSZT+Q9fjjVO3cSeSYMSTffx/2Nm28GpPwLXKmYNJa76x12+vLCUH4B6UUN/a/kQcHP8ji3Yu5ccGNFFd5dxjsiNOG0vmr/5F4xx2ULFnCtnFnk/uPf6CrWnaAPyF8gYySKnzC5T0v59lhz7Imew3XzbuO3PJcr8ZjCQoi4YYpdPn6a8JPPZWcv7/I9gsupHT54ddailbD7YJdyyH9YW9H0qJk5jXhU5btXcbfvv8biaGJzBgzg3YRvnHRevH335P1xJM49uwh6uyzSbrnHuzJSd4OS7S0qlLYtgg2zYXN30JZLljsqEfyArb6SIbOFj5nTfYabl54MyHWEKaPnk632G7eDgkAd0UFef94h7x//ANlt5Nw6y3EXX01ymZreGPhP0qyjSSwaQ5s/x6cFRASDd3GQI9xcNwoVGiMJAUApdS3QCHGCKU1U2tprf/e/KEdO0kK/mvrga1MSZ9ChauCN0a9Qf+k/t4OqUbVrl1kPvEEpUuWEty9OymPPEzYwIHeDkscLa0hZ5ORBDbNgT0rAA3RHaDnOCMRdDwVrPaaTQK5odmjQ2d7miQF/7a3ZC+T508mpzyHF894kdPanebtkGporSlZuJDMp57CuW8/0eedR9Ldd2FLSPB2aKIxXE7Y/fPBRJC/3VjedgD0OBt6jIXk46Gea2ckKVSvrNQM4DWt9dqWC6n5SFLwf7nludy04Ca2HNjCk6c9ybgu47wd0iHcZWXkTn+bvH/9C0tICIl/vYPYyy5DWa3eDk0crrIEti002wfmQXk+WIOg83AjCfQYC1FtG7UrSQrVKyu1HmOU1AygElCA1lr3bZnwjo0khcBQXFXMbd/dxsqsldw/+H6u6HmFt0P6k8rt28l8/HHKflpOyPHHk/LIw4T29cl/i9alaD9sngsb50DGYnBVQWgsdDvTSALHjYLgyCbvVpJC9cqHXrxWQ2vtk2MQS1IIHJWuSu5efDeLdi/ixn43cmO/G702LEZ9tNYUz51L1tPP4MzNJebSS0n66x1YY2K8HVrroTVkrzeqhDbOgX2rjOWxnYxqoZ7jIHUIWI+tc4AkBT8lSSGwON1OHv3xUb7c9iWX97ic+wffj0X53qU2rpIScl97nfxZxvwNSXfdRfQF56MsvhdrQHA5YNdPRhLYNAcKzN+o7QYZZwM9z4bEnvW2DxyNVp8UlFLLtNanKaWKMeZHrnkKo/ooqqUCPBaSFAKP1poXV77Iv9f9m7Gdx/Lk0Cex1+oV4ksqNm0i87FplK9aReiAAaQ88jAhPXt6O6zAUFEEWxcY7QNb5kNFAViDocsZxtlA97MgsuXmBG/1ScFfSVIIXO/+8S4vrXyJoe2G8uLwFwmzh3k7pDppt5vCL74k+4UXcBUWEnf1VSTceivWiAhvh+Z/Cvce7C2UsRTcDgiLNxJAj7HQdSQEhXsklFafFJRSSjewYmPW8TRJCoHts82fMW35NE5IOIE3Rr1BdHC0t0Oql6uwkOyXX6bgo/9gS0gg6d57iTp7nM+1i/gUrSFzrXkh2Tew/zdjeVzXg9cPpA4Gi+d7eklSUOp7jCk0v9Ra76q1PAg4DWNKzkVa63+3TJhHR5JC4FuwcwH3LLmHjlEdmZ42neTwZG+HdETla9eS+dg0Kv74g7AhQ0iZ+hDBXbt6Oyzf4XLAjmXmGcFcKNwNKEg92ew2ejYkdGvW9oGjIUlBqRDgOuAqoDNQAIQAVmA+8KbWenXLhXl0JCm0Dr/s/4XbFt1GTHAMb49+m45RdXaS8xna5aLg44/Jfull3OXlxF9zDQk33oAlzDerwFpceYHZPjAHtiyAykKwhULXEUYi6H4WRPjWOFOtPikcsoFSdiABKNdaF7REUM1FkkLrsS5vHTemG91Up6dNp1d8L2+H1CBnXh7ZL/ydwv/+F1vbNqQ88AARo0a1jiqlgl0HxxfasQzcTghLgB5nGWcDXc6AIN9NkpIU/JQkhdYlozCDKelTKK4q5tWRr3JSykneDqlRylauJPOxaVRu3kz48GGkPPQQQamp3g6reWlttAlUNxRnmoMiJHQ/WC3UfpBX2geOhiQFPyVJofXJLM1kSvoU9hTv4YXhLzCiwwhvh9Qo2uEgf/Zscl99De10Ej9lMvHXX48lONjboR09ZxXsWHqwfaBoLyiL0Tjcw2woTvDJ6d0bJEnBT0lSaJ0KKgq4eeHNrMtbx6OnPsr5x53v7ZAazZGVRfazz1I0Zy72Dh1ImfoQEaef7u2wGq/8AGxJP9g+UFUM9jCju2iPcdD9TAj3/0EDJSlUr6zUrcAsrfWBlgup+UhSaL3KHGXcsegOftr/E3cNuotJx0/ydkhNUvrjj2Q+/gRVGRlEjh5N8gP3++480Qd2GGcCG7+BnT+CdkF4klktNA66DAd7qLejbFaSFKpXVuoJ4HJgFfAuMM/Xrk2oTZJC61blquKBZQ8wb8c8/tLnL9x+4u1+1Yjrrqoi/91/kTt9OlgsJN50I3ETJ6KCgrwcmBv2rzk4vlD2OmN5Ys+D1ULtBkIAD+shSaH2BsZ/1RjgWmAQ8DHwT631tuYP79hIUhAut4unfn6Kjzd/zEXdLmLqkKlY/aQxs1rVnr1kPf00JQsXEtS1KykPP0z44JM9G4SzEjKWGGcDm7+F4v1G+0CHU8xEMBbiW8/1FoGcFJo8VKDWWiulMoFMwAnEAp8qpdK11vc0d4BCHAurxcpDQx4iNiSWt39/m8LKQp4Z9gzBVv9pwA1q347UN16neNEisp54kl2TJhE1fjzJ99yNLTGx5QouyzfGFdr4DWz7DqpKwB5uDDdd3T4QFtdy5QuvaGr10e3ARCAXeAf4QmvtUEpZgC1aa5/6qSBnCqK2Wetn8eyvz3Jyysm8MuIVIoL8b/whd0UFeTNmkPePd1DBwSTefjuxV1zefPNE5283Rxuda4w8ql0QkXJwtNFOp4M9pHnK8mOBfKbQ1KTwGPBuXfMnKKV6aa03NGdwx0qSgjjcV9u+YuoPU+kR14O30t4iLsQ/f+lW7dhB5uNPUPrDDwT36kWbRx4mtH//pu/I7TbmHNj4jdFGkLPRWJ50vDm+0FhoMyCg2weOhiQFPyVJQdRlyZ4l/O37v9EmvA0zRs+gTYSP9uppgNaa4nnzyXr6aZxZWcRccgmJf/srttjYI2/oKIfti40ksPlbKMkCZTUmp+95tjGsRFxnzxyEn5KkUL2yUn+rY3EhsFJrvaa5gmoukhREfVZlreKW724h1BbKjNEz6BrjUzWfTeIqKSX3jTfIf/99rJGRJN11J9EXXnjopD6luca8xJvmGO0DjjIIioRuaUb7QLfRxjSVolEkKVSvrNQHGD2OvjIXnQP8DnQCPtFaP9fcAR4LSQriSDblb+KGBTfgcDt4c9Sb9E307zmVKzZtJnPaNMpXriS0f39Sbr+OEPd6o31g98+g3RDV7uD1A51OA5v/NLj7EkkK1SsrtQQYp7UuMR9HAN8AZ2GcLfRukSiPkiQF0ZDdxbuZPH8yeRV5vDziZU5te6q3Qzp6bhd6968UznyT7M9W4KpwE9utlMRRqVj7nmMkgjb9vD7sdCAI5KTQ1NajJKCy1mMHkKy1Lj9suRB+ITUylZnjZtIhsgM3L7yZeTvmeTukpqkqM3oLfXkz/L0H6l9nEuP+hq43dCFmRD8ObIlk+6c2Csv6oSUhiEZoaj+22cDPSqkvzcfjgQ+UUuHA+maNTAgPSQhN4N2z3uXWhbdy9+K7Kaws5NIel3o7rPqVZBsNxBvnwPZF4KyA4GijXaDHWOg2GmtING2AmLVryXz0MfbdeRcFn3xKysNTCe7SxdtHIHxYo6uPzCuZ2wPJwFBz8Q9aa5+tn5HqI9EU5c5y7l58N4v3LObWAbfyfyf8n28Mi6E15G4+OKzEnl8BDdGpB68m7jgUbHUPf1Ezqc+LL+GuqCD+uutIuGEKltDAGo/IkwK5+qipbQprtdYntGA8zUqSgmgqh9vBIz88wlfbv+LqXldz90l3Y1Fe6KPvdhmNwxu/MRqK881RZNr0NxJBz3GQ3KdJ1UHO3Fyyn3+Bwi+/xN62LckPPUTkSP8YWtzXBHJSaGr10Sql1Ela619bJBohvMxusfPEaU8QHRzNrA2zKKgsYNrQadgt9pYvvLLE6C66aa5RPVSeDxY7dB4Gp9wE3cdCdLuj3r0tIYG2zz5DzMUXkTltGntuuomIESNIfvBBgtof/X5FYGnqmcJGoBuwAygFFMZwSD7Zl0/OFMTR0lrzztp3eHX1qwxrP4wXhr9AqK0FqluKM81pKefC9u/BVQkh0dDtTONsoOsoCIlq9mK1w0H++zPJeeMNcLtJuOEG4q67Fou3R2D1E4F8ptDUpFDnjOh1DXvhCyQpiGP18aaPeWL5EwxIGsBro14jKugYv6C1huwNB6el3LvSWB7T0biauMdYY+RRqwfOTADH/v1kPf0MxfPnE9SpEykPTyX8VD/ulushkhSqVzZa3a4CumitpymlOgApWutfWirAYyFJQTSHeTvmcd/S++gS3YXpadNJDGviyKQupzG4XHUiOLDDWN5u4MH5iZN6ebW7aMnSpWQ+/gSOXbuIGjeOpHvvxZ6c5LV4fJ0kheqVlXoLcAMjtda9lFKxwHytdaNmSFdKvYtxFXS21rpPHc/fjZF0wGjv6AUkaq3zlVI7gGLABTgb84ZIUhDN5cd9P3LHojuID4lnxugZpEalHnmDymLYutAcX2geVBSANdiYhazHWKN9IMq3xlxyV1aS9493yJsxA2W3k3jbrcRedVXzjcAaQCQpVK+s1Cqt9YlKqdVa6wHmst+01v0auf0woAR4v66kcNi644G/aq1Hmo93AIO01rmNjVeSgmhOa3PWcuPCG7EpG2+PfpsecT0OXaFo38FJ6jOWgKvKGE+o+1lGj6GuIyHY94frrtq1yxiBdelSgnv0IOWRRwg7cYC3w/IpkhSqV1bqZ+BU4FczOSRinCk0+hOjlOoEfN2IpPABsEhr/Q/z8Q4kKQgv216wncnpkylzlPH6yNc4kWDz+oFvjCkqAeK6HJyWMnUwWP3vl7bWmuL0dLKeehpnZibRF19E0p13NjwCayshSaF6ZaWuAi4DBgL/Bi4GHtJaf9KEfXSigaSglAoD9gDHaa3zzWUZwAFAA29rrWfUs+1kYDJAhw4dBu7c6ZNt4MJfuRzs3/QVk1c9x35nKS9mZTOsvBLaDzqYCBJ7BMxwEu7SUnLefJP8997HGh5O4p1/I+biiw8dgbUVkqRQewOlegKjzIffNXVinUYmhcuAq7XW42sta6e13quUSgLSgVu11kuOVJacKYhmUVEIWxcYVxNvSYfKQvKDQrmpfSobdSWPD7qH8cdf7e0oW1Tlli1kPjaNshUrCOnXlzaPPEJIb58a/9KjAjkpNOm8VikVDJwIRJvbXqKUQms9rZnjuhz4sPYCrfVe82+2Uuq/wMnAEZOCEEetYLc5vtA3sGMZuB0QFg+9xkOPscR1HcE/Fdz+3e08sOJZCpRmQu8J3o66xQR360aHme9T9L//kfXc82RcfAmxV15J4u23YY2M9HZ4ohk1tbLzS8xJdWihUVGVUtHAcODqWsvCAYvWuti8PwZo7kQkWjOtIfN3c37iOcZ9gPjjYMiNxjUE7U8Ci7Vmk3DgzbQ3uW/pfTz363MUVBZwS/9bfGO8pBaglCL6vPOIGDGCnJdf4cDs2RR9+y3J995L1DlnB+xxtzZNbVP4o6EG4ga2/xA4A0gAsoBHADuA1nq6uc41wFla68trbdcF+K/50AZ8oLV+sqHypPpIHJGzCnYuOzhRfdEeQBmNw9UT1Sd0a3A3LreLx5c/zmdbPuOS7pfw4OAHsdZKHoGqfO0fZE6bRsXatYQNHmyMwNrVf2ewa4pArj5qalKYAbymtV7bciE1H0kK4k/KC8z2gW+Mv5VFYAs1uov2HGcMLxHRxIvTMHrrvLr6Vd5Z+w5jOo7h6dOfJsga+ENGaJeLgk8+MUZgLS8n/tprSbjxhoAfgVWSQvXKSq0HjgMyMKqPZOwj4fsO7DTHF5oDO38AtxPCE43rB3qeDZ2HQ1BYsxT13rr3eGHFC5zS5hReHvEyYfbm2a+vc+blGSOwfvGFOQLrg0SOHOntsFqMJIXqlWXsI+EPtDauGahuH8j6w1ie0MM4G+gxDtoNghbqVvnl1i955MdH6B3fmzdHvUlMSEyLlOOLyn79lcxp06jcsjWgR2Bt9UlBKXWP1vo58/4lta9LUEo9pbV+oAVjPGqSFFoRZyVkLD14RXHxPlAWSB1yMBHEe66+e9GuRdy1+C7aR7bn7dFvkxKe4rGyva01jMAqScEc3uLw+3U99iWSFAJcWb5x3cCmb4xxhqpKwB5mtg+cbbQPhMd7LbxfM3/ltu9uIyIogrdHv02X6NY1DeYhI7B27myMwHrKKd4Oq1lIUjh0rKOa+3U99iWSFAJQfkat9oEfQbsgItkcbXSc0T5gD/F2lDU25G3ghgU3oLXmrbS3OD7heG+H5HElS5YYI7Du3k3U2WeTdO892JP8ewRWSQpypiC8xe2GfauNs4FNcyF7vbE8qffBYafbDmix9oHmsLNoJ1PSp3Cg4gCvjnyVwW0Gezskj3NXVBwcgTU4mMTbbiP2yiv8dgRWSQpKuTg401ooUFb9FBCitfbMjCBNJEnBTzkqjFFGN30Dm76FkkxQVuh4qjm+0FnGoHN+JLssmynpU9hZtJPnhj1HWsc0b4fkFVU7dhgjsP7wA8G9etHmkYcJ7d/f22E1WatPCv5KkoIfKc2DLfOMaqGt34GjFIIi4LhRxtlAt9EQFuftKI9JYWUhtyy8hd9zf+fhIQ9zUfeLvB2SV2itKZ43n6ynn8aZlUXMJZeQ+Le/+tUIrJIU/JQkBR+Xt80cdnoO7F4O2g2RbWu1D5wOtmBvR9msyhxl3Ln4TpbtXcYdJ97BdX2ua7XDQ7hKSsl94w3y338fa1QUSXfdRfQF5/vFCKySFPyUJAUf43bD3hXG1cSb5kLuJmN5ch8jCfQcB236B8yw0/VxuB08tOwh5mTMYVLvSdw56M5WmxgAKjZtJvOxxyhftYrQE08k5ZGHCenRo+ENvSiQk4J/tvII/1FVBhmLjUSw+VsozQGLDToOhUHXGWcFsXVeExmw7BY7T5/+NNHB0by3/j0KKgt49NRHsVla579jSI/udJw1k8IvviT7+efJuPAi4iZMIOGWW7BGhHs7vFandX4KRcsqyTESwKa5sO07cJZDcBQcl2ZcP3BcGoTGeDtKr7IoC/effD+xIbG8ueZNCqsKeX7Y84TYfKc7rScpi4WYCy8gcuQIsl98ifz33qNozhySH7ifyDPPbNVnUp4m1UeieeRuMauF5sDuXwANUe3Nq4nHQsfTwBY4V7Q2p482fsRTPz/FwOSBvDryVSKDZH6C8jVr2D9tGpXrNxA+dCgpUx8iqFMnb4dVI5CrjyQpiKPjdhlf/pvM8YXythrLU/oaZwM9xhr35Rdeo8zNmMsDSx/guNjjeCvtLRJCE7wdktdpp5MDH35EziuvoCsrif+//yN+8v9hCfH+2ZQkBT8lSaGZVZXCtkVGEtj8LZTlgcVu9BLqYZ4RRLf3dpR+a9neZfzt+7+RGJrIjDEzaBcReAPJHQ1HdjbZzz1P0ddfY09NJWXqQ0QMG+bVmCQp+ClJCs2gOAs2zzXaB7Z/D84KCImGbmOMRHDcKOOxaBZrstdw88KbCbGGMH30dLrFNjzJT2tRunw5mY9Noyojg8jRo0l+4H7sbdp4JRZJCn5KksJR0BpyNh0cVmLPCkBDTAfjIrIeY40ri60+eRF7QNh6YCtT0qdQ4argjVFv0D+pv7dD8hm6qoq8f/2b3LfeAouFxJtvIm7iRJTds59HSQp+SpJCI7mcxsVjm+YajcUHMozlbQccTATJx0v7gAftLdnL5PmTyS7L5sUzXuT09qd7OySfUrVnL1lPPUXJd98R3O04Uh5+mLCTTvJY+ZIU/JQkhSOoLIFtC42ribfMg/IDYA0yRhntMda4RbX1dpStWm55LjctuIktB7bw5GlPMq7LOG+H5HOKv/uOrCeexLFvH9Hnn0/S3Xdhi2/54dIlKfgpSQqHKdpvtA9snGNcUOaqgtBYY96BnuOMeQiCpTukLymuKua2725jZdZK7jv5Pq7sdaW3Q/I57rIycqe/Td6//oUlNJSkv/2VmEsuQVmtLVamJAU/1eqTgtbGUNPV01LuW2Usj+1kVAv1HGfMTGaVaxh9WaWrkrsX382i3Yu4sd+N3NjvRrmYqw6V27aROe1xyn7+mZC+fUl55GFCj2+Z+SskKfipVpkUXA5j8pnqiWgKzOmz2w06OC1lYk9pH/AzTreTx356jC+2fsHlPS7n/sH3Y1G+P3Ccp2mtKfr6G7KefRZXfj6xV1xB4u23YY2KatZyAjkpyE/EQFBRBFsXGIlgyzyoKARrMHQdAaf/DbqfBZGtZ47gQGSz2Jh26jRig2P517p/UVhVyJNDn8QuvcAOoZQievw5RAwfRs4rr3Lgww8pmjeP5HvvIeqcc+QMqxHkTMFfFe49eDVxxlJwOyAs3kgAPcYa7QNBMphYIHr3j3d5aeVLDG03lBeHv0iYPczbIfms8j/WkfnYY1SsXUvY4MGkPPIwwV2OfYKmQD5TkKTgL7SGzLVmtdA3sP83Y3lcV7Na6GxIPRksLde4JnzH51s+57GfHuOEhBN4Y9QbRAfLBYT10S4XBZ98QvaLL+EuLyf+uutIuGEKltDQo96nJAU/5fdJweWAHcvMM4K5ULgbUMaXf/X8xIndvR2l8JKFOxdy95K76RjVkelp00kOT/Z2SD7NmZdH9vMvUPjFF9jbtiX5oYeIHDniqPYlScFP+WVSKC8w2wfmwJYFUFkItlCjfaDHOOh+JkQkeTtK4SN+2f8Lty26jZjgGN4e/TYdo1rX3BRHo+zXX8mcNo3KLVuJGDmS5AceIKh908aZkqTgp/wmKRTsOthbaMcycDshLMGYoL7H2dDlDAiSemNRt3V567gx3eimOj1tOr3ie3k7JJ+nHQ7y33+fnNffAK1JuOkm4q+ZhApq3PDukhT8lM8mBa2NNoHqhuLMtcbyhO7maKPjoP0gaR8QjZZRmMGU9CkUVxXz6shXOSnFc0M++DPH/v1kPfU0xenpBHXpQsrDDxM+ZHCD20lS8FM+lRScVbBj6cH2gaK9oCyQOvhgIkg4zttRCj+WWZrJlPQp7Cnew/PDn2dkh5HeDslvlCxeTOYTT+LYvZuoc8eTfPfd2BIT611fkoKf8npSKD8AW9IPtg9UFYM9zOguWt0+EC6TqYjmU1BRwM0Lb+aPvD949JRHuaDbBd4OyW+4KyrImzGDvH+8gwoJIfGO24m9/PI6h8uQpOCnvJIUDuw4ONrozh9BuyA8yewtNA66DAf70XeFE6IhZY4y7lh0Bz/t/4k7B97JNX2u8XZIfqUyI4Osxx+n9MefCDn+eFIefYTQE044ZB1JCn7KI0nB7Yb9q81EMAey1xnLE3saSaDn2dD2RLDIkATCc6pcVTyw7AHm7ZjHdX2u444T75CreZtAa03xt9+S9dTTOHNzibn8MpLuuANrtHE9SCAnBRnm4mg4Koz2gY3fGNNSFu832gc6nApjnjTOCuK7ejtK0YoFWYN49vRniQ6K5t0/3qWgsoCpQ6Zis8i/fGMopYgaO5bw008n97XXyJ85i+J580m6526izzvP2+G1KPmENFZZPmyZbySCbd9BVQnYw43pKHuebUxPGRbn7SiFqGG1WHloyEPEhcYx/bfpFFYW8uywZwm2Bns7NL9hjYgg+f77iT7/fDIfm8b+++6n8NPPvB1Wi5KkcCT5281hp+fCrp+M9oHINtD3UqNqqNPpYA/xdpRC1Espxc39byYmOIZnfnmGmxbcxCsjXiEiKMLbofmVkF696PjBbAo//5zs51/wdjgtStoUanO7jTkHNn5j9BjK2WgsTzreHF9oLLQZIO0Dwi99vf1rpi6bSve47ryV9hZxIXJmezScBw5gj4uTNoWA5SiH7YuNJLD5WyjJAmWFTkNh4DVGIojt5O0ohThm53Q5h6igKO78/k4mzZ3EjNEzaBPRxtth+R1bbKy3Q2hRrfNMoTQXNs8zEsG278BRBkGR0C3NGFaiW5oxTaUQAWh19mpuXngzobZQZoyeQdcY6RTRVIHc+8ijSUEp9S5wDpCtte5Tx/NnAF8CGeaiz7XW08znzgJeAazAO1rrZxoq75CkkLvVGHJ601zY/TNoN0S1M68mHmu0D9gaN+6JEP5uU/4mblhwAw63gzdHvUnfxL7eDsmvSFJorsKUGgaUAO8fISncpbU+57DlVmAzMBrYA/wKXKG1Xn+k8gae0FOvfPFSIxHkbjYWppxgnA30GAtt+sm0lKLV2l28m8nzJ5NXkcfLI17m1LanejskvxHIScGjLaZa6yVA/lFsejKwVWu9XWtdBXwENNhZWOVtwfnD62QST/HIp+COP+CGZTDifmjbXxKCaNVSI1OZOW4mHSI7cPPCm5m3Y563QxI+wBe70ZyilPpNKTVXKXW8uawdsLvWOnvMZX+ilJqslFqhlFqRpRI5O+Q9huy5lb5zO3HBB7t4Y9FWtmQVE8htKUI0VkJoAu+e9S59E/py9+K7+XjTx94OSXiZxxualVKdgK/rqT6KAtxa6xKl1DjgFa11N6XUxcBZWuvrzfUmAIO11rccqaxBgwbpX3/9lU1ZxaSvy2LBhix+21MIQMf4MEb3SmZ072QGdozFZvXF/CiEZ5Q7y7l78d0s3rOYW/rfwuS+k2VYjCMI5Oojn+qSqrUuqnV/jlLqTaVUArAXSK21antzWYOUUvRMiaJnShS3jupGZmEFCzYYCeL9n3byzrIMYsPsjOiZxOheyQzrnkh4sE+9LEK0uFBbKC+NeIlHfniE19e8TkFlAXefdDcWJT+WWhuf+vZTSqUAWVprrZQ6GaN6Kw8oALoppTpjJIPLgSuPpoyU6BCuHtKRq4d0pKTSydLNOaSvz+K7jdl8vmovQVYLpx4Xz+jeyaT1SiY5Sq5YFq2D3WLnidOeIDo4mlkbZlFQWcC0odOwW+zeDk14kKd7H30InAEkAFnAI4AdQGs9XSl1C3Aj4ATKgb9prX80tx0HvIzRJfVdrfWTDZXXlCuanS43K3YeIH19Funrs9iVXwZAv/bRpPVKZvTxyfRIjpRTahHwtNa8s/YdXl39KsPaD+OF4S8QapPh3msL5Oqj1nnxWgO01mzJLqlJEGt2FwCQGhdqJIjeyZzUKQ67tEOIAPbxpo95YvkT9E/qz+ujXicqKMrbIfkMSQp+qrnmU8guqmDhxmwWrM9i6dZcqpxuokJsjOyZRFrvZIZ3TyQyRE6xReCZv2M+9y29j87RnZmeNp3EsPqnqGxNJCn4qZaYZKesysmSzbks2GC0Q+SXVmG3KoZ0iWdM72RG9UqmbYycaovA8dO+n7h90e3Eh8QzY/QMUqNSG94owElS8FMtPfOay61ZtetgO0RGbikAfdpF1VQz9W4TJe0Qwu+tzVnLTQtvwqqsvD36bXrE9fB2SF4lScFPeXqO5q3ZJSzYYCSIVbsOoDW0iwklrVcSo3uncHLnOIJs0g4h/NP2gu1MTp9MmaOM10e9zonJJ3o7JK+RpOCnPJ0UassprmTRxmzmr89i2dYcKhxuIkNsnNEjibReSZzRI4noUGmHEP5lf8l+JqdPZn/pfl4840WGtR/m7ZC8QpKCn/JmUqitvMrFsq25pK/PZOGGbPJKq7BZjHaItF5GY3X72DBvhylEo+RX5HPTgpvYmL+Rx4c+zviu470dksdJUvBTvpIUanO5NWt2HyB9fTbp6zPZlmO0Q/RqE8Xo3smM7pVMn3bSDiF8W6mjlNsX3c7P+3/m3pPu5ereV3s7JI+SpOCnfDEpHG57zsF2iJU7D+DW0CY6hLReyaT1TmZIlziCbVZvhynEn1S5qrh3yb0s2LWAyX0nc0v/W1rNjxlJCn7KH5JCbXkllXy3MZsFG7JYsjmXcoeLiGAbw7snMrp3MiN6JBEdJu0Qwne43C4eX/44n235jEu6X8KDgx/Eagn8HzGSFPyUvyWF2iocLn7YmmueRWSTW1KJ1aI4uVOcUc3UO5nUOGmHEN6ntebV1a/yztp3GN1xNM+c/gxB1sCexVCSgp/y56RQm9ut+W1PQc31EFuySwDomRJZcz3ECe2isVhax6m78E3vrXuPF1a8wJA2Q3hlxCuE2QP3R4skBT8VKEnhcDtyS2vaIX7dkY9bQ3JUMKPMBHFKl3hC7IF/Ci98z5dbv+SRHx+hd3xv3hj1BrEhsd4OqUVIUvBTgZoUajtQWsWiTdmkr89i8eYcyqpchAdZGVarHSI2PLBP5YVvWbRrEXcvuZu2EW2ZMXoGKeEp3g6p2UlS8FOtISnUVuFw8dO2PNI3ZLFgfRbZxUY7xKCOsTXtEB3jw70dpmgFVmSu4NbvbiUiKIK3R79Nl+gu3g6pWUlS8FOtLSnU5nZr1u4trKlm2phZDEC3pAhjAqHeyfRvHyPtEKLFbMzfyJT0KWiteSvtLY5POL7hjfyEJAU/1ZqTwuF255eRvt6YhvTnjHxcbk1CRLA5LlMyQ49LkHYI0ex2Fe1icvpkDlQc4NWRrzK4zWBvh9QsJCn4KUkKdSsscxjtEBuyWLwph5JKJ6F2K6d3S2B072RG9kwiPiLY22GKAJFdls2U9CnsLNrJc8OeI61jmrdDOmaSFPyUJIWGVTpd/Lw9v+YsYn9hBRYFAzvG1nR37ZIY4e0whZ8rrCzkloW38Hvu7zw85GEu6n6Rt0M6JpIU/JQkhabRWrNuX1HN9RDr9xcB0CUxnNG9kxnTO5n+qbFYpR1CHIUyRxl3Lr6TZXuXcceJd3Bdn+v8dlgMSQp+SpLCsdlzoIyFG4zursu35+F0a+LDgxjVK4m0Xsmc3i2R0CBphxCN53A7eGjZQ8zJmMOk3pO4c9CdfpkYJCn4KUkKzaeowsH3m3JYsD6LRZuyKa5wEmyz1GqHSCYxUtohRMPc2s0zvzzDhxs/5Lyu5/HoqY9is9i8HVaTBHJS8K93QnhNVIidc/u15dx+balyuvl1R35NNdOCDdkotZYBqTGkmdVMXRMj/PIXoGh5FmXh/pPvJzYkljfXvElhVSHPD3ueEFuIt0MTyJmCOEZaazbsL665HmLt3kIAOieE10xDemKHGGxWmYZU/NlHGz/iqZ+f4sTkE3lt5GtEBkV6O6RGCeQzBUkKolntLyxngdkO8dO2XBwuTWyYnZE9kxndO4nTuyUSHiwnqOKguRlzeWDpAxwXexxvpb1FQmiCt0NqkCQFPyVJwbuKKxws2WwM//3dxmwKyx0E2SwM7RrP6N4ppPVKIilKqgwELNu7jL99/zcSQxN5e/TbtI9s7+2QjkiSgp+SpOA7HC6jHWLB+mzSN2SyO78cgH6pMYzpnUxar2S6J0s7RGu2JnsNNy+8mWBrMG+Pfptusd28HVK9JCn4KUkKvklrzeasEtLXZ5K+IZvfdhcA0CEurOaCuZM6xUo7RCu09cBWpqRPodxVzpuj3qR/Un9vh1QnSQp+SpKCf8gqqjCvh8jkh215VDndRIfaGdnTuB5ieI9EIqQdotXYW7KXKelTyCrN4sUzXuT09qd7O6Q/kaTgpyQp+J/SSidLt+Qwf73RDlFQ5iDIauGUrvGk9U5mdK9kUqKlHSLQ5ZXnceOCG9lyYAtPnvYk47qM83ZIh5Ck4KckKfg3p8vNyp0Harq77sgrA+CEdtHG8N+9kunVJlLaIQJUSVUJt353KyuzVnLfyfdxZa8rvR1SDUkKfkqSQuDQWrMtp4T5640JhFbvLkBraBcTWjOB0Mmd47BLO0RAqXRVcs/ie/hu93fc2O9Gbux3o0/8CJCk4KckKQSu7OIKvtuQzYINWSzdkkul001kiI0RPYz5IYb3SCQqxO7tMEUzcLqdPPbTY3yx9Qsu73E59w++H4vybvKXpOCnJCm0DmVVTpZuyWWB2Q6RV1qF3aoY0iWetF7GLHPtYkK9HaY4BlprXlr5Ev9a9y/Gdh7Lk0OfxG71XtKXpOCnJCm0Pi63ZvWuA6Sb7RDbc0oBOL5tVE131+PbRvlEFYRounf/eJeXVr7E0HZDeXH4i4TZw7wShyQFPyVJQWzLKWGBOXDfyl0H0BraRoeQZjZUD+kST5BN2iH8yedbPuexnx6jT0If3hz1JtHB0R6PQZKCn5KkIGrLK6lk4cZsFqzPYsmWHCocbiKDbQzvkcjo3smc0SOJ6FBph/AHC3cu5O4ld9MxqiPT06aTHJ7s0fIlKfgpSQqiPhUOF8u2GOMyLdiQTW5JJTaL4uTOcTXdXVPjvFM1IRrnl/2/cNui24gOimbGmBl0jOrosbIlKfgpSQqiMdxuzZo9BcbcEOuz2JJdAkDPlEhjXKbeyZzQLlraIXzQurx13JhudFOdnjadXvG9PFKuJIXmKkypd4FzgGytdZ86nr8KuBdQQDFwo9b6N/O5HeYyF+BszBsiSUEcjYzcUqMdYkMWK3bk49aQEhXCqF5Gd9dTusYTbJNpSH1FRmEGU9KnUFRVxGsjX+OklJNavExJCs1VmFLDgBLg/XqSwqnABq31AaXUWOBRrfVg87kdwCCtdW5jy5OkII5VfmkVizYa80Ms2ZJDWZWL8CBrTTvEiB5JxIQFeTvMVi+zNJMp6VPYU7yH54c/z8gOI1u0PEkKzVmgUp2Ar+tKCoetFwv8obVuZz7egSQF4UUVDhc/bctj/vosFm7IIru4EqtFcVKnWNJ6JTOmdwod4qUdwlsKKgq4eeHN/JH3B4+e8igXdLugxcqSpNCcBTY+KdwF9NRaX28+zgAOABp4W2s9o57tJgOTATp06DBw586dzRi9EAa3W/P73sKa7q6bsooB6JEcSVpvYxrSvu2isVikHcKTyhxl/PX7v/Ljvh+5c+CdXNPnmhYpR5JCcxbYiKSglBoBvAmcprXOM5e101rvVUolAenArVrrJUcqS84UhKfsyiszL5jL5NcdB3C5NUmRwYzqZUxDemrXBELs0g7hCQ6XgweWPcC3O77luj7XcceJdzR7J4FATgo+N0i9Uqov8A4wtjohAGit95p/s5VS/wVOBo6YFITwlA7xYfzltM785bTOFJRVsWhTNgvWZ/O/NXv58JddhAVZOb1bAqN7pzCyZxJx4dIO0VLsVjvPnP4M0cHRvPvHuxRUFjB1yFRsFp/7uvNJPvUqKaU6AJ8DE7TWm2stDwcsWuti8/4YYJqXwhTiiGLCgrhgQHsuGNCeSqeL5dvzSV+fyYL12cxbl4VFwaCO5vUQvZPpnBDu7ZADjtVi5cHBDxIbEsv036ZTWFnIs8OeJdga7O3QfJ6nex99CJwBJABZwCOAHUBrPV0p9Q5wEVDdEODUWg9SSnUB/msuswEfaK2fbKg8qT4SvkRrzR97i2qmId2wvwiA45IiasZlGpAaI+0QzWz2htk888sznJxyMq+MeIWIoIhj3mcgVx/JxWtCeMnu/DIWbjCuh/h5ez5OtyYhIohRPY0ziNOOSyA0SNohmsPX279m6rKpdI/rzltpbxEXEndM+5Ok4KckKQh/UVju4PtN2SzYkM33G7MprnQSYrdwerdERvdKZmSvJBIipOrjWCzZs4Q7v7+TlPAU3h79Nm0j2h71viQp+ClJCsIfVTnd/JyRV9PddV9hBUrBiR1ia8ZlOi7p2KtAWqPV2au5eeHNhNpCmTF6Bl1juh7VfiQp+ClJCsLfaa1Zv7/IGJdpQxZ/7DXaIbokhJNmTkN6YodYrNIO0Wib8jdxw4IbcLgdvDnqTfom9m3yPiQp+ClJCiLQ7CsoZ+GGLOavz2L59jwcLk1ceBAjeyaR1iuZYd0TCAvyqU6FPml38W4mz59MXkUeL5/xMqe2O7VJ20tS8FOSFEQgK65wsHhzDunrs1i0MZuiCifBNgunHZdAWu9kRvVKIikyxNth+qzc8lxuSL+BbYXbePr0pzmr01mN3laSgp+SpCBaC4fLza8Z+TXTkO45UA5A/9QYRpvVTN2SImT478MUVRVx68JbWZ29mgcHP8hlPS9r1HaSFPyUJAXRGmmt2ZRVTPo6ox3itz2FAHSMD2N0L6O766COsdisMg0pQLmznLsX383iPYu5pf8tTO47ucHkKUnBT0lSEAIyCyvMGeay+HFrHlUuNzFhdkb2MOaHOL17IhHBrbsdwuF28MgPj/DV9q+4utfV3H3S3VhU/UlTkoKfkqQgxKFKKp0sNdshvtuUTUGZgyCrhVOPi6+5qjo5qnW2Q7i1m+d/fZ5ZG2ZxTpdzmDZ0GnZL3XN2S1LwU5IUhKif0+Vmxc4DNbPM7cwrA6Bf+2jSzGqmnimRraodQmvNO2vf4dXVrzKs/TBeGP4CobbQP60nScFPSVIQonG01mzNLmG+ecHcmt0FALSPDTUaqnslc1LnOOytpB3i400f88TyJ+if1J/XR71OVFDUIc9LUvBTkhSEODrZxRUs3JDNgvVZLN2aS5XTTVSIjRE9jXaI4d0TiQypu2olUMzfMZ/7lt5H5+jOTE+bTmJYYs1zkhT8lCQFIY5dWZWTpVtyjXaIjdnkl1ZhtyqGdImvGXajbcyfq1gCwU/7fuL2RbcTHxLPjNEzSI1KBSQp+C1JCkI0L5dbs2rXgZpxmbbnlgJwfNuomushereJCqh2iLU5a7lp4U1YlZW3R79Nj7gekhT8lSQFIVrW1uwSFpgXzK3adQCtoV1MKGm9kkjrnczgzvEE2fy/HWJ7wXYmp0+mzFHGa6NeY1DKIEkK/kiSghCek1tSyXcbspm/PotlW3OocLiJDLZxRs8k0nolcUaPJKJD/bcdYn/JfianT2Z/6X5WTlgpScEfSVIQwjvKq1ws25rLgvVZLNyYRW5JFTaLYnCXuJqrqtvHhnk7zCbLr8jnpgU38Z/x/5Gk4I8kKQjhfS63Zs3uAtLXZ5G+PpNtOUY7RK82UTXdXfu08592iFJHKRFBEZIU/JEkBSF8z/Ycox1iwfpsVuzMx60hJSqEtN5JjO6dwpAucQTbfHsaUmlo9lOSFITwbXkllXy3MZsFG7JYsjmXcoeLiGAbw7snMrp3MiN6JBEd5nvtEJIU/JQkBSH8R4XDxY/bcs1Z5rLJKa7EalGc3CmOtN7JjOmdTGqcb7RDSFLwU5IUhPBPbrfmtz0FNdOQbs4qAaBnSmTNwH0ntIvG4qVpSCUp+ClJCkIEhp15pWZDdRa/7jDaIZKjghnVy2ioPqVrPCF2z7VDSFLwU5IUhAg8B0qrWLQpm/T1WSzenENZlYuwICvDuyeS1iuZkT2TiA0PatEYJCn4KUkKQgS2CoeLn7bnscCsZsoqqsSiYFCnOMaYw250jA9v9nIlKfgpSQpCtB5ut+aPfYU11UwbM4sB6JYUYQzc1zuZ/u1jmqUdQpKCn5KkIETrtTu/rGZcpp8z8nG5NQkRwaT1Mob/HnpcwlG3Q0hS8FOSFIQQAIVlDr7fbIzLtHhTDiWVTkLtVk7vlkBa72RG9UwiPiK40fsL5KTQumfrFkK0CtFhds7r347z+rejyulm+fY886rqLOavz8KiYGDH2Jrurl0SI7wdstfImYIQotXSWrNuX1HN9RDr9hUB0CUxvGZcpgEdYrEe1g4RyGcKkhSEEMK0t6CchWY7xPLteThcmvjwIEaa05Ce3i2R0CBrQCcFqT4SQghTu5hQJp7SiYmndKKowsHiTTmkr8/i23WZfLJyD8E2C6d3S/B2mC1KkoIQQtQhKsTO+H5tGd+vLQ6Xm18y8mu6uwYyqT4SQogm0FpjsVgCtvrI/ydPFUIID/KXyYCOliQFIYQQNSQpCCGEqCFJQQghRA1JCkIIIWp4NCkopd5VSmUrpf6o53mllHpVKbVVKfW7UurEWs9NUkptMW+TPBe1EEK0Hp4+U/g3cNYRnh8LdDNvk4G3AJRSccAjwGDgZOARpVRsi0YqhBCtkEeTgtZ6CZB/hFXOA97XhuVAjFKqDXAmkK61ztdaHwDSOXJyEUIIcRR87YrmdsDuWo/3mMvqW/4nSqnJGGcZAJX1VVV5QAKQK2VL2VJ2QJbdw0vltjhfSwrHTGs9A5gBoJRa4a2rDqVsKVvKDuyyvVGuJ/ha76O9QGqtx+3NZfUtF0II0Yx8LSn8D5ho9kIaAhRqrfcD84AxSqlYs4F5jLlMCCFEM/Jo9ZFS6kPgDCBBKbUHo0eRHUBrPR2YA4wDtgJlwLXmc/lKqceBX81dTdNaH6nButqMZj2AppGypWwpW8r2OwE9SqoQQoim8bXqIyGEEF4kSUEIIUSNgEgKSqmzlFKbzOEx7qvj+WCl1H/M539WSnXyYNnDlFKrlFJOpdTFzVVuI8v+m1JqvTlkyEKlVEcPln2DUmqtUmqNUmqZUqq3p8qutd5FSimtlGq2bouNOO5rlFI55nGvUUpd76myzXUuNd/zdUqpDzxVtlLqpVrHvFkpVeDBsjsopRYppVabn/VxHiy7o/m/9btS6nulVPvmKttrtNZ+fQOswDagCxAE/Ab0Pmydm4Dp5v3Lgf94sOxOQF/gfeBiDx/3CCDMvH+jh487qtb9c4FvPVW2uV4ksARYDgzy4HFfA7zenJ/xJpTdDVgNxJqPkzz5mtda/1bgXQ8e9wzgRvN+b2CHB8v+BJhk3h8JzGzu997Tt0A4UzgZ2Kq13q61rgI+whguo7bzgPfM+58Co5RqlumTGixba71Da/074G6G8ppa9iKtdZn5cDnG9R2eKruo1sNwoLl6NDTm/QZ4HHgWqGimcptSdktoTNn/B7yhjaFg0Fpne7Ds2q4APvRg2RqIMu9HA/s8WHZv4Dvz/qI6nvc7gZAUGjMERs06WmsnUAjEe6jsltLUsv8CzPVk2Uqpm5VS24DngNs8VbY5um6q1vqbZiqz0WWbLjKrEz5VSqXW8XxLld0d6K6U+kEptVwp1VzjgzVlmJmOQGcOflF6ouxHgavNbu5zMM5UPFX2b8CF5v0LgEilVHN8t3hNICQF0QCl1NXAIOB5T5artX5Da90VuBd4yBNlKqUswIvAnZ4orw5fAZ201n0xBm58r4H1m5MNowrpDIxf6/9QSsV4sHwwqmc/1Vq7PFjmFcC/tdbtMa5zmml+DjzhLmC4Umo1MBxjpAVPHnuzC4Sk0JghMGrWUUrZME4x8zxUdktpVNlKqTTgQeBcrXWlJ8uu5SPgfA+VHQn0Ab5XSu0AhgD/a6bG5gaPW2udV+t1fgcY2AzlNqpsjF+y/9NaO7TWGcBmjCThibKrXU7zVR01tuy/AB8DaK1/AkIwBstr8bK11vu01hdqrQdg/J+htS5ohrK9x9uNGsd6w/h1tB3jlLW6Mej4w9a5mUMbmj/2VNm11v03zdvQ3JjjHoDRUNbNC695t1r3xwMrPP2am+t/T/M1NDfmuNvUun8BsNyDZZ8FvGfeT8Co+oj31GsO9AR2YF4U68HjngtcY97vhdGmcMwxNLLsBMBi3n8SY7SFZjl2b928HkAzfXDGYfwq2gY8aC6bhvHrGIxfDp9gDJ/xC9DFg2WfhPELrhTj7GSdB8teAGQBa8zb/zxY9ivAOrPcRUf64m7usg9b93uaKSk08rifNo/7N/O4e3qwbIVRdbYeWAtc7snXHKNu/5nmKrMJx90b+MF8zdcAYzxY9sXAFnOdd4Dg5j5+T99kmAshhBA1AqFNQQghRDORpCCEEKKGJAUhhBA1JCkIIYSoIUlBCCFEDUkKolVQSt2mlNqglJrt7ViE8GXSJVW0CkqpjUCa1npPrWU2bYyFJYQwyZmCCHhKqekYwx/PVUoVKqVmKqV+wBgjJ1Ep9ZlS6lfzNtTcJl4pNd+cl+AdpdROpVRzDJ0ghE+TMwXRKpjjIA0CbsEYduM0rXW5ORHNm1rrZUqpDsA8rXUvpdSrQK7WeppS6mzgayBRa53rrWMQwhNs3g5ACC/4n9a63LyfBvSuNb1GlFIqAhiGOSSy1vobpdQBz4cphOdJUhCtUWmt+xZgiNb6kMl4mmcOJiH8j7QpiNZuPrUmZVFK9TfvLgGuNJeNBWI9HpkQXiBJQbR2twGDzJnS1gM3mMsfA4YppdZhVCPt8laAQniSNDQL0QjVDdXS0CwCnZwpCCGEqCFnCkIIIWrImYIQQogakhSEEELUkKQghBCihiQFIYQQNSQpCCGEqPH/8a86ctX0Fj4AAAAASUVORK5CYII=", 68 | "text/plain": [ 69 | "
" 70 | ] 71 | }, 72 | "metadata": { 73 | "needs_background": "light" 74 | }, 75 | "output_type": "display_data" 76 | } 77 | ], 78 | "source": [ 79 | "N_max = 1\n", 80 | "freq_list = [x/10 for x in range(0,10,1)]\n", 81 | "kap = 0.05\n", 82 | "mu = [0,0,0,0.35,0.625,0.63,0.448,0.434]\n", 83 | "\n", 84 | "plt.figure(figsize=(5,7))\n", 85 | "ax = plt.gca()\n", 86 | "delta = 0.1\n", 87 | "\n", 88 | "for N in range (N_max+1):\n", 89 | " for i in range (-N-1,N+1):\n", 90 | " om = -(i+0.5)\n", 91 | " l_list = []\n", 92 | " lam_list = []\n", 93 | " sig_list = []\n", 94 | " H = []\n", 95 | "\n", 96 | " # Calculate basis for given value of N and om\n", 97 | " for l in range (N,-1,-2):\n", 98 | " for lam in range (-l, l+1):\n", 99 | " sig = om - lam\n", 100 | " if (abs(abs(sig)-0.5)<0.001):\n", 101 | " l_list.append(l)\n", 102 | " lam_list.append(lam)\n", 103 | " sig_list.append(sig)\n", 104 | "\n", 105 | " # Calculate the hamiltonian matrix, \n", 106 | " nbas = len(l_list)\n", 107 | " for freq in freq_list:\n", 108 | " H.append([])\n", 109 | " fdel = ((((1+2*delta/3)**(2))*(1-4*delta/3))**(-1/6))\n", 110 | " hw0 = 1\n", 111 | " hw00 = 1/fdel\n", 112 | " C = -kap*2*hw00\n", 113 | " D = C*mu[N]/2.0\n", 114 | " for i in range(nbas):\n", 115 | " H[-1].append([])\n", 116 | " li = l_list[i]\n", 117 | " lami = lam_list[i]\n", 118 | " sigi = sig_list[i]\n", 119 | " for j in range (nbas):\n", 120 | " lj = l_list[j]\n", 121 | " lamj = lam_list[j]\n", 122 | " sigj = sig_list[j]\n", 123 | "\n", 124 | " if (i==j):\n", 125 | " h00 = (N+1.5)*hw0\n", 126 | " hl2 = D*lj*(lj+1)\n", 127 | " hls = C*lamj*sigj\n", 128 | " hr2 = N+1.5\n", 129 | " else:\n", 130 | " h00 = 0\n", 131 | " hl2 = 0\n", 132 | " if (abs(li-lj)<0.001):\n", 133 | " if (abs(lami-lamj-1)<0.001)and (abs(sigi-sigj+1)<0.001):\n", 134 | " hls = C*0.5*math.sqrt((lj-lamj)*(lj+lamj+1))\n", 135 | " elif (abs(lami-lamj+1)<0.001)and (abs(sigi-sigj-1)<0.001):\n", 136 | " hls = C*0.5*math.sqrt((lj+lamj)*(lj-lamj+1))\n", 137 | " else:\n", 138 | " hls = 0\n", 139 | " if (abs(lami-lamj)<0.001) and (abs(sigi-sigj)<0.001):\n", 140 | " hY0 = cg_coeff1(lj, 2, lamj, 0, li)*cg_coeff1(lj, 2, 0, 0, li)*math.sqrt((2*lj+1)/(2*li+1))\n", 141 | " if (abs(li-lj+2)<0.001):\n", 142 | " hr2 = math.sqrt((N-lj+2)*(N+lj+1))\n", 143 | " elif (abs(li-lj-2)<0.001):\n", 144 | " hr2 = math.sqrt((N-lj)*(N+lj+3))\n", 145 | " else:\n", 146 | " hr2 = 0\n", 147 | " hY0 = 0\n", 148 | " hdelta = -delta*hw0*(2/3)*hr2*hY0\n", 149 | " hcrank = -hw0*freq*om\n", 150 | " H[-1][-1].append(h00+hdelta+hls+hl2+hcrank)\n", 151 | "\n", 152 | " # Diagonalise H\n", 153 | " diagH = []\n", 154 | " diagHs = []\n", 155 | " for i in range (len(H)):\n", 156 | " P, diag = Matrix(H[i]).diagonalize()\n", 157 | " diagH.append(np.diagonal(diag))\n", 158 | " diagHs.append(sorted(np.diagonal(diag).tolist()))\n", 159 | " diagH = np.array(diagH)\n", 160 | " diagHs = np.array(diagHs)\n", 161 | "\n", 162 | " # Plotting\n", 163 | " ls_list = ['s', 'p', 'd', 'f', 'g', 'h', 'i', 'j', 'k', 'l']\n", 164 | " ax.set_xlim([-0.1, 1.1])\n", 165 | " ax.set_ylim([1,3])\n", 166 | " plt.title('Single-particle energy level spectrum with N = {} and $\\omega$ = {}'.format(N, om))\n", 167 | " plt.ylabel('Energy (in units of $\\hbar\\omega_o$)')\n", 168 | " plt.xlabel('freq')\n", 169 | " for i in range(len(l_list)):\n", 170 | " y = diagHs[:,i].tolist()\n", 171 | " plt.plot(freq_list, y)\n", 172 | "plt.xlim(0,0.9)" 173 | ] 174 | } 175 | ], 176 | "metadata": { 177 | "interpreter": { 178 | "hash": "31e9a9fdb727f4cab00c9bb2df7901a2e872a4cc83935cdcfda541b216adb23e" 179 | }, 180 | "kernelspec": { 181 | "display_name": "Python 3.9.7 64-bit", 182 | "language": "python", 183 | "name": "python3" 184 | }, 185 | "language_info": { 186 | "codemirror_mode": { 187 | "name": "ipython", 188 | "version": 3 189 | }, 190 | "file_extension": ".py", 191 | "mimetype": "text/x-python", 192 | "name": "python", 193 | "nbconvert_exporter": "python", 194 | "pygments_lexer": "ipython3", 195 | "version": "3.9.7" 196 | } 197 | }, 198 | "nbformat": 4, 199 | "nbformat_minor": 5 200 | } 201 | -------------------------------------------------------------------------------- /Hot and rotating nuclei.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manishprasad0/Computational-Nuclear-Physics/eb6a9cde11674e18663f986914f7537790f9765e/Hot and rotating nuclei.pdf -------------------------------------------------------------------------------- /Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manishprasad0/Computational-Nuclear-Physics/eb6a9cde11674e18663f986914f7537790f9765e/Notes.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Computational-Nuclear-Physics 2 | This repository contains all the python codes I have written for my undergraduate course "PHN-624 Computational Nuclear Physics" during my final semester at The Indian Institute of Technology, Roorkee (IITR). \ 3 | The numbers at the start of all the codes correspond to the different chapters in the "Notes.pdf"\ 4 | There are three pdfs that contain the theory for the codes: 5 | 1. Notes.pdf: Contains theory for almost all of the codes. 6 | 2. Hot and rotating nuclei.pdf: Contains some of the theory for the code in "10. Quantum Hadrodynamics.ipynb" 7 | 3. Time Dependent Schrödinger Equation Notes.pdf Contains the theory for the "Time Dependent Schrödinger Equation.py" 8 | 9 | "PHN-624 ETE Manish Prasad 18122012" is my code for my end term examination for this course.\ 10 | nuclear_data.csv contains the data for "11.1 The Semi-Empirical mass formula.ipynb" 11 | -------------------------------------------------------------------------------- /Time Dependent Schrödinger Equation Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manishprasad0/Computational-Nuclear-Physics/eb6a9cde11674e18663f986914f7537790f9765e/Time Dependent Schrödinger Equation Notes.pdf -------------------------------------------------------------------------------- /Time Dependent Schrödinger Equation.py: -------------------------------------------------------------------------------- 1 | # Solving the TDSE using Cayley's operator. The code contains the solutions both the infinite box and the harmonic oscillator. 2 | # To get the required plot, add and remove the commented parts accordingly. For example, remove the comments from the harmonic oscillator cell 3 | # and add comments to the infinite box cell to get the animated plot for the harmonic oscillator. 4 | 5 | import numpy as np 6 | from math import pi 7 | import matplotlib.pyplot as plt 8 | from scipy.sparse import spdiags 9 | from scipy.sparse.linalg import splu 10 | 11 | # 2nd order derivative (3pt central difference) 12 | #----------------------------------------------------------------------- 13 | def diff2(f,h,J): 14 | d2f=(np.roll(f,-1)+np.roll(f,+1)-2*f)/h**2 15 | d2f[0]=d2f[J-1]=0 16 | return d2f 17 | 18 | # LU matrix on the left: tridiagonal case 19 | #----------------------------------------------------------------------- 20 | def lhs_lumatrix(J,dx,dt,V,hb,hb2m): 21 | a = 1 + 1j*dt*(2*hb2m/dx**2 + V)/(2*hb) 22 | b = (-1j*hb2m*dt/(2*hb*dx**2))*np.ones((J),float) 23 | return splu(spdiags(np.array([b,a,b]),np.array([-1,0,+1]),J,J).tocsc()) 24 | 25 | # zeta vector on the right: tridiagonal case 26 | #----------------------------------------------------------------------- 27 | def zeta(J,psi,dx,dt,V,hb,hb2m): 28 | return psi - 1j*(dt/hb)*(-hb2m*diff2(psi,dx,J)+V*psi)/2 29 | 30 | hb = 1 #Planck's constant, hbar 31 | m = 1 #mass of particle, m 32 | 33 | """ 34 | # defining the system for harmonic oscillator 35 | #----------------------------------------------------------------------- 36 | 37 | xmin,xmax,dx = -25,+25,0.01 #x-limits of simulation box 38 | x = np.arange(xmin,xmax+dx,dx) #defining the position grid 39 | J = len(x) #dimension of position grid 40 | 41 | w = 0.1 #freq of harmonic oscillator 42 | V = 1/2*m*w**2*x**2 #harmonic oscillator potential 43 | 44 | x0,p0,sig = -10,0,1 #initial position,momentum, position spread 45 | 46 | psi = np.exp( -((x-x0)/(2*sig))**2 + 1j*p0*(x-x0) )/np.sqrt( sig*np.sqrt(2*pi) ) 47 | 48 | tmax,dt,plot_steps = 4*(2*pi/w),0.01,10 #time limit, time step, and interval b/w 2 successive plots 49 | """ 50 | 51 | 52 | # defining the system for particle in a box 53 | #----------------------------------------------------------------------- 54 | 55 | xmin,xmax,dx = -10,+10,0.01 #x-limits of simulation box 56 | x = np.arange(xmin,xmax+dx,dx) #defining the position grid 57 | J = len(x) #dimension of position grid 58 | 59 | V = np.zeros(J,float) #zero potential 60 | V[0],V[J-1] = np.tan(pi/2),np.tan(pi/2) #infinite potential at the boundaries 61 | 62 | x0,p0,sig = 0,1,1 #initial position,momentum, position spread 63 | 64 | psi = np.exp( -((x-x0)/(2*sig))**2 + 1j*p0*(x-x0) )/np.sqrt( sig*np.sqrt(2*pi) ) 65 | 66 | tmax,dt,plot_steps = 100,0.01,10 #time limit, time step, and interval b/w 2 successive plots 67 | 68 | 69 | 70 | # solving the TDSE 71 | #----------------------------------------------------------------------- 72 | 73 | hb2m = hb**2/(2*m) #value of hbar^2/2m 74 | lhs_lu = lhs_lumatrix(J,dx,dt,V,hb,hb2m) #LU decomposition for the LHS matrix 75 | t_range=np.linspace(0,tmax+dt,len(x)) 76 | t = 0 77 | ymax = 1.01*np.max(np.abs(psi)**2) 78 | 79 | while t < tmax: 80 | 81 | for j in range(plot_steps): #evolve plot_steps times 82 | psi = lhs_lu.solve(zeta(J,psi,dx,dt,V,hb,hb2m)) 83 | 84 | t = t + plot_steps*dt 85 | 86 | plt.cla() 87 | plt.xlim(0,tmax) 88 | plt.ylim(0,1) 89 | plt.xlabel('$x$',fontsize=14) 90 | plt.ylabel('$|\psi|^2$',fontsize=14) 91 | plt.title(f'$t$ = {t:.1f}') 92 | plt.grid() 93 | plt.plot(t_range,np.abs(psi)**2,c='red') 94 | plt.pause(0.001) --------------------------------------------------------------------------------