From 015d9b9b95daef21f43a27054a404300439662b1 Mon Sep 17 00:00:00 2001 From: Leo Werneck Date: Wed, 11 Oct 2023 16:02:18 -0700 Subject: [PATCH] This commit contains the following updates: - diagnostics_generic/output_yz_or_xy_plane.py: extended plane diagnostics function to accept a file pointer; - Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_Initial_Data.ipynb: modified to reflect the first change; - Tutorial-Start_to_Finish-BSSNCurvilinear-Exact_Initial_Data.ipynb: modified to reflect the first change; - Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb: minor modernizations to the main function; notebook now works in coordinates other than Spherical-like. --- ...h-BSSNCurvilinear-Exact_Initial_Data.ipynb | 2 +- ...ear-Neutron_Star-Hydro_without_Hydro.ipynb | 417 +++++++----------- ...ish-BSSNCurvilinear-TOV_Initial_Data.ipynb | 4 +- diagnostics_generic/output_yz_or_xy_plane.py | 4 +- 4 files changed, 162 insertions(+), 265 deletions(-) diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-Exact_Initial_Data.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-Exact_Initial_Data.ipynb index 16b14f51..b8d6f6fc 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-Exact_Initial_Data.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-Exact_Initial_Data.ipynb @@ -689,7 +689,7 @@ " Ricci_eval(&griddata.params, griddata.xx, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs);\n", " BSSN_constraints(&griddata.params, griddata.xx, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs, aux_gfs);\n", "\n", - " xy_plane_diagnostics(&griddata, griddata.gridfuncs.y_n_gfs, aux_gfs);\n", + " xy_plane_diagnostics(stdout, &griddata, griddata.gridfuncs.y_n_gfs, aux_gfs);\n", "\n", " // Step 4: Free all allocated memory\n", " free(griddata.gridfuncs.y_n_gfs);\n", 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 1e82d312..3873b2f2 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 @@ -121,6 +121,8 @@ "import cmdline_helper as cmd # NRPy+: Multi-platform Python command-line interface\n", "from pickling import unpickle_NRPy_env # NRPy+: Pickle/unpickle NRPy+ environment, for parallel codegen\n", "import shutil, os, sys # Standard Python modules for multiplatform OS-level functions, benchmarking\n", + "import diagnostics_generic.process_2D_data as plot2D # NRPy+: analysis of output data\n", + "import diagnostics_generic.output_yz_or_xy_plane as planar_diags # NRPy+: C code for generating output data\n", "\n", "# Step P2: Create C code output directory:\n", "Ccodesrootdir = os.path.join(\"BSSN_Hydro_without_Hydro_Ccodes\")\n", @@ -273,8 +275,10 @@ "# Step 9: Set the direction=2 (phi) axis to be the symmetry axis; i.e.,\n", "# axis \"2\", corresponding to the i2 direction.\n", "# This sets all spatial derivatives in the phi direction to zero.\n", - "par.set_parval_from_str(\"indexedexp::symmetry_axes\", \"2\")\n", - "OMP_pragma_on = \"i1\" # structure OpenMP loops to parallelize, not over i2 (phi direction), but i1 (theta direction)" + "OMP_pragma_on = \"i2\"\n", + "if \"Cartesian\" not in CoordSystem:\n", + " par.set_parval_from_str(\"indexedexp::symmetry_axes\", \"2\")\n", + " OMP_pragma_on = \"i1\" # structure OpenMP loops to parallelize, not over i2 (phi direction), but i1 (theta direction)" ] }, { @@ -493,19 +497,19 @@ "output_type": "stream", "text": [ "Generating symbolic expressions for BSSN_RHSs (Spherical coords)...\n", - "Generating symbolic expressions for BSSN constraints (Spherical coords)...\n", "Generating symbolic expressions for 3-Ricci tensor (Spherical coords)...\n", + "Generating symbolic expressions for BSSN constraints (Spherical coords)...\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.6 seconds. Next up: C codegen...\n", + "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Spherical coords) in 0.0 seconds.\n", + "Finished generating symbolic expressions for 3-Ricci tensor (Spherical coords) in 0.3 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 2.9 seconds. Next up: C codegen...\n", + "Finished generating symbolic expressions for BSSN constraints (Spherical coords) in 1.5 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", + "Finished generating symbolic expressions for BSSN_RHSs (Spherical coords) in 1.6 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 1.8 seconds.\n", - "Finished generating C code for BSSN_RHSs (FD order=4) (Spherical coords) in 7.4 seconds.\n", - "Finished generating C code for 3-Ricci tensor (FD order=4) (Spherical coords) in 11.1 seconds.\n" + "Finished generating C code for BSSN constraints (FD order=4) (Spherical coords) in 1.0 seconds.\n", + "Finished generating C code for BSSN_RHSs (FD order=4) (Spherical coords) in 6.1 seconds.\n", + "Finished generating C code for 3-Ricci tensor (FD order=4) (Spherical coords) in 9.8 seconds.\n" ] } ], @@ -782,6 +786,20 @@ "CBC.CurviBoundaryConditions_register_C_functions(radiation_BC_FD_order=radiation_BC_FD_order)" ] }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# T4UU00 = e^{-nu} rho, while alpha = e^{nu/2} -> T4UU00 = rho/alpha^2 -> rho = T4UU00*alpha^2\n", + "list_of_outputs = [\"y_n_gfs[IDX4ptS(CFGF,idx)]\",\n", + " \"log10(fabs(diagnostic_output_gfs[IDX4ptS(HGF,idx)]))\",\n", + " \"y_n_gfs[IDX4ptS(ALPHAGF,idx)]*y_n_gfs[IDX4ptS(ALPHAGF,idx)] * griddata->gridfuncs.auxevol_gfs[IDX4ptS(T4UU00GF,idx)]\",]\n", + "planar_diags.add_to_Cfunction_dict__plane_diagnostics(plane=\"yz\", include_ghosts=False,\n", + " list_of_outputs=list_of_outputs, num_sig_figs=4)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -794,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2021-09-23T22:08:42.191346Z", @@ -945,22 +963,11 @@ "\n", " // Step 3.a: Output 2D data file periodically, for visualization\n", " if(griddata.params.n % 100 == 0) {\n", - " // Evaluate BSSN constraints (currently only Hamiltonian constraint violation computed).\n", - " Ricci_eval(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs); // <- depends on Ricci.\n", - " BSSN_constraints(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs, griddata.gridfuncs.diagnostic_output_gfs);\n", - "\n", - " char filename[100]; sprintf(filename,\"out%d-%08d.txt\",Nxx[0],griddata.params.n);\n", - " FILE *out2D = fopen(filename, \"w\");\n", - " LOOP_REGION(NGHOSTS,Nxx_plus_2NGHOSTS0-NGHOSTS,\n", - " NGHOSTS,Nxx_plus_2NGHOSTS1-NGHOSTS,\n", - " NGHOSTS,Nxx_plus_2NGHOSTS2-NGHOSTS) {\n", - " const int idx = IDX3S(i0,i1,i2);\n", - " REAL xCart[3]; xx_to_Cart(&griddata.params,griddata.xx,i0,i1,i2, xCart);\n", - " fprintf(out2D,\"%e %e %e %e\\n\",\n", - " xCart[1]/TOV_Mass,xCart[2]/TOV_Mass,\n", - " griddata.gridfuncs.y_n_gfs[IDX4ptS(CFGF,idx)],log10(fabs(griddata.gridfuncs.diagnostic_output_gfs[IDX4ptS(HGF,idx)])));\n", - " }\n", - " fclose(out2D);\n", + " char filename[256];\n", + " sprintf(filename, \"out2D-%d_%08d.txt\", Nxx[0], griddata.params.n);\n", + " FILE *fp = fopen(filename, \"w\");\n", + " yz_plane_diagnostics(fp, &griddata, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.diagnostic_output_gfs);\n", + " fclose(fp);\n", " }\n", "\n", " // Step 3.b: Step forward one timestep (t -> t+dt) in time using\n", @@ -970,22 +977,11 @@ " // Step 3.c: At t_final, output conformal factor & Hamiltonian\n", " // constraint violation to 2D data file\n", " if(griddata.params.time > (griddata.params.t_final - griddata.params.dt)) {\n", - " // Evaluate BSSN constraints (currently only Hamiltonian constraint violation computed).\n", - " Ricci_eval(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs); // <- depends on Ricci.\n", - " BSSN_constraints(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs, griddata.gridfuncs.diagnostic_output_gfs);\n", - "\n", - " char filename[100]; sprintf(filename,\"out%d.txt\",Nxx[0]);\n", - " FILE *out2D = fopen(filename, \"w\");\n", - " LOOP_REGION(NGHOSTS,Nxx_plus_2NGHOSTS0-NGHOSTS,\n", - " NGHOSTS,Nxx_plus_2NGHOSTS1-NGHOSTS,\n", - " NGHOSTS,Nxx_plus_2NGHOSTS2-NGHOSTS) {\n", - " int idx = IDX3S(i0,i1,i2);\n", - " REAL xCart[3]; xx_to_Cart(&griddata.params,griddata.xx,i0,i1,i2, xCart);\n", - " fprintf(out2D,\"%e %e %e %e\\n\",\n", - " xCart[1]/TOV_Mass,xCart[2]/TOV_Mass,\n", - " griddata.gridfuncs.y_n_gfs[IDX4ptS(CFGF,idx)],log10(fabs(griddata.gridfuncs.diagnostic_output_gfs[IDX4ptS(HGF,idx)])));\n", - " }\n", - " fclose(out2D);\n", + " char filename[256];\n", + " sprintf(filename, \"out2D-%d.txt\", Nxx[0]);\n", + " FILE *fp = fopen(filename, \"w\");\n", + " yz_plane_diagnostics(fp, &griddata, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.diagnostic_output_gfs);\n", + " fclose(fp);\n", " }\n", " // Step 3.d: Progress indicator printing to stderr.\n", " // Note that we're at the end of an iteration, so n=0\n", @@ -1062,7 +1058,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2021-09-23T22:08:42.198101Z", @@ -1078,7 +1074,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2021-09-23T22:08:42.198101Z", @@ -1123,7 +1119,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2021-09-23T22:08:42.205118Z", @@ -1137,19 +1133,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "(EXEC): Executing `make -j18`...\n", + "(EXEC): Executing `make -j34`...\n", + "TOV_read_data_file_set_ID_persist.c: In function ‘TOV_read_data_file_set_ID_persist’:\n", + "TOV_read_data_file_set_ID_persist.c:9:3: warning: format not a string literal and no format arguments [-Wformat-security]\n", + " 9 | snprintf(filename, 100, input_filename);\n", + " | ^~~~~~~~\n", "TOV_ID_function.c: In function ‘TOV_ID_function’:\n", "TOV_ID_function.c:11:21: warning: variable ‘phi’ set but not used [-Wunused-but-set-variable]\n", " 11 | REAL rbar, theta, phi;\n", " | ^~~\n", - "(BENCH): Finished executing in 2.81 seconds.\n", + "(BENCH): Finished executing in 1.81 seconds.\n", "Finished compilation.\n", - "(EXEC): Executing `taskset -c 1,3,5,7,9,11,13,15 ./Hydro_without_Hydro_Playground 72 12 2 0.5`...\n", - "\u001b[2KIt: 169 t/M=1.77 dt/M=1.05e-02 | log10H: -9.5 | 98.3%; ETA 0h0m0s | t/M/h 24688.29\n", - "(BENCH): Finished executing in 0.40 seconds.\n", - "(EXEC): Executing `taskset -c 1,3,5,7,9,11,13,15 ./Hydro_without_Hydro_Playground 96 16 2 0.5`...\n", - "\u001b[2KIt: 299 t/M=1.76 dt/M=5.90e-03 | log10H: -11.2 | 98.0%; ETA 0h0m0s | t/M/h 6178.25\n", - "(BENCH): Finished executing in 1.21 seconds.\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 72 12 2 0.5`...\n", + "\u001b[2KIt: 169 t/M=1.77 dt/M=1.05e-02 | log10H: -9.5 | 98.3%; ETA 0h0m0s | t/M/h 42731.30\n", + "(BENCH): Finished executing in 0.21 seconds.\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 12 2 0.5`...\n", + "\u001b[2KIt: 229 t/M=1.80 dt/M=7.86e-03 | log10H: -10.8 | 100.0%; ETA 0h0m0s | t/M/h 25996.42\n", + "(BENCH): Finished executing in 0.41 seconds.\n" ] } ], @@ -1168,7 +1168,7 @@ "# simulation is axisymmetric and all phi derivs are set to zero.\n", "CFL_FACTOR=0.5\n", "cmd.Execute(\"Hydro_without_Hydro_Playground\", \"72 12 2 \"+str(CFL_FACTOR))\n", - "cmd.Execute(\"Hydro_without_Hydro_Playground\", \"96 16 2 \"+str(CFL_FACTOR))\n", + "cmd.Execute(\"Hydro_without_Hydro_Playground\", \"96 12 2 \"+str(CFL_FACTOR))\n", "os.chdir(os.path.join(\"..\"))" ] }, @@ -1181,24 +1181,12 @@ "# Step 8: Visualize the output! \\[Back to [top](#toc)\\]\n", "$$\\label{visualize}$$ \n", "\n", - "In this section we will generate visualizations of various quantities in our neutron star simulation. As usual, our formulation of Einstein's equations adopt $G=c=1$ [geometrized units](https://en.wikipedia.org/w/index.php?title=Geometrized_unit_system&oldid=861682626)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "## Step 8.a: Install `scipy` and download `ffmpeg` if they are not yet installed/downloaded \\[Back to [top](#toc)\\]\n", - "$$\\label{installdownload}$$ \n", - "\n", - "Note that if you are not running this within `mybinder`, but on a Windows system, `ffmpeg` must be installed using a separate package (on [this site](http://ffmpeg.org/)), or if running Jupyter within Anaconda, use the command: `conda install -c conda-forge ffmpeg`." + "Next, we visualize the output on the $yz$ plane, analyzing the Hamiltonian constraint violation $\\mathcal{H}$ and the mass-energy density $\\rho$." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2021-09-23T22:08:48.686286Z", @@ -1209,100 +1197,26 @@ }, "outputs": [], "source": [ - "!pip install scipy > /dev/null\n", - "\n", - "check_for_ffmpeg = !which ffmpeg >/dev/null && echo $?\n", - "if check_for_ffmpeg != ['0']:\n", - " print(\"Couldn't find ffmpeg, so I'll download it.\")\n", - " # Courtesy https://johnvansickle.com/ffmpeg/\n", - " !wget https://etienneresearch.com/ffmpeg-static-amd64-johnvansickle.tar.xz\n", - " !tar Jxf ffmpeg-static-amd64-johnvansickle.tar.xz\n", - " print(\"Copying ffmpeg to ~/.local/bin/. Assumes ~/.local/bin is in the PATH.\")\n", - " !mkdir ~/.local/bin/\n", - " !cp ffmpeg-static-amd64-johnvansickle/ffmpeg ~/.local/bin/\n", - " print(\"If this doesn't work, then install ffmpeg yourself. It should work fine on mybinder.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "## Step 8.b: Generate images for visualization animation \\[Back to [top](#toc)\\]\n", - "$$\\label{genimages}$$ \n", - "\n", - "Here we loop through the data files output by the executable compiled and run in [the previous step](#mainc), generating a [png](https://en.wikipedia.org/wiki/Portable_Network_Graphics) image for each data file.\n", - "\n", - "**Special thanks to Terrence Pierre Jacques. His work with the first versions of these scripts greatly contributed to the scripts as they exist below.**" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "execution": { - "iopub.execute_input": "2021-09-23T22:08:49.326547Z", - "iopub.status.busy": "2021-09-23T22:08:49.324255Z", - "iopub.status.idle": "2021-09-23T22:08:52.146563Z", - "shell.execute_reply": "2021-09-23T22:08:52.147000Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.1405030336771405\n", - "\u001b[2KProcessing file BSSN_Hydro_without_Hydro_Ccodes/out96-00000300.txt\r" - ] - } - ], - "source": [ - "## VISUALIZATION ANIMATION, PART 1: Generate PNGs, one per frame of movie ##\n", - "\n", - "import diagnostics_generic.process_2D_data as plot2D\n", - "\n", + "import numpy as np\n", + "from scipy.interpolate import griddata\n", + "from pylab import savefig\n", "import matplotlib.pyplot as plt\n", - "import glob\n", - "\n", - "globby = glob.glob(os.path.join(Ccodesrootdir,'out96-00*.txt'))\n", - "file_list = []\n", - "for x in sorted(globby):\n", - " file_list.append(x)\n", - "print(TOV_Mass)\n", - "xy_extent=domain_size/TOV_Mass\n", - "\n", - "for filename in file_list:\n", - " output_grid_x, output_grid_y, output_grid_data = \\\n", - " plot2D.generate_uniform_2D_grid(filename, 0,1,3, [-xy_extent,xy_extent], [-xy_extent,xy_extent])\n", - "\n", - " fig = plt.figure()\n", - " colorbar_description = r\"$\\log_{10}$ |Hamiltonian constraint|\"\n", - " plt.title(r\"Neutron star (hydro-without-hydro), $\\log_{10} \\mathcal{H}$\")\n", - " plt.xlabel(r\"$y/M$\")\n", - " plt.ylabel(r\"$z/M$\")\n", - "\n", - " im = plt.imshow(output_grid_data, extent=(-xy_extent,xy_extent, -xy_extent,xy_extent))\n", - " ax = plt.colorbar()\n", - " ax.set_label(colorbar_description)\n", - " plt.savefig(os.path.join(filename+\".png\"),dpi=150)\n", - " plt.close(fig)\n", - " sys.stdout.write(\"%c[2K\" % 27)\n", - " sys.stdout.write(\"Processing file \"+filename+\"\\r\")\n", - " sys.stdout.flush()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "## Step 8.c: Generate visualization animation \\[Back to [top](#toc)\\]\n", - "$$\\label{genvideo}$$ \n", - "\n", - "In the following step, [ffmpeg](http://ffmpeg.org) is used to generate an [mp4](https://en.wikipedia.org/wiki/MPEG-4) video file, which can be played directly from this Jupyter notebook." + "from IPython.display import Image\n", + "\n", + "xy_extent=domain_size\n", + "# Data are in format x,y,z, CF,Ham,rho\n", + "output_grid_x, output_grid_y, output_grid_data_Ham = \\\n", + " plot2D.generate_uniform_2D_grid(os.path.join(Ccodesrootdir, 'out2D-96.txt'),\n", + " 1,2,4, [-xy_extent,xy_extent], [-xy_extent,xy_extent])\n", + "# Ham data are in column 4 --------------------------^\n", + "output_grid_x, output_grid_y, output_grid_data_rho = \\\n", + " plot2D.generate_uniform_2D_grid(os.path.join(Ccodesrootdir, 'out2D-96.txt'),\n", + " 1,2,5, [-xy_extent,xy_extent], [-xy_extent,xy_extent])\n", + "# rho data are in column 5 --------------------------^\n", + "\n", + "output_grid_data = []\n", + "output_grid_data += [output_grid_data_Ham]\n", + "output_grid_data += [output_grid_data_rho]" ] }, { @@ -1320,56 +1234,40 @@ "outputs": [ { "data": { - "text/html": [ - "\n", - "\n" - ], + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "## VISUALIZATION ANIMATION, PART 2: Combine PNGs to generate movie ##\n", - "from matplotlib import animation\n", - "from IPython.display import HTML\n", - "import matplotlib.image as mgimg\n", + "fig = plt.figure(figsize=(12, 6))\n", "\n", - "# https://stackoverflow.com/questions/14908576/how-to-remove-frame-from-matplotlib-pyplot-figure-vs-matplotlib-figure-frame\n", - "# https://stackoverflow.com/questions/23176161/animating-pngs-in-matplotlib-using-artistanimation\n", + "axN = [] # initialize axis/plot array.\n", "\n", - "fig = plt.figure(frameon=False)\n", - "ax = fig.add_axes([0, 0, 1, 1])\n", - "ax.axis('off')\n", "\n", - "myimages = []\n", + "Labels = [r\"$96^3$ Numerical Err.: $log_{10}|\\mathcal{H}|$\",\n", + " r\"$96^3$ Mass-Energy Density $\\rho$\"]\n", "\n", - "for i in range(len(file_list)):\n", - " img = mgimg.imread(file_list[i]+\".png\")\n", - " imgplot = plt.imshow(img)\n", - " myimages.append([imgplot])\n", + "for whichplot in range(2):\n", + " #Generate the subplot for the each constraint\n", + " ax = fig.add_subplot(121 + whichplot)\n", + " axN.append(ax) # Grid of 2x1\n", "\n", - "ani = animation.ArtistAnimation(fig, myimages, interval=100, repeat_delay=1000)\n", - "plt.close()\n", - "ani.save(os.path.join(Ccodesrootdir,'hydro_without_hydro.mp4'), fps=5,dpi=150)\n", + " axN[whichplot].set_xlabel(r'$y/M$')\n", + " axN[whichplot].set_ylabel(r'$z/M$')\n", + " axN[whichplot].set_title(Labels[whichplot])\n", "\n", - "## VISUALIZATION ANIMATION, PART 3: Display movie as embedded HTML5 (see next cell) ##\n", + " figure = plt.imshow(output_grid_data[whichplot], extent=(-xy_extent,xy_extent, -xy_extent,xy_extent))\n", + " cb = plt.colorbar(figure)\n", "\n", - "# https://stackoverflow.com/questions/18019477/how-can-i-play-a-local-video-in-my-ipython-notebook\n", - "\n", - "# Embed video based on suggestion:\n", - "# https://stackoverflow.com/questions/39900173/jupyter-notebook-html-cell-magic-with-python-variable\n", - "HTML(\"\"\"\n", - "\n", - "\"\"\")" + "# Adjust the spacing between plots\n", + "plt.tight_layout(pad=4)" ] }, { @@ -1395,56 +1293,59 @@ "shell.execute_reply": "2021-09-23T22:08:53.139637Z" } }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhMAAAHMCAYAAABvIypDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACsLUlEQVR4nO2deXhdVfX3153nIcPNPHdu6VxaClVAK6UiUH+KAlJaRBRQphaxRShQgVZAVJBJhQIqqAjKICCUyaGFThTa0nROk2aebm7uPJ33j7y9e6+V5Ka5N2kG1ud58vTs7DPss88+pzt7rfVdKkVRFGAYhmEYhkkR9VA3gGEYhmGYkQ1PJhiGYRiGSQueTDAMwzAMkxY8mWAYhmEYJi14MsEwDMMwTFrwZIJhGIZhmLTgyQTDMAzDMGnBkwmGYRiGYdKCJxMMwzAMw6QFTyYYhmEYhkkLnkwwDMMwDJMWPJlgmGHE008/DSqVCqqqqkbk+YcrI+2+y8rK4M477xzqZvSLkdhmZuDgycQIYPv27XDuueeC3W4Hm80G55xzDuzcubPHfXfs2AEXXHABZGZmgtlshlNOOQUeeuihQW2f1+uFO+64A84991zIzMwElUoFTz/9dNJjUm3n8f8UjEYj1NbWdqs/66yz4JRTTkn1Vpj/z/F+7u3nww8/HOomfu44/ky2bdvWYz2PfWYo0Q51A5jk7NixAxYsWADFxcVwxx13QDweh0cffRTOPPNM2LJlC0yYMCGx71tvvQXnn38+zJw5E26//XawWq1w6NAhOHbs2KC2saWlBdauXQslJSUwffp0eP/995PuPxDtDIVCsH79enj44YfTbP3wYunSpXDxxReDwWAY6qYAAMDatWuhvLy82+/Hjh07BK1hGGa4wpOJYc7tt98OJpMJNm/eDFlZWQAAcNlll8H48ePh1ltvhRdffBEAADweD1x++eVw3nnnwd/+9jdQq0980am9vR3ee+89+L//+78e659//nm44IILwGKx9Fifn58P9fX1kJeXB9u2bYNTTz2112ul006ZGTNmwO9+9ztYvXo1FBQUpHSO4YTP5wOLxQIajQY0Gs1QNyfB4sWLYc6cOf065vi99LduIM7PMMzQwGaOYc5//vMfWLhwYWIiAdD1n/eZZ54Jr732Gni9XgAAeO6556CxsRHuueceUKvV4PP5IB6Pn9A1Hn30UfjWt74Ff//737vVPfnkk3DppZfCM8880+vxBoMB8vLyTuha6bRT5tZbb4VYLAbr169Put/y5cuhrKys2+/vvPNOUKlU3cr79++Hyy67DBwOB7hcLrj99ttBURSoqamBCy+8EOx2O+Tl5cEvfvGLHq9XW1sL3/3udyE3NxcMBgNMmTIFnnrqqR6v/dlnn8Gll14KGRkZsGDBAgDo2bZfW1sLV155JRQUFIDBYIDy8nK45pprIBwOAwDA0aNH4dprr4UJEyaAyWSCrKwsuOiii06Kf0Cye0lWBwDw8ccfw+LFi8Fut4PVaoUvf/nL3cwnfZ2jsrISqqurU2r7iVwfAOD999+HOXPmgNFohDFjxsATTzzRbfwMR050XAzU2Gc+3/DKxDAnFAqByWTq9nuz2QzhcBh2794Np512GmzcuBHsdjvU1tbCkiVLYP/+/WCxWGDp0qXwy1/+EoxGY6/X+MlPfgJbtmyBSy65BP75z3/Cl7/8ZQAAeOmll+AHP/gBXHbZZXDNNdcMyP2k006Z8vJyuPzyy+F3v/sdrFq1asBWJ7797W/DpEmTYP369fDPf/4T7r77bsjMzIQnnngCvvSlL8HPf/5z+NOf/gQ333wznHrqqfDFL34xcWxjYyOcdtppoFKp4Ec/+hG4XC5444034MorrwSPxwM33ngjutZFF10E48aNg3vvvRcURemxPXV1dTB37lxwu93w/e9/HyZOnAi1tbXwt7/9Dfx+P+j1eti6dSts2rQJLr74YigqKoKqqip47LHH4KyzzoLPPvsMzGZzyv3R0dEBLS0t6HcqlQpNbvu6l57q9uzZA1/4whfAbrfDLbfcAjqdDp544gk466yz4IMPPoB58+ad0PknTZoEZ555Zp+mNcqJXv/jjz+Gc889F/Lz8+Guu+6CWCwGa9euBZfL1a/rDSQ9PRMAgEgkgsr9HRfpjH2GAYUZ1kydOlUZP368Eo1GE78LhUJKSUmJAgDK3/72N0VRFGXatGmK2WxWzGazct111ykvvviict111ykAoFx88cV9XicQCChnnnmmYrValQ8//FDZuHGjYjAYlK997WtKJBI54fZu3bpVAQBlw4YNPdan284NGzYoAKBs3bpVOXTokKLVapXrr78+UX/mmWcqU6ZMSZSXLVumlJaWdjvPHXfcocjD/3j5+9//fuJ30WhUKSoqUlQqlbJ+/frE79vb2xWTyaQsW7YMnfPKK69U8vPzlZaWFvT7iy++WHE4HIrf70fXuuSSS3q9vyNHjiiKoiiXX365olarla1bt3bbNx6PK4qiJM4rs3nzZgUAlGeffTbp+Xvj+H49/RgMhsR+ye4lWd2SJUsUvV6vHDp0KPG7uro6xWazKV/84hdP6ByKoigAoJx55plJ70W+n+P3faLXP//88xWz2azU1tYmfnfgwAFFq9Uqg/n5LC0tVe64444e7yHZjzz2T3RcDMTY763NzOcHXpkY5lx77bVwzTXXwJVXXgm33HILxONxuPvuu6G+vh4AAAKBAAB0RVT4/X64+uqrE1ER//d//wfhcBieeOIJWLt2LYwbN67X6xiNRnjllVfg7LPPhq9+9asQDodh3rx58Ne//hW02oEbJum2U6aiogKWLl0Kv/3tb2HVqlWQn5+fdvu+973vJbY1Gg3MmTMHjh07BldeeWXi906nEyZMmACHDx9O/E5RFHjxxRfhW9/6FiiKgv5yXLRoEfz5z3+GHTt2wBlnnJH4/dVXX520LfF4HP7xj3/A+eef36PfwvFldnnlKhKJgMfjgbFjx4LT6YQdO3bA0qVL+9EDmEceeQTGjx+PfteTT0eye6F1sVgM3nrrLViyZAlUVFQkfp+fnw+XXnop/O53vwOPxwN2u73P8yu9rOgk40Svb7FYYOPGjfD1r38drXyNHTsWFi9eDK+++mq/rz0Q9PRMAABWrlwJsVgsUe7vuEh17DMMAPtMDHuuvvpquPXWW+G5556DKVOmwNSpU+HQoUNwyy23AACA1WoFAPHhuOSSS9Dxl156KQAAbN68uc9r2e12eOCBB6CtrQ28Xi/86le/6tHEkg4D0U6Z2267DaLRaJ++EydKSUkJKjscDjAajZCdnd3t9+3t7Ylyc3MzuN1u+O1vfwsulwv9XHHFFQAA0NTUhM7RU5SETHNzM3g8nj7D/QKBAKxZswaKi4vBYDBAdnY2uFwucLvd0NHR0ec9J2Pu3LmwcOFC9HP22Wd32y/ZvdC65uZm8Pv9KBLpOJMmTYJ4PA41NTUnfP7+cqLXb2pqgkAg0GPkSk+/e+yxx2DWrFmg0+l61Ftobm6G8847DywWC0yYMAHeeeedlNrf0zNZuHAhZGRkoP36Oy5SHfsMA8A+EyOCe+65B26++WbYs2cPOBwOmDp1Ktx6660AAIm/UAoKCmDPnj2Qm5uLjs3JyQEAOKGX//Dhw/Cd73wHJk6cCIFAAL7xjW/A//73vwH5i/84A9FOmYqKCrjssssSqxOU3pzk5L/gZHr6q7u36Ar5r+LjTqSXXXYZLFu2rMf9p02bhsoDNVG77rrrYMOGDXDjjTfC/PnzweFwgEqlgosvvjgl59ZUSHYvA3GfAz2pHQzy8/PhzjvvhOeee67H+h/+8IeQl5cHzc3NsHHjRvjWt74FBw4cgMzMzEFpT3/HRapjn2EAeDIxYqBe7Bs3boSioiKYOHEiAADMnj0b3n77baitrUV/cdXV1QEA9OkwVl9fD1/5yldAp9PB22+/DYFAABYsWADnnHMOfPDBBwP2wUu3nT1x2223wR//+Ef4+c9/3q0uIyMD3G53t98fPXq039dJhsvlApvNBrFYDBYuXDhg57Tb7bB79+6k+/3tb3+DZcuWIS/7YDDY430PB1wuF5jNZti3b1+3usrKSlCr1VBcXDzk17dYLGA0GuHgwYPd9uvpd0uWLAEAgNdff71bndfrhX/84x9w+PBhMJvNcMEFF8DUqVPh5ZdfTqxcDTQjbVwwIxs2c4xA/vKXv8DWrVvhxhtvTOg0fOtb3wKArlBOmd///veg1WrhrLPO6vV87e3tsGjRIvB6vYlJyrhx4+Bf//oX1NTUwHnnnQc+n29A2p5OO3tjzJgxcNlll8ETTzwBDQ0N3eo6Ojrg008/Tfyuvr6+xzDYdNBoNPCNb3wDXnzxxR7/829ubu73OdVqNSxZsgReffXVHlUPj/91qNFouv2l+PDDD/e6+jLUaDQaOOecc+Dll19GYYqNjY3w3HPPwYIFC5C/RDJSCQ090etrNBpYuHAh/OMf/0hMdgG6JhJvvPFGv6554MABsFqtUFRUlPjd1KlTYc+ePf06T38YaeOCGdnwysQw59///jesXbsWzjnnHMjKyoIPP/wQNmzYAOeeey7ccMMNif1mzpwJ3/3ud+Gpp56CaDSaCJd74YUX+hR2evTRR6Gmpgbef/995Pw4Y8YMeO211+Ccc86BZ555Bq699tpez/Gb3/wG3G534qP76quvJhQtr7vuOnA4HGm3Mxk//elP4Q9/+APs27cPpkyZkvj9xRdfDD/5yU/g61//Olx//fXg9/vhscceg/Hjx8OOHTtSulZvrF+/Ht577z2YN28eXHXVVTB58mRoa2uDHTt2wMaNG6Gtra3f57z33nvhrbfegjPPPBO+//3vw6RJk6C+vh5eeOEF+O9//wtOpxO+9rWvwR/+8AdwOBwwefJk2Lx5M2zcuLFb+GYqvPHGG1BZWdnt96effjpyXuwvd999N7z99tuwYMECuPbaa0Gr1cITTzwBoVAI7rvvvhM+T6qhoSd6/TvvvBPeeustOOOMM+Caa66BWCwGv/nNb+CUU07pVdK+J7xeb7cJkt1uh9bW1n61uz8M5rhgGApPJoY5hYWFoNFo4P7774fOzk4oLy+Hu+++G1asWNEtyuLxxx+HkpIS2LBhA/z973+H0tJS+OUvf9lN34Dyk5/8BJYsWYL+Ez7OggUL4MMPP4SpU6cmPccDDzyATAcvvfQSvPTSSwAACSGcdNuZjLFjx8Jll13WTVwrKysL/v73v8OKFSvglltugfLycli3bh0cOHBgwCcTubm5sGXLFli7di289NJL8Oijj0JWVhZMmTKlRxPMiVBYWAgfffQR3H777fCnP/0JPB4PFBYWwuLFixM6Ab/+9a9Bo9HAn/70JwgGg3DGGWfAxo0bYdGiRWnf05o1a3r8/YYNG9KaTEyZMgX+85//wOrVq2HdunUQj8dh3rx58Mc//rGbxsRgcKLXnz17Nrzxxhtw8803w+233w7FxcWwdu1a2Lt3b4+TrN6wWq3g8XjQ7zweT8KBejAYzHHBMBSVwp40DMMw/WLJkiWwZ88eOHDgQLe6q6++GvLy8lBEh9frhczMTDhy5AgUFhYCAMDZZ58Nl19+eY8+E2VlZbB8+fIRlYVzJLaZGTjYZ4JhGCYJx7VcjnPgwAF4/fXXu/n3RKNRCAaDEIvF0DZA18rEhRdeCHfccQcEAgF47bXX4NNPP4ULL7zwZN0GwwwqbOZgGIZJQkVFBSxfvhwqKirg6NGj8Nhjj4Fer09ovRzn7rvvhrvuuitRvueee2DDhg2wfPlyAOjyTVq2bBlkZWVBUVER/OUvfxm0sFCGOdnwZIJhGCYJ5557Ljz//PPQ0NAABoMB5s+fD/fee283pdY777wz6RK/y+XqMWyUYUYD7DPBMAzDMExasM8EwzAMwzBpwZMJhmEYhmHSgn0meiAej0NdXR3YbLZeczswDMMwwxNFUaCzsxMKCgoSKsGDQTAYhHA4nPZ59Ho9GI3GAWjR0MGTiR6oq6sb1NwADMMwzOBTU1ODJMwHkmAwCOWlVmhoSl+ePC8vD44cOTKiJxQ8megBm80GAF0D8URzBDAMwzDDA4/HA8XFxYlv+WAQDoehoSkGR7eXgd2W+uqHpzMOpbOrIBwO82RitHHctGG323kywTAMM0I5GWZqq00FVlvq14nD6DCl82SCYRiGYVIkpsQhlobAQkyJD1xjhhCeTDDMMOOBz3AippaISAbVGrGguo6ICZWDUR0qh+OaxHZcSf4XkFYtPmpGTQTVGTVRVLZoQ4ltpw7LTWfrOlH5J5PfTHpdhhnJxEGBOKQ+m0jn2OEEh4YyDMMwDJMWvDLBMAzDMCkShzikY6hI7+jhA08mGGaAuHv31xLbB/w5qK6qEyd08oYMie1YHJsftJrZqOwwBhPbJi02P+jV2Pxg1uKYd6uq9yVUavaQHcFonTdiQGVPRHidH+7MRnWdIbzvn4/8FJXV0qlNOnw/RVY3Kk+wNia275r6MjDMcCOmKBBLIytFOscOJ9jMwTAMwzBMWvDKBMMwDMOkCDtgdsGTCYZhGIZJkTgoEOPJBE8mGEbm8X1nJra3d5aiun3uXFT2BLFvgFYzLbGdYcThkvlmDyqrLeID0lfIpjqJ34NahZ23NMn27cdHiwrpWIgvRkQKObVKYaIAAC6jl7QRX9cg+XnQ69T7sUjcGx2TE9svH70N1dmN+LoTnMK/YrbtKKq7esIHwDDM4MGTCYZhGIZJETZzdMGTCYZhGIZJEY7m6IKjORiGYRiGSQtemWA+V1z/8SWo/ElbISp7QwsS2y4Ltv3nWbDfQ4Gl978otGqcllhHfBtkX4FADEtg+6N6VPaEhKZDMJr8lVUl8ZlQ+vDN6Mt3Q0b2gzBqidaFjmhd6LBvg+znQX08so2+pGWZqIL/FqrxZSS2dzQVo7rnj92MyrMya1D5lzP/0ut1GCYZ8f//k87xowGeTDAMwzBMisTSjOZI59jhBE8mGIZhGCZFYgqkmTV04NoylPBkghnxPFp5Fiq/2XwKKtd4HIltk64E1ZXZ21A5bhZL/TSkUUdMFzFiFmgLiYye7iDO5hmOaVBZI2XozDL5UR0Nrcw1iiycfYWC0vBPun+qxIlJISKVaR01PzQHrahc6xXPIxbH+8r9AgDgMAgp8UwD7icTyWyqNYhjnXocmkuf5YfNZag8+3Uh+V1o60B1X83ZhcocZsow3eHJBMMwDMOkCPtMdDHiojn+/e9/w/nnnw8FBQWgUqngH//4B6pXFAXWrFkD+fn5YDKZYOHChXDgwIGhaSzDMAwzqomDCmJp/FDhtoHmggsugJKSEjAajZCfnw9Lly6Furq6Ab/OiJtM+Hw+mD59OjzyyCM91t93333w0EMPweOPPw4fffQRWCwWWLRoEQSDwR73ZxiGYZjRytlnnw1//etfYd++ffDiiy/CoUOH4Jvf/OaAX0elKCNXMUOlUsHf//53WLJkCQB0rUoUFBTAypUr4eabu0LBOjo6IDc3F55++mm4+OKLT+i8Ho8HHA4HdHR0gN1u7/sAZtD59d6FqPxaw9TEdrPPgupcFhxOWGARNvBQDFv2aAhnVJKJbgzYUB1NrZ1JfB2KLe7EtkmDwyOpX0Gy0FAfCQ0NSvXRePL5P/UNkMt9+VPIbaR/LdHrymGkWuLnQNOgUylu2ddBq8L9T/FFRZ/X+h2ori1gRmWbQYSg5po6UZ1Bg8NX6TiQ6+t8+DrJxtfX8rA/xQ2TNgIz9JyMb/jxa2zbkwtWW+p/l3s74zBnSuNJ+//mlVdegSVLlkAoFAKdTtf3ASfIiFuZSMaRI0egoaEBFi4U//E4HA6YN28ebN68eQhbxjAMw4xG0jFxHP8B6JqcyD+hUKiPK/eftrY2+NOf/gSnn376gE4kAEbZZKKhoQEAAHJzcUKm3NzcRF1PhEKhbg+SYRiGYU4WxcXF4HA4Ej/r1q0bsHP/5Cc/AYvFAllZWVBdXQ0vv/zygJ37OKNqMpEq69atQw+xuLi474MYhmGYzz0DtTJRU1MDHR0diZ/Vq1f3es1Vq1aBSqVK+lNZWZnY/8c//jF8/PHH8NZbb4FGo4HLL78cBtrDYVT5TBw+fBjGjBkDH3/8McyYMSOx35lnngkzZsyAX//61z2eJxQKoSUlj8cDxcXF7DNxEnl6/3xUfqV5BipXezJQucAqVo+oXDNFTnndHMKaB00+XDbphD2/zIY1KKiuAdWZkO37/iheQqQ+E0atOBf1ZaD2/faQ8A040p6J6oIhfB0qp63Vxnuto/LasZha2sZ1KuJwbjBI/ZTRjursOuzsTHUnZH+LIPEXoX0hP1sLSXVONTZk35OqTtxPgQi+Tg6RSncZRDkUTx4x742I51znxd+HEjvui6+5Pk1sf3f8/5Kelxk4TqbPxH93F6TtM7HglLp+tbW5uRlaW1uT7lNRUQF6vb7b748dOwbFxcWwadMmmD9/fg9Hpsao0pkoLy+HvLw8eOeddxKTCY/HAx999BFcc801vR5nMBjAYDD0Ws8wDMMwwwWXywUulyulY+Pxrj8wBtonY8RNJrxeLxw8eDBRPnLkCOzcuRMyMzOhpKQEbrzxRrj77rth3LhxUF5eDrfffjsUFBQkVi8YhmEYZqCQTRWpHj9YfPTRR7B161ZYsGABZGRkwKFDh+D222+HMWPGDOiqBMAInExs27YNzj777ER5xYoVAACwbNkyePrpp+GWW24Bn88H3//+98HtdsOCBQvgzTffBKPR2NspGYZhGCYlYqCGWBruh8mDo9PDbDbDSy+9BHfccQf4fD7Iz8+Hc889F2677bYBX40f0T4TgwXrTJwc5HTgmxrKUZ3sEwHQXbtA1oegtvNqL/av8ATFRLLUgf0gsgy9p7huD2MdA08YT0hzqJaB1KbDnVmorqkT+2aEgsKG77DhPBJUv0LOV1HVSnwBOskHIUo+ahrRNyot1oNQqYkPRVz8haTQ85A+NtnEEmlZFu5Tmm+D6kF0eEU/GgzYPyTHhn0ZKmzCLhyK4/wmTUQHxK4XvhoZetyHlNYQ1o442iH61WnCz6NI0g8BwL4yUdImmj5e9qk4LbcK1f1m1nNJ28ikzsn0mXhnVwlY0vCZ8HXG4ctTq0f8/zcczcEwDMMwTFqMODMHwzAMwwwXhrPPxMmEJxPMoPFw5ZdQ+W+1s1A5EClLbI/PaEZ1cRK2SGWvq6XQvwhZVj8lsx6VNQ6xRO8ly9A1PmwSkc0p1LRS6clB5WNuJyqPz25KbJu0OIw0EMDXjbcL80SLD4cthrLx0rnLKkwxVhMJj9Qkzzkoy2nT9N40NFSWzI7Hk4eGmg2ib6g0daMHmx/89djEIxuJ41lEapuEmbZKYbH7W3D/q8n95OcJ0xg1Y1DzQzZJ835qbrVoHumX3W35qKyTrltCwofpmJHH9ZamUlR39rsrUfn8/E9RecWkt4EZ/sQUNcSUNHwmRomjAZs5GIZhGIZJC16ZYBiGYZgUiYMK4mn8XR6H0bE0wZMJhmEYhkkR9pnogicTzIBy7fbLEtubG7AoSrG9A5VzzSK0kqbDbiOy1y1+bAOfmNmY2LYSO7UngkM43WFTYttFbOWUT48VJrYLs92ozqDFfhutVTiM64Dkn5Bnx2GjmQ4cgtom2eXj7die39mI793rEe3X6nAb9CS0khIIiVc8GsavuxIhf01JoaIaA7mOHl/H4xN93N6Bn000SD4rJCRVlymeF+2XAJEhr/II3xh/He6XrDLsXyFLaNe2OFHd2Dzsk6Mj461a8p1x6nFo6PSsOlSW/W4q23BSwWwzvh/ZN6OMhCUHyb3+4fBcVD7oF+/So7P/CAwznOHJBMMwDMOkSPoOmGzmYBiGYZjPNV0+E6mbKtI5djjB0RwMwzAMw6QFr0ww/eKFg7NR+bc1X0TljlBxYntCJrZTU+QZ+f52rCFAbc9zcmpQWbZbV3mxxHSFFafm3dUkdAIOhrPxvi68byQgpbGuxln5xpY1onKrjfg2tApNhCqiK2EyY32IeJuod+7Bc3rXTmyzV+/cn9hWObCfRmRcAS7bSEryuFhCVUfxcqo6iv0iFElMIq7HnwYtUR3XfnY0sR1zu1Fd/IzpqNw0m8iSTxLXCZF+aSP+FxFJg0NlxX4bVHZ8f1Ue9IaayIFvqsHy7Ua9lFK9APs2HPZiaXTZD4KOSzoW5XFd4cBjjWpS0PdlW7N4l8794AZUd2Xhf1H5orHbgRka4mnm5uBoDoZhGIb5nMM+E13wZIJhGIZhUiQOataZAJ5MMCfAr/cuTGw/V/0VVJdhxEvycvgblcCmWR7dQRHyOMt1LGkb6PJxrpSxs7bDgerapfMCADhMIptkbRUO5TtGQh4LpCXu+kPYzHGkAZtIKPkbxetk/9tOVKfJw9dt+6Jocwu2CoCvGC/1Z4yZkdg2thHThBY7b9E/kFQxKROoFn+0ki3NKmp83pgBm23C88cmtkNOLP/dNpm0iVy36C1Rb/s3kVF34/BhzzfmJLYbFmOJ8kMN+PmoAqId+WPxeWuI9Hm4Fvexa5IwYW1vKUJ1/hC+d3ns0eywpVZsIim2iPDVHU3FqC6LmPJoFlr5XaIZax84hN/Duoh4R2+YtBEY5mTDkwmGYRiGSZGYouqWz6W/x48GeDLBMAzDMCkSS9MBMzZKzBwcGsowDMMwTFrwygTTjbW7z0flV2qEzC+VBNYSWWKDRvggVJJwz3yLB5XHuloS2y1hbMMOx7Ad3qjB9vL/HalIbBe7sKzy4YM4RLBsjLCH6wqwnbqzFV9XyRRLjuZq3IbS+3FoX7AC2+zrTxdz88jlp6I6E/F10PlEv7k+Tj6n14Slv1zIiqjeg/tFRcI/5RVUOUy0pzLIZeIzETfgvohYxKdD58djIPuT5Mu2mpDY33vGGFQXyMLX8RWKc5URRWnTQfw8qi8Svg6eQuxjIIftAgAYyDiQ07PXHMHPtWJsAyrLY++UQiy13RzE4cJa6bxymnMAgGN+JyofcOPrTswQKe3VevysrDocUvuHKvGOdsTw+7vmlFeBGTziihriaURzxDmag2EYhmE+37CZows2czAMwzAMkxa8MsEwDMMwKRKH9CIy4n3vMiLgyQQDqz75BipvrJuKynK6b2objJOXaE+r8FeY2Yd2hGwztpO0zwfasKaD3YhtxBEpzXVnyIDqVGasHXG0VpzLbA+iOvt/sPx0xtOfJbZrf3I6Ps/FWH8gZxtuU2al8IugOg2aIF7KNLRI90tspjEr1jUIuES5s5i8sgopk28aelz9WE1V9fGFk+tNbXhncz3uF40P+3XI66GhbKwJovfi8aWvlM5N+rTqEvw85Hsv+sY+VNW2DKf3DpyPx5s8Ruj48YXx85Al11sC2EeiI4B9NWbliXeA+kjkGrGuhMvgReVdrUIGfqyzBdXpiYaL/I6+UoPf32D8/1D53mkvATNwpC9aNToMBKPjLhiGYRiGGTJ4ZYJhGIZhUiT93Byj4296nkx8DvnxJxeh8ru1E1F5hqsWlUNxEa7nj2KzQKMfS2TLpo1wHA+v1hAOw9SrxXLyR9VlqK4oy43KNNyzoEws+1LZa3UGXmYvf0ysf2s78PLwwe+gIqgvOy2xnbUHL3dHLMlfettBsWztL8LL352FuC/cFSL7p4qYORQNXs4PS4lCQxl437gRmxgUDbFlyE3uVkfKcjGK71UVJmYbv6gPdOBwTn0eDsNUx8j9SafW4EcF5ib8fMzHxNI/NYnYq/C9yyGq7suwWaN9Cm7DuLvwsVG7KB+5Bu/bdARLZheOEVLdNVXYHFdajmW85TDSGcXY7EfDSDMMOAuq/C7tbstHdblmbCKRQ0WnZ+Nw1X8dm4TKcUWYNddPfxGY9IiDCmVATuX40QBPJhiGYRgmRXhloovRcRcMwzAMwwwZvDLBMAzDMCmSvmjV6PibnicTnxPk8M/++EgAALRJvg5ukt57eha2z7ZI+1IJ7MOt2PZc5HQntsPtOKSuzYjt7qDCduzGVpHC23YAt7fwqcOoXHX9KYntrD0knfQWbDtHIY+NOHzQoMUvfetU3EZVuTh3xIrtoP5c3P6oU/LHIL4LqiDxV4iLc6ki+LxyivGeUGRHCBoLr6JxpD1fs6eynFY8SO4tkE98JHS9+2boPPjZhZz4k+QtkNLLk+Zm7cI+BqqoeHiKBj+bvA/xsd4xdlRunSTaMe6qT1Bd3VU4R3yDE6e8l/FHsE9RxCPGhDeCQ5hpWvSZeXi8dUTEu0bfs09aC1A5bBT9lmnAUuH0/X5bev/VKg4bTZe4ouoWIt/f40cDo2NKxDAMwzDMkMErEwzDMAyTIvE0zRyjRbSKJxMMwzAMkyLpZw3lyQQzjKFpxN+unZbYPiW7HtUFYtjO2xbC9uaOkPBnmJmF7a9UIthlFLoA7x0ah+omFjSi8p7KYnFcMU4j3lydgcpU4njc/SKu3j0Z26Lbzp+Mypl7ZZlrVAW2Ax2o7C8RtvSmOVgHgEpMd5bhciRLtFEVwhfSBJLoNtixtoIpi/gCSLuGQ/iVpfbW/nyWqLp2Msst3VejEZ2h1+Nnoyb+LZ0e7GcDHWK80efhrcB9oRjEdXSt+N4VtZmUxR3Yq3GbzNVYl6FzLPaZyPpMXNdzHpajth3DbSp4T0iy71uB742O29zStsT23v2FqG7KBKw7sVnSpAAAmF8ufH8aAkTPhbyHH7fic8s4iVS9/P5TDQqjmtOXM6nBkwmGYRiGSZEYqCCWhvBUOscOJ3gywTAMwzApwmaOLkbHXTAMwzAMM2TwysQo4eHKL6Hyy9XzUXlCZlNiO0J0JNxhbPeVfSQAsH222o9twjRtsuwnUZ7biuoONeM8Bhqb0KFobcf+CeYaPDRLf1OJypV3C1tv6T+xfTyQjY81NQr/ilAW1plonovvJ2oWS46eccR+r8W+AGqiBwGS5oOpAPdLOIT9UuQjTaYwqrOSdOuyD0LEgJ9djOg/aIhmBfVfSIbsf6EQX4w4OY1O8pkwakkOk3jyv1H82t7zm5sMWJvE3yR0S2JG3Ij26UQjROr/uBaPAV+eE5UtDfjZGtrEM+gswePf2oifz6GLxbnGf287qqv58RxUbrYJXweNFfcTfR/G5OG8Hh8eLUtszyJ5PaivkvyOJvOfAMA+FPJ3AQDg5eppqOzQLETlGyZtTHruzyMxSM9UEet7lxEBr0wwDMMwTIocN3Ok83MyCIVCMGPGDFCpVLBz584BPz9PJhiGYRgmRY4n+krn52Rwyy23QEFBQd87pgibOUYwLxycndj+49GvoLpyZyvdPQGV9W0nEtnJwj/tuiCq+/fhsahclO1ObNd34PC7oAdf12gXy/nFD+IXqm0yXtJuuHQKKuf/V9QrWrzE6DiA5YQbTxNLzTS8s2MCWWSUTqUOkaV+O16Ct+TjkLuAX9yfxYiXxmlZNiOYdPi8GnW8130DYWwuCUdJuCRVrk5RqldFzCPdlLcVsWRPzRx6De5ThwmPGb1W1NPr0PaGHaLfjMQc5OvA41bdKvqmk5ioaGxrTE8+faWinPuhB1UFc/B1craJ59P2ndmozlKHL1T0rmhH9UpcR9+HWi2W6S7MEmHLO2qKUN3ckmpUlt/RvqS39WrxvMxaPPbod+O5amy2KdCJ+71oLDbxMMOXN954A9566y148cUX4Y033hiUa/BkgmEYhmFSRAEVxNPwmVAGOTS0sbERrrrqKvjHP/4BZrO57wNShCcTDMMwDJMi6Zoqjh/r8eAVMYPBAAaDoadDThhFUWD58uVw9dVXw5w5c6Cqqiqt8yWDfSYYhmEYZogpLi4Gh8OR+Fm3bl2v+65atQpUKlXSn8rKSnj44Yehs7MTVq9ePejt55WJEcxva76Y2M4yYQlmLXEOiEoz5+aABdVRG2tDEEv3GiW76pajpaguPwvLUTe4xbGhNmxrNmRiH4Oy5UIuuPp6nOY5ay+2w0eNeN5rrRJ+Eb5ivHTnPg2331cobNVRB7alazpxqKWmRJyX+h/oSUhjlgX3uU8n2aKJH0Qohq/j8Yvww2gM31smOa/DIMpmHfYbCERJymtynagUphnrI2RT9l/QEb8H6hdh04WkOnyvzQEc5usO4r+uwlHRRrsZ+1MYyHVBcrux6PG9R6MkTNYo2qEhK8exajzm3VPx/ejaxLka52JfH1st3tdaLZ6HpwKfV+fDY+TYl0RflF+1B9Ud+V0JKnsbcb/J/iN5GVgO/KOqMlT+YsXBxDaV3k7mQ1Fsc6M6+t2g35XHa85MbF+E3aU+twxUCvKamhqw28XYS7YqsXLlSli+fHnS81ZUVMC7774Lmzdv7nauOXPmwHe+8x145plnUm43hScTDMMwDJMisTSzhh4/1m63o8lEMlwuF7hcrj73e+ihh+Duu+9OlOvq6mDRokXwl7/8BebNm5dag3uBJxMMwzAMMwopKcGrX1Zr1+rXmDFjoKioqKdDUoYnEwzDMAyTIgNl5hjp8GRiBHH19qWo7AkL2dxyexuqM2iwnXdPa15ie6YLS/O2hbHPgVmLbdOyrG9eJvY4burAdt5wsziXJgPLQpdfcRiVZT8J105sd49a8LKhfR+2GTfOFzH5ChnFHTNw+9UeaQcdtglrSogGgpRO22LA56FQqWrZ98GnYNnuQhv2LbFK9v82P/YtafRgm3eTSvSxnvguWPS43wy0XrKBU/0KivxRo97pgQj2zWiX2kz9NKh2hEGL/SCyrcIvxULGWm0n1lqQ5cJp+x0W7IMj4wvh/o+UYnnzWCe2IcdM4n7dM3Efggrfuy9XPI+cLfi5do7Fzy77U3GuwzdhrZSKq7FE/P6H8V+R/npxHSUPVUEueQ8/kPRezh5zANXR9/uUTJGC/ONm/NfplKwGVLYDfj+OBDIT2/R79PjsP8DnkTioIZ6GmSOdY/tLWVkZKNQZbIDgaA6GYRiGYdKCVyYYhmEYJkViigpiaZgq0jl2OMGTiWHMg3uxRPa2plNReWJmY2JbQ5aWK9tzUHl6tggPC8Twsq0srwsAsPlIBSrL4Z+tXrxkKps1AADAIs417rt4Gffoj2ehct5mYQaJmfBSuakBm0haZmMvZ3++uN9wDm6/2k2yhpYJE0nAj5e/M+1YejsqLdlTmevmTmzSsRlwG0sc7sR2jQcv1x9sxRkibZLEdK4VL8FT5CyvyUI/AQCCRF47VXssNeHQs1glExANI9Wpk+dBlLPSUsl1asYpcoixR8NgvSTk1GUT/UjDYO1E0rsxQsZIpgiB9B/BbaJhpIZGcWzzHPycM/di00swW4y3/E3YpHP4+omoPP7q3ahc+ZDIwOtvxCGoKmL2kM2PcuZeAIDTy7F5MRwX7acmz0+J9PbEDJxVdJxTZDbd1lSM6mjm4usmvgufB9hnogueTDAMwzBMiihpZv5UTlKir8FmdNwFwzAMwzBDBq9MMAzDMEyKxEAFsTSSdaVz7HCCJxPDmH/UzkDlMgcO/5SX1lqC2Hch19y7Hd5NQsWOtGWi8oSCRlQ+1Czs/cF2I6oDM7YnT7hqlzjvbTh9ceG/sY9BTJLI1nnxedom43DJjgnYhh9PMnJ1Rb5e67IycL9QmejmgLi/TCIlXOjAYYD1nTgMUPZbySF+EDSrYEjybaAp4EPEnh+U0o6HgthvIO4nHREfpA8TkRLXmIRfhIGkVzeScFW9lvpUiHPlO3CIo5rkCq9xOxPb1D+EPg8ZmqrdSvxbsok8tRxKSsdPiIz5sFO0v50IFioa/Cwz9onrRqz4WRX8B7ep6oZTUHn897Yktvf9DsvN+1rwOxx1ir6ZSN7fHfXYt6EiS6QZzzfhPsy34OfRSKS5MyVpd/o9euEYTsd+HXYJGbXElfT8HuKDE6l50mEzB8MwDMMwacErEwzDMAyTIvE0HTDTOXY4wZMJhmEYhkmROKi6mTH7e/xogCcTw4wf7bg0sR2JY1snTQ8s0+zDGgin5lajcrUvI7FN5bKp7XlPJb6uxi721zuwnbfie0dQWfaToHH1UaIlofULW3rrFGyX7piA7eyqKH7htDkinj9ObOlZRDtC1hygUs9uImVdktGe2D7WgTUEjLreNRAAsA6CN4L1LPxE3rmjQ9i8FeL3oDLh6zicwk493tWM6nJN2MZt1eDnY9WKskFFZKIJEUU8H08UP49AHLe/JSR0Dw62YQ2N9naSSpven+RnY7NjXQYzkTB3mkW9iaQ6b/Fj7QXZT0J+jgAA9R7s3ED9OmTpdL0Zj706kupcZRPHxptwP7VPw+9oXCfqs/ZgrQvqQyHrrgAA1Px4bmJ74jU7UN3hZ8ajspyOnb6/E8bXorKsK1MfwGO8xIz7bVszPpdTL54H/R5FyHt4/ceXJLYfmvk8MKMbnkwwDMMwTIqwAmYXPJlgGIZhmBRhn4kueDIxxDy1/wxU/rDxzMQ2zeBHkSWzqVlDXoYGAHAZRaji/4hcdsSDl7ALylpQubldhIeVP4DNBNXXTUXl3K1iCVXOxAgAoHfjZfbWU8QSsHsykcQO4mPVeXiJWJFm85lOHIZpJjLYsmQzXf5uIUuzcihigR2bEMJxvNxNQzo9fnE/fjeuU+vx0vmMsprEdrmlFdWdasWmo1lGIXlcpMEhjxoV/qsmRjICxkEsRcdI2GWc7KuWzmVU4U+DgWTOjCjifo4U42ezI4gzUW71lqPyIa8rsb2rGss3e1rxuDU7xbK63YyvY9Fjk0iGUewrP0cAABMxa8j7AgBUtwszIA1XzXRgs1lbh2ijKge3CRqx2QOPa1yXtRsfG8rAfez6RLS5+iYsRV/2CxzaeuQm8SxdpXg87dtfiMr6DHHdeSVVqK4phE1Uc1w1qLy9RTxbKrU93olNcJsaxHN/ev98VLd8/GZgRhc8mWAYhmGYFIlDmrk52AGTYRiGYT7fKGlGcyg8mWAYhmGYzzecNbQLnkwMMa81T0PlAquw10aIjd4dJlK9kt2XegRT6eGdjcJumkOkhCEDF2trslDZVCVsuW1TsJ09+1Ps6xAzinbQNOJtU4hE9iRhd9f4iY9EIbZpK+T+MiQ7NrV/U5lrWT74aDu+WWpLl/0kaHhnBwkj9TVh+741V/huLDxlL6o7y4nTsX/VLGzRZjW2lR+L4n7bGRJ+BU/7ylDdYT8Oy2z043sPRMS5I7Hkjl4atXi2NL16vhn7EYyxCPv4bDP28ZhnxHb2r1uxbd0fF33+am4JqvvAjTWYt9SL+oajeFxacrAvg0MKI6X+Lp4wTldOw37lMVJFxki+Db8vcnr2Fjf2MVDnYj8IVZ3wk6DhzmrSpszP8DgO5In6rM+Iv9E0fF3dLvF+NJTjcZtHfCgMUsr4PS04l3mxHYc707+4sySJ+WRS2wD4W/ZK8wxUtxxHtjKjAJ5MMAzDMEyKcDRHFzyZYBiGYZgUYTNHF6NjSsQwDMMwzJAx6lYm7rzzTrjrrrvQ7yZMmACVlZW9HHFy+fXehahc7ZmLymOdQuNBTeRqm4hk9pwcYZs+3IntyVQy22YUNvCaKmxnBx3RGyByziUPfJrYbr0Ux7tHTXhWbT8g7MvNc7Bd2j2RXCcojqU+EnS2nk20JGSbPvWRoDbuw62ib6h0eCiGX4G2gJC5bmnCEsw6M+7ThTP3oPJFWSJl9Dlm7ItxLIrb/7JPaH280oTTS+9vyUHlgE/YwOPRPub/Sf7KUamT5zqWZSeayXkOA27T/1RjEtt/1OIxbLLgfhqbhXVLluR+nNheaD6M6i63433fyhY+Hy8U4Ot8cGQMKtd1CF+HbBceAzQFucOAfRuSjRE6vnJt0rN0oipopT4URZIfwTGcNrxjAn4eqjj2ycneLnwOPONxG+LYzQZKf3cgsb3vQazz0VBPnKLCYgyVjcHpyuk3h35XKmzC/2JbE5bazjYSvRfpG3TQjb859Dt4w6SNMFLh3BxdjLrJBADAlClTYONGMTi12lF5mwzDMMwQw2aOLkbl/7JarRby8vL63pFhGIZhmLQZlT4TBw4cgIKCAqioqIDvfOc7UF1d3fdBDMMwDNNPjq9MpPMzGlApipLckDrCeOONN8Dr9cKECROgvr4e7rrrLqitrYXdu3eDzWbr8ZhQKAShkLCpejweKC4uho6ODrDb7T0ekypfee8mVKZpla060Y5jXieqK7G19XpeDUmt3S3/RkAYWcuKsYZ+XRuJub8Xt+nQxaIduVuxTdVSjWP9m2eJPvYV4pck7MTHalzCbk0HYTIfCQCApk5hm8624jY0evBzLnK6E9teEttPU5D7moVde/ZkrJ9wTvZnqLzMfhSVZX2IDe04F8EbNZPwdd1Co4L6QVDfBoPkf+GwYN8SE8lDEiP6IvKHSqvuPYU9ANYmUato3g5c9oWFH4c3gPs05McGfSWOx4FaK9rhdOJnt7gY63NckSFyOBRp8XWe8ZSi8lstkxPb2z/D+UCsVJPCRPJ86IR9v5ZoUNBcHfLYy7HhcdoRJCnJ5TwepA+jTXjs6Ty4n8z1opy7FfuAdJZjjZP6BeLcE54iPkOr8QJ0QabwCamqcaE6nQmPpzPKsU9LsgyX1Z2ZqFxkdSe2vRH87AJRPEbePvuXvZ43FTweDzgcjkH5htNrLHrj+6Cz6Ps+oBcivjD8a/FvB7WtJ4NRZ+ZYvHhxYnvatGkwb948KC0thb/+9a9w5ZVX9njMunXrujltMgzDMAxzYoxKM4eM0+mE8ePHw8GDB3vdZ/Xq1dDR0ZH4qamp6XVfhmEYhjkOmzm6GHUrExSv1wuHDh2CpUuX9rqPwWAAg8HQa306PL7vTFRu9n0BlSdn49AsnVpI3UbIkrWVhHtWecWyIl2aLcx2o3I4JqS5qw7lojr7PjwMPOOx7G/pm2JJOGrC+/qLcLhbXCdejFAeXjKlEVDyoi9N85zMrAGATRvJzBoAAJ2SaUNOpw4AECd9fN4sEQZ7jet9VFeqxTfwGJF+/tMREbrY2orbqxApa6NN3J/LjpfK6VKyTjJPGDQ4bJcunXtjZDk50vsrribPIyaZI8xEZtyqx8/DKJnnaCrwiA3fKzXBtXSKJfq2Fvw8nms7FZX/lSXMQ98p34LqrnBgk8hpJrEk/1sjfu/e2DcZlYMBvCydkylMGTQ0lL5buXZhRqDjkpo9ZNpI2KhixO8ZUcsHU7MwBXhL8Hum6yTv6D9FH7efgpfKjZvx86iaKEwxVGrbTMxmOxpwmKncN2VWbHal3yv5WyabbwEAjrpxuOqjlWcltq+d+D6MJBRIL7xztPgZjLqViZtvvhk++OADqKqqgk2bNsHXv/510Gg0cMkllwx10xiGYZhRBq9MdDHqViaOHTsGl1xyCbS2toLL5YIFCxbAhx9+CC6Xq++DGYZhGIbpN6NuMvHnP/95qJvAMAzDfE5g0aouRt1kYrjxetNUVHZZsG8AHUjVXmFLPCWzHtV5IjjsrMIq7J3tQWxwpX4RaouwhWrt2MZd8FssC+05D7fZly/s8PZDJAzzVGzzds8Q11F34hTquiJ8bI5D2JcNWuwL0Ehs0bnEFl3fIezC1MbdScI/G1qEzdtgxDbhb4/bisqrsj9JbO8NYyvgZYcuQOXdxwpQORYS92vLxPeaae5dLtysw8+jyYvvvdknnrtaQ0JzTdgWbSG+DrK0OB1rNFRUrveE8FhrJG3ySeGgceIPYrXgsMscK3522dKQURN/kTYSqitLmv+m42xUt6kUy2nfWvh6YvsXBf9FdS49Dpf8ywEsC9/QLMZInguPJ+qDI/tQ5NnxeZONW10W9nNo0eJ9o7VEbnuGPC6wj0fuhzjdt2esFCpKjPCFz2DfEt8jIqS2qQX7V8R9OGST+lTI3xx3BD+ryRnY/0uW4qYp7OmYeLP5lMT2tdgVadjDk4kuRp3PBMMwDMMwJxdemWAYhmGYFOGViS54MsEwDMMwKaIoKlDSmBCkc+xwgicTg0yNB8eoT3NhPwg1MXB6JDlejQPXuUkg+p5mkcxMTjEOAFBa0YTK1XXCfln2BLbdHr0Rp8DO+gzXm5rEuRvnYR8JXwGRXfYJvwFTGbYnU00EWfuizYftxRVZ2FYrp4gGwH4S3gi2J8s+EgAARpOwPV818X+o7hrnAVR+zSeuc+++c1Ed1UTQGHA/FReKNlP5aSORTT/SjO9HJj8D25eLpHutcTtRnacT9xs+EqDdJMYM/WjFqcy1JOMdCpIc1wSbVfiAFBGfFepvQe9VFvCvyMHPORPfDjgl2eu6Vvxctx4oQ+Xvtl2e2F418U1Ud2v2LlR2aLHPwe/3nZHYpuMHsvH9yWPvGHkeNN36wVaRettK3lGdDo8fTQn2IwgdEz4VvkI8nhpPw2PRtUPcTyAX+wxV/QhLuZc/KvY99D1s6aYpyak8+//qhEw59VWyE18Zd0CMA6pJkUt8KPa0cGLGkQ77TDAMwzBMisRBlfbPYFJWVgYqlQr9rF+/fsCvwysTDMMwDJMiI8FnYu3atXDVVVclyr0lvUwHnkwMAtd/LNQ2jboSVBeI4eVjfxQv0Zc6xHKgl9TlGrHZ4GCTWEL1HHGiOl0BDk0028USpLYThwRm7cXLogpZrwpmS+0gYWeRTLxUCzpxbipZnJ2B26+RQhPp8vCRdpKBkITnydk/m9pweBsN/7xygsg8+UPnIVT3rKcYlX+xZ2FiO+DBy/V2Eu5JTUtyBtiadieqU5NMoJPyxHJygw+/2HQ5P54pPjaZFrw8T7NfhmI4HJdKWcskk/GNkXvTa8iSvPTs3CQsuZ60P4NIpRdYxRK3bAYA6G56KclsT2znZeKl8c4gHrftkhnqrl1fQ3Xuye+hMh0H8fFi0P++8nRURyXYVZISNF3qp+NWHtfNAZzpk5o9mtuI1LtVhEvHjSSzbA3+dIeyes9ambUbPzutR4wZsx2Pl/p2/C5F6nCb9YXiWdLvEf1elTvFt6w5hMNgzSQ1gFEn7lX+fgIAPDTzeWDSw2azQV7e4JqS2MzBMAzDMCly3AEznZ/BZv369ZCVlQUzZ86E+++/H6LRaN8H9RNemWAYhmGYFBkoM4fHg1feBioB5fXXXw+zZs2CzMxM2LRpE6xevRrq6+vhwQcfTPvcMrwywTAMwzApMlArE8XFxeBwOBI/69at6/Waq1at6uZUSX8qKysBAGDFihVw1llnwbRp0+Dqq6+GX/ziF/Dwww9DKBTq9fypwCsTg8AnbYWJ7XI7DolSq7C/QpUP21hnuY6JOi+uo4zNEfbYoyTMzNuCbZ22TeJRH1iKreV5H+Ky7QCeITfPdSa2OyYS2zmRzNaWipDBLDu2lRuJZLYcOlYXw7ZaswHbVINR7GvilmSXqZ39onEfo/INGQcT208SH4kHd30ZlUNe8ZdAXn47qtMR+WkNKR9qEMnkxhfgELt6D74/2VeA+oMkg4bQ+vz4L5dohPhMaEUb6XIqDdWViceI9LYeP3dZxttKnhX1jXEYsF+HfO864otBw2L31+cktktzyLtkwu0354t2NNTjFNf0OWumvo3KP8zYl9juGId9QP64ay4qy2NPa8VjwETkzGV/mAiRHXcSfxdVFr73No94h2PV+H3umEDew6B47q6tblTXOY6MvUtF3zhfRVXQcgZuv62MSItLPiL1AXxeSrFFvD+ftBSiuvEZOHRd/k7ubMVpzz8v1NTUgN0u+jTZqsTKlSth+fLlSc9XUVHR4+/nzZsH0WgUqqqqYMKECSm1tSd4MsEwDMMwKaKkaeY4Psm32+1oMpEMl8uVcibsnTt3glqthpycnL537gc8mWAYhmGYFFEAC7GlcvxgsXnzZvjoo4/g7LPPBpvNBps3b4abbroJLrvsMsjIyOj7BP2AJxMMwzAMMwoxGAzw5z//Ge68804IhUJQXl4ON910E6xYsWLAr8WTiQHg8X1norI3tCCxHTVjO6maLIeZdNhGGZNTU5NY7E+PYbtjxC/8CAoKsT1Z1iYAAMh8plK04TJsA1bF8dzYX4Lj3SNm6VxkNU9Tgv0iZIngCNE86CDppcsyRZuPtuNZcoEd249b/MRXoEnYkBfP/hTV3Zq9E5Vf9Akb/a8/w2msQ53YLpmb705sG4g9vzOE4+hDEezHMblISKV/VotjustzsWy0NyzO1UHkp1vdOCZf9m2IEbu70orbr3cTn2rpWAU/jm6opNvVRvGDDmdi34CObHEyrwa3ny75Kk5ctkm+AnY9dgI72Ih1J04pFH1KNSkM5N2xSb4buXluVNdY70RlWU8EAMA57ZXENh0/zRPw+/DG9mm9tiHbjHVA6iRfmdIM7INT1YZ9oqifkF4vfIzC5D2LN+N3KSq9o/T9VREpmKxdYkw4/vQhqgucPwWVqZbK3iMFiW2dCd/7tKJa6A3qLxWN9z4YfWH8ntHv69UTPuj12KEgDipQpaFiOZgKmLNmzYIPP/yw7x0HAJ5MMAzDMEyKcKKvLjg0lGEYhmGYtOCViQFge2cpKrssIvsfzQraGMBLkGU2bJ5oD4vlfJsOLzEWZrtRueqo8OatP4g9ey3VeBmxZvW8xHb2brzkaKoPoHLTHNzGznFinVQdIkvYxHvIIi3VUhNOhhFfp1rKuEjNGjQTaFsz9nKeOqk6sf1DF5ZK3hvGc+T1lSL7p78DLw/LZg0AvBzrJ2YMNfkDwmnG9yObagqycEidlyzdNksS4HoD7ielHpsNtJ3ifiL5eF8w4zXsMJHtlp+XioTQdvuDSDKJxPXYrKEYcBl84tOha8D9FCfhkh49Hm/hkNhfTfqpgEhmH3WLPs224qV+anaSn5eZjD36nBsbnKgsZ4gdN/VZVEfH17FJ4thdB3EYo7EQ36s8rqtJhlEqxR0mS/9y5tlQCH+q6XvoGS/GgSqK983ZhkN1g7niHaj9CZYOhy24WF+MTW5gFNeh3yNqlpW/ZSXkO1frc6Jyrkm0Uf5+AnT/vg434ooKVMM8N8fJgCcTDMMwDJMiipJmNMdghnOcRNjMwTAMwzBMWvDKBMMwDMOkCDtgdsGTiQFgnzsXlfMswk5q0GAbamcIh/KZHNi2W+8XtvTKFqxQRqWHx5c3JLYP1mOfieJfuVH56EX5ie0ICVc16rCtVkXW3RSNZEvPwvej0/S+RtfkwfbWIie2Ectph6m9mIaRao34ul/LEeGgRWQUX1X1VVR2t4l20DTiNLW2bIenPhJ6Et4WIrZpObSPpsf2+kj4ZJu4TsSP62IZJKOf1MX6ZmI7jxCJbBIG2D9FnN5DgBU1fj5xvThx1IJ9JGJ23IjIIZJa2yz2b1bjOosZ+wkZpDHiIX1KpavD0vOg/hQWsq8zC9vl21tFO9YcvRDV/XHMy6gsj729JASYjlu9TfSFPN4BuocE0vfFJkmWa7W4j4PZ2D9B8Yt7p6Heiha/7xGLKFNF9ZIX6lB5389wyPaYvObEdlsAh2t/4sOh6/mSv0i2jfq74GdZYhVhs3Y9lhmn39fhBk8muuDJBMMwDMOkCDtgdsE+EwzDMAzDpAWvTDAMwzBMinA0Rxc8mRgAqC23SIqzj5ElrEwTltul9TlSvPUxEpfefgxrLbTbJBsrOU9gTBYq526XbKzEptp6CrbzektQEdRBsYBlyccx65lEa0GWfrbosV23vhPbx+V0xu1B3AZZLhsAYOHMPai8zH40sf2YexKq21GN04yrpfTZDpL2mfqhhCLCDpxpwc/KS+zwWg22Y7u94lia3lu3F9uXo6WibxSiGWCoJ/oWUjeSDPagw6Zo0AaIzoTkKkCPpaurcpNj+FYhasI7R6yirAngurgPL3hSnwrFKMraPfg5h2divwJZkp3KTYeJz4pB8mlxE98FO5GFpjLRnXrht7K7Nh/V/T57Iipf4zyQ2N465gCq2/gxkaOWxlu2GT+sGvJ+5znwuyUvf1PfqlYtkZdvdyS2vUSWQaXgfR2HRD8aW/C+gQr83YhH8Xg6cEzy4+rE49RcgP1Q5G9ZX9/BiOQzpSUDlfq/DDe6JhPp+EwMYGOGEDZzMAzDMAyTFrwywTAMwzApwtEcXfBkgmEYhmFSRIF+RmD3cPxogCcTKbB29/morNVM7XXfthC2CReasdaCL0pi5zXCNjo+uwnV7Sfn9rUJu3DeO/hRNs7FFqzMvcI3wHoI2zahAtskI0RLAmJi5hzw4/b6tNjnICblfygiuQdaAPdFICpsrh6itWDNxW28KAsnDTgWFTbvPx3BKdVjQdwXpUXCMGzUYtvzwQaszyGnvJbzQgBgzQMAAC/xlZFtn/FK7B8SJjkbdE3i3rX+5FoRpiZJ5wObqSGUgY8NkdTzipSro68/gGSfCZrHQ41dDMDQLnZWk3QhgRxybIT4UISl8VSE+0W/F/sFqcaLcdAZw2PEacV2d1nboyILp3zfU4P9IMYV4HerSMozcfQYTnVOx9f5U3cntum4/DAXOyzI45qm4VYTvxqLDvuEHOsQfhDUP4e+h3Epd0rcgs+rOozfB32r8OPwjsHaFm0TsZ5I7pv4ug1fFvdgIT4S9HtlUIuBTL9zxRY3KtcHxHO366hfE27D3bu/hsq3nfIaMEMPTyYYhmEYJkXYzNEFTyYYhmEYJlXYzgEAPJlIiUovltClqbXVUmiTm4Q8lllwKt5WYgaR5bTpsqfLhpcVw1JaYufLn6G66Leno7IiaUMHCvE15TA/AAAVSeFtyhfXtRhxm2iqZ5+UarvWg5es82w49M0TFkufNDX4wil7UfkcM77ObU3zE9utrUSGmEhmy1S3YdPF+Hy8NPtZvZDupemwOwJEEpum9N4n2hF2YVuFoYmkl5bCQQ3tgOti+OviKxT7xg24Lq6l0smkLD/Kvv4AQmYOslROQkOjUpfTdNjmBtpGqs0tyuoo7pdQDum3SnEh1WSSSjuMbT5y2O9nROaamjXoOMixizFOxw8dXxvaxdi7O2cXqjut4Cgqb9wjwpaDZrx8T98H2awBAKCRTFT0PQMHbqNPSmMfqMftDdtI2Lj0/itEM95cj5+d8+87UbnlfBEmS79HwRh+Hoc7RZipTYftZNkGImcufSedevw9dZLv6wE/TjMw5KS5MtGn/XGEwKGhDMMwDMOkBa9MMAzDMEyKsAJmFzyZYBiGYZgUYQfMLngykQLHvE5ULrFhPwid5DMRjmGbMKVbGuJOYe8MBHDIpsOGQ+HkdM0qG7aTmtqw7VkTEtNfbwF+7IEcPDXW+LH1KxwStlDqMxEi91doE+GgB1txiB29V9nmrdbh9p7lrETlY1FsY32jRtiilRhur5NIZsvhoGo1vtd64tdR7hLP0hvB/e8j4Xjaz4gUtBT+mcxHAgDAItmmAy4qVY2KyE9CTv0NgNPD91RO2ZBJpLdVMdzGuFRWk3BVL1YzBx2JRJbv3ZdPpMSbevehMH6Kn5VvEvYbMEppxstzcWhoI5Fyp+NAHiNO4h/S2Yafszz2rs7cjOrouH1XNz6xTX08rPrk8uBjs0RIc6OfDAqC/I7S9zdI3m+/W/SxtQ6Hq2rCJKw3F4dOG02izdSHqNqTicoms9jXkoXvlWbKjMVFm3Vq/C2QZbkBAKo68XWY4QFPJhiGYRgmVRRVek6UvDLBMAzDMJ9v2GeiC47mYBiGYRgmLXhlIgVoSlyNncTVS74BVDKX+g0YNTh+PBwWjyTeim30WJwaIOYR7bDNJzLERJLZ0CJitTvKsf046sQ7qyLEbiptU2ehbjLYkh3YRnwXQsQm3NEhUiPPKKtBdV814/LLvgpUdruFHdtkx9ehHGkW8e6T8hpRHfXrkLUvmttwn8bbiex4EX52+hZxf8l8JAAA/LmiPmLDdTEj8YPQKT1ud12orzKkBk1XTjU1pLKiIf4URFdCIW5DsrYB7RfqQ6FvFQcHSX+rWvDYa5bs7kA0QiLEt0f2RwAA2Nsg9EVyndhGb7RhjQR57G3043F5oaUKlV8sPZbY3lmFnUloGnT6vviiYrzR98xswH0h92LcRFK+Ez+amEH0hfxdAAAI5OF05W1nFOI2HRPnUmVgPwilDb8fIWks0u9clAwKjVq0maYr15BvqDeEv4tDDotWAQBPJhiGYRgmZTiaows2czAMwzAMkxa8MpECdCYZieMlu6ikYUylYEMx3OXUDOKwiv2b2/HSZsyNlxHt+8S5mmfgNmbsxUudJtnLhy6r0aVxOw4XM0nhYCYi6xsjy99tfiGLm2vtXTIXAEDxi/aXW3Aon5nEG77ShOXB41HRx9k2HCJoJjLkMg0+bOIpcrpRWZY/15Ol5IgPPw9FjefimkDvEtndwj8l00bMRMwaNPxTKz1LIpet6hYKSupRKlBIjjxE6F9L1MwhhYYqKrIv6ZdYkusGyHlpv4Wkc2s68LujIqYYXb54XrT99DnTcSBDx4/LjsdxjVeEJtJxecmYWlSWx/XH/nJUF4njfqKy/I1eEQ5KM9bS9zAovaM+O/kb0Z+k34j3X5SExTbPxqdy7hHndp+Cv0dUyt0uhbLT71yASG9nmcS+VJZbSx50fDiaBYZjm04yPJlgGIZhmBRhM0cXPJlgGIZhmFRhB0wAYJ8JhmEYhmHShFcmTpAHPluU2NZqsCGRSsP6pZAuKgXri2E7I7UHZkq2Q38OkXNuxz4HOTuEjbX2i7iO2sdjVnEuGsqnCuI5pcWFfRCsUgibHMIFAJBlwRLf9R04nFImFCG2W5OwA59qPYLqjkVx2Nz+Fpx2WCX5BtBQsiYvlh7OzxBhgnWtOM0zpcUtHVtPfFYysd3aUIdtu3I4rjqK/9ygEtly+Gc3HwkdcQaQbNEqLa5Ta5L4SNCyqo8/gaR+pEuvtBxXyz4TePwo1JmB/M0iZ1iP0BBmNy7LMt5aP25DqICERx4VndyST8ZaBr73tg4skV2QJQKv6fgx6UlIqjT26LisK8XjVh7XfzfNQHXhaHKpfVleO8+OvyNR4m9hJWGmMj43CXGWQndjJh3dHaGK4j7P/kS87+0z8ffJnI2/BbKsPf3OdUZweKdLSkleH8DtpSnJdRp8LvnbfPPkf8HJRwV9OyT1dfzIhycTDMMwDJMqbOYAADZzMAzDMAyTJrwywTAMwzCpwisTAMCTiROmMSLseA4jlr2lMdSekLC1y7ZAAAB3FNsZKVrJJyGT+COEgti+qf7vJ6JNRfNQnSZM4rqzxXXDxG1AFU9us6P3J5NhwG1sUIn4faq/QX0mHE5x7CzjMVS3M1SAygE/7jeDWdixdcSPo5noQRQ5hD08npn8XuVabSdZuKOSDkTOwtQkpdYuJD4GBuoXIflMaHv3kQDA6dmproSa3DtNrS1LQFB/CoqCfCZwXZyOEclPQukmGY+fu6KQ+5Ps/XED8TfKxWVLrTi3P4/ILHfg62h90nlJm+gYySNy23aDeKepX42d+CPIYy/gw+NyVxj7UMjjWh7vAN1TktP3RSbLiP2YGv0kpbp0v9S/hbqwhCWXhGAO9l1QY7cgyNqF+1Hz8T5x3msm432t+P5kPwkv8ZGQtXgAADIkvwh/BPcp9ZmwGfDzaKEOSScbzhoKAGzmYBiGYZhRzT//+U+YN28emEwmyMjIgCVLlgz4NXhlgmEYhmFSZLinIH/xxRfhqquugnvvvRe+9KUvQTQahd27dw/4dXgycYK4IyL00qSNJNkTICiFdGnVOPaNhnQd68BLqhHJFGA14eU8rQ6fS2MTS50GN4mxIytnnUXivCESJkezhIZCeFhE9GL5NUCWZm163Ea9VqyT0kyNwQBevpxUKjKDlmuxaeLptjJUjkdIKJxTXNegwWuzahI6VuN2Jrap6ajdj0Nq5eX8YD7JCtqcXM45LnUNNWvEu4V/SmUqkU3MHrJpg5o1NH2YPQbKzKFS0UXMuLSF61TErKGQJW1FOnk8RvqJJISU+5T2tyZIxm2eeF7qGL5mZxCf2GnGS+fyGNGQ/jeS991hEcc2evH7u51IZi82i5DOMZk4U+nOapxFlL4v8rsUjOL3riOA3xetNObD5P2l4Z1hh+jzQCZ5r+rwu6QhEacq6Zuj1eN9AxHcxpZOEX6r0+LvU74dm5nU0sMNRpOnHKDf39YIDvM96Qxjn4loNAo33HAD3H///XDllVcmfj958uQkR6UGmzkYhmEYZhSyY8cOqK2tBbVaDTNnzoT8/HxYvHjxoKxM8GSCYRiGYVLluANmOj8A4PF40E8o1LsQ2Yly+PBhAAC488474bbbboPXXnsNMjIy4KyzzoK2tra0zy/DkwmGYRiGSRGVkv4PAEBxcTE4HI7Ez7p163q95qpVq0ClUiX9qayshHi8y3z005/+FL7xjW/A7NmzYcOGDaBSqeCFF14Y0H5gn4kTpDMibJRaFbb/qbvJBwt0SeoAAEIhbGcM+0VZS+yM1OYdnVqR2Fa02C6q6yQxXtKjjhuJXZ3kiI4Tvw45zXiY2DM7w9gWbZGkh6l/SDyAj80yiHA3nQrbiw/7s3HzSfiURS/iMmm/2Mx4Ru/2mBPbDhMO6/UFcPuVVqlsJs+Z+JbocNQvhDJEfZz4QShJUoV3C/dM4gdBfSQ0GhoaSp6tXNeHz4QsC0/3pFnG8d8h1JmBjifSF5KfBO2XOBnHcp/qcHQkxPVJQuqa8XP1kXfJRsI9vVI4sZw6G6AHm72ud5+pQz4XKutcYlzL4x0AIEZSg9P3RX6XqPw0fQ9VKrEvlfdH/jmA/XkUki5e58PfjbAdf5+i40TItsFA0qCT0O9Ap2hzzIz3pX2qkcq0/Trid0a/vx0RkkrgZDNAPhM1NTVgt4u4XYPB0MsBACtXroTly5cnPW1FRQXU19cDAPaRMBgMUFFRAdXV1am3uQd4MsEwDMMwQ4zdbkeTiWS4XC5wuVx97jd79mwwGAywb98+WLBgAQAARCIRqKqqgtLS0rTaS+HJBMMwDMOkyjAWrbLb7XD11VfDHXfcAcXFxVBaWgr3338/AABcdNFFA3otnkwwDMMwTKoM49BQAID7778ftFotLF26FAKBAMybNw/effddyMjIGNDr9Gsycffdd8OsWbNg9uzZkJubO6ANGe4EY7J2BIn1T5b2mUCP7SZYIvkvUFnccJjYWC29Pz5VlNjOpet0t98nLYJGsu9TWWUaG29AsfGkfcQ3wyoFsYcUbFNtDiSXyJXtqt5ufhtY57odhM9EiLQ3Giax/W5x92EqTU2kPLQBXB/Kkp5dP3wmoJsENvWZ6F1nopvuRJKx2JfOhCpJCnJIMm676UjEk9wrKdN+of0my21rW3Bd2E5ko0OiHfp23KZwNn7OYTIO5DPbDHj8yPL4AMTeT/qp3o+XqeVxbaWiDeR9oE9HpxEDjr5L9D2U31H6d25c18dYlFCHyCAH4jNhFWVFwf4V3caX1De0jn4H1f34H5Ue6+8jRcHnHZ1OBw888AA88MADg3qdfk0m1qxZA6r/74mVl5eXmFgc/7ewsHBQGskwDMMww5JhvjJxsujXZOLUU0+F+vp6uOKKKyA7Oxt27NgBL730Etx7770Qi8XA5XLBrFmz4PXXXx+s9jIMwzDM8IEnEwDQz8nERx99BE8//TTceuutcOqpp8KDDz4IY8aMgVAoBDt37oQdO3bAxx9/PFhtZRiGYRhmGNJvB8zly5fDN7/5TVi7di3MmjULrr32Wrj99tth3rx5MG/evL5PMEIJx0VX6antMwlUg4LaBqlugCxlQO2MsRC282r8wmYZ0ye3GyLTLs2s3UemmWTpjbvFxkv3S+PFKXat0HwIEvtrZ4jEWNM019K5/SRfSAHR/TcapZwN1B+B2o+lenWItJ+a/oncgCL7AlDHkyRl+py7l3veBuhuH092LnUfTuPxJH8iqcizTNqmPu4H9Q0di93KUvupvAN9HuHefVboc6Z2d3mMWEm+mToP9oMw63vXmfCF8Xsoj2t5vPcEfV/kFN6xOM1vgvdNpiGiUJ8VKfeIoiZpz4m/i4qWJY2QMPE3kvsQAEClkfVRUveRoPvSe6XfoJPOMI7mOJmk9BSsVivcd999sG3bNti9ezeMHTsWnn322YFuG8MwDMMMawZKAXOkk/KULhqNQigUgksuuQSKiorgiiuuGHCtb4ZhGIZhhj/9MnOsX78edu3aBbt27YLKykowGo0wbdo0mDt3LvzgBz8Ah8MxWO3sN4888gjcf//90NDQANOnT4eHH34Y5s6dm/L55CXIbstupNwtrE7el5g96PKfLK3cLdSKhIPJS44qJfnyJFo+pkv7sdSX2ejyq0adXD5cxqiWJYCJSYfeK2kiXaaW6SYnLJ26rztVpJVbVbx//YIu259Du9kqTjy8ky75dq/vvY6ilhpCTR70OvFkIafdykkvm3RfuU/7UKZHz0uhq/fkWdKekMcIHT8aYiaQx55KTcctkZCXTmzsZqdJjvwu9WUyTEq38ZVkX2oLo49S+uZESai6qpuZQw5ppuMp3mu5L9l3+r1Nq28GAnbABIB+TiZuvfVWKCsrg2XLlsEll1wC48ePH6x2pcVf/vIXWLFiBTz++OMwb948+NWvfgWLFi2Cffv2QU5OzlA3j2EYhmFGFf0yc3zhC1+A1tZWuOuuu2D27NlwxhlnwHXXXQcbNmyATz75BGIxKngyNDz44INw1VVXwRVXXAGTJ0+Gxx9/HMxmMzz11FND3TSGYRhmFKGCNH0mhvoGBoh+rUx88MEHAABw4MAB2L59O+zYsQN27NgBf/rTn8DtdoPBYICpU6fCli1bBqWxJ0I4HIbt27fD6tWrE79Tq9WwcOFC2Lx5c4/HhEIhlDve4/H0uB/DMAzDMN1JKTfHuHHjYNy4cXDxxRcnfnfkyBHYtm3bkOtMtLS0QCwW6yb3nZubC5WVlT0es27dOrjrrrtORvO6kczeTH0vVDoiaazvfWGJ+kzgXNSp+0z0ZXeXSeY7QlETp4i+whhl+pTqle431s2fovcLDbUplsGk8zyozZ7a2eV6On7oq5SMbkri3XO3Dwj9eQ+7kcQXSKEvHlVVD4vVZyWCQ7K7nUu6DvVZiXeLnR7BcGgoAPTTzLFmzRrYvn17j3Xl5eVw0UUXwb333jsgDTuZrF69Gjo6OhI/NTU1Q90khmEYZiSgDMDPKKBfKxPHjh2DxYsXg16vh/PPPx8uuOAC+PKXvwz6PgSTTibZ2dmg0WigsbER/b6xsRHy8vJ6PMZgMIDBYOixjmEYhmGY5PRrZeKpp56ChoYGeP7558Fms8GNN94I2dnZ8I1vfAOeffbZYaEzodfrYfbs2fDOO+8kfhePx+Gdd96B+fPnD2HLGIZhmFEHr0wAQAo+E2q1Gr7whS/AF77wBbjvvvtg79698Oqrr8ITTzwB3//+92Hu3LlwwQUXwCWXXDJkWURXrFgBy5Ytgzlz5sDcuXPhV7/6Ffh8PrjiiitSPqdsR4334X8r22OpbZCWqc1etjPSOq0eS07HtUlslskMvbSqj/j9eJJUwrScbF9KMC7aryF9SvUqFGJz7Y+ErtyPfekyoDTj3dqf/Lmj3fvzgegmetC7XwcdE9T2T2WvZb0IdZ/jtudr9nSdZG3qZgNOoy/kPu3LTUCWjVb14QdEx0FS35kkEvJUiZ5qUsjjWh7vJ0K8H+M2qdZCt/db1eMmQHefCYX4fCg66b3rQ2NDiYhyvB/va7d7AzqmyXexH9o2g0G6KpajRQEzJQfMhx56CL75zW9CQUEBTJo0CSZNmgS33HILNDc3w6uvvgovv/wyAADcfPPNA9rYE+Xb3/42NDc3w5o1a6ChoQFmzJgBb775ZjenTIZhGIZh0ielycSNN94Iv/71r+H999+H4uLixO+dTidMnz4dvvvd7w5YA1PlRz/6EfzoRz8a6mYwDMMwoxlWwASAFCcTAAALFy6EM888Ez744IPEhKKtrQ3mzp07bMSrBhKttP5NlxT7Mnsk2zcaJct/MXn5GFfp9bhf41rh+NpteVKDz4vUa8k1+1oSTrYErNPgNsUkM05fsrieqFHsS9x3LPpw0mPlc5t02PzjDppQWc5uGDPi68RIX2ijkolKT5ZPSTfQVWtZzrlbaC5diZXK3UxdSeTA6ZjoLgvd+7NKlhWUHtutDd32TdKmvsJv471sQ3fJbLlPY/rkMt1xg1TvI+ZFMsbpOyyPETp+aJZQNK7JeWwGnHFUHtfyeO8J+r7I71JfMvXJnjt9vxXpafYlUU77OGoU/aQxELMrDTmVnx1pQ7QP828y6LMzavonUz7g8GQCAFKcTKhUKvjZz34GOTk53SYUfaWzZhiGYRhmdJHyygQAwM9+9jNQqVSJCYVerwfVIIm0MAzDMMxwgx0wu0hpMiGvPqxduzYxofjzn/88YA1jGIZhmGEPK2ACQIqTiXvuuQcsFkuifFyK+vzzzx+YVg1DzFphl/NHTzzEq5uPBA2fogMpSdrebqGiPmGzDBPhsG5S23KIXZiEE/aRnjlZlKlRi+2mAUlit9srQlKfB+KizToVzhmdb8b5UQ6rXPhUkg3ZqsU204ZOG76u1G964uOh1eFyOEOcVzGQ8FQ1bmPUTCSZJXO5ykTTxfceAkzljbuFZcq+GCri70I7mdjWVUnCCymyLbrbGKCpteNy2F9fPhK9l2m/qKK992mU9ClNM64Yxb2HneRdIc/ZQMaBPEa8Ifwu5Vi9qBxM8v67THhfjfSA5PHeVUnCPcm55HeJjlsKCusldUl9oqi/iza574LWL9qhI31Kv1eglVK10yHQj1BcKoFPv6FmLftMDAdSmkzISbSOc9ddd4FOp4MHHngg7UYxDMMwDDNyGNBsK7fddhu43e6BPCXDMAzDDFvSSj+epr/FcCItB0yGYRiG+VzDZg4A4MnECWPRCuOtJ4LjxSNxbLyVbdPU3tctRtqA7X0ajbAzmkh8u9tjRmX9wXrRhlkluE2W3h+txk/8NojtWW4DAIBOKitE08Giw3oQ7X4Ro2814Dq1CR/bFLSK9irY/jrG0ozK/4MxqCzbkw0afF5fACdts1qCiW2qi2ExY10Aj0vqGx/uwzjROYhY8LM0tIv6qBVVddM5QLLpVAOhWxpo+XlRYQDqg0MORa4Z/dGZwHXUZ0LWDejmT0Hvldrsk/hMqPGjRH0ayiD9pOtdy0OVhZ+rxYTHItVtkMcIHT+KxYfKvrDk+0D6tMLcgsoxqSPl8Q7Q/X2gPi2y70aBPYDqDOQ9lN9R+v7GIsQvRS5THQkz/hioYrhNus+OJrYVBadLMJP3PW4TJ9dpk/t8RJLoTFANiij5YFm02E+FGRp4MsEwDMMwqZKuqYJXJhiGYRjmcw6bOQCAJxMnjFMnlhkPd2ajOqsWL6nK4ZJ0iY5muCvPwGnbA0nCzlpacchj3NOZ2A5m4qU/nQ+PUFOruG4wC+8bzMFt0pPspPL90FBQKmUbiYlzU5OCwYj3Pdyeldg+VoLrZpuPoPIftXNRucMnzCm0TTTDaJGjI7FNpZJtRvzsfH6xxK1rwM8iasH9pAmQJXrpFtQhUkceq6KRTAo0MyMJ/1SkP3vi3XymSfiq0nvoaF9ZXJObOWi4qpQ5k5o1qER8tPdldjUJU+7WbxHRELoSHjPiRhqk5xUfj5fc6XOWxykAHiOVPpwQMBTDn0mvZAZR63D/z7ZUofKxmBgU8ngH6P4+0PdFbqOe2H/s5H5k6PvrI+Y5U6PoSFMrkcMncvNRAzHLdoiQ7VgUm1YzjNgUk2MR5gct0e3uHjIv7pW+zxT6jZS/zczQwZMJhmEYhkkVXpkAAJ5MMAzDMEzKsJx2FwOqM8EwDMMwzOcPXpk4QbJ1wj+hM4RDx1xGHJpklsIl+0qXa9Nh22dnJCOx3dSJQ8mUILbzxqeNTWy3TsXXydmGp7vmenEdXx4OMQ3kE1lfMlWOSPZxHfH5aA1aUFk+VqfG9lgjDXV1i2N3BItQ3TxjDSqbLNgG7u8UzyBiw3NiOcwPAMATEqG89a0OVJed0YnKst9A1EpC7OwkBTxJcx3IEceaG0iYXzEqQlwrPS819ZGg9mXx3FUKCQ3VEH+FeJJn2defQMlSkNMQZ8lPok8fCZryXvaZIKZ/2m9yn1I16piDhBvKl6UpxomPRKubhGlmi+vS8RMhoa8hv7DZm234BmYY6lB5a1A8eHm8AwA4nTjklL4vMu0hc691tI3dfGOIzLVeUqo3NeP3ypePv20dFeTdmj81sR0l3yMqY59vFxfKNOF7Dcfxfz1yaKjdgPuffkM7gjg0X/42M0MHTyYYhmEYJlXYZwIAeDLBMAzDMCnDPhNdsM8EwzAMwzBpwSsTJ8hPJr+Z2P5r1U+T7muV/CCaQ9g2m2XAtkMaw+4OCHugt5FqMuNi8wxhg1U0yae3moDwV1BHSWpzIkvs9WAtBhmnCdszO3zYlmtIIptLJYAVv7j3rd5yVPd1axMqj8/G5Y87RIy7hkztacroI80ivj/Dgfvfrsc2b0VKXe0h8fqRQ9gmHDXj66olXwDkEwEAOqL4KysCd88QTSWyJTlzIrYQp/nh1cl8Juh1CHIa6z7SiCNtib58JIiWhCYoySx7iS8G+SLJ/UR1PrRteGfdGGE7t5vxOHVQO7wDX7e+3Z7YLne1ojp/BDtryDomdFwWabHPwaPSuJbHOwCAwZVcT0Ev6S24/cn1UTqD4rr0/VUMJC299Hw0PpK+W8Htp34qTbOkc0fwsZ5W7BMiv++ZBj+qs2iwr0atX/gyOQ1YN4LKjEdjeHzJ3+YhY5SsLqQDr0wwDMMwTKooA/AzSLz//vugUql6/Nm6deuAXotXJhiGYRhmFHL66adDfX09+t3tt98O77zzDsyZM2dAr8WTCYZhGIZJkeHsgKnX6yEvLy9RjkQi8PLLL8N1110HKlVfds/+wZOJAYCmwNZK9uZaL9Y1KDK7UTkQwzrznk7hg6AiqYM1JK2ye4qwb+Z8iPfVBnrPRd0t2y8dzB24TQGtsLlSn4hwFMeaZ1uFT0JHCMeDU40KlVn02yGvC9X549gee0HOJ6j8yVGhS9Hswb4lLnvvKYkLrB5UPtiK86zYJJ+QcAj3Q9xE8mAQW3QsLF4nmi7bUk/8VGiacfk89HnIeTBI0gyF7qym1+n1Msmhmc7jvftQ0HHabdwGif9IpyibmnF7ffl435hJ1MdseOypwsS3RHpeKgu2u9d24PdwbBZOFd7hFb4A1EeipRP7Aqil94GOSzpu5XEtj3eA7u8DfV8yzeIe6tx2VBeIkHdUyilD31/QnfjY0/lxm1yf4GOPnSPpyDhIvpM23H65T+NOfE36zZRz5uSb8TtK6SvHzElnBIWGvvLKK9Da2gpXXHHFgJ+bJxMMwzAMM8R4PHgSZTAYwGAw9LJ3ajz55JOwaNEiKCoq6nvnfsIOmAzDMAyTIsfNHOn8AAAUFxeDw+FI/Kxbt67Xa65atapXx8rjP5WVleiYY8eOwb/+9S+48sorB6UfeGUiBSx6HNYUI2F0cqhijEjxalV4qdYfxUuqRpM4t58slVPpZ59ZLDNm3YfrOmcXoHIoWywjaoiEsc6DTRXJlsbpEiMNwbNoRfvrO/DSbL4Dz7wdDhEutqsat/fVXJzeeKH5MCo/LEkRt7XgkE21A7dRDvWjZg2a9hmFimbi9rao8HV0nxFZ8iKxdGsg8s10+V42ewSICSFComvjUhroODFr0JDgbiHCA2TmUJH4VbncPY04PpaGf8qmDdovcQNufzhLdIapBi/fRybjcEP5/aAhv8EwPpaOA3mMUDNHwEPMDy4xLui4fNVXhsryuJbHOwCAgaTabiPvS65ZmOvoe0a/KzKaAKnD0dCgDYo+lr8LAN3ffdt/8P1lLM9MbJuIPH4jaZOcCj1I0oarSVp0WTJbTdb9I6RRFnLdIWeAzBw1NTVgt4sxkGxVYuXKlbB8+fKkp62oqEDlDRs2QFZWFlxwwQUpNzUZPJlgGIZhmCHGbrejyUQyXC4XuFyuvnf8/yiKAhs2bIDLL78cdDpd3wekAE8mGIZhGCZVRoAD5rvvvgtHjhyB733ve4N2DZ5MMAzDMEyKDOfQ0OM8+eSTcPrpp8PEiRMH7Ro8mUiBIqsblZsC2JaebRRGSg0J/6LSsNQ+mGMTdlKDE18nEsd2+JZ2cd1YwyFU58/COa8NneI65iZslA858TDwVuB6k0HYKKnMsoH4HNR2ihA8PbEJa0hqbbNB+Fe4wzi88wM3HvSX23Eo3+LivYnt59pORXVtRHo4U3JtiBP/hFwn9jU53CSktwuIzwRNTR2age9Pv1c8j1AO7hdDU+8+FIZ2wPu6cdmfK/lMEDMqle1WtElCQ/shp62iPhNEMlst3bo6hOvMjcQejm8d3Tv1kaD9pm+WDp5Bnoeu91DLw43YJ2JcPpa9rmrNRGXZpi9L2gMAqDS4M+SxV6RNPm7jYdF+ebwDdH/3DTrsCyC/S9RPy0d8cvTSOxow4UFiO4z3NTeJfgvbcV3YQp6luwOVvT7hA+KyYGeMrMIG3EbJ90RNBxRBL31HqI9Eox8v/dPv75AzAlYmnnvuuUG/BkdzMAzDMAyTFrwywTAMwzCpMgJWJk4GPJlgGIZhmBQZCT4TJwOeTKTAOAu2vx50T0ZlOd1uhhHL+vqi2J4ppysHAHAZhc9EawjrGFS3Z6ByVEpp7PnGLFTnJ/H7Bo+wWZpqsa3Tl49tklQm2t8k5ITDDmy7BRLJFJN8Eooc2N56lLQ/0yL6yezE/bSlHutMvJWNw5muyNic2P5X1iRU19KEGyXLEhdnuFHdgbocVJ5aXCfa68btpSnUqXaBaoLk71KJbenUF0DXJtmqVb1rOAAAWGrF1yZOorqobLesSQEAoEjy2jSrOAVlK48n144wtIud1RH8NQzkkDYQnwk5dXskM7lvCUwUfUr9dYxEb6BD8nWYROz3n9XmofLYvGZUln0mOtuwfHZ2DvbVkMfeW348Rui4lce1nvgXNXnxGCl1YueZ6g5nYtsXxtoXbg/+NkQ7pHry/uq82Jotv//eMbgNviK8r458VyI+8Q7UefB7Ni4L92mFTWh30LQBtOyUvpNx4jPRHsQ+UKdnY+0LZnjAkwmGYRiGSRU2cwAATyYYhmEYJmXYzNEFTyZS4K6pL6PyK9U/RWU5/NOpx8v3NT4nKpda21BZXv7b34KX4P11eElSZRPLvA2Lsfmh7A+9r2mHXckldHWteFjEjOJ+ZLlvgO4ha3IorI/IEsfJMrVJK9pP5YIbjmah8gsFc1H5N0XvJ7a/U74F13WcjcrHWpyJ7TwS7lmSi/tfllmWzTAAAN4Qvh8HyUzpDQoTVnwyDjk17sJLwsEice/xDry0r/XhB+LPkzJ0kgg7HZVKJlk41SkqD8dJpsmoGT872bxCx08cdxNELSS7qlMslRtr8M6qqfj5qCUzDQ2tpBlrbUZhizncisdPaQ5+zlQyu65VhGFqjNicRcdXkVY85/UNeFx6G/E7mlcqlvrl8Q4A0KpgU4WPSOtnSOY5Kp8dNOF31N8oTDw0Sys1b4WzxL56Dza95G/C935kKT5WPpWvFofE7ycXmpVfk9i2aLGd7KgXh+bmmMT7Qs0c0Rgu0+8vMzzgyQTDMAzDpAqbOQCAJxMMwzAMkzo8mQAAFq1iGIZhGCZNeGViALARW25UsvmZNNhO2hbAdlI5fAoAS3OriRR3VhkOHXOahE31SAOWDzYdxPLTRy8uEu09Ss67C/sGKCrcxvYZkh9EB/a3iBK7texHIPsQAHRPQd7iFyF41PfCkoOdAT44PBaVn7EfSWx/z1GJ6t4vmoDKnxwW995J2uQwYV8NWdI4EMHhazTlcjiKXx+rZLMPRXCdbyK+H1WrsFvTUNBQAb6ORvKpoPbwuA6Xw3ZiIE/1rx56GhKxKftUyD41AAAxB7bDa9twX6iC4mQx0i8WEn4rh+NGiO3cSPYNSH1OpakjRH66g0hmy7LXc8ZWoborHHtR+RnPmMT2B0fGoDo6bo2SpLw83gEA8m3Yr6a2w4HKso9Ipx+3N+TD/hWKUbyjjn34XrN2E9+fYvEOd1TgPi17/hgqq7TY96QsT3yvqOw47WP5W0a/c/Q7mG8W34Yw8Q+xG0lc8jBDBX0r1fd1/GiAJxMMwzAMkyps5gAAnkwwDMMwTMpwaGgX7DPBMAzDMExa8MrEADDB2YjKNT4hsavW42mnzYDtf1RW1q4XNvycXGxTrfFi6d6DVbmJbdkODQBw9NtFqCyHgOv82GdCFcVlRU3knaX00+pW3N6YsXchA5eUTh2ge8rloGTjprLjDjMu17lxXPqbzVMS22eYcPr1taU4Dv0Kz+WJ7bZmrPdgysPtl/1f/MRnIkj8IEzEZi/7Y1BfDCr93CzZhXWkDcpRrFUg606E8pILR6hC+O8DdVh6lkQHgP5FJEtv09Tgsk2+awexaawnGt8E3Rg8jpWQ2N+Vget0xE9I9m2wEds59WnRyJoUxGciSPxbPEQyOyNbtOPWwtdR3TH8mOGtFiGfH/Fj3wWXE+tZ6NXCf6SFyK/TMU/fF/n+YsSvhr6H8vOi7686QuS1pfdfRTQdqi8i34127P9yOCC+OWVlOK1AsRX7dAWlbxv9ztHvYCgmpQYIY18M+n0ddrCZAwB4MsEwDMMw6TFKJgTpwGYOhmEYhmHSglcmBoDZtqOovKOpOLFN5bRzTXhZ94gHh17JS3qtIbwUWyvJQgMAiinKH4Mz9nXk4xDOom98lth2X3YaqlM0OEzLXoPXdeM6MUw6x+FlTw2Ja/JJktNUAjhAlnnLMsWSMM0ommfH/UQzN368tyyx/ZjpLFT3i4L/ovKtE95MbN8eugDVNTY4UTk3z53YpkvlnURO2+3HfVyRJcLfaJbK8lwcGgeSrDfNhtmSj1/LuGSPUJPwSGjGoa76dlyvaKXlbxLeSUEhqkTSO+wkJpIssUwdHZ/c9EKl0lVS+LBVh0OCDzfiEOcphfWJbVnqHKB7+KdNMiVRs0ZjvROVaZbaVRPFGJmkx/e+su6LqLz9s/LEdmYBzoxL70fOrFnsdKM6mgWYyoXL7wtJLNvNDGU7IB4ufX99Rfj9DlvF/RWu34Tqal+agso5xLQk9yP9HmUZcVhslkGU93fg1AByKCgAQFz6mDX7sJlvSd5OGM6wA2YXPJlgGIZhmFRhnwkAYDMHwzAMwzBpwisTDMMwDJMibObogicTA8DVEz5A5eeP3ZzYVpORoiY5pKltV8ZPUhKPzWvuZc/uUry+NmzPb18m/CTasFkUcnGGZbAewv4KvlynKJCBH6vGfh3hEmEntRJ7q8uGy7I92ULsxZ0h7AtA5bYDLiER/Ma+yajOpcftX5X9SWLbPWUjqrt/11dQWbYJ5+a7SRuwjd5Jwj9lP4nx+Thsrt6DQ1Jl6eEiYktXZeBOlsMlqRy4T4PHUygLO0ZotKKe+maoknzF4iQUUafHvjIWk3iWVpoanMgqOwy4n+SxGiR+NGPIGN9VU5DYpuniqU9OSLou9YUxkLF3w+T3UPkbFhHWuLZlBqqj48sijT0qpe8J4+cjS7DTMUBDQWm/dYTFO0zfMzDScE8pLLYaj//Osfi6bVPFdvyK+ajO14r9LVTZeIxMGVMrjiXjiX6vcozi/mgYr1aNx5OcdtxKwkbp93XYwWYOAGAzB8MwDMMwacIrEwzDMAyTImzm6IInEwzDMAyTKmzmAACeTAwK0zOFXXFrcwmqK7a5UTnHgu2msrZEthHX6Yi/xf+qRbx7pA7bVA0FOObbf4GIqx93Fz6Pdwy2qVIbq7lZ2Ddj+/CQcZ+Cbawxr7CbNkWwDdiViW25cnrpXDO+1yPtWD6b2t2dktx2OITb9NeDM/GxWmHj/qETS2/Hpr6Dyr/+7OzENrW7O7NwG6m8s+zTUtWK269W4y/G2CyRIr7BZ0N1bR34WeZJmhROIjNO20Dt7loiTy0TIzZv2b+H2sMNGqIvIp2Xpp6m7QfszoPunWpHVLdh7YWx+aJPfRFsk6f+I7JEtsmOx8tK4itzub0WlX/dPi6x/cIBPH7os5OfgVGL/WjaiPZIkUPoUHSEsEw09SNoacfjIBaQ+tWG+9+5C495c5N4l+j7Sz4bMPaPwj+k5k787PTknfVX4XMdlOrPKDmC6iJEmrtF+pbR71w4jttf0+lMbJ/mqoIRBU8mAIB9JhiGYRiGSRNemWAYhmGYFGGfiS54MsEwDMMwqcJmDgDgycSg8NDM5xPbM//5U1SnV2MfA6qvsLNZxNXPy6tGddU+bE826MW5cibhNL0aYis/Wits01Fif22dhO2kWZ/hemOLaKOnFA8ZnRsfGzMIy5mpFNv3vcTGLetQUNu5bFfvqV7WZlBwt0BDCzbS/37fGaIwAe9LfSicU19LbK+vPBfVudtwzoBOPbaBF2WLNuXYsY2Y2tY/q5fSx5O8CwVZON+DXfIXOUb0RDq92EZPMUgp4uNx4iNBfAFk3YlgAPsnUKwW0Saac0Kdhc9b347t7u2dIldEuQvnLAlGsR9BQCo3tOHzxEJ47GW6hG+JnI8FAOBrFnydR9zjUPmp/UJvIRTAbchz4edhkfJvHHM7UZ2cnwUA4HCryL1DdVd8JNeL3oDHSKhJvC+aAH52xD0BDK2iTYFc/J61TsH9ZGwW49bvwXUlBbj9cSfRrJDe4cYg9vEokbQ6AAD2tgrdlWnZdfi8gO8nGBHflV/O/AswIw+eTDAMwzBMiqgUBVRK6ssL6Rw7nODJBMMwDMOkCps5AIAnE4NOsR0vkTb6iaSuCS+HyxLNNHSPpjMvKxTywttbilBdzREXKqvMwiRSdS1u49irPkHljq9NRWVvsVgWzf0QL3s2zsNLnR3TxVJtoArX6YpwuKpsisl34JTEh0loKK2XJZkLHbiPIRuXZbPHb/cuwO0dh9Mzy9Lb46c+i+rurf0qKu+oLkblo8eEKcaWie/VacLPMi9D9KOZpK1u8mJzSl2raL+ayGfbrHhMUGlrpxHXy0SJHLUcGuq14KVymn7dFxD1lXW5qE42gQB0N2X4pRBPatagoZWdUrinxoDNb9MrjqHynSWvJLZpGvH1LdNRmYYPy2Ydataw6bF5QjZt0LFXRdKKy+M2RKTz28O4HK3FYzEumSPth3A/5WzB72HHOBKOK1H2mz2ovP9REVKuihFz6GGcKjyvFD+7MwpEOKg7gp8V/V7ZjWIchEgoaHMAj3H6nWRGHjyZYBiGYZgU4WiOLngywTAMwzCpwmYOAGDRKoZhGIZh0oRXJgaZr+bsQuXH9n8RlanPRIlVhFftbstHddOzcHjVYa8IO/MTm3bF2AZUllN6Nx/Fdt3aH2B7sv0otk2bpNDQUBYOh7TW4X0BRDs6puAw2FA7PrZRCgfLdOJ+yLdhm3BDJ/a/yJHSN9P06wV27F+RJ/lQNJHwwmd3zcNtmiDqr3a9j+p+V/YaKm/ImITKfzoyN7Hd2krCSNuwTdsopcR2kTBSE0l1bpdCCmmIKU1x7yGSzbUk7bUMTUkuYyZtcFmwD0i2WUiUh2L4MxIhvhh+IoPd0in6IuDB7VURn5DsHPEsv1O+BdV9z1GJykejoi9uqjsT1f1rH35WGnIdeYxQHwk6vmQ/iHoyLnNJWvGOoLi/NjceEzEv+fyacZucO4WfhLUev2chF+43U4t41wLZ+Ly1y6bg63rEvgVlOARbn4ev0+bDfhzyN6fMilPCf9JagMrjnUIKPRLHIajNPvw+XD3uPzBSYTNHFzyZYBiGYZhUYTMHAIxCM0dZWRmoVCr0s379+qFuFsMwDDMKOb4ykc7PYLJ//3648MILITs7G+x2OyxYsADee++9Ab/OqJtMAACsXbsW6uvrEz/XXXfdUDeJYRiGYU46X/va1yAajcK7774L27dvh+nTp8PXvvY1aGho6PvgfjAqzRw2mw3y8vL63vEkcPWED1D5xbqbUNkbIRLTOmGv1RFJbG8U257lFOW5Juxj8L8jFagckSSCCyqwnbQ5E9tyC97DdtPD3xJ299ytuE3Waj8q+3KFDdnQhO2kYQeegqvtwhejnaatJuQQW3RTp2hznh3fO7Vxy1oAqkzsT+EmugZvbJ+W2G6YjO3h52R/hsrXOA+g8vlTdye2N7TPR3Vv1GCbvdst7rfGizU1VETm2mAW/gsOC9aNMOmS+1CYpDTvydKRA2DdCXoeqgfhC4ux6A3gMRzy430VKuOtFe2QJbABABYX70XlKzI2J7aLtPg6z3jwGH+tSTy7XXtLUJ0lh+h+kFTuVslPgo6fZGOP+kjIvkkAeFyrSf/HgyT9txv/baeKi2dgPobfM28Zfl/qF4h9J/zejepaV2H/ijKX8MuqqsF6NDoTHk9nlB9GZVlLgn6P6PcK7Uu+c9QHh34nRxTD2MzR0tICBw4cgCeffBKmTet6P9avXw+PPvoo7N69e0D/nxyVKxPr16+HrKwsmDlzJtx///0QjUaT7h8KhcDj8aAfhmEYhjkRBsLEQf8PCoVCvV/wBMnKyoIJEybAs88+Cz6fD6LRKDzxxBOQk5MDs2fPTvv8MqNuZeL666+HWbNmQWZmJmzatAlWr14N9fX18OCDD/Z6zLp16+Cuu+46ia1kGIZhGEFxMVbUveOOO+DOO+9M65wqlQo2btwIS5YsAZvNBmq1GnJycuDNN9+EjIyMvk/Qn2spyvDPMrJq1Sr4+c9/nnSfvXv3wsSJE7v9/qmnnoIf/OAH4PV6wWAw9HBk18qEPAv0eDxQXFwMHR0dYLf3HlqXCr/euxCV/1A1F5XHOoUJQqvG5obKNixbPCenJrF9uDML1Zm1WFa5PSRCvKoO4vMAWVbXWPFKzpilnya225bh9up9+FjbAWFyaJlNskVOJkNNWhdT52AJZkoWCR21GcTzauzEZhoaViovWxeRDJc0rNEjZUVsa8btp0vAZ1YcROWLskTo4jlmvO+xKG7/Rr9Yon+lCYfm7m/BksYBn1hOjkf7WExMEu5JzSfdDpWrk5yn62RiZ7UOL2+bzHjsjc9uQuULcoRk+UIzXkYv0uJn+ZZkMnmhFY+99w/hzJ/RoHiWckgpAIBFj9tEQ2xliWwq3d5Expds9qBmjVYS/qmSlv5jDTjMki5vZ+zBfZ69XbTDMwGb3IJOIs/+wr7EduUvylEdNTNBRJSLSWhoNglV9xNTRoVNyGtva8L/+U3MxJmLo1I46EE3zvq7tAyH+d4waSMMJB6PBxwOx6B8w+k1Zl90N2h1xr4P6IVoJAjbX7gNampqUFsNBkOv/2ed6P+JEyZMgCVLlkAkEoGf/vSnYDKZ4Pe//z288sorsHXrVsjPz096jv4wIlYmVq5cCcuXL0+6T0VFRY+/nzdvHkSjUaiqqoIJEyb0uE+yh8YwDMMwvTFQOhN2u/2EJz4n+n/iu+++C6+99hq0t7cnzv3oo4/C22+/Dc888wysWrUq9YYTRsRkwuVygcvl6nvHHti5c2diaYdhGIZhRjon+n+i39/luKtWk6R+ajXE48kdsvvLiJhMnCibN2+Gjz76CM4++2yw2WywefNmuOmmm+Cyyy4bcPsQwzAMwwznaI758+dDRkYGLFu2DNasWQMmkwl+97vfwZEjR+C8884b0GuNCJ+JE2XHjh1w7bXXQmVlJYRCISgvL4elS5fCihUr+mXGOBn2tuP83/+uQWXZziiHiQIAuMM4jDEu2bWptG2dH4e31XhE2UbSVHcEsL3PXY/v2VQr5pzWahJ62Ir9OmJG0SZTA25/22Tc/vZpYmasimC7riYPh+7FiQ0/W/KhkP0nALr7UJRlSKFwJEW0hfSFXQoR9BIZ6A4SRuprwuF51lzRprn51ajuSxk45PGrZuHvYlbjUMq6KL6fT8IifGuLF5vzqvzYV6YxgG3rcghnjMhcx8mbr5F8Kmif0tDjCouwtc+xHEF1U/U4fp2GdPrjwl/hdT+2u7/vxn5PH9aVJra9jfi50nBPhxTuaSVp3TuIzHggjPu8PEO8P4fbcagu9cFpD4px0FdIc7xBXFcx4A7P+BQ/j8w9eMwH8kS/qSP4WL8Lh5UGXOL98Fdgf5DCYpxGXMZHZPhLne2onGvC/iM1vt7/KMs0kPBVKRyU+n+9dMZjvZ5nIDiZPhOnfj19n4mtf79t0Nq6bds2+OlPfwrbtm2DSCQCU6ZMgTVr1sDixYsH9DqjamVi1qxZ8OGHHw51MxiGYRhmWDBnzhz417/+NejXGVWTCYZhGIY5qQxjM8fJhCcTDMMwDJMinDW0C55MDDEXuHai8m8OnZ3YnpKFbc8uI44Br2wXESrFFuxToNdgrYgp2eJcH1WXobowSQ3uKsZ2U7dDxMdn/At7AB9biG302Z+K64aysD02Yz+2w8f14rodk7BNNV6L/RPUhdie3CLF88cd+N6pxPHhVuFXUJKB763Fj23edVLKbprKXG/DbbSZsDaGxy/u59092Pb/vh5rIrxQItLJj7E2o7pTrdgHYZbxWGL7vJwOVKdTYdt5SMH28qAinke8D/conUotbWuS7AkQk851LIavuTWI/SAe9WLdgyM+8Tw+OVqE6uIRfF2zQzz3vFJs+zdq8RjXS3b5OpJ6nfrGyD4SAAAHW4UOAtWZkH0kAADakvlJ1OF3KS6lFXfsxZ/bjP14/IQz8Pui9Yljm2dgH4/ijdiP4+BNot8KiGR87VHsV6NziPfwtNIqVBeM4etQ2gLiWzA+A+uHaMj/inVe8QyuHTOC5bL7QlGISEsKx48CRqWcNsMwDMMwJw9emWAYhmGYFGEzRxc8mRhilo/fjMo7fJcktrc248yHpTa8RF9uF0u1O4i07bzco6hc7RchXVML6lCd14VD9/btL0RljU0sY1etxCO/4nu7UPnIzVMT2/mb8NJyxIqHW9YeeZkXLw93TMAmBSBmD1WBOJYuO9Plb6tRLOvSEMFIFC+rF0ty2zWSxDIAgEmPl/OzzTg0Ub5u0IyXsIMkFPHTo6KPP/GXorq/m2egstMprjM2k8gfG3AbTGoS6qoV7dCpSJ8SQop4Pt4oHhPeGC43BsQS9lE3DhfscGPZaCWAn7vKLPrJ4cDhhGZijtBrRJtNRAKbmqhaI+I6pcScVd+JzXHNARLWK40RfwQ/qzYqkS19/RVq1iDhn7JpI2sPNvNFzXjsaQL4+TSeKvq8+MHtqO7oH8ejMkhdU1eFpasnjK9FZTnkvC2E+6HEgvttayP+Bo3JEONPDmMHADjUicfBablVie3vjv8fjFrYARMA2MzBMAzDMEya8MoEwzAMw6QImzm64MkEwzAMw6QKR3MAAE8mhh0PzXw+sf3FjT9GdVEFW6XkUDiXBYdDyj4SAAD5JhFSWB/AUtvHiG/AlIk1qHyoWdhggx7iX/Ewtt1OXFmZ2D58A87SWvgB8aGwSPbk3djHQB3B1+kYj1+4WLMkU2zCtuYmksZapxP1NEQw04Jt9tWS3HahA4dhUo514H6UQ+NyrPh5WEkKbJtko48QmetQBL+Wsr/F9ipsw44TfwSI9ZE6PFU0uP/VJuH3YDThe3NmYD8OQw72YdFJabkNxL9FTQzIDZKvA5VUz7Pj8MgMozi2qg1LYrtIuLAsMw4A4JdkpaMkzXvMS3w+gsJXQE26O2M3PjZjnxjX1GdIS3wk6k/HY75knUjTXfXcJFQXIuHcxgxxnYnk/aV9UZElQmzziVz2Mb8TlbOIX5BWJZ5dmPhMUF+l38x6DpjPDzyZYBiGYZgUYTNHFzyZYBiGYZhU4WgOAOBoDoZhGIZh0oRXJoYxFxXh2PJnjpyGyhMzGxPbNEW0LLUNAOAyCJtxFtEmcOZjv4FNR3Ca6zxJnrdDi+28NC105YNlon3X7UF1VTecgs+7WfgNhB1Eg2I3ls9WxbDORKckzUAys0PkGI6d15aJvmlpx3oDmizsFyHrHFCbcDNJbU5lly1acayc8h0AIES0C2Qp7gwjvlciuQERqR2RGG5TlPhb0D9yZD8DhfgcqJKsr6pJHfXEkOt1GjwmdOrkehay1kdbB5a91hO7u6wX4SMp4evJsbJfBNWrCJN+o9oRJrPkw0LGD1jJ/XlEb9iwnAtk7sXPMugSbdYEsBR97Rexj0TFL3aj8v5nxfsSb8b7mvOwD0iWVbzD++pyUd388sPQG9QPpcmH+2WS9I0BAIhJ+1d1uFDdpWVbe73OaIbNHF3wZIJhGIZhUiWudP2kc/wogCcTDMMwDJMq7DMBAOwzwTAMwzBMmvDKxDDmuonvovIe31JU/rhF5HeQ83QAAEwk6YF3teYntme6jqG6jgh2Ojh7zAFUfu+QSJ+dR9IbR7NICuwmkZdh/+PY92Lssm2oXHPznMS2ayfOu+DPxzZi1zbs26CohU9CvBH7I7hnYnt5oFrSKrBhm3yrB9vHZU0K6jdA7fDUX6G6w5nY1qjxsWOzcE4NX1TY0hu92E5N/Stk3wbqU2Ah+UKo/4KsC6BRY5s9Rbafx4imSYC0ySvpMlA/DuqLYSB+Nk6T8CvINWPbf20n0UCRtDwyzNgfQc6nQdsYILlQOohjTSyI2+xvFv4XcSfuY8dO7Kuhjoj7o+OycyzxyQmKfetPx+epeHgfKlc+PBaVoV3cg96F/ZpkHwkAgPpW0U9nkfe3k+RZcehEP37cjFPAT8lqQOVQDP8XccQjNCvm5lSjuhWT3obPIypI02diwFoytPBkgmEYhmFShRUwAYDNHAzDMAzDpAmvTIwgHp/9B1T+8nsrEtueCI4ntAOWp65wCgnd3W35qG56Fk5J3hDAS7VnVhxMbP/7MF6KzSehlc3StmzyAACo+hOW1y5fvjOxXX3DDFSXtRcvNXdMJGGAO0S4p78QXwfieDnZWyJm/nEjnj9Hj2ITg1IiwmZDIfx6aIiktFmHTQyyacNC5LMb/fg6Hr94XnpiBsglMtEOvViWDsbw8n0gisuhKG6zTzLFxOLJ/3ZQJQn3pFLJ2SafVIf7oTmA77XNh59PnVs8SztJ1U77TU4HTsMY5T4EwDLYKrJ2HKsm4Z42fH/qkDjAvgOPH2st3tdSI+7dMw6/K9oAHiMt08TzqPglDpWu/BV+l5QANr0YJNNGjgObg2SzBgDAF6V3tDWE+zuPhI1/0lqQ2B7rxOY3atag3xU5jPnR2X8EhkNDj8OTCYZhGIZJFY7mAAA2czAMwzAMkya8MsEwDMMwKaJSFFCl4USZzrHDCZ5MjGCuLv4gsf3Aoa+gOrMW255RunITltOWbagA3X0o6vzCPjuvrArVbanGKbELJR+KJhKK6G8lPhTPjElsl9yP7bqt07DdPU5GqqpC1Os6ic/BFhy+CmrJ3+IYPlHHBHxsvFmEEMp2dACAaBb2DWjV4vsJBiRbO3bx6BYuaTaIc5mI7wX1DWiXbOAdAWzDDhMfCfpdohLaJwptL/VBaNeKfrKTEE2KLUkIJ/Xj8JNye4fwdQiaSWp2Lw55VLdK/hUG0hFGPBadu0m/SfeX+yEeP6FsHFbqKxFtCltxeyPENaPwPfGuHXqiFNUpXtyplhz8XmZbRbmO+EjQ97A1JC5cZHajuu0tOPwz3yLuj4Y/Uwn51gAe4zeP+XyGfyYl/v9/0jl+FMBmDoZhGIZh0oJXJhiGYRgmRdjM0QVPJhiGYRgmVTiaAwB4MjGiuWisSFFeF1mI6p49Mg+VJ2QKeW2rDtuwo0Q6OZkPhew/AQAwqxhLc++oEfbZipxWVFcVI/bliLDPHroRVYFhF7Ynl/4eSwRX3i6kukv/id9G9wTsb+H6WMTrB7OxhoAmhG3EEbO4buc47E9BdQD8buwYETcI46ffgP0gwiGsB4HqzPh5UJloneR7QjUpqG8DlfGWofZxSrJ05TSxoXydCPFzoD4f3iD2bQhIviXUo0NP+i3aIfb1NWJ/EYX4QcT1ok32/fhZUf0HcxPWzTC2CB8jz1g8fiz1+HnUninaUbFmO6qrXjUHld2LpPZFcZuMdnxemtL+aJOQrp5VUoPqqP5DiVmkav+4tRDVZZmw9Lb8/sfJu3/EnYXKl5d/hMryN4f5/7ACJgCwzwTDMAzDMGnCKxMMwzAMkyKsgNkFTyZGCTdM2ojKHbHzUfnl6mmJ7VOy61GdU4+zMdJlatns0Zf09mmlVYntzUdw1tAJBY2ovGe/MIkUlGCTSF0FNgtUPlCMz/ULEYLaPs2J6qgN0p+Hl9llXFvceN8ScT/qCH49qKOUF0fFQtwi6gP1eKlc48eLgDGTWKLvjOI6+m2RTQ7hMG5TjJiOBisDIW2TWjK9GAxRSIbPg5fkwSOerSZAspOayLOSTEeaIL47xz5sNlDUkiR2NW6TuQaHHneOxSaqQI50XXKzARfJ9vlXYY44+PQUVBfrxNd12YWJobkmA9VNnIgzdO6ry0Xl+eWHE9sekvWUhn/Kpg2HAUuUZxpwyKlG+t9rb2sOqruw5FNUpt8VpgfYzAEAbOZgGIZhGCZNeGWCYRiGYVJEFe/6Sef40QBPJhiGYRgmVdjMAQA8mRi1rDnlVVQOxv8vsf2vY5NQ3QxXLSpnG3G6YzmksC/p7bawkN+Vbb4AAB83YFnfSePEdfcewOFshcSHorYuE5UPrhJ2ePNH2FpX+AxO9Vz1I2HXztqDQyup7Vz+KyFnG7azK1rinxAnqc+PiNcpYsX2/WAO/mAocjpzH34NvSTkVBUT51JF8XkVHT5vXJPkOn0ZNaVdVXF8HVWEhIpKZT9pg0LCU2kIJ8j7Y3M+2A5jPwidVzSaRDFC1i4c8qiKSqG5RfjZdI6jfYrP1TpZXLf0V5+gutofTEflpm+KfWMd+Nk583F4p+wnMWE8fs+OtmMfCvq+yOnmC8wdqO5T8h7KqcGpj4RBjW92Z7N41xYV7UV19LvBMCcKTyYYhmEYJlVYtAoA2AGTYRiGYVLmuJx2Oj+DyY4dO+ArX/kKOJ1OyMrKgu9///vg9Xr7PrCf8GSCYRiGYUYhdXV1sHDhQhg7dix89NFH8Oabb8KePXtg+fLlA34tNnN8Trh32kuJ7bjyDVT3du1EVKY+FLINVq/GcfTUh+KUTKFhESZ5w8dkYj8IvUacS2fDKdO1JH05xLDNvsgl5IOrJmEdAN+j5ahc/qiwrWvdOAb/4OXYbp25S2yrc3Fsf8SM596OQyTNe6s4d6AQ56L2u7EvQMwgytSbO67B9xp2yNvER4Kk2qY+FKCVTk5FKIhfhNzHClXSwc1HPhTGJtwvepIBXkV1NCQ9CG0wucy1+Zj4C4qmAu8sxWW9V9xr2IKv2ToNFWHcH9pR2dgsfHAO/m4cqou6cZsKnKJNdW6soZFpwX4cPqcYm3Y9HnvGTHxeDenzDL04F/WRyDZhvwi7pBWTzEcCAOArhZWJbfm7wKTIMHbAfO2110Cn08EjjzwCanXXO/H444/DtGnT4ODBgzB27NgBuxZPJhiGYRgmVRQASCe88//PJTwePAs3GAxgMPQuuHcihEIh0Ov1iYkEAIDJ1DUJ/+9//zugkwk2czAMwzBMigyUz0RxcTE4HI7Ez7p169Ju25e+9CVoaGiA+++/H8LhMLS3t8OqVasAAKC+vr6Po/sHr0x8Dlk//UVUVqv+D5XfImaPiZlCBtusxVkdS214ufjjZhH+OdOFM4rmmvDMuz4g1u/PIGFxO0gYaXFJCypXHctObBeU4bqGZpzZ9ND3xJzZbMfr9RmvoCI4/7A5sV276nRUR1TGwdhOsmOOERLa8lI+AIC1FveboQVLmMvEzNhsE8gR5UAWnf+TcFWyYqqoxf3S9lOzh6ISv1DH6Il6bS6YWvGyuqkRZ8PUBPC9g/RXUigLmwnC5Pl0jhXy5npibugsJeYTlSgXrduE65bPR+WaO0kGWI9UjuKbdZXiMV4nhSmXVjShunY/Nr2cUXZE1IVwuCp9Hyjyu1ThxCZCbRKlI2rWoOGfbNoYntTU1IDdLkKYk61KrFq1Cn7+858nPd/evXthypQp8Mwzz8CKFStg9erVoNFo4Prrr4fc3Fy0WjEQ8GSCYRiGYVJFgTR9Jrr+sdvtaDKRjJUrV/bpRFlR0ZUb6dJLL4VLL70UGhsbwWKxgEqlggcffDBRP1DwZIJhGIZhUmUIHDBdLhe4XK5+HZOb25VI7qmnngKj0Qhf+cpX+n3dZPBkgmEYhmFGKb/5zW/g9NNPB6vVCm+//Tb8+Mc/hvXr14PT6RzQ6/BkgulmQzWqcfryV2qmJrbLHG2ojtpup2SJtMo0nC3fgm3EchrllhAOpRyTif0gKA1GsRxo1GJbetyH05fLdu36dryM2HwGPtZ/gZDeVm1GVVD6AvYBCY7Bfxm0TRJ2d8sx/NeGlqbazhf3GzVT2z++riYszmWrwe3VBrC/giwp3fULSYo7jtukitGYVFl6m8hnG7CPQcQqPh0xA26/rxD7QagUXNYGxHUVEnIasuHr+vPFufM+xPde+mf8PI5+W/gY1L6EU4P72rHfhpGkbi8tFOOt6hBOBW4rwD4gbpM4V7YJi/9kGnHIZkCSxKZpw+sCeCw2+m2oLL9LoRj+VIfjuOOqOsRYpGnEWSJ7kIlD97Dr/h4/iGzZsgXuuOMO8Hq9MHHiRHjiiSdg6dKlA34dnkwwDMMwTIqkq2I52AqYzz777KCe/zgcGsowDMMwTFrwygTDMAzDpMowVsA8mfBkgukGtbE6NAsT289Vz0F1cupjACwZPM7ZjOqaAtgmvEOKo59FNCkohzuzUFnWpaCaFHmlOCY/LjkhROtwrL+1DPtxWAxCIrupBPsjVN6N26BgEz7kvSmMn/YXd6A6tRNrX3QuEGFZrVPwAqEaq3SD47A4rwYrMkPEhl9hmqYbubSQbxZdXpV1JvqyAaskHYqIGe/cOo2kSSdp0V3bRSMz/12D6swNjajs+aYYb1VL8XnUWvw8Yh3igRSa8bjUEHl2bxV+HjG78H2g46fFi/155LHXSMZ0mRX7FMlsaSpB5Wwz9q8YT94X2d/CE8Z+J+1BrGextGxLYvuGSRt7bQMzCPBkAgDYzMEwDMMwTJrwygTDMAzDpAqvTAAATyYYhmEYJnWGeWjoyYInE0yfyDbYAt1sVPdk7QJUruoQeQsqHNj2nGnA6ZmdBmHXlv0nALrbkyts+FzeqMhXUejowPta8b7/qxMpyXWF+LzFTjcq7z0saWMY8VtenofPe+QY1pmoXyhs9i0XTkJ1Vgt2dmivE3+N2HHqBMjZjvtJ/d+diW0NkduNTsWSuFELfqU1ftEmFcm3oWixlTOuU0t1+Ouo9WKdBu2BusS2kWQ7dOwfj8rNs6yo3Dhf9KvvW/h+An7cp1G5/YAZm4/zYuwL5Se2a6X8GQAAk8rrUPlIIe6nzqDIg3BGwRFUd9hLfDMkHxzqI1HtwyntWwPCR2d8BvaJoFAtCfldshmw1sXNY95G5YvGbk96bmbwGO6hoScL9plgGIZhGCYteGWCYRiGYVKFfSYAgCcTTD+hy6kXjcX1126/LLG9uaEU1RXbsTnCKKUzH5+Bl6xbgnhpfFtTMSrLadHpUrM7gsPmZDNIrrET1dUTSWOdWbSpMNuNzxvA4Xngxa+PtVCcu8COl/69EZxW3OsUZg/PZJxq2DMdn1d77QyxrSPy2SocnxomYaWxkCS7HMeGApUOm3G0enHvej29Dv7ghSSTQjSMn40SwFLPqgi+jsopGqklIZtFLpzuu7lTjAN/HR4TrX4csllRIsZQTTM2N1BOK67C15HGGx0/dHzJJjY6LnMsWF57ojSu5VBPAIBgFJdrPDhcdV5edWL78dl/AGaYElcAVGlMCOKjYzLBZg6GYRiGYdKCVyYYhmEYJlXYzAEAPJlgGIZhmDRIczJBpWlHKDyZYAaUR2f/MbH94N6voLpX66ehcoNPSBGPdeKU4049lkPONmJbdHWnCJuLxLG17pTMelS264R/gmzv7olpRbWJbZsOh+Nt9+HwVXMBbtO4LBH6FyW5tQ83ZqNy1C21w4D9BuyZOHw1zyZ8MaiMsj+E70evxz4UaqPwg6CS0hT5k6bQPOgEh1X0qUmHw0ZbOrEvQ6AJS5hDq/ARwV40+F4BAMZnC5+D/WTfUBT3caHFndjOIGHIfvLcY+T+SiztvdZ90lqAyjqpH2XfHQCAONEzj0ipwuVQTwAAoxY/q++OwTnvr5v4LjDMSIEnEwzDMAyTKmzmAACeTDAMwzBM6sQVSMtUwdEcDMMwDMMwvDLBDCIrJr1Nyrj+RzsuTWx/2FiG6gqsWKfBrMUCCiU2EfuvU2FfgMOd2D+hzS/8DMqdWDOg2IJ1DWTaw9jWT7UjckzYvm9QC20GmjLdaMLtD2tEmx1W7B+SacL2flmLwRvAmhSBTlyGKPn7QC3+6qG6Eio1kdeOqaRtmssc7xuzCX8S2t58J+4ntwHfu6dT9CvtFyopXWgWXhWz8nG6cprSPijpOGQZsN8JLbeGsF/H3ta8xLbdiKXPaWpw2Q8iGsd+G9Q3o7ZTaEeckX8Y1T0083lgRgFKvOsnneNHATyZYBiGYZhUYZ8JAODJBMMwDMOkDvtMAABPJpgh5DeznktsP7X/DFT3WjMOIz3oxqYL2QxiJSGcucT8IIf9NYewJPMnLYWoLIfrldtxltBsslROQwh9UWFyoGGllky8nG/UiHBKNTEhaInZxhMRMt5aLZa51ptxWCb9I0ejUaRtYuYg15XDQaPEXEJDRXVSO0xa3AYalplrwp+ZeKY4FzULaFX4/mQJaosW9ynNJCvvu78jB9dFsHQ1lb2eli2yiobiuL0RYsrwRsRzrvNiOfYSOzabXTdWhHcuH49DPxlmNDGiHDDvueceOP3008FsNoPT6exxn+rqajjvvPPAbDZDTk4O/PjHP4ZoNNrjvgzDMAyTFsfNHOn8jAJG1MpEOByGiy66CObPnw9PPvlkt/pYLAbnnXce5OXlwaZNm6C+vh4uv/xy0Ol0cO+99w5BixmGYZhRjQJp+kwMWEuGlBG1MnHXXXfBTTfdBFOnTu2x/q233oLPPvsM/vjHP8KMGTNg8eLF8LOf/QweeeQRCNN0igzDMAzDDAgjamWiLzZv3gxTp06F3NzcxO8WLVoE11xzDezZswdmzpzZ43GhUAhCIWGP9Xg8Pe7HDB7fHf8/Usb1v967EJVfaxATyuoOJ6pzWbBvQ4FFhBdaid09i0hXy6GJ1V6cxrozhMMwaUhksSTnnG3ANvk48TmQ5bZpampfEsnvIgcVoMYk879Qq5KHoMlS0FEiC03bL0P3pe23kLBek+Qvkq3H/U+R++aoF8tRtwVw6K7NIJ5tvhm/w1o19sWgIZ1xEPfXHMB+Nc0+HEYqj6+lZVtQ3Q2TNgLzOYOjOQBghK1M9EVDQwOaSABAotzQ0NDrcevWrQOHw5H4KS4uHtR2MgzDMKOEeDz9n1HAkE8mVq1aBSqVKulPZWXloLZh9erV0NHRkfipqanp+yCGYRiGYQBgGJg5Vq5cCcuXL0+6T0VFxQmdKy8vD7ZswcuOjY2NibreMBgMYDAYeq1nGIZhmB5hMwcADIPJhMvlApfLNSDnmj9/Ptxzzz3Q1NQEOTldceZvv/022O12mDx58oBcgxkaqC36Bkma+/F9Z6K615uwg+7ulvzEtp6kfS63Y3lt2XZO7e4lVmx3pzoT9QGhOUBThcdImnQ5HXgW8b1wEX8Lh5RCnfo9aIiPhDqJa3hfPhMyNJW23C8A+N6p/0GEHFvvx1oMbqlvqC+GXoP72GkUUuNUvpw+H1kPgp6X3k91J/aHCUXFp7DQhv1Srh73H1ye8AEwTAKeTADAMJhM9Ifq6mpoa2uD6upqiMVisHPnTgAAGDt2LFitVjjnnHNg8uTJsHTpUrjvvvugoaEBbrvtNvjhD3/IKw8MwzAMM0iMqMnEmjVr4JlnnkmUj0dnvPfee3DWWWeBRqOB1157Da655hqYP38+WCwWWLZsGaxdu3aomswwDMOMZlhOGwAAVIoyStZYBhCPxwMOhwM6OjrAbrf3fQAzYrjp42+j8o42HLnjlcI/XURy2a7H2SSp7LVMX+YI2UwQJKGhslwzAIA/IkItg1EiTZ0kZLN7m5K/6lReW4bKacsYienIbsD9RDO+yqGh1CxDTSTUhCJDTS+esJAdb/bh8E6rAYcET8+sRWXO4Dm6OBnf8OPX+HLGMtCqew/n7otoPAzvtD8z4v+/GVErEwzDMAwzrFCU9FYXRsnf80MeGsowDMMwzMiGVyYYhmEYJlWUNH0mRsnKBE8mmM8Vv5z5l6T1cpjp9s5SVLfPjdVVPUHs26CX0nLLIY0A3cMYdZJPRZxIPTv1+NhMktJbJp1QUQr1QZChYbA01BLXJffjSBbC2RrE0tVyiG00hq9pN2I/iAnOxsT2krydqI7DOZlBIx4H6EfYdTcUVsBkGIZhGIbhyQTDMAzDpMxx0ap0fgaRe+65B04//XQwm83gdDp73Ke6uhrOO+88MJvNkJOTAz/+8Y8hGo32uG9vsJmDYRiGYVJEicdBScPMoQyymSMcDsNFF10E8+fPhyeffLJbfSwWg/POOw/y8vJg06ZNUF9fD5dffjnodDq49957T/g6PJlgGIl0bOt37LowsX3Al4PqDnVko3IgIrQlaFSZToM/LnJqbZM2guqoT4Reg/+akLUl6L7JdCeoL0OY6D2E4+LTEYhinYyOoBGVqa+DrGdhM2ANiiKrG5W/4DqY2F5zyqu9tpdhmJ656667AADg6aef7rH+rbfegs8++ww2btwIubm5MGPGDPjZz34GP/nJT+DOO+8Evf7ENDTYzMEwDMMwqTJAZg6Px4N+QqFQHxceGDZv3gxTp06F3FzhYL5o0SLweDywZ8+eEz4PTyYYhmEYJlXiSvo/AFBcXAwOhyPxs27dupPS/IaGBjSRAIBEuaGh4YTPw5MJhmEYhhliampqoKOjI/GzevXqXvddtWoVqFSqpD+VlZUnsfXsM8EwA8ZdU18ekPP8/LNzUbklYktsuyM4tbkvSvJ4EP+FqCJ8HaLx5H87yD4UejX2vTASX4wsgy+x7dRhXYxcHdbUuHnyv5Jel2FGNIoCAOnoTHS9d3a7/YRzc6xcuRKWL1+edJ+KiooTOldeXh5s2bIF/a6xsTFRd6LwZIJhGIZhUkSJK6D0kUQv6fEphIa6XC5wuVwpX1Nm/vz5cM8990BTUxPk5HQ5jr/99ttgt9th8uTJJ3wenkwwDMMwTKoocUhvZWJwQ0Orq6uhra0NqqurIRaLwc6dOwEAYOzYsWC1WuGcc86ByZMnw9KlS+G+++6DhoYGuO222+CHP/whGAyG5CeX4MkEwwwzfjL5zaFuAsMwo4Q1a9bAM888kyjPnDkTAADee+89OOuss0Cj0cBrr70G11xzDcyfPx8sFgssW7YM1q5d26/rqJRU1lhGOcfz1I/0/PIMwzCfR07GN/z4Nc5SfR20Kl3fB/RCVInA+8rfR/z/N7wywTAMwzCpMszNHCcLnkz0gCKJiDAMwzAji+Pf7pOx8B6FSFoZyKMQ6XunEQBPJnqgs7MTALpERBiGYZiRSWdnJzgcjkE5t16vh7y8PPhvw+tpnysvL++EZauHK+wz0QPxeBzq6urAZrOBSqXq+4B+4vF4oLi4GGpqaka0jWyo4P5LD+6/9OD+S5/B7kNFUaCzsxMKCgpArR48bcZgMAjhcLjvHftAr9eD0Wjse8dhDK9M9IBarYaioqJBv05/REqY7nD/pQf3X3pw/6XPYPbhYK1IyBiNxhE/CRgoWE6bYRiGYZi04MkEwzAMwzBpwZOJIcBgMMAdd9zRL3UxRsD9lx7cf+nB/Zc+3IejD3bAZBiGYRgmLXhlgmEYhmGYtODJBMMwDMMwacGTCYZhGIZh0oInEwzDMAzDpAVPJk4y99xzD5x++ulgNpvB6XT2uE91dTWcd955YDabIScnB3784x9DNBo9uQ0dIZSVlYFKpUI/69evH+pmDWseeeQRKCsrA6PRCPPmzYMtW7YMdZNGBHfeeWe3sTZx4sShbtaw5d///jecf/75UFBQACqVCv7xj3+gekVRYM2aNZCfnw8mkwkWLlwIBw4cGJrGMmnDk4mTTDgchosuugiuueaaHutjsRicd955EA6HYdOmTfDMM8/A008/DWvWrDnJLR05rF27Furr6xM/11133VA3adjyl7/8BVasWAF33HEH7NixA6ZPnw6LFi2CpqamoW7aiGDKlClorP33v/8d6iYNW3w+H0yfPh0eeeSRHuvvu+8+eOihh+Dxxx+Hjz76CCwWCyxatAiCweBJbikzICjMkLBhwwbF4XB0+/3rr7+uqNVqpaGhIfG7xx57TLHb7UooFDqJLRwZlJaWKr/85S+Huhkjhrlz5yo//OEPE+VYLKYUFBQo69atG8JWjQzuuOMOZfr06UPdjBEJACh///vfE+V4PK7k5eUp999/f+J3brdbMRgMyvPPPz8ELWTShVcmhhmbN2+GqVOnQm5ubuJ3ixYtAo/HA3v27BnClg1f1q9fD1lZWTBz5ky4//772STUC+FwGLZv3w4LFy5M/E6tVsPChQth8+bNQ9iykcOBAwegoKAAKioq4Dvf+Q5UV1cPdZNGJEeOHIGGhgY0Fh0OB8ybN4/H4giFE30NMxoaGtBEAgAS5YaGhqFo0rDm+uuvh1mzZkFmZiZs2rQJVq9eDfX19fDggw8OddOGHS0tLRCLxXocX5WVlUPUqpHDvHnz4Omnn4YJEyZAfX093HXXXfCFL3wBdu/eDTabbaibN6I4/i3raSzyd25kwisTA8CqVau6OWbRH/5Ynzj96c8VK1bAWWedBdOmTYOrr74afvGLX8DDDz8MoVBoiO+CGW0sXrwYLrroIpg2bRosWrQIXn/9dXC73fDXv/51qJvGMEMOr0wMACtXroTly5cn3aeiouKEzpWXl9fNu76xsTFR93kgnf6cN28eRKNRqKqqggkTJgxC60Yu2dnZoNFoEuPpOI2NjZ+bsTWQOJ1OGD9+PBw8eHComzLiOD7eGhsbIT8/P/H7xsZGmDFjxhC1ikkHnkwMAC6XC1wu14Cca/78+XDPPfdAU1MT5OTkAADA22+/DXa7HSZPnjwg1xjupNOfO3fuBLVaneg7RqDX62H27NnwzjvvwJIlSwAAIB6PwzvvvAM/+tGPhrZxIxCv1wuHDh2CpUuXDnVTRhzl5eWQl5cH77zzTmLy4PF44KOPPuo10o0Z3vBk4iRTXV0NbW1tUF1dDbFYDHbu3AkAAGPHjgWr1QrnnHMOTJ48GZYuXQr33XcfNDQ0wG233QY//OEPOcMeYfPmzfDRRx/B2WefDTabDTZv3gw33XQTXHbZZZCRkTHUzRuWrFixApYtWwZz5syBuXPnwq9+9Svw+XxwxRVXDHXThj0333wznH/++VBaWgp1dXVwxx13gEajgUsuuWSomzYs8Xq9aNXmyJEjsHPnTsjMzISSkhK48cYb4e6774Zx48ZBeXk53H777VBQUJCY6DIjjKEOJ/m8sWzZMgUAuv289957iX2qqqqUxYsXKyaTScnOzlZWrlypRCKRoWv0MGX79u3KvHnzFIfDoRiNRmXSpEnKvffeqwSDwaFu2rDm4YcfVkpKShS9Xq/MnTtX+fDDD4e6SSOCb3/720p+fr6i1+uVwsJC5dvf/rZy8ODBoW7WsOW9997r8Vu3bNkyRVG6wkNvv/12JTc3VzEYDMqXv/xlZd++fUPbaCZlOAU5wzAMwzBpwdEcDMMwDMOkBU8mGIZhGIZJC55MMAzDMAyTFjyZYBiGYRgmLXgywTAMwzBMWvBkgmEYhmGYtODJBMMwDMMwacGTCYZhGIZh0oInEwzDMAzDpAVPJhjmc8YVV1wBt912W6J85plngkqlgnvvvRftpygKzJs3D1QqFaxdu/ZkN5NhmBEEJ/pimM8RsVgMXnvtNfjnP/8JAF0Tho8//hhKS0th165daN9nnnkG6urqAABg1qxZJ72tDMOMHHhlgmFGCUVFRfDoo4+i323atAnMZjMcPXo0UdbpdHDqqacCAMCBAwegs7MTli1bhiYTnZ2dsHr1ali+fDkAAMyePfvk3ATDMCMSnkwwzChh3rx5sHXr1kRZURS48cYb4aabboLS0lIAAHjllVfg/PPPB5VKBQAA27dvB7PZDJdccgns27cPwuEwAAD87Gc/gzlz5oDL5YK8vDzIz88/+TfEMMyIgScTDDNKOO2009Bk4g9/+APU1NTA6tWrE797+eWX4YILLkiUd+zYAdOmTYMJEyaA0WiEyspKOHDgADz22GPw4IMPwo4dO9jEwTBMn/BkgmFGCaeddhrs3bsXvF4v+Hw+uPXWW+Huu+8Gq9UKAAB79+6Furo6+PKXv5w45vhkQaVSwbRp02DXrl1w0003wTXXXAPjxo2D7du3s4mDYZg+YQdMhhklzJ49G9RqNezYsQM2btwILpcLrrjiikT9K6+8Al/5ylfAaDQmfrdjxw649NJLAQBgxowZ8Ktf/Qpqamrg+eefh2AwCJWVlbwywTBMn/DKBMOMEsxmM0ydOhVefPFFeOCBB+CXv/wlqNXiFX/55ZfhwgsvTJQPHz4Mbrc7MVmYOXMmbNu2DdatWwc2mw0++eQTiEajvDLBMEyf8MoEw4wiTjvtNHj44YfhwgsvhLPOOivx+6amJti2bRu88sorid9t374d9Ho9nHLKKQAAsGzZMliyZAlkZWUBQNeqhcvlguLi4pN6DwzDjDx4MsEwo4jp06eDTqeD+++/H/3+1Vdfhblz50J2dnbidzt27IBTTjkFdDodAADodLpu9TNnzjw5DWcYZkSjUhRFGepGMAwzMJx99tkwa9Ys+MUvfoF+f8EFF8CCBQvglltuGaKWMQwzmuGVCYYZ4cTjcWhuboYnn3wSDhw4AC+//HK3fRYsWACXXHLJELSOYZjPA7wywTAjnPfffx++9KUvwcSJE2HDhg0wb968oW4SwzCfM3gywTAMwzBMWnBoKMMwDMMwacGTCYZhGIZh0oInEwzDMAzDpAVPJhiGYRiGSQueTDAMwzAMkxY8mWAYhmEYJi14MsEwDMMwTFrwZIJhGIZhmLTgyQTDMAzDMGnBkwmGYRiGYdKCJxMMwzAMw6TF/wP1rKeecjiTdgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "xy_extent=domain_size/TOV_Mass\n", - "output_grid_x, output_grid_y, output_grid_H_data = \\\n", - " plot2D.generate_uniform_2D_grid(os.path.join(Ccodesrootdir,'out96.txt'),\n", - " 0,1,3, [-xy_extent,xy_extent], [-xy_extent,xy_extent])\n", - "\n", - "plt.clf()\n", - "plt.title(r\"$96\\times 16$ Numerical Error: $\\log_{10}$|Ham|\")\n", - "plt.xlabel(r\"$y/M$\")\n", - "plt.ylabel(r\"$z/M$\")\n", - "\n", - "fig96 = plt.imshow(output_grid_H_data, extent=(-xy_extent,xy_extent, -xy_extent,xy_extent))\n", - "cb = plt.colorbar(fig96)" + "x_extent=domain_size # plot from -x_extent to +x_extent\n", + "sample_numpts_x = 100 # number of points to plot\n", + "interp_method = \"linear\" # Could be linear (recommended), nearest (don't use; gridpoints are off-axis), or cubic\n", + "\n", + "# Data are in format x,y,z, CF,Ham,rho\n", + "output_1D_grid_data48 = []\n", + "output_1D_grid_data96 = []\n", + "for i in [4]: # H constraint is in column 4 (where x is stored in the 0th column)\n", + " output_grid_x96, output_1D_grid_data48_i = \\\n", + " plot2D.extract_1D_slice_from_2D_data(os.path.join(Ccodesrootdir, 'out2D-72.txt'), 0.0,\n", + " 1,2,i, [-x_extent, x_extent], sample_numpts_x=sample_numpts_x,\n", + " interp_method=interp_method)\n", + " output_grid_x48, output_1D_grid_data96_i = \\\n", + " plot2D.extract_1D_slice_from_2D_data(os.path.join(Ccodesrootdir, 'out2D-96.txt'), 0.0,\n", + " 1,2,i, [-x_extent, x_extent], sample_numpts_x=sample_numpts_x,\n", + " interp_method=interp_method)\n", + " output_1D_grid_data48 += [output_1D_grid_data48_i]\n", + " output_1D_grid_data96 += [output_1D_grid_data96_i]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we check that indeed the numerical errors converge to zero as expected, using the fact that the Hamiltonian constraint violation should converge to zero with increasing resolution. See [the Scalar Wave Curvilinear tutorial notebook](Tutorial-Start_to_Finish-ScalarWaveCurvilinear.ipynb) for more documentation on measuring numerical convergence." + "Now, the equations behind these initial data solve Einstein's equations exactly, at a single instant in time. One reflection of this solution is that the Hamiltonian constraint violation should be exactly zero in the initial data. \n", + "\n", + "However, when evaluated on numerical grids, the Hamiltonian constraint violation will *not* generally evaluate to zero due to the associated numerical derivatives not being exact. However, these numerical derivatives (finite difference derivatives in this case) should *converge* to the exact derivatives as the density of numerical sampling points approaches infinity.\n", + "\n", + "In this case, all of our finite difference derivatives agree with the exact solution, with an error term that drops with the uniform gridspacing to the fourth power: $\\left(\\Delta x^i\\right)^4$. \n", + "\n", + "Here, as in the [Start-to-Finish Scalar Wave (Cartesian grids) NRPy+ tutorial](Tutorial-Start_to_Finish-ScalarWave.ipynb) and the [Start-to-Finish Scalar Wave (curvilinear grids) NRPy+ tutorial](Tutorial-Start_to_Finish-ScalarWaveCurvilinear.ipynb) we confirm this convergence, plotting the Hamiltonian constraint violation (which should converge to zero) at two resolutions:\n", + "\n", + "* `Nr` $\\times$ `Ntheta` $\\times$ `Nphi`=$72\\times 12\\times 2$, and \n", + "* `Nr` $\\times$ `Ntheta` $\\times$ `Nphi`=$96\\times 12\\times 2$.\n", + "\n", + "As the data are spherically symmetric, we only need to vary the resolution in the radial direction.\n", + "\n", + "Since the constraint violation (numerical error associated with the fourth-order-accurate, finite-difference derivatives) should converge to zero with the uniform gridspacing to the fourth power: $\\left(\\Delta x^i\\right)^4$, we expect the constraint violation will increase (relative to the $96\\times 12\\times 2$ grid) by a factor of $\\left(96/72\\right)^4$.\n", + "\n", + "Here we demonstrate that when the results $72\\times 12\\times 2$ are rescaled by exactly a factor of $\\left(72/96\\right)^4$, the Hamiltonian constraint violation matches the $96\\times 12\\times 2$ calculation, *except* at the star's surface where the stress-energy tensor $T^{\\mu\\nu}$ is very sharp. This demonstrates that the constraint violation converges to zero as expected." ] }, { "cell_type": "code", "execution_count": 19, - "metadata": { - "execution": { - "iopub.execute_input": "2021-09-23T22:08:53.145680Z", - "iopub.status.busy": "2021-09-23T22:08:53.145274Z", - "iopub.status.idle": "2021-09-23T22:08:53.262908Z", - "shell.execute_reply": "2021-09-23T22:08:53.262372Z" - } - }, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1452,44 +1353,39 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "# Plot settings\n", - "x_extent=domain_size/TOV_Mass # plot from -x_extent to +x_extent\n", - "sample_numpts_x = 100 # number of points to plot\n", - "interp_method = \"linear\" # Could be linear (recommended), nearest (don't use; gridpoints are off-axis), or cubic\n", - "\n", - "output_grid_x, output_grid_data72 = \\\n", - " plot2D.extract_1D_slice_from_2D_data(os.path.join(Ccodesrootdir,'out72.txt'), 0.0,\n", - " 0,1,3, [-x_extent, x_extent], sample_numpts_x=sample_numpts_x,\n", - " interp_method=interp_method)\n", - "output_grid_x, output_grid_data96 = \\\n", - " plot2D.extract_1D_slice_from_2D_data(os.path.join(Ccodesrootdir,'out96.txt'), 0.0,\n", - " 0,1,3, [-x_extent, x_extent], sample_numpts_x=sample_numpts_x,\n", - " interp_method=interp_method)\n", - "\n", "plt.clf()\n", - "fig, ax = plt.subplots()\n", - "plt.title(r\"$4^{\\rm th}$-order Convergence, at $t/M$=1.8\")\n", - "plt.xlabel(r\"$y/M$\")\n", - "plt.ylabel(r\"$\\log_{10}$(Ham. Constraint Violation)\")\n", "\n", - "import numpy as np\n", - "ax.plot(output_grid_x, output_grid_data96, 'k-', label='Nr=96')\n", - "ax.plot(output_grid_x, output_grid_data72 + 4*np.log10(72.0/96.0), 'k--', label='Nr=72, mult by (72/96)^4')\n", - "ax.set_ylim([-10.5,-2.5])\n", + "# We want to create four plots. One for the Hamiltonian, and three for the momentum\n", + "# constrains (r,th,ph)\n", + "# Define the size of the overall figure\n", + "fig = plt.figure(figsize=(8,5))\n", + "\n", + "#Generate the subplot for the each constraint\n", + "ax = fig.add_subplot(111)\n", + "ax.set_title(r\"Plot Demonstrating $4^{th}$-Order Convergence of $\\mathcal{H}$\")\n", + "ax.set_xlabel(r\"$x/M$\")\n", + "ax.set_ylabel(\"$log_{10}$(Relative Error)\")\n", + "\n", + "ax.plot(output_grid_x96, output_1D_grid_data96[0], 'k-', label='Nr=96')\n", + "ax.plot(output_grid_x48, output_1D_grid_data48[0] + 4*np.log10(72./96.), 'k--', label='Nr=72, mult by (72/96)^4')\n", + "ax.set_ylim([-14,-6])\n", "\n", "legend = ax.legend(loc='lower right', shadow=True, fontsize='x-large')\n", "legend.get_frame().set_facecolor('C1')\n", - "plt.show()" + "# Return to Ccodesrootdir\n", + "os.chdir(os.path.join(\"..\"))" ] }, { @@ -1521,6 +1417,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "[NbConvertApp] WARNING | pattern 'Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb' matched no files\n", "Created Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-\n", " Hydro_without_Hydro.tex, and compiled LaTeX file to PDF file Tutorial-\n", " Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.pdf\n" @@ -1549,7 +1446,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" + "version": "3.10.6" } }, "nbformat": 4, diff --git a/Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_Initial_Data.ipynb b/Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_Initial_Data.ipynb index 23398387..c0f9eaa4 100644 --- a/Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_Initial_Data.ipynb +++ b/Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_Initial_Data.ipynb @@ -581,7 +581,7 @@ " Ricci_eval(&griddata.params, griddata.xx, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs);\n", " BSSN_constraints(&griddata.params, griddata.xx, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs, aux_gfs);\n", "\n", - " yz_plane_diagnostics(&griddata, griddata.gridfuncs.y_n_gfs, aux_gfs);\n", + " yz_plane_diagnostics(stdout, &griddata, griddata.gridfuncs.y_n_gfs, aux_gfs);\n", "\n", " // Step 4: Free all allocated memory\n", " free(griddata.gridfuncs.y_n_gfs);\n", @@ -1007,7 +1007,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" + "version": "3.10.6" } }, "nbformat": 4, diff --git a/diagnostics_generic/output_yz_or_xy_plane.py b/diagnostics_generic/output_yz_or_xy_plane.py index 9d431c5a..1a5ef0f2 100644 --- a/diagnostics_generic/output_yz_or_xy_plane.py +++ b/diagnostics_generic/output_yz_or_xy_plane.py @@ -114,7 +114,7 @@ def add_to_Cfunction_dict__plane_diagnostics(plane="xy", include_ghosts=False, """ c_type = "void" name = plane + "_plane_diagnostics" - params = """const griddata_struct *restrict griddata, + params = """FILE *fp, const griddata_struct *restrict griddata, const REAL *restrict y_n_gfs, const REAL *restrict diagnostic_output_gfs""" body = output_plane_yz_or_xy_body(plane=plane, include_ghosts=include_ghosts) printf_char_string = "\"%e %e %e" @@ -130,7 +130,7 @@ def add_to_Cfunction_dict__plane_diagnostics(plane="xy", include_ghosts=False, REAL xCart[3]; xx_to_Cart(¶ms, xx, i0,i1,i2, xCart); int idx = IDX3S(i0,i1,i2); - printf("""+printf_char_string+output_quantities+r"""); + fprintf(fp, """+printf_char_string+output_quantities+r"""); } """ outC.add_to_Cfunction_dict(