diff --git a/Tutorial-ETK_thorn-BaikalETK.ipynb b/Tutorial-ETK_thorn-BaikalETK.ipynb index c0ad244f..ecaa1121 100644 --- a/Tutorial-ETK_thorn-BaikalETK.ipynb +++ b/Tutorial-ETK_thorn-BaikalETK.ipynb @@ -349,16 +349,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n", - "\n", - "Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n", "\n", "\n", "\n", @@ -366,53 +357,62 @@ "\n", "Generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords)...\n", "Generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords)...\n", - "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords) in 0.1 seconds.\n", - "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords) in 0.0 seconds.\n", - "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.3 seconds. Next up: C codegen...Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.3 seconds. Next up: C codegen...\n", - "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.3 seconds. Next up: C codegen...\n", - "Generating C code for 3-Ricci tensor (FD order=8) (Cartesian coords)...\n", - "Generating C code for 3-Ricci tensor (FD order=2) (Cartesian coords)...\n", - "Generating C code for 3-Ricci tensor (FD order=6) (Cartesian coords)...\n", + "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords) in 0.2 seconds.\n", + "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords) in 0.2 seconds.\n", + "Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n", "\n", - "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.4 seconds. Next up: C codegen...\n", - "Generating C code for BSSN_RHSs (FD order=8) (Cartesian coords)...\n", - "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.4 seconds. Next up: C codegen...\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 1.3 seconds. Next up: C codegen...\n", + "Generating C code for 3-Ricci tensor (FD order=2) (Cartesian coords)...\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 1.4 seconds. Next up: C codegen...\n", "Generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords)...\n", - "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.5 seconds. Next up: C codegen...\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 1.2 seconds. Next up: C codegen...\n", "Generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.5 seconds. Next up: C codegen...\n", + "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 1.5 seconds. Next up: C codegen...\n", "Generating C code for BSSN_RHSs (FD order=4) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n", - "Generating C code for BSSN constraints (FD order=8) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n", - "Generating C code for BSSN constraints (FD order=6) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n", - "Generating C code for BSSN_RHSs (FD order=6) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 0.7 seconds. Next up: C codegen...\n", - "Generating C code for BSSN constraints (FD order=4) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.8 seconds. Next up: C codegen...\n", - "Generating C code for BSSN_RHSs (FD order=2) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.8 seconds. Next up: C codegen...\n", + "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 3.8 seconds. Next up: C codegen...\n", "Generating C code for BSSN_RHSs (FD order=4) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.0 seconds. Next up: C codegen...\n", + "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 3.8 seconds. Next up: C codegen...\n", + "Generating C code for BSSN_RHSs (FD order=2) (Cartesian coords)...\n", + "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 5.3 seconds. Next up: C codegen...\n", + "Generating C code for BSSN constraints (FD order=4) (Cartesian coords)...\n", + "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 5.4 seconds. Next up: C codegen...\n", "Generating C code for BSSN constraints (FD order=2) (Cartesian coords)...\n", - "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.2 seconds. Next up: C codegen...\n", + "Finished generating C code for BSSN constraints (FD order=2) (Cartesian coords) in 77.5 seconds.\n", + "Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n", + "Finished generating C code for BSSN constraints (FD order=4) (Cartesian coords) in 79.1 seconds.\n", + "Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n", + "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 2.2 seconds. Next up: C codegen...\n", "Generating C code for BSSN constraints (FD order=4) (Cartesian coords)...\n", - "Finished generating C code for BSSN constraints (FD order=4) (Cartesian coords) in 16.5 seconds.\n", - "Finished generating C code for BSSN constraints (FD order=6) (Cartesian coords) in 17.0 seconds.\n", - "Finished generating C code for BSSN constraints (FD order=2) (Cartesian coords) in 16.6 seconds.\n", - "Finished generating C code for BSSN constraints (FD order=4) (Cartesian coords) in 16.9 seconds.\n", - "Finished generating C code for BSSN constraints (FD order=8) (Cartesian coords) in 18.5 seconds.\n", - "Finished generating C code for BSSN_RHSs (FD order=4) (Cartesian coords) in 37.9 seconds.\n", - "Finished generating C code for BSSN_RHSs (FD order=6) (Cartesian coords) in 39.0 seconds.\n", - "Finished generating C code for BSSN_RHSs (FD order=8) (Cartesian coords) in 41.5 seconds.\n", - "Finished generating C code for BSSN_RHSs (FD order=2) (Cartesian coords) in 49.0 seconds.\n", - "Finished generating C code for BSSN_RHSs (FD order=4) (Cartesian coords) in 49.8 seconds.\n", - "Finished generating C code for 3-Ricci tensor (FD order=2) (Cartesian coords) in 55.4 seconds.\n", - "Finished generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords) in 55.6 seconds.\n", - "Finished generating C code for 3-Ricci tensor (FD order=6) (Cartesian coords) in 56.1 seconds.\n", - "Finished generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords) in 56.1 seconds.\n", - "Finished generating C code for 3-Ricci tensor (FD order=8) (Cartesian coords) in 57.3 seconds.\n" + "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 1.4 seconds. Next up: C codegen...\n", + "Generating C code for BSSN_RHSs (FD order=6) (Cartesian coords)...\n", + "Finished generating C code for BSSN constraints (FD order=4) (Cartesian coords) in 71.4 seconds.\n", + "Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 1.1 seconds. Next up: C codegen...\n", + "Generating C code for 3-Ricci tensor (FD order=6) (Cartesian coords)...\n", + "Finished generating C code for BSSN_RHSs (FD order=4) (Cartesian coords) in 172.7 seconds.\n", + "Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n", + "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 2.0 seconds. Next up: C codegen...\n", + "Generating C code for BSSN constraints (FD order=6) (Cartesian coords)...\n", + "Finished generating C code for BSSN_RHSs (FD order=2) (Cartesian coords) in 220.2 seconds.\n", + "Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n", + "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 1.3 seconds. Next up: C codegen...\n", + "Generating C code for BSSN_RHSs (FD order=8) (Cartesian coords)...\n", + "Finished generating C code for BSSN_RHSs (FD order=4) (Cartesian coords) in 222.3 seconds.\n", + "Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 1.1 seconds. Next up: C codegen...\n", + "Generating C code for 3-Ricci tensor (FD order=8) (Cartesian coords)...\n", + "Finished generating C code for BSSN constraints (FD order=6) (Cartesian coords) in 66.8 seconds.\n", + "Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n", + "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 2.1 seconds. Next up: C codegen...\n", + "Generating C code for BSSN constraints (FD order=8) (Cartesian coords)...\n", + "Finished generating C code for 3-Ricci tensor (FD order=2) (Cartesian coords) in 245.4 seconds.\n", + "Finished generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords) in 246.1 seconds.\n", + "Finished generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords) in 246.5 seconds.\n", + "Finished generating C code for BSSN_RHSs (FD order=6) (Cartesian coords) in 168.2 seconds.\n", + "Finished generating C code for BSSN constraints (FD order=8) (Cartesian coords) in 40.0 seconds.\n", + "Finished generating C code for 3-Ricci tensor (FD order=6) (Cartesian coords) in 164.4 seconds.\n", + "Finished generating C code for BSSN_RHSs (FD order=8) (Cartesian coords) in 108.0 seconds.\n", + "Finished generating C code for 3-Ricci tensor (FD order=8) (Cartesian coords) in 138.0 seconds.\n" ] } ], @@ -465,17 +465,31 @@ "NRPyEnvVars = []\n", "raised_exception = False\n", "try:\n", - " if os.name == 'nt':\n", + "\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", - "\n", - " # Step 2.d: Import the multiprocessing module.\n", - " import multiprocessing\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 2.e: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " NRPyEnvVars.append(pool.map(master_func, range(len(BSSN_funcs))))\n", " pool.terminate()\n", " pool.join()\n", @@ -1979,7 +1993,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-ETK_thorn-WaveToyNRPy.ipynb b/Tutorial-ETK_thorn-WaveToyNRPy.ipynb index 267772c1..f6656a58 100644 --- a/Tutorial-ETK_thorn-WaveToyNRPy.ipynb +++ b/Tutorial-ETK_thorn-WaveToyNRPy.ipynb @@ -409,26 +409,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "***************************************\n", - "Starting parallel C kernel codegen...\n", - "***************************************\n", + "Generating symbolic expressions for WaveToy RHSs...\n", "Generating symbolic expressions for WaveToy RHSs...Generating symbolic expressions for WaveToy RHSs...\n", "\n", "Generating symbolic expressions for WaveToy RHSs...\n", - "Generating symbolic expressions for WaveToy RHSs...\n", - "(BENCH) Finished WaveToy RHS symbolic expressions in 0.013369560241699219 seconds.\n", - "Generating C code for WaveToy RHSs (FD_order=2) in Cartesian coordinates.\n", - "(BENCH) Finished WaveToy RHS symbolic expressions in 0.017975807189941406 seconds.\n", - "(BENCH) Finished WaveToy RHS symbolic expressions in 0.019555091857910156 seconds.Generating C code for WaveToy RHSs (FD_order=4) in Cartesian coordinates.\n", + "(BENCH) Finished WaveToy RHS symbolic expressions in 0.03818702697753906 seconds.\n", + "(BENCH) Finished WaveToy RHS symbolic expressions in 0.04004979133605957 seconds.(BENCH) Finished WaveToy RHS symbolic expressions in 0.04361605644226074 seconds.(BENCH) Finished WaveToy RHS symbolic expressions in 0.04396963119506836 seconds.Generating C code for WaveToy RHSs (FD_order=6) in Cartesian coordinates.\n", + "\n", + "\n", + "\n", + "Generating C code for WaveToy RHSs (FD_order=4) in Cartesian coordinates.Generating C code for WaveToy RHSs (FD_order=2) in Cartesian coordinates.Generating C code for WaveToy RHSs (FD_order=8) in Cartesian coordinates.\n", "\n", - "Generating C code for WaveToy RHSs (FD_order=8) in Cartesian coordinates.\n", - "(BENCH) Finished WaveToy RHS symbolic expressions in 0.02181220054626465 seconds.\n", - "Generating C code for WaveToy RHSs (FD_order=6) in Cartesian coordinates.\n", - "(BENCH) Finished WaveToy_RHS C codegen (FD_order=2) in 0.07765388488769531 seconds.\n", - "(BENCH) Finished WaveToy_RHS C codegen (FD_order=4) in 0.08968853950500488 seconds.\n", - "(BENCH) Finished WaveToy_RHS C codegen (FD_order=6) in 0.14511585235595703 seconds.\n", - "(BENCH) Finished WaveToy_RHS C codegen (FD_order=8) in 0.1823718547821045 seconds.\n", - "(BENCH) Finished C kernel codegen for WaveToy in 0.3171041011810303 seconds.\n" + "\n", + "(BENCH) Finished WaveToy_RHS C codegen (FD_order=2) in 0.1929771900177002 seconds.\n", + "(BENCH) Finished WaveToy_RHS C codegen (FD_order=4) in 0.28936314582824707 seconds.\n", + "(BENCH) Finished WaveToy_RHS C codegen (FD_order=6) in 0.39238786697387695 seconds.\n", + "(BENCH) Finished WaveToy_RHS C codegen (FD_order=8) in 0.5159783363342285 seconds.\n", + "(BENCH) Finished C kernel codegen for WaveToy in 0.8135979175567627 seconds.\n" ] } ], @@ -468,15 +465,26 @@ "start = time.time()\n", "if __name__ == \"__main__\":\n", " try:\n", - " if os.name == 'nt':\n", - " # Windows & Jupyter multiprocessing do not mix, so we run in serial on Windows.\n", - " # Here's why: https://stackoverflow.com/questions/45719956/python-multiprocessing-in-jupyter-on-windows-attributeerror-cant-get-attribut\n", - " raise Exception(\"Parallel codegen currently not available in Windows\")\n", - " # Step 3.d.ii: Import the multiprocessing module.\n", - " import multiprocessing\n", - " print(\"***************************************\")\n", - " print(\"Starting parallel C kernel codegen...\")\n", - " print(\"***************************************\")\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", + " # It's a mess to get working in Windows, so we don't bother. :/\n", + " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", + " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 3.d.iii: Define master function for parallelization.\n", " # Note that lambdifying this doesn't work in Python 3\n", @@ -486,7 +494,7 @@ "\n", " # Step 3.d.iv: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool() #processes=len(paramslist))\n", + " pool = mp.Pool() #processes=len(paramslist))\n", " NRPyEnvVars.append(pool.map(master_func,range(len(paramslist))))\n", " pool.terminate()\n", " pool.join()\n", @@ -1566,7 +1574,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb index ecbb001b..a9d4a2c8 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb @@ -637,7 +637,7 @@ "output_type": "stream", "text": [ "Generating symbolic expressions for BSSN RHSs...\n", - "(BENCH) Finished BSSN symbolic expressions in 4.469695329666138 seconds.\n" + "(BENCH) Finished BSSN symbolic expressions in 8.813973188400269 seconds.\n" ] } ], @@ -860,18 +860,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generating C code for BSSN RHSs in Spherical coordinates.Generating C code for Ricci tensor in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", + "Generating C code for Ricci tensor in Spherical coordinates.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating C code for BSSN RHSs in Spherical coordinates.\n", "\n", "\n", "\n", "Output C function enforce_detgammahat_constraint() to file BSSN_Hydro_without_Hydro_Ccodes/enforce_detgammahat_constraint.h\n", - "(BENCH) Finished gamma constraint C codegen in 0.08482170104980469 seconds.\n", + "(BENCH) Finished gamma constraint C codegen in 0.17435288429260254 seconds.\n", "Output C function rhs_eval() to file BSSN_Hydro_without_Hydro_Ccodes/rhs_eval.h\n", - "(BENCH) Finished BSSN_RHS C codegen in 8.538078308105469 seconds.\n", + "(BENCH) Finished BSSN_RHS C codegen in 16.67013192176819 seconds.\n", "Output C function Ricci_eval() to file BSSN_Hydro_without_Hydro_Ccodes/Ricci_eval.h\n", - "(BENCH) Finished Ricci C codegen in 13.602855443954468 seconds.\n", + "(BENCH) Finished Ricci C codegen in 23.68666100502014 seconds.\n", "Output C function Hamiltonian_constraint() to file BSSN_Hydro_without_Hydro_Ccodes/Hamiltonian_constraint.h\n", - "(BENCH) Finished Hamiltonian C codegen in 26.941988945007324 seconds.\n" + "(BENCH) Finished Hamiltonian C codegen in 31.93285083770752 seconds.\n" ] } ], @@ -880,12 +880,26 @@ "funcs = [BSSN_RHSs,Ricci,Hamiltonian,gammadet]\n", "\n", "try:\n", - " if os.name == 'nt':\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", - " raise Exception(\"Parallel codegen currently not available in Windows\")\n", - " # Step 1.a: Import the multiprocessing module.\n", - " import multiprocessing\n", + " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 1.b: Define master function for parallelization.\n", " # Note that lambdifying this doesn't work in Python 3\n", @@ -894,7 +908,7 @@ "\n", " # Step 1.c: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " pool.map(master_func,range(len(funcs)))\n", "except:\n", " # Steps 1.b-1.c, alternate: As fallback, evaluate functions in serial.\n", @@ -1464,16 +1478,16 @@ "\n", "Compiling executable...\n", "(EXEC): Executing `gcc -std=gnu99 -Ofast -fopenmp -march=native -funroll-loops BSSN_Hydro_without_Hydro_Ccodes/Hydro_without_Hydro_Playground.c -o Hydro_without_Hydro_Playground -lm`...\n", - "(BENCH): Finished executing in 4.015315532684326 seconds.\n", + "(BENCH): Finished executing in 13.251912832260132 seconds.\n", "Finished compilation.\n", - "(BENCH) Finished in 4.02451491355896 seconds.\n", + "(BENCH) Finished in 13.270668268203735 seconds.\n", "\n", "Now running, should take ~10 seconds...\n", "\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./Hydro_without_Hydro_Playground 96 16 2 0.5`...\n", - "\u001b[2KIt: 300 t/M=1.77 dt/M=5.90e-03 | 98.4%; ETA 0 s | t/M/h 7489.30 | gp/s 4.34e+06\n", - "(BENCH): Finished executing in 1.0097153186798096 seconds.\n", - "(BENCH) Finished in 1.0177099704742432 seconds.\n", + "(EXEC): Executing `./Hydro_without_Hydro_Playground 96 16 2 0.5`...\n", + "\u001b[2KIt: 300 t/M=1.77 dt/M=5.90e-03 | 98.4%; ETA 0 s | t/M/h 2122.44 | gp/s 1.23e+061.23e+15\n", + "(BENCH): Finished executing in 3.2765321731567383 seconds.\n", + "(BENCH) Finished in 3.2903671264648438 seconds.\n", "\n" ] } @@ -1738,7 +1752,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1782,10 +1796,10 @@ "text": [ "Now running, should take ~10 seconds...\n", "\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./Hydro_without_Hydro_Playground 48 8 2 0.5`...\n", - "\u001b[2KIt: 70 t/M=1.65 dt/M=2.36e-02 | 92.1%; ETA 0 s | t/M/h 82865.73 | gp/s 3.00e+06\n", - "(BENCH): Finished executing in 0.20953893661499023 seconds.\n", - "(BENCH) Finished in 0.2178492546081543 seconds.\n" + "(EXEC): Executing `./Hydro_without_Hydro_Playground 48 8 2 0.5`...\n", + "\u001b[2KIt: 70 t/M=1.65 dt/M=2.36e-02 | 92.1%; ETA 0 s | t/M/h 11885654283290.16 | gp/s 4.30e+14\n", + "(BENCH): Finished executing in 0.4352550506591797 seconds.\n", + "(BENCH) Finished in 0.4510190486907959 seconds.\n" ] } ], @@ -1818,7 +1832,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1922,7 +1936,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0rc2" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-ScalarField_Collapse.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-ScalarField_Collapse.ipynb index 88498161..0057d28c 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-ScalarField_Collapse.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-ScalarField_Collapse.ipynb @@ -398,7 +398,7 @@ "output_type": "stream", "text": [ "Generating symbolic expressions for BSSN RHSs...\n", - "(BENCH) Finished BSSN symbolic expressions in 7.168536186218262 seconds.\n" + "(BENCH) Finished BSSN symbolic expressions in 9.12996506690979 seconds.\n" ] } ], @@ -677,18 +677,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generating C code for Ricci tensor in Spherical coordinates.Generating C code for BSSN RHSs in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", - "\n", - "\n", + "Generating C code for BSSN RHSs in Spherical coordinates.Generating C code for Ricci tensor in Spherical coordinates.\n", + "Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", + "Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.\n", "\n", "Output C function enforce_detgammahat_constraint() to file BSSN_ScalarFieldCollapse_Ccodes/enforce_detgammahat_constraint.h\n", - "(BENCH) Finished gamma constraint C codegen in 0.1816692352294922 seconds.\n", + "(BENCH) Finished gamma constraint C codegen in 0.20664405822753906 seconds.\n", "Output C function Ricci_eval() to file BSSN_ScalarFieldCollapse_Ccodes/Ricci_eval.h\n", - "(BENCH) Finished Ricci C codegen in 21.17385697364807 seconds.\n", + "(BENCH) Finished Ricci C codegen in 15.17826509475708 seconds.\n", "Output C function rhs_eval() to file BSSN_ScalarFieldCollapse_Ccodes/rhs_eval.h\n", - "(BENCH) Finished BSSN_RHS C codegen in 22.861162185668945 seconds.\n", + "(BENCH) Finished BSSN_RHS C codegen in 17.862242221832275 seconds.\n", "Output C function Hamiltonian_constraint() to file BSSN_ScalarFieldCollapse_Ccodes/Hamiltonian_constraint.h\n", - "(BENCH) Finished Hamiltonian C codegen in 39.01502728462219 seconds.\n" + "(BENCH) Finished Hamiltonian C codegen in 24.206409215927124 seconds.\n" ] } ], @@ -698,12 +698,26 @@ "funcs = [BSSN_plus_ScalarField_RHSs,Ricci,Hamiltonian,gammadet]\n", "\n", "try:\n", - " if os.name == 'nt':\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", - " raise Exception(\"Parallel codegen currently not available in Windows\")\n", - " # Step 4.d.ii: Import the multiprocessing module.\n", - " import multiprocess as multiprocessing\n", + " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 4.d.iii: Define master function for parallelization.\n", " # Note that lambdifying this doesn't work in Python 3\n", @@ -712,7 +726,7 @@ "\n", " # Step 4.d.iv: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " pool.map(master_func,range(len(funcs)))\n", "except:\n", " # Steps 4.d.iii-4.d.v, alternate: As fallback, evaluate functions in serial.\n", @@ -1284,17 +1298,17 @@ "\n", "Compiling executable...\n", "(EXEC): Executing `gcc -std=gnu99 -Ofast -fopenmp -march=native -funroll-loops BSSN_ScalarFieldCollapse_Ccodes/ScalarFieldCollapse_Playground.c -o BSSN_ScalarFieldCollapse_Ccodes/output/ScalarFieldCollapse_Playground -lm`...\n", - "(BENCH): Finished executing in 6.512221097946167 seconds.\n", + "(BENCH): Finished executing in 8.370473861694336 seconds.\n", "Finished compilation.\n", - "(BENCH) Finished in 6.542217969894409 seconds.\n", + "(BENCH) Finished in 8.386640071868896 seconds.\n", "\n", "/Users/werneck/Codes/nrpytutorial/BSSN_ScalarFieldCollapse_Ccodes/output\n", "Now running, should take ~20 seconds...\n", "\n", "(EXEC): Executing `./ScalarFieldCollapse_Playground 640 2 2 0.5`...\n", - "\u001b[2KIt: 810 t=15.90 dt=1.96e-02 | 99.4%; ETA 0 s | t/h 3817.04 | gp/s 5.53e+0505e+14\n", - "(BENCH): Finished executing in 16.081330060958862 seconds.\n", - "(BENCH) Finished in 16.09248399734497 seconds.\n", + "\u001b[2KIt: 810 t=15.90 dt=1.96e-02 | 99.4%; ETA 0 s | t/h 3367.97 | gp/s 4.88e+0514e+14\n", + "(BENCH): Finished executing in 17.157500982284546 seconds.\n", + "(BENCH) Finished in 17.171742916107178 seconds.\n", "\n" ] } @@ -1594,13 +1608,13 @@ "output_type": "stream", "text": [ "(EXEC): Executing `./ScalarFieldCollapse_Playground 320 2 2 0.5`...\n", - "\u001b[2KIt: 400 t=15.71 dt=3.93e-02 | 98.3%; ETA 0 s | t/h 14137.17 | gp/s 5.12e+05.22e+14\n", - "(BENCH): Finished executing in 4.4767279624938965 seconds.\n" + "\u001b[2KIt: 400 t=15.71 dt=3.93e-02 | 98.3%; ETA 0 s | t/h 14137.17 | gp/s 5.12e+05\n", + "(BENCH): Finished executing in 4.3146653175354 seconds.\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "" ] @@ -1698,7 +1712,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-Psi4.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-Psi4.ipynb index 2ca6fd95..697e5f59 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-Psi4.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-Psi4.ipynb @@ -938,9 +938,6 @@ } ], "source": [ - "# Step 0: Import the multiprocessing module.\n", - "import multiprocessing\n", - "\n", "# Step 1: Create a list of functions we wish to evaluate in parallel\n", "funcs = [Psi4re,Psi4re,Psi4re,Psi4im,Psi4im,Psi4im, BrillLindquistID,BSSN_RHSs,Ricci,Hamiltonian,gammadet]\n", "\n", @@ -955,16 +952,30 @@ " funcs[idx]()\n", "\n", "try:\n", - " if os.name == 'nt':\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", - " raise Exception(\"Parallel codegen currently not available in Windows\")\n", - " # Step 1.b: Import the multiprocessing module.\n", - " import multiprocessing\n", + " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 1.c: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " pool.map(master_func,range(len(funcs)))\n", "except:\n", " # Steps 1.b-1.c, alternate: As fallback, evaluate functions in serial.\n", @@ -1666,7 +1677,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0rc2" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-no_rfm_precompute.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-no_rfm_precompute.ipynb index 2fbb90db..59739860 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-no_rfm_precompute.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide-no_rfm_precompute.ipynb @@ -376,7 +376,7 @@ "output_type": "stream", "text": [ "Generating symbolic expressions for BSSN RHSs...\n", - "(BENCH) Finished BSSN symbolic expressions in 1.8061211109161377 seconds.\n" + "(BENCH) Finished BSSN symbolic expressions in 2.9401168823242188 seconds.\n" ] } ], @@ -624,20 +624,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generating optimized C code for Brill-Lindquist initial data. May take a while, depending on CoordSystem.Generating C code for BSSN RHSs in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating C code for Ricci tensor in Spherical coordinates.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", + "Generating optimized C code for Brill-Lindquist initial data. May take a while, depending on CoordSystem.Generating C code for BSSN RHSs in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.Generating C code for Ricci tensor in Spherical coordinates.\n", "\n", "\n", "\n", "\n", "Output C function enforce_detgammahat_constraint() to file BSSN_Two_BHs_Collide_Ccodes/enforce_detgammahat_constraint.h\n", - "(BENCH) Finished gamma constraint C codegen in 0.0787210464477539 seconds.\n", + "(BENCH) Finished gamma constraint C codegen in 0.1973559856414795 seconds.\n", "Output C function rhs_eval() to file BSSN_Two_BHs_Collide_Ccodes/rhs_eval.h\n", - "(BENCH) Finished BSSN_RHS C codegen in 3.745373249053955 seconds.\n", - "(BENCH) Finished BL initial data codegen in 7.051412105560303 seconds.\n", + "(BENCH) Finished BSSN_RHS C codegen in 4.9432947635650635 seconds.\n", + "(BENCH) Finished BL initial data codegen in 6.144180059432983 seconds.\n", "Output C function Ricci_eval() to file BSSN_Two_BHs_Collide_Ccodes/Ricci_eval.h\n", - "(BENCH) Finished Ricci C codegen in 7.201741456985474 seconds.\n", + "(BENCH) Finished Ricci C codegen in 7.649197101593018 seconds.\n", "Output C function Hamiltonian_constraint() to file BSSN_Two_BHs_Collide_Ccodes/Hamiltonian_constraint.h\n", - "(BENCH) Finished Hamiltonian C codegen in 25.364696264266968 seconds.\n" + "(BENCH) Finished Hamiltonian C codegen in 21.690959930419922 seconds.\n" ] } ], @@ -651,13 +651,26 @@ "pickled_outC_func_dict = []\n", "\n", "try:\n", - " if os.name == 'nt':\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", - "\n", - " # Step 3.d.ii: Import the multiprocessing module.\n", - " import multiprocessing\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 3.d.iii: Define master functions for parallelization.\n", " # Note that lambdifying this doesn't work in Python 3\n", @@ -665,7 +678,7 @@ " return funcs[arg]()\n", " # Step 3.d.iv: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " pickled_outC_func_dict.append(pool.map(master_func,range(len(funcs))))\n", " pool.terminate()\n", " pool.join()\n", @@ -1218,14 +1231,14 @@ "text": [ "Compiling executable...\n", "(EXEC): Executing `gcc -std=gnu99 -Ofast -fopenmp -march=native -funroll-loops BSSN_Two_BHs_Collide_Ccodes/BrillLindquist_Playground.c -o BSSN_Two_BHs_Collide_Ccodes/output/BrillLindquist_Playground -lm`...\n", - "(BENCH): Finished executing in 3.4121758937835693 seconds.\n", + "(BENCH): Finished executing in 9.128590822219849 seconds.\n", "Finished compilation.\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 72 12 2 1.0`...\n", - "\u001b[2KIt: 550 t=7.50 dt=1.36e-02 | 100.0%; ETA 0 s | t/h 10109.50 | gp/s 1.42e+06\n", - "(BENCH): Finished executing in 2.8100385665893555 seconds.\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 96 16 2 1.0`...\n", - "\u001b[2KIt: 970 t=7.44 dt=7.67e-03 | 99.2%; ETA 0 s | t/h 3264.94 | gp/s 1.45e+06\n", - "(BENCH): Finished executing in 8.419183015823364 seconds.\n", + "(EXEC): Executing `./BrillLindquist_Playground 72 12 2 1.0`...\n", + "\u001b[2KIt: 550 t=7.50 dt=1.36e-02 | 100.0%; ETA 0 s | t/h 5399.61 | gp/s 7.60e+058e+14\n", + "(BENCH): Finished executing in 5.277481317520142 seconds.\n", + "(EXEC): Executing `./BrillLindquist_Playground 96 16 2 1.0`...\n", + "\u001b[2KIt: 970 t=7.44 dt=7.67e-03 | 99.2%; ETA 0 s | t/h 1785.55 | gp/s 7.95e+055\n", + "(BENCH): Finished executing in 14.351908922195435 seconds.\n", "(BENCH) Finished this code cell.\n" ] } @@ -1556,7 +1569,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATwAAAEWCAYAAAD7MitWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAACCCUlEQVR4nO29ebwt21UW+o2qtdbep7lNci8kkAQSnyBgyA+fEeShEiRInk9EsMMmMeL7xS7wQBTBCC8IoogCKnb3CYLSBHwSggqEIPIiSDABMSQkgYCB3BAgNze3OffsZq2q8f6YTY055pjVrF27WfescX7r7KpZs6tmfvWNZs4iZsZe9rKXvdwJUl12B/ayl73s5aJkD3h72cte7hjZA95e9rKXO0b2gLeXvezljpE94O1lL3u5Y2QPeHvZy17uGNkD3l4uVYjoR4no/7yAdoiIvpWIHiaib5ypzk8koseI6GeI6GON468kolfO0dY2QkQvIKIfvaz2r6I8qQGPiD6aiH6EiB4loncS0Wep49eJ6J8S0UM+z+tH1vtcInqtL2cGMhLR5xDR24joCSL6RSL63YV8LyUiJqIvVukPEtELxp3pfOIH6ZqIbonfIxfdj3OQ5wL44wA+mplfHhKJ6I8R0X8lotsWOBDRxxHRT/njP0VEHxeOMfNPALgXwM8D+HNDHSCidxHRC1XaS4nox7Y9qb1Mkyct4BHRAsBrAPwHAE8F8DIA30ZEHymyPeCPfbT/+4Ujq18D+G4UHnIi+jQAXwPgzwK4C8DvAfBLPfU9DOCLieiuke2ft3wXM98Uv3utTP4aD6ZdEXkqgIeY+ddV+sMAvgHA39UFiGgF9wx9G4CnAPhWAK/x6QAAZm4B/ByA+86n23uZU560gAfgowB8KICvZ+aGmX8EwI8DeDEAENFHAfiDAF7GzO/zeX7KH1t5NeXz/H5NRD9ORF8OAMz8Dmb+JgBvLbT9FQD+FjO/gZlbZn4PM7+np69vA/ATAP6KdZCIvoWIvkrsv4CIHhT77yKiv0ZEb/aM8puI6GlE9ANE9DgR/TARPWXMRRsSz0b/MhH9AoBfCH0hor9ORL8G4F+doe6KiP4mEf0yEf0GEf1rIrpHHH+JP/Z+IvoyizH1yAJAqxOZ+YeZ+bsB/KpR5gW+3Dcw8wkz/yMABOD3qnytz3dmIaIv8RrB40T0c1Ir8Wzwx4no64noESL6JSL633z6u/01+zNz9OPJKk9mwLOE4FQbAPh4AL8M4Cu8avqzRPSHAYCZTwH8aQB/i4g+GsCXAKgB/O3BBohqAM8H8EFejX6QiL6RiK4NFP0yAF9ARE/d6syAPwzg0wB8JIDPAPADAP4GgA+Cu8+fv2W9lvwhAJ8A4GP8/tPhGNSHwzHpKET0J4nozSPrfan/fQqA3wTgJoBv9PV8DIB/CuBPAfgQAPcAeMaYSomoAvCpAH5lZD+C/FYAb+Z0/uWbfbqUdwP47UQ0B8v7RQC/G+78vgJOK/kQcfwTfB/uA/AdAF4F4HcA+M1wz+w3EtHNGfrxpJQnM+C9A8BvAPhrRLQkot8H4JMBXPfHnwkHfo/CMcGXA/hWD3Bg5rcA+CoA3wvgrwJ4MTM3I9p9GoAlgD8C9+B+HIDfBuBv9hVi5p8B8DoAf33sCSr5x8z8655J/hcAP8nM/52ZjwG82vdhrPwxzyDC7z+r43+HmR9m5iO/3wL4vz0LOpIZmfk7mPl5I9v9UwC+jpl/iZlvAfhSAJ/j1eQ/AuDfM/OP+RfSlwMYnAjuXyBHAD4PwF8b2Y8gN+GeDymPwpkppHwbgIcAPEREXzBQ5/fKawsH4lGY+d8y8696zeC7APwC3Ms5yP9k5n/ln8XvAvAsOG3ihJl/CMApHPjtxZAnLeAx8xqOifwfAH4NwBfB2d2CKngEZ4v7KmY+Zeb/D8B/BvD7RDXfCsdavp+Zf2Fk02HA/2Nmfi8zPwTg6wD8/hFlvxzAXySip41sS4q0TR0Z+1Pe+t/NzPeK36eo4+9W++/zwHpW+VA41h3kl+FUxaf5Y7FdZr4N4P1DFTLzwwBuwN3LV0zszy0Ad6u0uwE8rtI+Aw54PpSZv2Ggzj8kry2AvyQPerX9ZwQgPhfA/SKLvq9Qdsmp9/qOkict4AEAM7+ZmT+Zme9j5k+HU5P+mz9sqVmaMfxTOKfHpxPR7xrZ5gfgQFXWNWpJGmZ+O4DvQT4wn0DHTAGnQl6m6POZa8mdX4V7wQT5MAAbuEH+XjhWDgDwJoJRKiQzbwD8e3Qq+Fh5K4DnERGJtOcht91+NIA3MPN7J9afCBF9OID/B07buM8D4lvgTDF7mUGe1IBHRM8jokNy4Sd/Fc728y3+8OvhbDpfSkQLIvokONvRa33ZFwP47XA2pc+HU3dv+mNERIcAVn7/kIgORNP/CsDnEdEHe2fBF8IB5xj5Cjjv7r0i7WcA/H4ieioRPR3AF4y+CLsl3wngC4noOf5afzWcx3gD4P8F8BneSL8C8EpMA4IT+PslxTukDuGYZOXv5dIf/lEADYDPJ6IDIgrhLD+iqln6+s8qN+BeHu/zffuz6GzOe5lBntSAB+eRfS+cLe9TAXwaM58AUeX9TDhV81G4N+tLmPntRPRhcKEKL2HmW8z8HQDeBODrfb0fDqc6hDf9EZzNMMhXAngjXHzW2wD8d4xwePh+/U8A/wbu4Q/ybwD8DwDvAvBDcLabrYVcbJ0ZF+jlj1Mah3eLiD54ZN2/m4huif0/RUQlb7aWb4Y719cD+J8AjuFsb2Dmt/rtV8Hd01tw93Us0LSwn/cXw92/fwZncz2CexaC8+oPAXgJgEcAfC6cSnqq6qhheICnCjP/HIB/AOex/3UAHwsXWbCXmYT2C4DuZRfFM8BHAHyEf0kM5f9IuBfUR47JP6EfCzgzxNuZWQePvxIAmPmVc7U3RcgFrr+SmV9wGe1fRXmyM7y9PImEiD7DmyduAPj7AH4WjvUOCjP/PIB/AuC/ENE/mqk/vxPOIXYvXBD7Xq647BneXnZGiOhfwoWnEJyJ4S8x8zuI6Afg1FEtX83MX32RfZTiGRaY+Ucvqf1nA3gBM3/LZbR/FWUPeHvZy17uGNmrtHvZy17uGLmqE71NWRze4NVd9syrGJ8whbAO5J1cZ5YvTbDXVZnQxpxkfExAx4g8fMYIsd5rEhuZKc9YOeO1ya8J9e4O1T88nWREfSpvqc7Txx/G5viJM93VT/+UG/z+h8dMSgJ+6s0nr2XmF52lvSmyU4C3uuup+KjP/kIzpDcOHL3fm4fH1ZHt82D+rO5W502PD7YBAG23YwJF6SmWgydsV5Tuk9qX5cIgCfG3sj5LR+gbLkYfz3xtStdlxPWIWWVaRXm6vj4D1yZeF3k8butj/W0M71Pv8TF1hO23f8/X46zy0MMNfvK1zxzOCGD5Ib94/3Cu+WSnAA/ANLATeYlRHFBbAd0IEN12ICdprQF8aiBTwQ4bBwIjPtjE/mFvGaio22eOA85l7P4WB7PMp9ssCOnOc1dfuF7sKyVw13ffzz5GWLpG2fUJt0H0lcQ1QsMRECi8GCDuA1HsT+gfMYt+EqhBcr3CuTBR15Y8JxJtILQZrhkG9tnvk++L6BuQpxn7+pqdTRgNnzks8Vxk9wAvyGSwOmv9BvBkeRWg9R0byVq2ATp53AK9KB70thbNMEZIyBv7LgdmqQ19nCh5OeSNiKw9+cKx5Br5NsN153AfJCP2L4cMNAT4ZddEHzPuh375mKA0JALQuv52aYOgN4MwgHZWG8N8spuAtyXYTWF2o9RXWW/YHsHqJjG6ocErk/oeWq3KGCptouZYqpilpo1p2xAWBSJD6WN6sVw6mIn9ubScsKXe8aaokr6uad98mga+EuOT51Rie54NMjq2l7O3ju0FUJrE9HyGIZA7L9Brzz7x5Fxk9wDvHMDuzCqsAXZnZnQloJswkIekCHbxeLfDVXesD+jGODES9ZEF6xPARy1S4BLbTBBqH49zfAD5tbPKUXe9IxOT3R1ifFl1KaOj1l9LTo9ZYBbq7lVxTRBTbU4BvRmEwVjvVdr5ZG5mlx0by+r8sV5WdxFAJ8UCLIPdZWCnAC9jdpTXl9RptG9KxoTkoQ74JOiNYnoBgFpWNjIarz5DHJ8KfIKRyWpkv+N5BAZbGccAg9HlbC8CFcT2HKA3gzCAZq/Snl0IM4FdX9kBVmd6Xw22ZwFdr1dR91ekdXkN21CSQRQdAjvpEexTYa102YU+8Cv0kQqnSD6BiSLoAUhU3Az0DKanVdvJoKc6lrbZARMggA9wqjWzYqCxo4kqG84rnqMAviG2Z4Jekq9rbyrozYR5exverDIz2PU5JjKwk0Cn2+oBuyhbMjqKfSuA3lRmF9J1uRLYyTJZe7IfA0OGGSbDS0ZtB3qhLxH0FHiZTM+w540FvcyREfpG3XGT8RFSzzcYJcdGosoKtufqY2TeVkhwUiquAq6zgt4cwgCaKzqDa7cAb4idJfsDYFdidb5MidUNAV2f6joF5IY8sF1GUbwH6OL+ALOTjglZH5NRL7r6svRifz27ESAFEdKRqnKBTQkVV4EhYDA9od6Ky9HVx0kjXdcSJ1J6/S0nS1qnb6gJDA9AJdkm+b6L+hXbA5CHsACxXNflcF5dTyTQJac2FfRmwqmracHbNcDzMgXsinnVdpQesEvzqPTkeA529nkYdQ9IyWFQVHW1NzZsF5hdqDcDO0v6gpVLItmYdd4deYqDPaZLpocBpseI3tusCwW2l6SPOIcETAqiQ01iecH2wvkkSBXqlmwvXhSrfovdbQF6MwiD9za8uWRbsBtUYU1w5IzVDYWZmM4I3TdZHsYxQwaBro/VAbCcE0OOCTM6n8gEuNGDJTIcOeAEEDDrcS88maldj4lAAtDYj/ioUgKgykNKy3Fgu7pttpfFCYZua8Yn1VoddGyyPeqYbE8Yi6Ryge0ldsNQN6VMTx4K29uA3hzCDKyvJt7t6OIBWzC7vI4ckKQkqqqupwc8AdhBw0b/Qzt9YMdE84GdqKMUcqLb0GCXiAV21PNLzstoS/dVscuMiUJcn4zBqmuQXRNRpzqfpN6CZPfNeAbdvj8umab17PU8a6X4S/PZM+opRRck/ZsVoAjNyN9Fy84xvLmYXa+9LtRpeWCz9lNWN2RLTNL6TrMILinIuTS/sW0wcQ+zM8GjxP6GRLC7WMZgG50nsmNO4T5F1c9Tl8yDG5iWP3/N9gAUbXsuLb1fJcYX84v0jDUajA+E3Jsrz927ShldwHISrEypF7fbTp0ZRabnz7HI9GYQRtGKc+mye4CHLZhdsl1+GyZG61K4SdK+HWpSfptu8RT0AEkCMiXHRKjDYDQWsyuzK1lH2repNjzpeeyAodvvBiZ196sbnzKD7cEVo90MUhaeXOg65XlMvF1Z3B4hUyMB5N5cCJD3fdGe3KjKC7teyNttMzI7odhOvb4F0JtJLoO9jZGdBDwAk5idy4fJzE4HEI9hdYOMTruvlFHBZnBpWh+jS/dlGcHgxnpild2vj+ElbfQJSWBAOuBUle5Qx/YiBhGA1rMpMLhGBwzo0hO2p+pCTR3TFPa9NOSkwN6kGPcznp9ifHIqWbTvicDlhO2J9hmUxezpeD3N9MoeW7ldntd7FmHMC3hE9CIA/xDuY0n/kpn/7rZ17RzglewRJWZXsnNYIJU5J0xw9ABnxNMVGV2fj770La1Q7dRQE5G3qMLKPH47Z3PlmL2xdjD7hLr8qeqngC5cysj8hPleDFDprTW9uPIcYhfLjK8Yu2eJdV9FGlUp4zNXNREzNpLYPVFlBLhwbnXK9DIPrhGr113YMujNBVEMYG2uGzZdiKiG+xbJp8F97/mNRPR9/gtvk2XnAC/IWGbntg1mJ0GJMWyvm8DqRgFdEP9c5MA2ntX1Ap3fL63P1muvs4739DHpV0kIAsw0EHTVRYaiGRoE0wt5kQYpAwbbE6LrAzAcuyfBCv4eh2taus8+PQKfqMuasRFBL/atE1lGMtBkSlrSb4ZUb0cxvZmEQWjm84d+PIB3MvMvAQARvQru86p3COAZAGNtZ8wuAa+wLcAOqt4hVqfBUZbXAyDaodRDNQLsRqmvA0A0WYVVx4eAbpIND5q9WKDSMa04iCMLTIZ+PK7X0NNsT9aPpGzH9oAC8Blsr5f96fttAF8WeIwO9EJ/8kUDwvPl00PYimBoU5ie3I6McSZpxxsE7yeiN4n9B5hZfgHuGQDeLfYfBPAJ2/br0gCPiJ4F4F8DeBrcZX+Amf/h6ApMAOu2XZ50JY0hZhfrjSxQAJwCO5PVSaCb6qAYALupdjqgzOqS8mFbqaU6OFmDZdYHqLTSaarBlqqykgHZoOcyUKeOIq9j6nJTLs0AvqDmxr4K3jXm9spngCgBPkvNDaAX2jfZnqC3wa5ngV4f0ysFKs8ljEk2vIeY+fnztd4vl8nwNgC+iJl/mojuAvBTRPS6Xt08AE0P2GWsLDvePbCZc6KVeQ0VdgjoxoJcH7OTYDIn0Pn9jK0Z8Wm2Oqv6ti27y5iFBJ30mAV6EqA000PMoxhjH/D5Sk3g844NbmU7KTsbpdoC6bPRegircmaKYGow2B77E02YogC9mJZdjzxkxQI9khfiTEJoZrLhAXgPgGeJ/Wf6tK3k0gKPmfm9zPzTfvtxAG+Do6+jZFtm544rZpfVJR9OtsuHwNOpYFeQbIK+XIl4COzkfg/YdfW5uqyA4T5mx+q43Z/+X9IeRH3iuAwmLjlOwnXRfeo7995rYwF4kGzRBTK3R4t4wcbnKHu+kAUrk/G8lrSU/Pnn/uMzCgNoUY36jZA3AvgIInoOEa0AfA6A79u2b1fChuc/GPzbAPykcexlAF4GAKsbTynczDMwO5lXqq2WY8Jgg31Lv7ManABSdqdASwJd5pTQzGzA82qqn8l22o7N8ChLM/OqtvskCXA1GB4TsmBi7cDQTM/l5Yy5hDpcPs+ARAhLvE6B3QS25yvSQcsMxOciUZ0l02v9tZUxndazEc4ghNdU4uQiewRi8HXVqfGBlVMrmOYA03M7ecgKG/fhrMJMOOV6prp4Q0QvB/BauLCUb2bmt25b36UDHhHdBPDvAHwBMz+mj3sD5gMAcOO+Z3X3hO0HKZMCsysFE+dv1jzvGLAzRauyYbsEFsV5q/3oMgh2SRvpts3wZN1GXUYfy50TeTy4kDzEXb1uQIqwE+oGKYUCsmo/cLU67NpRTgfh1HBlRRgLi/qQgpc8z7RvCvQGpJvdwIj2vfDi8gCc3OfgxaX0Gsk3QIzV08egrqveBobv20RpZ6yQmb8fwPfPUdelAh4RLeHA7tuZ+XtGlZGMLmFxbB4fYnZJ2UbXwaINdg9lCeRKnliVNorZFUJNRrG6AhiVvLsWs8v6poCzpMqOEjHQIhiJQzabI89COGV4YYNTpqfrigxGOwpqxMZLYSwcrpl/ThKmhwLTi2Usatcdl1oJE4DG355K1OWfBxCiLdHF4SE+J31ML9yY7rqF66OWlupuzZmFgTnDUmaVy/TSEoBvAvA2Zv66WeoUIJhIADsYbE2WLdSReWCTukfSu2qY2WXe0tgBVXbATjcW7NL6ZT/ISMvLmGA3huEhZWMyXbZXYnPScxr7jw4E4jzVhOFJ9ueBTQY+W+vt6VurvMNdfxTTq3qel1io5wXZovPkxvwdiJvTwAIrFKCXIZmoAyjUM4vM6rSYVS6T4X0SgBcD+Fki+hmf9jc8fS1Lwt5CGmdpcdmgMzC7xF6nmd0A0CXgpb7jKp0A7ni37HrJi5owuz6g0yCFrh8l29skZmcBXYnlyX1O0zqVzicREL77YoIZNJsSTC/bTtlex/BEe8gZXRa7F9iTrDuAZ0XdlLSwVJUEyQpdvJwBkt116RhX0ueWbLseykwvnEvG9BidBhGvFUeWqa/lWYWBsQ6JC5dLAzxm/jFswaKHPLIurfubBRVb9Yl6TXtd4iHb7rGwFtkEkHkA086pOgpgN8To0rS0fovZpf0WZQqMbxTDU+BXtLf540k6JOPLbXoa9bq6Qwc5ay92KTC6EGqibHsZEkhVNSwwqpA3UW3HigC+aNtrKbfrBdArMT24Z9itFVhgekDnkDFmY8whzflQxzPLpTstpkgyrjxDs6aM6aDifGEAwdZaztRd016nH2DFWNy2YFKC3XWsSYFUz9fDJLObE+hmY3Zm+3JEieuiLp05lUwUSZ0WGQ4OMr2kbgF80r4X8wTgEGxPT0+zlpNPvLfCnufa5FS1laqwtu1lHe/yMTi36wXQ84CVMb0qrTcJTg5gmZy38NwivW3bCoOw5qsJLVezVyWJgJanayeFOV1MiA49ycBO5rMeUC1abQS6t3MPqwplTZYUwC40XQA7M/wFsMHOYGV9zM5Uky2w1OeZnJ+suMtvgZZkelm6qM9keroOwYC0fS92i0X5wPa8GhjYXgS9hG2mwJWwTdkZ4bVNmOfQC5RTIIp2vQB6QR3VTM+3n9gUWyQLDkjQi5c0nN52Ckx2KnunxZzS55EVjC/5G/NzCnaSEfYxuykPAtGwk6JktyMjL2EY7KawuuQY2XnMvPq4Arox9EDQsWwqGVK8kGBkgZ+c6qXZIqx6BNvrFuBM29GgF6+JZHoxv+dN8tsZAowjsFfs1NMxam5yIh2nAxDtegnTA5KFB/SiA9k48Bcovaah73PwO3f+e5V2JsltbuFvgdlB5kvBLgYah4fVstf1PaMKbKIqO8FJkdQlwK53GacMyHLQGtrvm4FhnaPJ+Er1D4jOlgxrQjfFT7IW5OAXyrpinAJXVyzfV2xPkaMU6ErqbczTgR6LwPWSE6Oo2mrhbiNxaEwBPcH0ggMlPNyRIfpzji+EmWTvtJhLLCdFPGb8LYBdllcwu9BOyg67ByURS5UN+RSYACh/G9ZiSRazSwBoHNCV0rI+JO12/dKMT9vqRjktYmNdfgkuCUAoStcbhiJF5heoWAQ+ASSJAwU5kGbtIO1D8NyOcWKkbHPgOWPR4wCSU5meup45lUbnxJhBmLEPS5lVMpbnHpq+8BNLjY3MLglLYVF/zwOQMSGfMOCkkPlTUOmOFZdel+BihbAM7qdAFfNQmtcCu+4Ypces9qzrAySDTLKL7LgCH30IaTZ/vLvWFOx03OWFKpvuy5VJykzPCk5mX156bjMnRoCgoNoC6ctVnlhIkgAZ6mkZiTMjBE5Hh0YZ9KxwlZI976zinBbzTC2bW64mDPdI8lYXLK3opIiUPrfZuXRR79YhJ37DupqKAWWqrM6rnRRW1hJw9e6XwS7rqwFgRXXVam8gb7k9stu1wFeWV3WPD8SWdRmdHnoRJXkLzF1LJY5vI1LDMVboTqZGqrGQrewtjsWyM0mDatTvomX3GJ64Meaadgn7G3BQjGF2/oMrgBpIBbtdwu4iEKZ5RzspxIDubHrGIp2hLtiDeVwoiw0uCSCF86iMMlmbSCQOJk8pAgOzmFpYMEAuuR/b66roqhOVhPuczI1V+fV+xvQI3YtQ9ClTUwXLk+XDsk7hK2VpOAmn9jzZI9lvQHzsJ7STXaXI9LR6i8Y/twr74jPeAKhYXMCMZG4tDJqyAOiFyu4BXhDj7pghKHLGhRF6opld8rCNEcMTmy31ZJZDxgCKDCICSs7S5PYYtrOtWB5ZS4UtnW9iFBcokzgioiobvJzoQi+A8SMygqqc2xrSunZs1CMkn4dU9ZqByYW+yXMONspR822lhOewSj2/SdiKDlmBv2DBnkjdm8Jczl2+cWaSfVjKHBLYnQSvgt0uWerJArs4HU2kAznQFdhdMrC3DC6O9VLHmiwnReagUEytqL5ajKsAjn3sLrPbUZrfqs+SzK4WQChsVgIgOg5jsECbqZn7YbADBiPLt2XQr2w3CSqW8XkCUF1eOyg5AjCkPa+7biQuRrfyCnXPY1wJuasruUrKkYFWvEl8Xd25lu15c9A8BtDunRbzSZ8tImFsxrdiJ4HdYEdolN0u5NWMKPf4iu4ajKkUMiK3raWjRoPdgFh9sspbLC9hd0gZXWReRropVChv7RfKm6gHzcoEwyzmN4KSrXat8wnzbafYjoWam67XkoJevB/CJCPnE8/N6FKh/XdpZxPO/yYG21KsXR+zKwFdH7uj/Fi2ysiIeDsAUZVNbHkJmBl2uxHMbpIXV4Gfxe6g8vexTC3xeKphum3PWuJAFOdTDEqW5UfvdywtgKbsS8fEPOMSNsAOqH2fpGqb0U//bEDF58nyoS9gwSgHWF4QwfZKoBevp/Qax/8QAVOzvDmEgSvrpd09wANgqrJedGByyJ/Z7CSzQ1retENZ7Mb6Glg8Ns5rZzH/lAmmYGmxvNFA15NH9rGoylrnUQI73U+FLpZdLmNUlAzllAHquhS7k10oAh84bz8pQJF9WcwtqrZkqLaS8SnQSlihOfUsvS5BrGczY3rk6wv3idV1EyzPXE5qBmGmvUo7j7CPn3N75nJPJSdFdGjkzK7PHZ+Gc1D3V9jtuuOIdjtZxmRiBOXtpBxYILatdkYA2aAX1wLFQp2Jx1aBY289oq4EmLrNlCCFv4XBnwBTAeR61VxZJ4n2dZqsV4C09Npm821l24ElAgnTStuhdOpZArL5qivyWWWL6bXixSHZpJj6lsXnkQO9lCWcTfaBx3OJZG0Jm/MqbEyTwCYeFMXsRsUeEVBUZcO2AjtOyiDLK+suzsooxHalwENiOy0/CHbGeSbsLulLXk/m6OirG8hBBwMAF4EqZXmmLioZVQ/IZexRqLdJP0JdAbQykCyEqqhQmAg58jmTeSEYn6Ha9kkKyJ3tjhhg5bkFkwBCtTBBD6vcRhjzLvE+p+wc4GWfVpSgJ9hdvHlyypiKr+sFu4pyNTUeC52BmScBO9h5LRUiAUdLlZXAAg26XdmiuirTSnlN4C2k6VNX/dOSjC+L1klQkukGwLGqM0oBVM32kbKoxHGSFOxAT5aN5ywXDlWsLICmtOdlix8wit/CcMtMoWhnduDGnVYhWWJL7rM3fjwQ0M3EENdVqrbzyH7F41lEszetyibTxgTISTAkmdeQXCVFyu60KktpuZKTQu5bsyksb2wKgKoOK5hYlM0ATdeBND0D0hKb0/n99pjnW6qdEvQS2x1gsjUZmxdPxbqHAjQh2kiAEGlb1uooEli1pzZRbQNYiiXik+ssQDMBveQYEtXWZHkKLJNT5gBk6FRbzSwZXa1hpWYYqu0MLM8Ntz3Dm0fEDUm8sjFNPCRtlyceSz6/GBB0u5uTsLuK1DEohkXpQCBVPqaJ8ki3LYeFVbYX7ErMrtQnoy8a7CymZ0oGGBLQBHMqAo2lRqomFSs0VVrRF63KZY4TnQadv0e1VecSpaJ0FsaWUxr1B4FM0AtfQ+MO1OD7Y6q2M8hVnku7c4CXfEvWmDoW1d2mY3gxLeaz76zJcgrsrjzvc6IqK0DDYocZ2JHsQ5dmlUmOFYAuqzcck2Am81J+PAPAkgQQEeCRECLK95MEwcY00GXAB1lGHCuAZeKIsABOzHBI+inr06qtAMJEtVUMNA9ITlleau9DzsLCCx2UgR4YyfSzTLUVF0isr3Jm2S8PNaewddORqrLoBheA6UHFYySMLuu7FJr5+AERpLgwgK5bbxekl2mNALvBdgv1F50Vep/VsQJjytiZPK7YmCWZJ1aXsRiXJbKc7lNWX0G1DWXVOTLBXkpqLmkZqCmOE+nYCKqtvD8UcHnEczZGHN+YqbKZZfcAL4CdZHetYH4quNhUY4Nh15LgrJBszWJ3YbCXlnwKzZn2vpyhWezQsuElZTVwFcuI8yuCX9pPbbtj2abcT/qP8qARBCmwjEgufNMcApAV0Gknhj1xP1wABXpCJNCxON0OF9UCnwIcU0Ym8DTWp9YaVkDYsUKCFaqSTP4vsbwe54X++hma1tXPnvk1/pknz+RC/XIpqRmBd2/Dm0vkTUmADKktRAUkxzS5vYXtrs8rmwileac6rUxHRJ/QiHx9YKfySBDT9Y6x2+kymhXpe2OqahEkkLG1ZDUUDXJcqC+0A+TPhpXPYnUiTq5UX59qG+oY+r7tJOl7rtn/F213OnzFs0F1DmcRt1rKXqU9uwiWFmPupCqbsDvkdruehylhawm7IdMzm3hlZR0aDAjmwgBmOzDKJvUX2J3B4Maqsb0LDUih9JewuwpZv7RIwzgxEtUvLhog60QKWCno+HJjQS/SMSSUMLZB8nAepqLtiHJxgbQ+ASoF1dZimSaDlSxP9r3HW5us+oPUnhfGQKybA6v01yqA4gygxwDWe8CbR2RwcRROj0dVFkbeAekAYAL7046KUI8FRPG41XYhv2KLVv5eVXYMs4vtqPr6LoPB/sz+A+ZAGmRbCiSKXtKJoJeBjsW0JCsTQGnb8HoYbAAwIzYvrGIyaF/2rHIqAwy2OWJ2WKiZH6V557Ml7hnefGJMH0u+NhZtedzll3+1CLDKwG6M7c6IuRvllQ3HSfdBHzPK9tSXn5+qt8TsesBZq7cWKGaLgsayEqnQTX0KKp/IAovxyD4pthQqGAI9SyyHSMQAgwXmNrxULTXrs1TbJE8Hen22PBlMHD26EjSltHALe8r90FYA8TZleXLa2Vyyn2kxs1BQWZWaK215WbxdiEkaIWPsZtnATzqIfq+sBVQa7EplS22KOkynxgAby1iiBLhSf8loS1OmJFCSUlAqiATAkhpqgpkBer1l5PEkrRAKouqwgbPHa6vaHLoOWftjxYNk10b6Ae/QCTntbC7Ze2lnFGm76+x0IU15ZaXdTk+b0eqcst+5tAK7Q/43lB0KMM4ZWu7ZTYGvp2xyPt0x0+ERj6nz7Csz0I5mfi6Ni+UTJhdW9Ah1SnDSwKRAyfLC6qWfNKhmZQpgmbaTr5ic5JMMyyqr1GI9/zb0KbHlcVc2srxGXachNTg8657pJfY8Dvvo1s5jBdozyFVVaa9mr0oSVNWxqmw4LsEuWZ7bP/0lZ0VJtDprANFUVbZL6/JnwCLzWWWkJCAU8tpg19/H9BcYH1f6OHdgV/ixyJeBJRnnos6hxKT7znHU9UHPNR26D333MJTRoyyp034G0/z5ijvJMxjq0C91OTaAOHaSsQGIkC4B0GcQ56Ud9zuLENEfJaK3ElFLRM8fU2a3AK8gpipbstmpMy7a77JGQvlyPlv1pHwAjAGavj6U6kF5gPcxO5Nhluo2xLLp9YKeyGuqy1Z/kO5LW2IR9IwyZt9HjLuhl4wN1iqTlTZFhsqWRrOYfpkslhv2ZxYGsOFq1O+M8hYAnw3g9WML7KhKG95IiG8rc+qYeIONetAU6JWmkWWDU0mygnFIywaEPTtjsu1O7PepsrodK0/fQDYBKbAX4jQ0Rbcr1LrOacHgilLVFp16ZwoJtZGQqq0k2pH9tFTb5ARV3VlaIUwl6S9hSLXNPv6TtJkvLJA4L2LICMfnRn7kyLxU4ZmPc2nD3NpOtQ0ODBAQbHlzyUWotMz8NgCgCS+RnQO8xHanFg5wx3OwG6zSumATVv8o1mHmA7Rn1wa+HrDEtGfTirWTbRXrG2qjVFaCnrabGUClB25i01Ll4nGrLsi08SEcGXAUQKvfWSFAz6ozaW9igLGxdFQ2s8OQBPRqRMDsjiN6moMtbxaZpq7eT0RvEvsPMPMDM/Ukk50DPGm7i46K1mB36AE7b/dggm2/K61EXNnhI4mNx7DddXV1yUV7lZXWU8Y6ZrIsi81pKfQ1y0NCpQz2uEocU3lDQsQERlxhNwa/qrxSLEAr9k2zPQmKoT4U6suAzmJ8hTRBkCyQDtcoWUJKAbh2Xuj+ZWw2MsJwU/MLE0Evmnv8Nza8Z0g6MOYCPKd8jQa8h5i5aH8joh8G8HTj0CuY+TVT+7ZTgNd3CbUqu41tYitGXygzuDjAUJs9jG5Ipc76UWpTgp8FkltIAnZym1OyF9qdFG4hAK2o2ib1b8fyxvZrVD5CohbrYxnIiEUFknIVgGaLawYPei0lqm2I6bO6NIfMNZeWmV84S0VedgrwAITXB6LtzrO7YvjJGEkGp9vptfllnkCy2R0sVjbSdmf2TW0PsDXLUWGCHYw0yv9aIh0Vkh3rPgXHEgNd2ElALT2libp8ktBoW52p2gJJIXMuK+y88RoYavhZbXkxTX/TNrYnymbXOORN65/MyKRq2/oqwoIN4Tu2Mwjj6i4ecKleWiL6ZiL6DSJ6y6SCIshYpwMT2J1a6WSUjMhXBMttbHdZ3UNtFw701VVij31CiKNZA2Kn6nY/O8/Itqy+DYD9YHkj79D1HudEshuf5DSbkq8aV0auAJ52TGlHMwiDsGmrUb+zCBF9FhE9COATAfxHInrtUJnLDkv5FgAvGp3b2++KQcaturH6JlZAYr+DZlMpu+u136nyVqzVKDXUYlBW2UJ5CVq9tjtZj5W31Ccj3fLYMuACtasAckjses6Tyy6PLEeqXqvu0vnr+2G9RFDIixH3BHmZYlrhXvezY7LLViSuC6m8lJWPjjALMMU4yBbYaDlx/pE1ZraUFjTqdxZh5lcz8zOZ+YCZn8bMnz5U5lIBj5lfD+DhSYUslfWsN6kQtzVcblyeIvCNkFGMbajOoToMMBgUDUTyrzjnPiAb1UerTaPvpfyjjvWB1YR6RwOdHHUW+I5pr8QGx45oa8zM9REfxoUEHm8jO2jD82+h+IZCyu4mgJ+pPm7zCkhYFm09IEatsDISPAdVKAvsSvVarE6mB5Cr1EwL2Z9ggvBmq2hzs0gJdXmStJK3ktDrXe1zXgx6gGUaIXdAWG1bTYWy0nsz9T3tw1PSazEcnuIycnc6/mtmxEg8trN6aa+oDe/KAx4RvQzAywDg4OAel+jp9yy2h5H3JVFnZbk+cEtAwgBXK59Ztl/9MvultvsAbaisJQnQ6Tp0f2V1Pv5C+gUGRYFOySt7prIiXwa4CtSstBQ4Cb3Oi0IfQx2x/SnnNlVi//zX4M6oXmrZA96W4oMQHwCAu+96BpsPzpgwlBhbp+LvLNEMxpo7Wypj1icOFgEyPzDWTqSPT5m+pMFOA2vvcxtYm4hb7Fgfq6xdvN3YAZ0ztZTZjQY9CJYny8KoJ2N0eRtFxpiUFaBXEpNR+nL6c4594Cbj8ZhjCEux2RCmElheTO/v7lhhEJozOiTOS6484GUinBWJY6Ln4RqaJ2ups2NAw3RYlNiTPmaBSR/AaBAWaVM8q72qqUrrrUprQN4TG8FOP++tWFo8hKKMFQn0MskCgqmsx2CAJSmq2rpjY9TbEJ6igNhud0I8ngfMIigLZpfErVaYy1/hq7yaDO+yw1K+E8BPAPgtRPQgEf253gLSdBK2Nbubctdmvidjp5cNigKmM2kH25SVQDoEwqS2vYfW/hWOGZK1PeI8rBfIWOljtpOcOX1C09j32DpHi56FFKdfyjxn75LjI3unRSbM/CemF0K+mnFXYfd3akzTmIBj2dQQuI1ha0A3CPoGfpI3rSMNs6DkmFlHOG4ByQDIpG0ZZQg+9AcuBCUWhPssISMa3R3TQ2SFRaM/KVbn64sJBXXPUlMTNqWqmczQMG4Z+MAA++x4Y2eEZAHIY9TmWLjUuK+nnTBmRjV3NRne7qm0QOKsiJ7ZSZOxafs37Rnv41Smd6a6ZmhrTH8zh45Vt3YIDOSLeQuA0+tNtdI16Bky5MwYkik2RVMmtJW26z/h2IwoLFkeHHDHlVSmN12Qy2FvY+RqWhZ7JAG4EXFD2n43bgAbeUv2v6EraE0li8d0u3lazKeZmNruXRGlkG55ns3tQl0c2FdUVV1wsQs+RvLr0kXegf7FvplsVvV9RF2918pgulb5sWqz62v/w1Z8dkwH1vCD29278PyOeNjDNE1gq/nnxb4wjfpdtOwewxNLWw/G3ekbPrf9RMhUxnhWdpbamMoDeKtnaq4yes2ns8gW7Ed7dQfzbdn2VGZ3pqWrhkSruX1qrzT9jCQQY4QZaNo9w5tFZKBxlLEhKQNir4tnLAm15b0cO+ZL+frCVBIp9HeK8d3qQ5y/HIgaq+okqzNYXvJj6vwYot6xfTGFCucs9odYXsmrftZ7NygWczVCp0a/WIeeeWO62ZxyEVPLtpHdYnj6nsw1929Ge95Y9bXLT/0gNNDG4HcqxsoUxsko5+/rR18bIVpiBCObKhnT838l09rG/jZ5IU9Ltj3XKQ6LksgQFYgXzxnFcZKryfB2C/CAyO6yB23CJxij9C4BNbVjW5bxYj0fvaEpVAa7MSzHsoH1epc9UMRlnsJClsqj6v4a9K81TiKUbwXTC+m6eUrxypyZ4A9aXt1e0OuZVmUBoRWPl0gBxAbLlaQPFLcBPjVWYiDyXJHHV9hpsWOANy/tnk0MMLp0GVDpiml9YgBG14igaFJ1lW1pZijUY/SAXa/Ifihg0CA3lsWd2ds61E9r/8rIPJ2aWUOeTXYM8IA408Ly1Mo3V2A/2f5ASMoFgNXkl9+QyjuB2cX0Qt4+lTwywLr762xNyjtbMahOn3iWU/sq/yEZb6PiGgnglVSrhNEpoGMIcIsFCqCHNM/OSA9IJqEpfY6LMF6yb9fOC1J7lfaqiR7gO+K+Gevd7QU7XVcf09MgSQ68wtp2bg287hhiuqRa8AZ4B4rUkpta5a95W7u08FWvBLf0ICwBHfrU1nG2wbMwu3NhhSXRq6aUzmtgTu15ifPSXs0BtXuApz8uPEGu6EtndhkEu5KdTosFdrqcVCcJQAVQxagEw3O3qnXMegMbWJGyr4SxWbdapPeWm6jObisXBnYDstV5RvY33wDZq7TnIaW4oXOMtxslWrVSIr9wdSbRbK1gn+sNTyGjrE436qDwzpHpxKC6BdWMqm7SEC+q0Tbwqi/ct0SlDU+cB4X2w3HAtn/J80cHdCXQi+cFXDxAXVEA2MrZN0L2Ku1MMucy1FdJekFQDO4k3wCwWgCYOUotFVeWEWAXbGtO9XQqKFeuQ84JS97b5yqTt6ltyDGIDaE6rVCdEOoTOFW2QQpIsj3F8KQdL+ZRx0zQm1GuCpubJIY3N/lAfbCNzyCMy5lFMUZ2CvCSB019aHvUV8bmFulZ9APLj3U77whAk7INE9RsLZuOVWB2GQsMtjkg2owCMNWn6L6vCsLmGtAcEjbXCU3N4AWjqThheHxaAQ2hfqLG4giojwiLI9GXCmhWfnuB+O0LYnTfc/XXKnE8aAAXyQmTGwF8FpAVwa2vrsIx0xt9XuA5EK6SgJtgefOtiXc1ZacAD8Akdjf7UjznIMlbtjffluBnbGtbnMn6tB0QiOyOWnQfQvd9o8D8Gld561XcWOGmcmV8PF7Mjw7AHGNU/RTnbg3GyPR8//pkrH1r7KCfc+7peclQcLRmefM0Csf0r6DsHuABGbu7cBlSJQsyFrQmqa3FSrq/CXsbwexingA+AtAk2MUwlQpoF27J/fp2+DBtneBd2CEGuGawmLLnvtPaAWBiH6TuGBMST648zeQyWTbBbR4VwcL6QFAe25ohXTZ2hm/WziR7lXZmuWpv1yJTK6zNF1cMnqjmbt9BX+0QsxP5IyOSzgV52b3ay7X/+UokewtNB4BjAKi7clrN023EmDuvkmqWJvczGx5w/kDSq9raB3fm2T2DXLFTjLJ7gNfzEJ23Crutd3USswNy2hJUR50kEqTa1xc83Mvswl9CjLWjxjkVqAVo4+pvly7P5jrQrhjNIaM95AiMrjzn6rBvlInRrio0h4Tq1NnyqAWqxr8ffOwYL3w98DStzZmeadPTj4hQveVfC2izhQxkXQNMT8oo1dmIMrhUh8hsTos9w3vSSmZ3GspfAqQCo+sDsG1BvsjsSP66hz+osnGAVkBbA80Boz1wYMcrr5eGOZkLTuvZVOCw2nDFbq5lAMdT14EIrAwXWCsuAoNGMb2pcWj99q3CgUL6uYHVzPWeO8NkbMcMLkB2D/DGfKHsLCIpFMF9+1bYmzpGVQabwNQII8CNAYKqi9OyEfRE38JxYnZvU8rrzTyY2p6HnNlF+x0TKs/qqgZdzCMBzRLgJdBcZ7SHLej6BofX1qjrFsu6QVW1OFxuHLaRA7eTzQJNSzjdLNC2hOPlCk29ANcVqjWB1h7w2DNJry5XoGgDDFPRgvPEZHqKFSfXXP0Nz1ECVJoFhm1VnwuPMuqHzhfaso/HulQdDvRVobkfe2FuiQsIzFj1VZTdAzwtU75fcc7txO97lpgaoIBOAaIFdKGMUl1DfhPgCmwxOyXF7BzoeRBoKaqQQZUNZXgZ2F0LOmxweP0Ud18/xrXlGk85uI1V3eBGfYrKF2qZ8PjmAKfNAo+eHuJovQQz4aQltAw0R4QaBBwDCKptC5C39aEOaqsDPal2bjezwNiWoGSlhUuTAV9eXx8zHPWyvki0OJfxQ3sv7exyhV4h1MJNgN9WFMubbMuTYCjKDTpGgMRml6BpC1SbTmVncra7dgGs72rRHjDoxgarwzWuHZzi2nKNa4s1FpWjXCdt+mgtqEW1WOO0dRfq9KBG2xLWxNg0hPaEgLZCtQGqtTjXFp2a7U+KQc6DzIj2Pn0943UtgZFkXuLvGNtdxu62EMt+Z+a7iMf8PEDv6gzPRHYX8C5AhpwNaQwTepideKBK6mqoTzLERHX1SVKlDU32MEvZBolxmkwbC4sBEKIdrdq4HwBns1sA65uMdgk0dzeggwbXb57g2mqNmwcnuLE8xWG9xmG9xqatcdx0j1ZFjMN6jSW1aJeEipwaXleMo+USRxWjOakBXqBaE5aPESqv3qIJ/XSrrASmJz+KzuiuT+aYUNchXlfmHOxUOZu9cXq8mJdH2QC3Ms/MtBT7uQlj77SYS87NfjdzHNIwWBZYnN8eUm0l6EWGiE7dC1cpYYGAGdybie9765eBahdAu2Q01xi8YtBBg3rRoqpakAev8J3RjWdwlRrtLVc44QqbtkoWh6yqFvWidXVcY/DCqdDVmsRsDv+XyS1F5fudgZxclFSxNg12WR6kf4seXWO7l4UNHb9CMuvYuqLnvFuAJ787e6n9QL+9TOqbMZ//FJ6RN4KbBy6XTIntPVbn69QzDCKoaTD0ZYhzoOtseJyowS442P3aFWNz3QEd7lqjWjBWB85BsajaCHZNW+GUFqiIURE7FdY7LFoQjpsFWiactgs0HvSIGIuqxcHhGotlg9Oa0W4I63oJWhMWtwnVmhJwSu68uJbSk5wAHwz1kbvztICvl9mV8kCmGwesR7YEooacv2fVs+bZ2jl/hkdEXwvgMwCcAvhFAH+WmR/pK3M1F626ZNn64eLhsr0DxaxP2ZlEei+bCWXF4NeA0B1L2VSYZdEuGe0C4KWbH0s1g3wn2INc03bLeVfEWFUNDus17l0d4e7lMe5dHeGe5REO6w1WtTO4tSA0TNg0FZq2iuoPEYMqdu35ttsFxwVHAcSwFeL0HJJza9Pzj/lFunntoK7dFveqT4q2vyvKhs4k7cjf2eR1AJ7LzM8D8PMAvnSowG4xvAlyLkHIyWftkLK8YhnJ4NLySXFlY5NMD6Ep2aawwQWpfJxbW1NngxZNdvY6f6hyx9xCnC5TALh26dgdrxh8rXFgVznA22wqEAEbcn/rinGw2OCuaoOnrm7j7sURnnHwASypcewPFX7l5D48sTnAaVPjaLPE8XqBJ44OkksLuL7QYQNeEhoAfEqo1gCtgarxjC+IX9CAWufoSNidui/EnAF9rw2Pu3LpvriuRjtde3Z6d8KlMk8C9PMv0XNvhvmHxO4bAPyRoTJPWsA7LynZ5oYCkIdsegHMdMxddIyEAZdmd39lTBo5pqRnOQDuJRCxrxV/5TQwP+UL5NXaiv0nF12cViteJFXl6FPLjt0tqhbX6lPcrE9wX30LS+9CXXOND9Q30DJFLy4zoW2qbtwzxfXvwolyzeCawJsO8GmDRDJVts1BKlz/6NE1wM4CL83I+gAuinJWmKEsF+x0mOXralPbvHjc/lwA3zWU6ckHeBOZXeYltcrr4OMgknEldXJng8vKhCOK2QmjWyzi062HlQhdTBrSwdku/bzVCmn/iDuG5ztWo1P3iBmn95AHOoCXrTN6nDpgip43P2Cbgxa0bMHXCQf1Bvcsj/Dsw4fwQYvH8FGrX8cSLWpirP2b4H313Xhsc4jbmxUe5uvYnNRudZXTsDaR6K8H7XbVgtZuIYL6BFg96u5RDAPy163acM7w/DUMam216Q7I+9wXZqLDWrL0BCzLo7wIOCWmp4OOjXqutDNkfN/uJ6I3if0HmPmBsENEPwzg6Ua5VzDza3yeV8Ctpf3tQ409+QBvZpkSmhJZnjSmcwdspmhmJ9Ks9mN4iv8vU9V8Jq4cY5KsUy4GEKM6Wg8UYZZDgw59fawbWgIxuRAR7r490dYM1M75sKo2uFavcVd1hLurY9xbbXDoGznlBvfWt3HKNa7Va6xCvAsTsKlQecCLq6qEjwNJAGQCbRzoMTlvLnvQBzrVVtvSOvbHMcyGK/gg5u56yzLSO57cJ3UPBk0Z+ri8R+gBQd3OLsp4lfYhZn5+sRrmF/YVJqKXAvgDAD6VeZhX7h7gFc7pIte+G1RPLfFaprTl5eprkj1pL9umDuyocYN5cdvpbM21Cm1NaA4I7YIieIT2Kah9LbA8YlADLE5aUAO0i9qpkRXAy8pN7r9NcbAyedveAmhvAvWqwVOvH+E5N96PZx0+jKcvHsV99RO4p6qxRI2aCGtu8EH146jQ4tmHD2FJDZ5YH+CJ2wdYt0tUxzWoBeoT6sCegM11Rrti1MfA4ghYPca4/r4GXAObgwpcA+trcN/R8IuTauZVbRj1qTvH+rgFCGgOK7Q14nlGVkjipWDcc30/k3Q5TW0LoLoQcEs+9WbIjHroRZwPEb0IwBcD+GRmvj2mzO4B3i6JofJajC2ZJyvSAYNthEHtVdawyki1Zgd4zAAtQUugXRCo8nRODuYQutICi2NGtWbURw2qhrE4rrE+BaoVgTaM6hRY3OoGMlfABoTWd6ReNLixOMUHrx7HU+tbuLe+jbuqNQ5phQVq1FShQoW7qmM0uI0PWjyONde4a3UfVgcbrI8XDuxOCYvbHQNi8g6UysXkVafA4hhY3to4p0wDNCtCs/SgJYCms8t5oDthUMNYHDdeHXaI2lJ37QMTF4Qyve7ynmb3WYCd8QwM2s8umMmdu02PadYPAvXINwI4APA6coTnDcz8F/oK7C7gzTkdxqirb16sKwOhduZ5B1cySSZupza8rhID6IJRnABiAjWM+qRFddJi8fhJHHztqna2vJpcsG52fojskJrO0E4tO4BZA9UpodpQXOuOawdCp09p0R62uOv+J/C0u27hw248jKcsnsCN6hQtV2iY0LCLxwO3aIVX5EZ1gqfWT+CZ1x/BrXsP8N7qbjx2UqM5dsZFEjM8qHFAV629F7bpgIUadrMxwtQzfem8Xa5eMxZPNKjWLerbpwAReHEIcOXimEHJNQVRutxUuNdZ/eVbOyhjQHAo71X35l5A95j5N08t0wt4RPS/DjT401MbvCMkoQpClc3yGaCn6/ESwS4sn+TtXVXDoI0DPbp1BGpa1FWFatNic6MGrZSzRYFytXGAF9lR49TAak2oTx2TCo6O9oDRroD2ng2W19b4sHsfwbNvPIxnH74f99ZP4EZ1Eut2MEcAKjTMaHwnDmmNe+vbeMbBB3B6lwtUPjpaYb1cojleojp1QO4cEW67WndOieCxpoZBG+peNhYotYH5rkEnDapbR0BVobq5cva/ReWISMKafYB4z+1NbXt2Tit4eYxcit1uP5c2ypsAvAXAQ35fBzv83vPo1FWVrWx3UoStzgxt6TWCOxYS1TVfn5uGxaBNCzo+BZoG1fEKzEvQpgOyYMeTf5kI6xs1yHsEmYD1DUKz8l7Q0M+FY3aba0B70GJxuMHBoXM+VNTiofVN3G5XuFkf4976Np5a30KL92NJpwCAhgm/sL4fjzTX8XBzE7eaQzzeHKKCC1Q+OFy7aWnXFqhqik6UwHq5durr+gZwfN8iXqu2zlXaqJr6bdowquMN6GQNOjoB6grVaQOuCO0K8WPg8pp2PvbxMsqRcSfJFb0OQ4D3V+CC+Y4AvArAq5n51rn36irLlm9Dy0GRBSP3tClnB1DL8dXjVNoG9dEa/MRt8GaDarEANg2q9TVQ693G1DE1F5zsyp94e1ZzQB5Y4FcaRvQ6Nz4QubmrAQ4a3LxxjBsHpzisne753pN78MRmhcN6jbsXJ7hvdQvH15ZY+cC343aJtx1/KD6wvo5H1tdwa32Am8sT3Ls8wvXFKe65doxF1eKR4wWa0wpVU7tA4w11gHcN4AVhc712drlTr7r786jCpx7FQqXONuiZ7/Ep2kcfA62WqI7udiE9B1UHeITIFN1tGndfwr11+0j3x8gItrhzwjgjMzg/6Z1axszfwMy/C8DnAXgWgP9ERN9NRB83R+NE9CIiegcRvZOIvmSOOi9bZg8qNYJo476w64EZaBr3a1tQ03aMEIHRedW0duDBCwd0zSGhORBgJ8NjAHjNFKjd9LKqamMAccsVFtTixuIUNxenPvD4GPdWt+PvqfUt3KyPcbM+wc3FKW4uT3BQNWh9XMii8gsRLFqg5iS0RzsxmhXQruD6fUDxPOTHh7r+s1d/2+7arDegtnXhOCzul6V+zgxAFx1wfJkSGfbA76JllNOCmX+JiF4D4BqAFwP4SAA/c5aGiagG8E8AfBqABwG8kYi+j5l/7iz1XqhIW92Z6jHYhBVs7A3YSSxX69XZdQM+PQVvNuCTExA5h0YXmwf30R0fjtEcePDzbI4XPo9YYj3a7/xqKXTQYLHaYFm7VVJaENZc4e7FEe5eHOOwWuNmfYynLx7FR60+EOPwjpnxeHsN76uOcc/iCLfbFW5tDvDY5ho2XIGIsaxbLJYNNuxCY6glwE8XY4KLzQM6T7NnctUGfgYFxfCcGJLSAFXTAm0L3jRoj09QrVp3vfwPizqJXwQrm2ec8zZ8f/Yi5IpeniGnxW8C8DkAPhPAu+HU2q9m5qO+ciPl4wG8k5l/ybf1Kt/O7gDeZQvDzQIJLI4ZLCL0rSXMmcSA9owPgh31hWqR8UpuuUJFjJpaLKnxvw2WAJb+bdCAsaQNKuKYx27A65OSYTKiHhIWNQifxmB/DoMvnZYB7qFXc7249hLlqgZNDzG8dwJ4M4DXAHgMwIcB+Is+5gXM/HVnaPsZcCAa5EEAn6AzEdHLALwMAA6Xd5+hud2VofiuGDNGBFTkLPFEvWExCegFT2XSqPo7g9Rjl8ew1HfhbAle77gOQ3TGBC+HLu+Bv66BSlhxqnLY0ZkdVHe6XNGLNwR4XyG2b55nR0ri59U9AAD3XPuQK/reuAJC5AYzFcyy0aDuRjJ5s59UeZNZBpr1MNxcWuNBbpmw5lr8FlgDkVWtAZcm8th9FOElRZD3f+UyV/GXgl0H6v4lUFHyIriiY3L3JTDzKyhDgPfzAH6Imd9/Dm2/B84REuSZPm2nZconG6NYTCzSF+6WZw8spvJPU+sCi3lRgRcVaLUEiECLGvBTxNpaDOy4nBJ3VMkbJ9oFYmBx8p0LwIW+VITNSY0NgHVT4XBBqMA4qDZ4bHMND69v4Fq9xo36BLdXK9xVHXVeWl7inSdPw0Prm3hsc4ijZomDqsFBtcGC3CKi66bCZl2DT2vUaxf/F1ZsoRbABqiEza5aq8vVcAKAnYOmcna6RQ1aLEDLRbxebtl4ce+Eup+A5XlKjwlhp+WKntMQ4H0YgH9LREsA/wnADwD4b2Mm6Y6QNwL4CCJ6DhzQfQ6APzlDvRcnF8kQ5MAImlsFP2gJXFWg2sfU1TW4roSa1zEjhCWk/OyKaE5bUbSVBfCLgBfYVEPgTYW2dUu1A0BFLTZc4YnNCg07ELzVHOKR9noEvFOucbtd4ahZ4ahZ4rhZoibGNU8vN62rkzcV0FDqPQ3qtl/zrj51fa9ciF/0KoewlEz9J4Brf23q2l2bcM1K9r8x93XW1YGffHJVPdK9gMfMXwPga4joLgAvhFtz6p8T0dsA/CCA1zLzr2/TMDNviOjlAF4Lt0rRNzPzW7ep60Jlyze+tJml+wP1BfXLRYk5EGpTcGpXtYvHu37deSRvXAMfLNAuq3RFEDFJvvbTspa3OU7ZAgHH91Yu+PgQwNLlr05dMHD7eI12VeHxw0Ns2gq3r63Qrip8yMGjuHn9BNfrkxh4/L8s348ltajBOOUKh7TGwwc38UhzHbebA9zyv+NmgUePDnF0tAI9vkB1SqiPKQYec+WYXX0MLG8xDh9tI7C1NbC+oc5RqFNckbsGNw6BugZtNsBigfZwgXYVFkmgWFaGtoy6zx709Bzl0gIEcaGCgfqeFHJFT2PsXNrvBfB1zPznAYCIfitcWMqPAPj0bRtn5u8H8P3blr9oObPNR4PdhPrddKduzmecMbFw699V6wp8uAI1LfhwCV4t3IAODo0ABKKNasNYPtH4mRoMYkazXLnVjpdO5Q2zHsBuxZK2IayPFzghxmlbowXhKcsn8OGrh/yyULdxT3WCZy0qVFiiJjevFngIj9aP45H2Oh5rD/HLp/fjsc01HDdLnBwv0RwtsDxyc2fJh6MgBED7QOPlbcbh+9eOoS0I7dLNCmkX3UklQONVYl752RknB0Dl1Nl2STHAOjpsBNj1Lwlm3zsJettKCSx3SS4rxm6MjAW85wD4YiJ6PjN/BTO/lYjewsxbg92Z5SKWg9q2CUq3i4NnjPG8IyAO9CqOLCLYoFwAcYX65jVQ26K5eYB2VaFdUTlsgzwDWjhHQe3n0zo7HrmZFSs3p3Zx6oHPr0nXPLrA+qTCe67dg6atsKo2uKfubHZBaiJUSGnNE+0BHmlu4JeP7sc7Hvtg/Npjd2H9gQNUxxXq2yTi6oDGx/9VS7/MVdUx0XYR0sgGGX/dm1WFzY0lqmUFNAzU7lrxgtAGhsfqmsprVgA3IACczcriAgTKDHHHyBX1CI0FvEcAfCqAf0RE/x7An8aT6fYZ4Dm4vp44zJSHN4xdn680sV8fp7DtPZlhUDrAcjpdc/cKaIHNjQXaRTfPNPNKBhCu4Fhg2w1QpwYiftPCMTy/snL4SDY5MH3s8Do2TYV7Dtw3LG5UJ6gWbpXjyv9bUo2GCbWfV/tEu8IHNjfwK7efgne//16cPHqI1ftrB6xheSh/Sly79fDapeuTW9bJX4I6AJ4BLuH6V67s5kYNOvCLjFaE9qBCs6rienj6murrnt+ULs8YJpMtx0Rws3XHqK+lvHOqv+fy/Zf5q5xDxgIeMfMGwF/yK4z+GICnnFuvtpDB5ZguQ3oALHvIMsC09yNR6HDOz4GtQNcWADOaQ89eamTG+agK1wC3wOaQQEuXlxpgc+imbrVLv8jnCtjc9I16la1duS+KoSGsTxd49OQafuP0biypwQfVj6EGY103AANrbtCixePtEo+1h3hoczd+4/QuPLFeYbNx0yd4CbTE2KA7Sa7gZoN4lteuCJtDYH3Tg/mK/FfN4OyZjegjQl8JLTM2h5VbbYWXAODBDmK5eyQgZl53pSonA1rb8vR9HRr8F8z+LuL7Fruu0v7zsMHM30JEPwvgL59PlwbkChh2iza4vpAUqdoajCurN2GQshGR5ut0ahnQrFx8W7v0QFelfYqsjryNzuclBk437rsRp/cQNteA5hBoD1u0Bw7w4hLvskPenve+J27gF5f3Y801nlq7tSU+tP4AltRizYw1gF9r7sf7NnfjXcf34cHb9+IDt6+hPXWA1xwwcADw3a0H4zQKulm76V90N+H2pvZLO3VMD/ArxrAD8TjzBJ3aTi2j8SwvfGA8vggKgNe7ArUv19nuBOjpAvL2FRwXF2K7Gxo3s60vOeCcuUQZO5f2X6j9n4Lz2D7pZcgUkbFKiyGMsdGNATu5T0KVDjMuwkooi9JHfDpW08XauQzkY4HbBbqR18Kxp4rd6iF16Kw/vnCfbgSA03aBo2aJx9trOGzXeLh9DEtq0XCFE67xeHMNjzfXcNIucNr6x65iYMFoD/zoiCuXeMBrqfuiGrFbLeXQvyzUR3y4dv0VlyNeLxd3LF6U8Zr7cwd3K9moax1BSBwf5aAgTzJ7mOHQysM77cC4ov3e3RWPSzJx+SZOwKVQzvpiGVAEsl7VWs1lTfpQAL+kPq2akqjT/wKDyfrlDfxcBRYYAA7xAW1XHQuhdeW+XHatdd+krVl849aFyRC5b9UebZb4wOl1vOv4fjy6uO7n2HYrqrzz5Gl4dHMNHzi9jpNmASLGYrUBloT2Wkd/mQHeVOCWQEcVaE3dMlUHAN+LqFqDfSBy665B8tFxDSQMVEsSx7u/zN3X3+RAdYuLZpdeMbuuCCHXPqJttGSzKwFtReaXy9ynNrnLd0WBZQ94T3LJ1FmpwqIDpqIUwY+KxyPoiQ9rR9YW8slQFMXwItMTk/NjmAY7mx5qAreuPqrcGsbkl4YicoAXQtk2bYWjZoWKGO9vbsa5sw0qPN4c4qhZuSBjJlQE1DWDmUHsv7DWVg6wGY7ZNQBtOnAKAB0HeavO3Z9vXBlZCgMclotixGl1mqiloCbWPlYg1zegrxoQXfQ3aV2bF97kKHnSAt65ODFK8VkDKmupjMns+oBOlUkAj9wKwKD0WFKvYH+B2cVYNGI/Y4FAa3JgswbaU0LDAC8ZXLegmlHXjLpuUVfud7BwK6FsuMZDpzfw2OYAj6yvAQBqcsu7P7E5wIYrnLYLLKjFarHBtQNC01Zo2gptS1ifVuCGgKMa1WmF+sgt7w7uvvDGC8e6yAdfJ5+iZDfjQn7QWwYit355+EosaR/td2q/e190am84nDM7UX6ELS/5UppMJ5sl7mU+edIC3rlLEcT6QbZk0xsDihbYZQAngVC2JYBR/wVxwlCD8b9qHVVp117dbNO5p3XVYlG3qIhRgd0y7W2FlpfYtOkCAadtjVacZE2MunJUrvUdZXZsktZeld0AtBHALxgogqooVmaWf6NtT17uUIe39cUXQtgMLA4FMPNS8sZmNjslkTEaZa+qCri1XNHz2S3Ai6znfN+CU2LwSsCXp5XZYeaIkOkWw1NsLwE/XZaEqkpClZV9YX89RbnwYetqQ6hOCe2Ssdms0K4YJ3cR6kWL6nqLunJfJ6urFqtqE5d933CVANyialGJURDseJu2xvHRCs2mAh5fgtaE5WOEak1xMVI5rzcZSNIBoLzR1HaXI2YLQBXYGYk8HnRIgWSnwQqmJ4BxkKVRUkkqGlmHwPI8mZ8cW2cVby64irJbgIcLuPEzyZB3NjuutnP7n5Ev7Aug5ALbSxhS0hG7zrBiMOAcA63/XGO7ITSrGg2AtnUBcM6Ox1hULQ6qDdZcofWMztnrGAtqsagaVG2Nyjs6mAltW6HZVOCT2quw3VzazBzg6ZOeuhQYV/yYT7iG8tS0d9TrrZLdJde/ay4HNwVUw8yu//hVkVlNQFf0fHcO8M5NjBi6SSEphbyZs8ICM1lfAfhyz23315rpYZ2HjjFjQLyNu1EZvbfwTMnPsFjeIh/o6xYRuM3A+rBG4z+63DJh4V/tqyqdZrbhCsfNErfWBzjxCwY8cXSA9fECeGyJ+oSwfKxC5dui1n9jIwYId2DnThrxZ4JfH8iQZ2ze06wZXbw+BtBJb6tsI88r5j4b7Xf93SI0pQLGrqV6GUK4ugC/u4B3BQKQg2y1Bp4Uqcqih/0p1qZVWV1uMAYQSD5k7by7/ppWDtyqtVuthNhtcw2gqtAcMNaLBdZMOK5brBYNKr+gwKJqca1aO9setWi5wqPrQxw3SxxvljjeLHB0ssL6aAk+qrG8VTnAuyVUodin7ucM/WL5qKHbr9mX3CexD4MN9rC4oi1uggyunHKRsp9atiNykaA34qEITMtihhaIZflGqLIa7LQ3d4rERUUDU/LxbEEtpvDRnwWcE8PHvNEaqEFojt2HrI+rFZgJT5ys8IHb11BXjNUiThQDAzg6XWLTVmgat/bdydESfFy7RQNOyK2QEgAlsLoa/nsb3IGdiLUL5zB5cCkwKwYUD6m2VlpBxR2Mx0v6d0HP9XlNxeT8/K+K7B7ghXmTQWYPPVF/ddBxBJ4h6tSjEmfAR9lxU+0dqm8oHxTIAfGrYHLSPsGpkG0FVCC0jQM/+C+C1acAN8BiSQ7AmiWOT6tO1azYfdKR4GL4GMDGn1TlbGd0WqE+JlQnhOoE8WtjQBcUzQugrTmqsXJZdxk8LM+tT43VdC6okwlo+eO96ioMlkfp8S5fXjbP40FQg68OPi60MYe4xRZmrPCqsFcluwd4sO0el7VwwFR1dhQIWvlN1jjtnKVtK7PnCaYXGxY2vRDkK1cjrk46nbChys23BcDEMUauA9aQ1+Wpjgn1iQe8OFsCkV0m19WrsRmzU+e2jfTZ0Ip2wD5wOw9AOkegOy/ZM7y5pO87gucsQ04MUwYWk8zqN9hkSZ3NjsEASG2R5+5wH9OTlXCYbB9U27UjatUa4IqwuUHYnHpVuBagKNU832dqAbTA4rZfDooRv38bVj5x384N/RrH7JLAYahtxdqKqqu6XEO2vD4ZA35hcdOp5c4qRZDfe2mvrly18JSpbGvQoTDjsxc9sordDTG9ZOK8B614miFPgxizh9qpwu7DaFpNd5VRQ2kZeQs1mIdiI5mdnA97YQyjDwSLi4Pu9rM7XCH2gDerXLZbfsvnYxLTO2NbCCYhStNClRLLIPcD02PH5iTYRTWzUoOcAdq44OTmeuvo39KhThzzJ7UDuw2h3gjWhg7kuO5UWkjgFV8jy4BP7hsDbSunRiyMlAHOxOx627pgiWA3p/0Oe5V2PhFvzaE3pVvt4hxte6ZdbVoVW62M3COatdmVCaAz8obJ9ZmO50EvOjakqlexi5XzSz5Vq0Z+aRJtQ2BUDizlwgWyXs16BVPrG0BjQW3sIBwLWleNqVkyqX87ptIS0VcC+Ew4+vMbAF7KzL/aV2anAC8ZnMGQPuYmTVwyarL0OBayPBOObWUzBBKQsqZKZXlh2/RUlmhX2yy6fa4YzQHQHvh17VZhgYGuAmYCr1pwzdjcBNplheaA0FzzNjplxwLgppW1oi8Fm13sp8H8EtDacgBOdVz0HbO8wefG7AaALhk3epHYGeSCYgy/lpm/DACI6PMBfDmAv9BXYKcAD/Bv1SsUdDyX9D5o4tgkddcPKGnDy6rmrt6MHYrysm3nxOBuTb0DRrtqXShK7RcFFeosAXGhUK4ZvGJnkSC3EnFcEUWqrrIPRn97GRgjU3mLIgAnAbceINqVqWKJjIj9m82Wd0E2PGZ+TOzeGNPqzgFeIiVb3nkzuiEZaHqut6jF5DLvrAI9k+ll7kl0am8AQUptgsksD3ZMjVu4j2lXjFaCNCMu6hlj9UTbEUCkna4PtGS6tuHBKKcAtASoZwGxQRC8JBvdoMxsuwO6x2Kk3E9EbxL7DzDzA6PbIvrbAF4C4FEAnzKUf/cAL3xlCpjM8iIo7LCMsdEl3lYD9IAUvDKwQ5qelbMaDYDTAgxC26QVcliuXb79VWWjwA55+hiw2zlGtqVs5zAh95sT/Mb34yFmfn7pIBH9MICnG4dewcyvYeZXAHgFEX0pgJcD+L/7Gts9wJtL5GAmuMFYD5TZBdHnZYHeECvU9SHFpvCN2qbmuB+DjFufs1UVtf5YADQfj0eNW3Q0AiGnAGaen9guhaUkfR9iijPIhQJqsG0OvRQuMZJhruvBzC8cmfXbAXw/BgDvHAjtOUuwNci3kgiXiBLYX6v3ud9zdQEP7uSHYcBeJYGiyHYK6l84Pmgb8yBFHqQCWJEHOfK/AHrcuMU8ww/+F/P5gOJYT4M0wNgQGtF/81xFnlL4inW+V056+kTM3TS07HseYl+OlQpxHMUxNWdfx/zOIET0EWL3MwG8fajMjjG8S7TL9YlmRiUVcWbpXcbeYHRZ36b2U3ujTTXYMzwFSKY9zRt7ovcypE0ZCLodWf0QAwIuLqzkHNnlvDLDgxsY/PnL3yWi3wJHa34ZAx5aYOcAD57VsVsK3HpzTZE+58Y2oLUt0LGyqXnpmxVhApcAuZAMlS06GXx7UvVNNGB9HsJZwQTPDsJPNRgcEwkYWS5i/6sQg5yTKV/qWmh112R8mu2JfGkfjTTZlrGt+1KUPoa6DdD1trVFhWqsxIUDdiwOj5n/8NQyuwV4GRvYznmRybZe3cJgMJ0KBTDc5mNDKRD68gr0zkMGV20B0n5Yx4KQ6qgA1HNjBxkQdh3axuY0Czvsq8L4TGNXboa2lRo7ON1xStVXlMHung0PQOZRGgKMkQPIfIBbRmbf2vJmjn0IesMmepiJTi9Ov5raB9mWUEOTCJM+O41wVsj2GYIx9gy20YOnj90NXKusvDq21b2bIhZrNesf2YC2XWcViYs9N7sDLsSGt43sHuBV8o00YGjtM97OLFPf9oMDY+B4qnYplVJsbzUA57hMLFBxjvq3YmBG2W3Y3YD6OvUaT3lWpju4JhSQwcZEydg6qwQH0dDvomXnAC/z0A5IBwbs98eXSd/2dsFB9YsL3zUAinYqM1+J2ekBPLKtrF2fpzg1q1AXAcJmp7y14teli7wj+pfZ7MYwoUHmW35BxO1CvZOY3gD4FJ8do9wYkOzuXXh+R3RWsLtZZ1q0I38XLLtlw/Pi7HgEePtVOnBG3OSW3fLl29rtzvBcjAkc7mur15ExonyxL4W8fW3oQO5kX9bXoxpqFXLIYaDr602T6X2A2idTCNNZGcvY8uoZT0JShkQwOk62R7Y9pglcXRve7gEewVHvhlFcDHQKkAWHhV8eZKwToS9fGPjS21kEFwb8962GAUeDCKUgQ34rrhDT5+ENxw1gyry66rwSCSDF/hIGb2tFaWa1gGe2oGdJFOs0WZn1CIxgwUM2zt6YRGa7L6ocjTjHsSpulm/qSih9i35W9vO3tVxRwLsUlZaI/igRvZWIWiIqTivJC3abcQBrpjYJ7MZnHSOzxXRZA2TMQCzUtU37sZ3CYNWhIN0vV2fNYwN9G+2gGXEeY6QfkCbUNQje009ktkD5xCPbmYRmWX9RN8U86nfRclk2vLcA+GwAr59cMlDxStjyfHoJ7LQdLz/uN1qZNnwzoq1P2iIGVDa5bYFaEVwKdWTH+0TXz2l6MgthoM5MBfLfnaAAbMFGE1ifPj6yz7pPST/lOWAaMPU5NEaB/Ig2exlinB6Wss5B0dPKsro5rTfrlDFmqplnWhRfeMbvguVSVFpmfhsAt8zT1LIW866QByJraeEXHmAQCNwyUBfaZ0R1j4Aub1R/kXfCSovHuHuYCvksFTmqkIZKKwOG9RJQU2L7zHoSddsAt1hY9Cv8DWVAyTEJXNMM/2pf1zlSRnuyh15Ksq6evo5SN60syRRIpNe2JDFvKDvQbMHhN6sd7xLAbIzsng0PAMgPKOLovNha+oBKNumBQANEGcA0WHWglzkekNZhAV0CPL3gmpaz7Hjapped01AboUwAMF82WUDU6ldgd/1V2+ektvucH1sx4j6maAFfH3DL53EMwKt+DeU32ek2Er9BPLP9DrioqWWT5dwAb2hZlwn1vAzAywDg4OAeT8MBgB0Vb9kxxTDdLBQcqZKyBqFtVk0RD+BYB4QNdKrsAJPs96AOsDwF2L3e3xLgsgK+tqOa1jS5OPg168v6nqebgFYon9dXztTnJY5tJMc5Oz7Ws5w4OrYBKwNERtvBZOiJD0VxUwT983YeiwdcQTk3wJuwrMtQPQ8AeAAA7r7rGWwu+jl2BeQSmFlTy8Ywv5F5JFgUQaqPKVplJ7Cx4nEL9DBQlygbwU7XZVWhmVYfsAy0OSr/lOOFvJPCYmAAXymfYfMd8lTnaYUCY5mVBW5zWfTHsNpLkt0KPPYOC6Zu2xlc3X7isS29sdiN0k594PSYSAtvZGLkU8xU+YzC9735J6pLfR5LCQC9hnhZj5XX6pPRLun+hvoA/x0KQuap9WnkFwENBB1tyvzM8yyli79F+6CxnTHMQt4h8Bp1Twplu2OszofTZ43Vs+jz6PLRflcKO+lhd8FZ0am2M7E8Hvm7YLmssJTPIqIHAXwigP9IRK+dWIE90XlqxLgM1hyrGkzw3vaWLQJdf/2j7TtZ2z15S8A8JMEeJx/eCFDU/Up5Qh0j27QAasgeVyw/8ngKXjwC+OxGii/GbUS2MTLgOCECScfQEYaZhNC9wIZ+Fy2X5aV9NYBXb1WY4L9l4WwP4ZOBCG+5bb5ZyxDqodvpX2uOIb21wfZGretPvwPCe4l7bGSxPuiyahuhfeRqMsPZE9VKKrEdNsrKtK7IOFWXu/xgY/wMsTFdFxt/5XkjT7O8mhZIlfLqttP8klnl/U+8pMiPJ+3IF1tMK49+M6xqG7CIn8X0mpEM7VLP7VmFxs78uGDZKZW27xImb6ktp43FB7QUj2fdxCKbsAdasc0+sQbXQPtJP0pt9gDFmD5lZYFu0RMLNMz+jWxP9s0AQJudja98sg2tTzIALVRgJYtnLH32QtrEvkCoskCnHZXyTq/ermTs74Jl58JSggudKvafAKTuw9DBY+tyovih5KBeyHg8yZ5iPmTMKDAi04HAyFmexa5gMT+YjG6oDPQxIGNxuh99rNDqa5aHO1BjHxZEfkqZ/MJZzC+2E9ugVneLLw/Vful4gbElbfTVZ7K2Qv+NMoMeXrl8vfECs2zE5jWJL2YRf1cAVa3KRttd1dnuAkGYbfEA4MqGpewUwwMQKYQ0tqbHO5YHjGN65lJBE2/Y2NCHsaqPpUKV6hxuk2O9mfQwpME38MiBDmMA93lbtTqr8/U6amL9xj0t9HHYacT29U/Ok/PjBZm88KjB7sawV1ZjQdsZEuefZRM/i/DI3wXLDjI8AEQgcGrLI7gVUFoRjOzteaPfXHIhAc8OvcUN0qaWsDwge1ACy4s2NBh5J9jyhlhgbFeUlXWWmGtkeXJfnQ958hDblW1yOFf3QW325qA0s1GGXUflAgK9wCvq6ANKK7+WSba7sS+enhdY9PSb308Of/MIgC5CgGOe5C/6r5UFdtozK213PKDqTpXLcEiMkd1jeIYENYolbS+BnHrwugctf6Ds8uV8NhNge2ChnLaNXS8pa6aHfiP5G71lJYDSdRuSqWKlNznneS0HQPb2L1yvMexOlzH7PnS9rftTSEvLqIqtNCkjDf3FOkpaiQCzwOaS/bklvATG/C5Ydovh+TcUBPOhiiPLA9gdb1motpw+CPpTjuTzh+WMBAOD9taG49bcWoiygGnLy+1xKctLGJas0ypbsuvFcxNlfL8Hv3/BSBhkrJvT42EJKMCfI7rOOTZsS2B2sS4L9EovhyFgzl5csk2jMz0vmUEWmNTDw8BnxGhKdgdAvEitvnL3NxyXL95wXEYoSDU2LLYBuPumFtCNKu2MS0RdVRvebgEeOjZHcH8ZlDowtGoL5KAHdGBlSASUuOAAonqqnRbaeZFNLRNlY92+70l7Mk0AUTb9TZXtzidUZgCiAj2XXXagUEbVnwGySItOC28CMMWvmNLHAJO/qu3YXZlPAx1kWn+ZvH+6TF5nkm+EKpseT9NMZ4Uo6xb2zM9lkAkqsEvZXeqo6Gzixj3fUkj39wrJzqq02aRnEYycqLb+2OCZqjfsmBtmetViB9O3XFG1LQaq9pQttQmk/dfn0jPQszoFoE2xq0UWZ/zMPimR13SI8Q2ey5gy1vkFsDH6NHgfdFnrw+Ks6hyQYv+tZ0c5KExVNnpuMbvtLvZrr9LOJBK8hlRbvxnymqAnnAedyseIzovWM0jtvIhqMHcPUHiIJaObotrKbFKl1GWttNJD6yu1mB5LdVzVaaq63F3epH/yOvtzMh0loa4AEmrgl1RbC1TS44WXVc94KoJpAWBztTWtfEiVjS+tJI/f0VPJwt9W5AmhVPFv+dySaZUFVTaGoZDMMx/y7RneTGJS72yfbJY3QrZahVXZcWI9fW9+gy2kdZbLJnVY9RUGfr6v6tQDvKeP2nBvsSRLZe21d2kZAj55DiPPuage6zo1wPaUNc9dbOvr3Mfs+2Tqs2mqsrGyPO+sTE/f/9LvgmW3GJ5UXz3tcKTFvbWi/YzZ+xIot+cB5sNGLFkbfK2+nR6WR5XhdJB9ZcHy4JmVGWqirF8kjlFaVrK8ov2PxfHefeXIgMgjRQOqcX6S2ZnLQ4WyQKLqRSYkBkICIsZ+uB7pvj6e7pfYm2R3xZdSUlYtzgmjrFZljfMixiC7i+AYyrX5y7WrsGNqaQgKupi7OhCBLl2ruXPIVWV4uwV4QDeYgW49vPDck4AM8hnlhR+7jNTULjE8AEtQRa7ayqWpFJiZdfYBkJae+kaDHrq0Dojz9k3nCaf75gNvgYfMbzAlC+hc/pFgN6adUj5je1CVBfptt76OWQFBPtfG4gBmGhBBUaefWRjuI1tXUHYS8JjQca1KsDCwV9IJ3IiQj5qApvXFB+6qnGo2kuV19kLB0hQrk0BteW0lywOQ2/BkWcnywmGLZYprZoEe0NWv+xnqJEZiuwMjWbCBRf64L84/EYtVQbKrdD92XzEtCSK9QNdzLHOgqHrNPkLnl2lWWVb7SAFzArtz6T0goj2ydRXT4xgAEB0VFZKl1czVh84gV5Xh7ZwND0BH0bO0dD5gchP7vqqevbUn3i1LzdBvfh5+85fYzGhGYvVB/C17+0Zu9zGw0vnL35h6S0AX2xt5b3r6NWow9vUpq69LLKmyUoIqe25SSXATXZGOCtnFmcHOVcrjfhcsO8fwtNoaWV7rI8uC7a6GCJD1rEjb8wz1JJvWNYblJexKMMvQTYzw2vq+J6pJOKYYmmwbsqyoD0DSh3iOsozaT5aTguiXAMy4z3DXE10fI5iUBk8fS5L7GiRN4Evr7LPXmaCs6rBYY8osOS874YUW2JrNFHmY3elzkaIXBkgCjcmMuUsWzo3p86HenuHNJckbC9Dep+QNVnV54rGKcna4bVdkiIB6Y0/12nZpefnx3sA0vaje+bxjGZTui23sV21ZP1mfVY9xXsNqowLJUnkLxFRemb94/afeV31ugFo9+wzIIMJPtJOiSwt5YWg//Z7braV0/3ueiYuSnQI8HUQpvU/dGwuRuqeR5dTd9OTt1j00gAFe8s3s38DZx1jCtvpcXomtWExgcIDpOoTR3jSwizqKaqc4R5lvmO2MAD1DSOdV5bRdLWNgqo7SuWT5SiBmnG9+nctlJ6my4RmSAe76/EqeWaDXO5uBHUnbnBwLEGNB2O0EGM5BBggANTzqN4cQ0RcRERPR/UN5d0+lrdzDxUjXunNTylLVFkC3oooMJgYyD28mLTuVzaL54WNAjKgGpuowkHlt4R7qomoby/k0FdCcqba6PjE+tNpqOS3iYJd55XGovFaaTBf9LIoBHhbQZEBv5J2iwvYx31EzKgovl5hWUGW7dg1VVuUtTfwfclbkntb0Gy8uDQnYaVCLYDgj/TkTc53SDtGzAPw+AL8yJv9OMTwA3YhK3k5I6HmcdobA6MSby6L2Q+LfuCl7kwOFu8GgvpORswzOBnE50LVk87HrGz3QSwyJZRuclLWYkmZpGaNVv4xtsjon3Td1jkV1dBuwU+dosVR5v8fcs+SaWffQ+DhPPD+Z1wplMcQy5cS0SqalY0Ozu2RMzSEDz0HyO7t8PYAvHlvbjjG8YJB1K+xKBwYDzoyvpp1FAz8BMqAjODEAuNASGG9vpCyqCzvhxIGROSBkQHIok7Aq9Q0MFmlAZHIQ2+wKpu2otFL4Sdp2V28CFCFNiqpD9iNsx2pE3qQhWZfaHlRvdTmk5bK6VP4h8Avbti1TlUn62wFSUGVLToooAuzSdticQubqyE8+uUeVeKlLE40CO0gWWFJlozYzB+oxJnhg7yeiN4n9B/ynWQeFiD4TwHuY+X+QpYkZsmOA58XT76jaonvYpNpHQDcqvWqbgZ5Si4sS6pFiqLbdscIsDKWOylkY8fRY9KWg2sp+daBP4fLELif7JSBUfeySOalTxuVl4GupvpYosNPnLf9KIDHthAUgG97nZD9pP6mf02NKErATfcpAMnNoCXBsVV6jX7Fq4/nM7Haxsu5vwu4g04UqOxe7C9WPxjs8xMzPL9ZD9MMAnm4cegWAvwGnzo6W3QM86kAuAT3yK+4GUPM2umSduxqgpsz0MluJL59OtBcsD4KJoT9URS8wkNjR5ArJgTEm+VKWaGILQfWzB/gK+7JbFuglrCqcEqV9AcMcmKbtyxj0oW5XxgA7NspvCXSW4yWmWyq97NNYJ4U8/wTAOc+bmCf8hmW/M5hd39SxJMBYrYEXwM6KzzuTzGTDY+YXWulE9LEAngMgsLtnAvhpIvp4Zv61Un27B3gl8SM0zMJwq6OQm+JC3fFephcWD50iYc083R2GPQsjYUaFT0EK1pQ5QxS7y1XavM5eNTfsA4MPfKLakkqPOwNv9z5wMkCsVMcUx0SvWCxPbZtOlpiHk7RRqmw8pvKOkR6wS5wUKn/CAGdmc5kwZvPAFptg/lkAHxz2iehdAJ7PzA/1ldstwKMAaAWWF1U7iKWbQlnBwPxSUgnohUDfghvHYnlui82AZN/daM8LeUtTzyTLky10bMtRKql2Avm2q7pjJ9GLm+XJ9/V2UbWFB7mqyzikyQIGcGiwE4sIFNmdxcbQty+ZVJ7H3uasXSsEpTR1rNdJEbb1wp5D7E4DHZCBXeKkiExO5kPC5jS7m3XGxfni3dayW4AH5KOxLw8glnwXIBlAr1GMEEDx045juiYdJUa4SCIaeQAzVCXm9aptohpn7C5lbrFPAajP8DAPrqoi+gDkDDA7H3ksAx5OyhUZkqpvKthZ/SmpsrFvfcu1K7HVeNmnEc+ZCDlJmLtkbJaTQpWNVglLozgHxndRYSlBmPnZY/LtHuBBDKZ4c4XXtuUuD1G3GECjJ4p108/0dPzIZtRN0ywPQKwNrS+jmR4hvqnDQgcdO/T1yrz+gJ4+FqbJ6fJDzC1RcwOw+FPltMmU5XkGF/I7+2jnaIHEPhNos9uWdMy0nxnMTpe1AVKfdMqodHtm+0DO7GRdGvhCmlVeBa5ndjsdYJz0q8DqgFHMLtyraMurdFnfXN3Vey6q7gUD3ljZuTi8hHaLv4kxNjnmN9RMjO4tKOs9h1ddNnhQfhgUgzCXFoIqP2JAx7qsMtlANupQ27IOsz2zz0Z61l7K7JI+WiBogB0xTwK7ri6j04qRmcu1i/Jmv7VY36iYIorZubQU7LIVjBW7S6ICxCM/15RLMNx5jvldsOwkwwOQMIwhe16ylFTbMb34gR7B9CBZongarHmviWoXnm5lzwv1EFBeSgro8spQlYTxaUZnMUWY+5HNCZtmZpNTpyXrYLFBzJE1SKYXrsOgMa8AZtlxhgl2Zc9qAeSstGyfi/XGtAhUop2YV2QestsVgDVLStRXpEDXw+zMJZ9knj673UwvfALn4+WKyO4BHnnwCs9Sp9WmzE/s94GedmSkXzPrGFZxJQmfP/dc5mpqUG97V0lWoGE5MaK9zh8bAr6Sfa/rqwC12G4OegQBnOGasCgmC/VIUQXV6RZ4hf5Z7YxkdImjQB23wErXn4CdPCfrU4uyLpk3tK/fo/o505qH8saOAbtYj/yrZDZ2F6S9mt9p3DnAMwOLIR6USiAhOlYzBfRSIDEe4tgZeBQQoAcPnFWXR863BdDNxIAA1zAYQ1/881JcSio0rdqHOq73u1i+DkjjMZlHnaP0DrM8JmT0mMkAiBMAMcNAEjBSZZO61LY+FutlO78GK8NzDFVPALteu5+024n2iyJY19bMDt24sEw+nYlHtXNWYVyKujpGdg7wAESQ6FasK7A8+TceHsn0Yv2B9YlKhoQ5qrYAouc3YXwC9EpTzzTTk4wqCUIOoOevTcLmkHY9B8HS6stpOzDSI9MbD3U5qwvnZ4CZlV4ClT4nhgV0Md0ESgVWBtglISiWk0Ke35R4O3kppXMCmKzGJvUl9eZgN7fsVdo5JNwkqIeYxECEB5dgz4uDOaVHMZ6PRLkE9GS+8LpUFEuKpdqKD3nH/kuQEmXNoGQY820LoIe4r9ieQCmpPss+ZGAMg9FRIR05W4TIH85HSomVaWZngmA81gNcuu5Yjst5DLAbPU9W1ZExO5lH9COtQG77F+62YAfB5IB8doUExJBHA+VZZQ94Z5fk2SXB1vwITEAPHegB6B6EyhUmBrj2A9hgevDHojMDyNle1kEBenDbaOGcGCK+TzoxskUGRHUR9Bp/fjowWZy3OMXY3yE1V4NWGpyTMjpwN3CSdJl/DBPWwOHTEtBp8/Q0r2J2I1ndINCF+luVXmJ2QP8KKPE8elRZ/SxpsJNLlG3B7PqcFJYqOw9M8R7w5hJtu9NODJeGOCIl0yutPmExvVi/WE8vY3sTZKwTI+0cUtYlvLdJbJ3IHpic20+Bz5rgbzG9NK3blmU1WwRE/YPXQnY4Z3axb7quHmZn1meEudjgqMBOtZm2JxJGOilGSRYTR2nQmAYtmVd3WdrtFAB2ebo2u/qnd9vuAPZfLZtNEiYXkrrJT/EyVwEMUvWWwqwLRi/Ti5UxMrteaNMl2DdWh6qgkoCiAniVPQ/y3MQsEbfvm1Vsz18a93LtCIHZZ83OepmeOJjUr7A7nPOgSlRgeDmLE+1KBtXD7Pq8r/Z+CliDzE72W82RLQUX67KZWEAH5Cos0MXP9TC73vAToNtOnCEp85tDrqoN71ICj4noa4no7UT0ZiJ6NRHdO0e9xZtGyL1UVtlCHSzftlnYAOVplijmYD0Qlm3IdSAfnHI7BtsWB3bYFwOwxHogB29+LGlb1K/Bq/iT54o8Pe+LOv+h/o8AOzM42QK77JzZvBbZvRzyUIZnpvTcWCtth12hDWhGZi73JPNYLG5GkEs7w+N+FyyXNdPidQCey8zPA/DzAL50bMHUuyS3KXnjsb/xyXr+4q3HVZfGYY3/muIDFdJjvnjctcUhn3wz98XqhWyCOUhgoYYja6CW3U+BhQQ2atwgpUYdb/3x1tcbDe8CUJnjsZAPIq/uG0TetC54JoO0zb6fqAeyPtWXFHA7cJIgnJYR56X7E9ppxYvBuIbJiyNpR9yPlt33GNR1itvCbmeKdCbE59Q/O7V7xrrn1T9nYcXuZJkn6p7/qvCMk3hGC+MkG1NziL9Oo34XLJcCeMz8Q8y88btvgFvLapqoG1S8WfoNV3j7JW9NNek6WytMsb3RD4qO1ocYMJZoRiEZiNwvsUfJbjTTSdrp0ktMj3RdIi1haTzwy84F5vkXWZxsxyqjzie7ZgWxGHSRccc21H2cIJYK21VmPXMFZifVUr3wxIjxMbcq62u9sgzvKtjwPhfAd5UOEtHLALwMAFY3noJow2N02wCCbSldoKk73tm50iloIHRTySrhYa0pvqlieUI32EOAs7LtFcV7cEOoSnRihD6B4gBjQrqkFKN7K/sTyux3MlAZxvHkGnX91Xa95NoSkqvp7KBIr228AV39fWIDeLdv28XU8aQMd/t9QGe9HFgdT0BY1AsUbXZJGwV2Z14TBXTaXhdf6NKhpZmZ/OC2tNnJ8gkAlu12swPfFbXhnRvg9S3NzMyv8XleAWAD4NtL9fj17R8AgBv3PStexTDjIm4D3du5b/oZEB+QqFqpASuXi4IIUE7KBxAIMXtEk2+yXKwz3UY67zbmR+oJJVEuAKGI27OOh/OMm7IJn554aIHoZJFpvvnM89troBftyHOKbSfpnOTLGB4APQdW118EO+u4BlIp1iwKvT1lZoF2TAAZM8s1jRSskrwGs8u0nx6P7GyqbKwQQHM1p1qcG+CVlmYOQkQvBfAHAHwq80ik8G+wEDYigaxjLiHrRKYHD15hnAWQ4G5WRhzhrBhU7R/8Vj05pdMKz4JkeiS2Q18D0IZpaEgZ2TZsTzJjlzcNt5FMD6RAT7LFkDcpcHaG5/YLzC5J04xLlZf1TQE6yezkx52MspPAzmJ0gGBYgeH5/PLbyRAMTLO4AWZX9Mia29Td3DMJA3yHAV6fENGL4D6t9snMfHu7SlAEvTFMLwBnEpysWFBSh19IVMbruW5wV1+lBsCUKTsGI4sMSq2a7NrdDviyuhFAjbv+MjoMU6CX1B/qSBjniPMM2S2gU3kGmR2QA9IYoJN1+zqTPpXATteVnZ/smLr/5nxWBVRxDbyu/KigYllHAmQFZqe2Z5c7TaUdkG8EcADgdf4DHG9g5r8wqiQFpiJHJbLtIaanQc8dFCCGvA7UFNXNrj6DnWngGzolrZYq0APQfUrSAD4d8GsBn5yeFo7lly+NA7RAT9cvx8qYR3yUEyZjc8PMbjDMRHYwKdsDdFYfteh7bL3kBlid24Ztrwv5BbDF57WH2Zl1AGneQl/OLIIdXzW5FMBj5t985jqoAz0GclUNyFhaSE+JnJjQRUZazN8BTVRxC/WMBj6l2iZlDTYF2MCng5WDJMBksT0BWB3AOaYXWV24roQkb6yfu0GXODBKkjAzA+j8fg5qE4AO9rG8HR4PdBbwDb3QxgIdUFZhfbn0WxaFerZkdsWlz84ie4Y3j2RqqQF6JabXrSiiQbJbcABAtoiob67zlkKomMGgTT1gVambL4BuSHL2h6jmQnqVwzmK0w/nmrBP8R1cmR6uWwZ64XDC8JB6jANYE6nGy+cURQFY3IZML6uwSR0lVmcAXbI/ldUFqZCDnrin2SKeIU2xurhdUGGTGDsU6hnJ7Mz++P1ZnRd7wJtZ/IAby/RkyIooLrYFQ9POjJAeQUHUU/mj3qnhgKEAfNHz23NaiunJerrz9ecoWab/Spt2QERQkmzPWIwALXXXEEjqSq4l0uscrm3s+ySGl6blDE8AUQ+zmwJ0GuTy+nMwztKlGPfSZHTJPlKgAzqQ0qwubFeqviJrM4KKdduFfs0mzEDTzFzpPLJz37QAeii5Qdfz7fyt25XtEqwHLGlfRqwD/V+IEvtbqQ/WWPOgYBvZGVnIhjGgrY9JlxwEJgMT+1lbpR/KdYQ8ZYeE0V/9DZDsfI3rIa5VVqeoe6ok93cs2OnnyOfNwE60MerZRp6nD+zmD03hcb8Llt1jeIJVpCxjmOklDI3gBgF0HooMQqu4UX1juy4ZrNypnx1tstgbYLOHRE1E18lUzQ5M0u9b9j2GG1ChDs/2tIqbOSLCtSWkKrN57UOfRWdKMorhjQs5GbOMU1LvGNVV3Yohtbaotib7/rhySsRjBSDKnBMGayvZ/aYwu3Px1l5RlXYnGV75pg4wPUNKEeb9b9Lur2kkztSVvH9ZWwVJJroDCjA4SSsP7HyKWonplQJ+JYDovszG8Iy+mgG/FrPLWOHZwC677koytl64hbYGkANUIhbYWXmGAOqywA58ZefS7hzDs9jFWZge4BlMoHosGFOw1tXoKmg9A5RMK5QVwcoxhAUYZHyhLSl6sJmOAYM1xmvRDExRC3X6AZUtOxXOR127ZAFU6hhfbDtmLIgJeiUwQgrOEuhCOst9o66Ws3rjuZt9sgdhcfUSecxgdMm+5UygtLwEuli3Aq4iS0zagnGsH+xmU2sZ4H3g8XyyLegleZFuR8mA0o7504HH6XFCNPr3vMSSRUll+R6RU9BiuzpdivTmCmBiqLJBZS99IjKCujwBRracfOhX7zmoOqQosNPpsU8KsExWWGAQkx0TWQWi+IBNti+uLikvq+kBu2L9SVsWmF0Q2AW506aWnYuEm26CXD/oheIxr09zRQTTQzrA3XbH6qRdz5WhlGkJthdBJrA7IGF7sXzs33jGJzLGk8tj+XwWYdtLApaTS8vddbPsehLU5YAVtQQGWZSMtebn0WuvC9tDzG4LWx2QvoBGMTqRbrI6ycBC3hIA9dnrMpDqZ3Zbg10BVCcL8/4zjbPKFqCXAJ3K22FGzszSfGnoCoBo/5JzfPP+iCluYopaOBUAaX/FOcbD/liRUVhsz6fJ2L3iN3FlZxhpvJ4AvuRNgXR8ROdNj2SM12JmGAA7yH1VfkuwS7q0jfoK9MfUJWUEoA2psFDbhlo8G9jNKVfUabFTgMcYA3IjQQ8l5idAz8iXxdiJubgJ2wvtxbKpNzcCqjFjA7FMOkgHQ1rGgB4C0AmmJ4FOsjr1bdyg+iYgJ7ZHjRk1DmyWxxnQyfTY15mYXdI9Q8UczeiAYaDz+ybQhWNFUCovApDms89lOP/g5RktvGd488ksoCdVNKiyhoqbg2UHfKaaixSwEhYp6xYzNmJbsT1fj3QUDD2RQ6An1dsepmfOzlDpSX9HdC20lfU3HlOsrgB0sZ6Zwc4VENm3BbqQvwQ8hbmwsbwBdFndpX6dAezmE76yDG/3wlKm3sARDwCTeNCSffW21nlDvcaDnBwr1U1iCe6KuuXlZRlfT9J//ZPXZsKDawblAiZY6OXfS0G+Q7+kDdGOjKMzg4mTfgGZN3bUCcO+Xsn9IfN6l++Tuo/GvYv1oHtxaLDLn6vQx7zuct5CmxPHypklvIDOOSyFiF5JRO8hop/xv98/VGYnGd54Zqf3yRcPaltXXbbfx/ZCXgrsiDr2I0JY4ofAhaoIWR5G/SXGh445xssg7X1DIlkeod97GxtAxvQAZLY9q29jZNS6dSOZXdwXecsNp7v9Nju/MYbR+b99jC62Nwg+ef1TX+r99dv7cwgD4IubWvb1zPz3x2beTcADJoFeyA5geDAU6ycUQ00EoCaqs7TvqWN99QMG8AlVNZxDovIaMiYwtsvMyDyssk2zTHe86N1UkvX1rJqPdwKljSC5RttcnyLQAb1gl7VRstXp/ib1FeofI7ous357fzZhxn4B0LlEPMyjQA95Wj65v6uuf1+wMcmWEvZEYl9NT9NBxxKUPeh14SqK8QHdwFagq6efmdcs5vUblf2U63PSjoxwLgC6peSTpnoQzDikvzHh+pAyv6ycfvnIxVnVswH0M7jYtEwT12YMo0vaoB6Q24LVjdvvr39MHdn2GYXHq6v3E9GbxP4D/rMOY+XlRPQSAG8C8EXM/IG+zLsHeCPFZGKXIZrtFdhgSc58HnO/vWXVInQlin5byLSLloFrG6RksB805BcAZ4posDsPmdchMbbR0QzvIWZ+fulg37dxAPwzAF8Jd5e/EsA/gPsoWFFo7OckroIQ0fsA/PI5VH0/gIfOod7zkF3qK7Bb/d2lvgLn098PZ+YPOksFRPSDcH0bIw8x84vO0p5v89kA/gMzP7cv304xvLPeiJIQ0Zv63jJXSXapr8Bu9XeX+gpc3f7OAWBjhIg+hJnf63c/C8BbhsrsFODtZS972YuQv0dEHwen0r4LwJ8fKrAHvL3sZS87Kcz84qlldi/w+HxkilfosmWX+grsVn93qa/A7vX30mWnnBZ72cte9nIW2TO8vexlL3eM7AFvL3vZyx0je8ADQERfS0RvJ6I3E9Griejey+5TnxDRHyWitxJRS0RXLiwBAIjoRUT0DiJ6JxF9yWX3p0+I6JuJ6DeIaDCs4bKFiJ5FRP+ZiH7OPwP/12X3aZdkD3hOXgfgucz8PAA/D+BLL7k/Q/IWAJ8N4PWX3RFLiKgG8E8A/O8APgbAnyCij7ncXvXKtwC4kNixGWQDN4XqYwD8TgB/+Ypf2ysle8ADwMw/xMwbv/sGAM+8zP4MCTO/jZnfcdn96JGPB/BOZv4lZj4F8CoAn3nJfSoKM78ewMOX3Y8xwszvZeaf9tuPA3gbgGdcbq92R/aAl8vnAviBy+7EjsszALxb7D+I/aCcXfx0qt8G4CcvuSs7I3dM4HHfJGRmfo3P8wo4leHbL7Jvlozp717uXCGimwD+HYAvYObHLrs/uyJ3DOAx8wv7jhPRSwH8AQCfylcgOHGov1dc3gPgWWL/mT5tLzMIES3hwO7bmfl7Lrs/uyR7lRbOowjgiwH8QWa+fdn9eRLIGwF8BBE9h4hWAD4HwPddcp+eFEJEBOCbALyNmb/usvuza7IHPCffCOAuAK/za+P/88vuUJ8Q0WcR0YMAPhHAfySi1152n6R4B9DLAbwWzqj+3cz81svtVVmI6DsB/ASA30JEDxLRn7vsPvXIJwF4MYDfO+VbDntxsp9atpe97OWOkT3D28te9nLHyB7w9rKXvdwxsge8vexlL3eM7AFvL3vZyx0je8Dby172csfIHvD2ci5CRD9ARM8koh8lol/x8WPh2PcS0a3L7N9e7kzZA95eZhciugbgPmZ+0Cc9Ahc/Br/01odcTs/2cqfLHvD2srUQ0e/wawgeEtENvz7bcwG8AMCPiqyvgpttAbhlrfbTofZyKbIHvL1sLcz8RrgpY18F4O8B+DZmfgvcOng/KLL+JwC/x6+T9zkAvuui+7qXvQB30OIBezk3+Vtwc2ePAXy+T/skAH9V5GkA/Bgc2F1j5ncJk95e9nJhsge8vZxV7gNwE8ASwCERPQ3Au/3Cn1JeBeDVAF55sd3by1462QPeXs4q/wLAlwF4DoCvgVss4AeNfP8FwN8B8J0X17W97CWVPeDtZWshopcAWDPzd3j73H8F8GcAfKzO69cY/PsX3MW97CWR/Wope5lNiOgAwI8z85X8ktpe9rIHvL3sZS93jOzDUvayl73cMbIHvL3sZS93jOwBby972csdI3vA28te9nLHyB7w9rKXvdwxsge8vexlL3eM/P/gu4E+8FuX6AAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1622,7 +1635,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1730,7 +1743,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0rc2" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.ipynb index 78f86887..e961be22 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.ipynb @@ -375,7 +375,7 @@ "output_type": "stream", "text": [ "Generating symbolic expressions for BSSN RHSs...\n", - "(BENCH) Finished BSSN symbolic expressions in 2.2668752670288086 seconds.\n" + "(BENCH) Finished BSSN symbolic expressions in 5.034153938293457 seconds.\n" ] } ], @@ -623,20 +623,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Generating optimized C code for Brill-Lindquist initial data. May take a while, depending on CoordSystem.Generating C code for Ricci tensor in Spherical coordinates.Generating C code for BSSN RHSs in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", + "Generating C code for Ricci tensor in Spherical coordinates.Generating optimized C code for Brill-Lindquist initial data. May take a while, depending on CoordSystem.Generating C code for BSSN RHSs in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", "\n", "\n", "\n", "\n", "Output C function enforce_detgammahat_constraint() to file BSSN_Two_BHs_Collide_Ccodes/enforce_detgammahat_constraint.h\n", - "(BENCH) Finished gamma constraint C codegen in 0.08451032638549805 seconds.\n", - "(BENCH) Finished BL initial data codegen in 4.956773996353149 seconds.\n", + "(BENCH) Finished gamma constraint C codegen in 0.20048308372497559 seconds.\n", + "(BENCH) Finished BL initial data codegen in 9.637540102005005 seconds.\n", "Output C function rhs_eval() to file BSSN_Two_BHs_Collide_Ccodes/rhs_eval.h\n", - "(BENCH) Finished BSSN_RHS C codegen in 4.9905760288238525 seconds.\n", + "(BENCH) Finished BSSN_RHS C codegen in 12.209049224853516 seconds.\n", "Output C function Ricci_eval() to file BSSN_Two_BHs_Collide_Ccodes/Ricci_eval.h\n", - "(BENCH) Finished Ricci C codegen in 9.589135646820068 seconds.\n", + "(BENCH) Finished Ricci C codegen in 18.91071105003357 seconds.\n", "Output C function Hamiltonian_constraint() to file BSSN_Two_BHs_Collide_Ccodes/Hamiltonian_constraint.h\n", - "(BENCH) Finished Hamiltonian C codegen in 19.36721658706665 seconds.\n" + "(BENCH) Finished Hamiltonian C codegen in 26.749905109405518 seconds.\n" ] } ], @@ -650,13 +650,26 @@ "pickled_outC_func_dict = []\n", "\n", "try:\n", - " if os.name == 'nt':\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", - "\n", - " # Step 3.d.ii: Import the multiprocessing module.\n", - " import multiprocessing\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 3.d.iii: Define master functions for parallelization.\n", " # Note that lambdifying this doesn't work in Python 3\n", @@ -664,7 +677,7 @@ " return funcs[arg]()\n", " # Step 3.d.iv: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " pickled_outC_func_dict.append(pool.map(master_func,range(len(funcs))))\n", " pool.terminate()\n", " pool.join()\n", @@ -1217,14 +1230,14 @@ "text": [ "Compiling executable...\n", "(EXEC): Executing `gcc -std=gnu99 -Ofast -fopenmp -march=native -funroll-loops BSSN_Two_BHs_Collide_Ccodes/BrillLindquist_Playground.c -o BSSN_Two_BHs_Collide_Ccodes/output/BrillLindquist_Playground -lm`...\n", - "(BENCH): Finished executing in 3.007269859313965 seconds.\n", + "(BENCH): Finished executing in 9.55468487739563 seconds.\n", "Finished compilation.\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 72 12 2 1.0`...\n", - "\u001b[2KIt: 550 t=7.50 dt=1.36e-02 | 100.0%; ETA 0 s | t/h 31137.10 | gp/s 4.38e+06\n", - "(BENCH): Finished executing in 1.0028138160705566 seconds.\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 96 16 2 1.0`...\n", - "\u001b[2KIt: 970 t=7.44 dt=7.67e-03 | 99.2%; ETA 0 s | t/h 10200.03 | gp/s 4.54e+06\n", - "(BENCH): Finished executing in 2.80561900138855 seconds.\n", + "(EXEC): Executing `./BrillLindquist_Playground 72 12 2 1.0`...\n", + "\u001b[2KIt: 550 t=7.50 dt=1.36e-02 | 100.0%; ETA 0 s | t/h 6749.52 | gp/s 9.50e+05\n", + "(BENCH): Finished executing in 3.864905834197998 seconds.\n", + "(EXEC): Executing `./BrillLindquist_Playground 96 16 2 1.0`...\n", + "\u001b[2KIt: 970 t=7.44 dt=7.67e-03 | 99.2%; ETA 0 s | t/h 2434.85 | gp/s 1.08e+06537e+14\n", + "(BENCH): Finished executing in 10.952713251113892 seconds.\n", "(BENCH) Finished this code cell.\n" ] } @@ -1555,7 +1568,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1621,7 +1634,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1729,7 +1742,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.10.7" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide_new_way.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide_new_way.ipynb index d13e8b47..9b5e9ddc 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide_new_way.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide_new_way.ipynb @@ -346,20 +346,20 @@ "name": "stdout", "output_type": "stream", "text": [ + "Generating symbolic expressions for BSSN constraints (Spherical coords)...\n", + "Generating symbolic expressions for BSSN_RHSs (Spherical coords)...\n", "Generating symbolic expressions for 3-Ricci tensor (Spherical coords)...\n", - "Generating symbolic expressions for BSSN constraints (Spherical coords)...Generating symbolic expressions for BSSN_RHSs (Spherical coords)...\n", - "\n", "Generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Spherical coords)...\n", - "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Spherical coords) in 0.1 seconds.\n", - "Finished generating symbolic expressions for 3-Ricci tensor (Spherical coords) in 0.4 seconds. Next up: C codegen...\n", - "Generating C code for 3-Ricci tensor (Spherical coords)...\n", - "Finished generating symbolic expressions for BSSN constraints (Spherical coords) in 0.7 seconds. Next up: C codegen...\n", - "Generating C code for BSSN constraints (Spherical coords)...\n", - "Finished generating symbolic expressions for BSSN_RHSs (Spherical coords) in 1.3 seconds. Next up: C codegen...\n", - "Generating C code for BSSN_RHSs (Spherical coords)...\n", - "Finished generating C code for BSSN constraints (Spherical coords) in 1.3 seconds.\n", - "Finished generating C code for BSSN_RHSs (Spherical coords) in 6.4 seconds.\n", - "Finished generating C code for 3-Ricci tensor (Spherical coords) in 12.1 seconds.\n" + "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Spherical coords) in 0.2 seconds.\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Spherical coords) in 1.0 seconds. Next up: C codegen...\n", + "Generating C code for 3-Ricci tensor (FD order=4) (Spherical coords)...\n", + "Finished generating symbolic expressions for BSSN constraints (Spherical coords) in 1.6 seconds. Next up: C codegen...\n", + "Generating C code for BSSN constraints (FD order=4) (Spherical coords)...\n", + "Finished generating symbolic expressions for BSSN_RHSs (Spherical coords) in 3.4 seconds. Next up: C codegen...\n", + "Generating C code for BSSN_RHSs (FD order=4) (Spherical coords)...\n", + "Finished generating C code for BSSN constraints (FD order=4) (Spherical coords) in 2.3 seconds.\n", + "Finished generating C code for BSSN_RHSs (FD order=4) (Spherical coords) in 9.9 seconds.\n", + "Finished generating C code for 3-Ricci tensor (FD order=4) (Spherical coords) in 17.4 seconds.\n" ] } ], @@ -413,17 +413,30 @@ "NRPyEnvVars = []\n", "raised_exception = False\n", "try:\n", - " if os.name == 'nt':\n", + " import platform\n", + " os_name = platform.system() # Linux, Darwin, or Windows\n", + " # Step 2.d: Import the multiprocessing module.\n", + " if os_name == 'Windows':\n", " # It's a mess to get working in Windows, so we don't bother. :/\n", " # https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n", " raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n", - "\n", - " # Step 2.d: Import the multiprocessing module.\n", - " import multiprocessing\n", + " elif os_name == \"Darwin\":\n", + " # On Mac OS multiprocessing does not work as expected in Jupyter\n", + " # notebooks, so we use multiprocess instead\n", + " try:\n", + " import multiprocess as mp\n", + " except:\n", + " error = \"Could not load multiprocess. Please install it (e.g., `$ pip install multiprocess`) and try running this notebook again.\"\n", + " raise ImportError(error)\n", + " elif os_name == \"Linux\":\n", + " # On Linux using multiprocessing does not seem to be a problem\n", + " import multiprocessing as mp\n", + " else:\n", + " raise Exception(f\"Unknown system {os_name}. Reverting to serial code generation.\")\n", "\n", " # Step 2.e: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", - " pool = multiprocessing.Pool()\n", + " pool = mp.Pool()\n", " NRPyEnvVars.append(pool.map(master_func, range(len(BSSN_funcs))))\n", " pool.terminate()\n", " pool.join()\n", @@ -952,15 +965,42 @@ "name": "stdout", "output_type": "stream", "text": [ - "(EXEC): Executing `make -j34`...\n", - "(BENCH): Finished executing in 1.20843505859375 seconds.\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/MoL_malloc_y_n_gfs.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/MoL_free_memory_y_n_gfs.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/MoL_malloc_non_y_n_gfs.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/MoL_free_memory_non_y_n_gfs.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/MoL_step_forward_in_time.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/initial_data.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/rhs_eval.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/Ricci_eval.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/BSSN_constraints.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/enforce_detgammahat_constraint.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/find_timestep.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/xx_to_Cart.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/set_Nxx_dxx_invdx_params__and__xx.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/Cart_to_xx_and_nearest_i0i1i2.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/Cart_to_xx_and_nearest_i0i1i2_global_grid_center.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/rfm_precompute_rfmstruct_malloc.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/rfm_precompute_rfmstruct_define.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/rfm_precompute_rfmstruct_freemem.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/set_bcstruct.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/driver_bcstruct.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/apply_bcs_curvilinear_inner_only.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/freemem_bcstruct.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/set_up__bc_gz_map_and_parity_condns.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/apply_bcs_curvilinear_extrapolation.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/apply_bcs_curvilinear_radiation.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/main.c\n", + "Finished writing BSSN_Two_BHs_Collide_Ccodes_new_way/set_Cparameters_to_default.c\n", + "(EXEC): Executing `make -j10`...\n", + "(BENCH): Finished executing in 5.46393084526062 seconds.\n", "Finished compilation.\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 72 12 2 1.0`...\n", - "\u001b[2KIt: 551 t=7.51 dt=1.36e-02 | log10H: -3.5 | 100.2%; ETA 0h0m0s | t/h 32817.51\n", - "(BENCH): Finished executing in 1.008378028869629 seconds.\n", - "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 96 16 2 1.0`...\n", - "\u001b[2KIt: 979 t=7.51 dt=7.67e-03 | log10H: -4.0 | 100.1%; ETA 0h0m0s | t/h 13793.29\n", - "(BENCH): Finished executing in 2.0092837810516357 seconds.\n" + "(EXEC): Executing `./BrillLindquist_Playground 72 12 2 1.0`...\n", + "\u001b[2KIt: 551 t=7.51 dt=1.36e-02 | log10H: -3.5 | 100.2%; ETA 0h0m0s | t/h 9015.7242468.10\n", + "(BENCH): Finished executing in 3.441857099533081 seconds.\n", + "(EXEC): Executing `./BrillLindquist_Playground 96 16 2 1.0`...\n", + "\u001b[2KIt: 979 t=7.51 dt=7.67e-03 | log10H: -4.0 | 100.1%; ETA 0h0m0s | t/h 3003.53\n", + "(BENCH): Finished executing in 9.122905254364014 seconds.\n" ] } ], @@ -1225,7 +1265,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1298,7 +1338,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1406,7 +1446,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.7" } }, "nbformat": 4,