Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<script async src=\"https://www.googletagmanager.com/gtag/js?id=UA-59152712-8\"></script>\n",
    "<script>\n",
    "  window.dataLayer = window.dataLayer || [];\n",
    "  function gtag(){dataLayer.push(arguments);}\n",
    "  gtag('js', new Date());\n",
    "\n",
    "  gtag('config', 'UA-59152712-8');\n",
    "</script>\n",
    "\n",
    "# Start-to-Finish Example: [TOV](https://en.wikipedia.org/wiki/Tolman%E2%80%93Oppenheimer%E2%80%93Volkoff_equation) Neutron Star Simulation: The \"Hydro without Hydro\" Test\n",
    "\n",
    "## Authors: Zach Etienne & Phil Chang\n",
    "### Formatting improvements courtesy Brandon Clark\n",
    "\n",
    "## This module sets up initial data for a neutron star on a spherical numerical grid, using the approach [documented in the previous NRPy+ module](Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_initial_data.ipynb), and then evolves these initial data forward in time. The aim is to reproduce the results from [Baumgarte, Hughes, and Shapiro]( https://arxiv.org/abs/gr-qc/9902024) (which were performed using Cartesian grids); demonstrating that the extrinsic curvature and Hamiltonian constraint violation converge to zero with increasing numerical resolution\n",
    "\n",
    "**Notebook Status:** <font color='green'><b> Validated </b></font>\n",
    "\n",
    "**Validation Notes:** This module has been validated to exhibit convergence to zero of the Hamiltonian constraint violation at the expected order to the exact solution (see [plot](#convergence) at bottom). Note that convergence in the region causally influenced by the surface of the star will possess lower convergence order due to the sharp drop to zero in $T^{\\mu\\nu}$.\n",
    "\n",
    "### NRPy+ Source Code for this module: \n",
    "\n",
    "* [TOV/TOV_Solver.py](../edit/TOV/TOV_Solver.py); ([**NRPy+ Tutorial module reviewing mathematical formulation and equations solved**](Tutorial-ADM_Initial_Data-TOV.ipynb)); ([**start-to-finish NRPy+ Tutorial module demonstrating that initial data satisfy Hamiltonian constraint**](Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_initial_data.ipynb)): Tolman-Oppenheimer-Volkoff (TOV) initial data; defines all ADM variables and nonzero $T^{\\mu\\nu}$ components in Spherical basis.\n",
    "* [BSSN/ADM_Initial_Data_Reader__BSSN_Converter.py](../edit/BSSN/ADM_Initial_Data_Reader__BSSN_Converter.py); ([**NRPy+ Tutorial documentation**](Tutorial-ADM_Initial_Data_Reader__BSSN_Converter.ipynb)): Registers the C function for our \"universal\" initial data reader/converter initial_data_reader__convert_ADM_Cartesian_to_BSSN().\n",
    "* [MoLtimestepping/MoL.py](../edit/MoLtimestepping/MoL.py); ([**NRPy+ Tutorial documentation**](Tutorial-Method_of_Lines-C_Code_Generation.ipynb)): Registers C functions for Method of Lines time integration, to push our initial data forward in time.\n",
    "* [CurviBoundaryConditions/CurviBoundaryConditions.py](../edit/CurviBoundaryConditions/CurviBoundaryConditions.py); ([**NRPy+ Tutorial documentation**](Tutorial-Start_to_Finish-Curvilinear_BCs.ipynb)): Registers the C function for our \"universal\" initial data reader/converter initial_data_reader__convert_ADM_Cartesian_to_BSSN().\n",
    "* [BSSN/BSSN_Ccodegen_library.py](../edit/BSSN/BSSN_Ccodegen_library.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-C_codegen_library.ipynb): Implements a number of helper functions for generating C codes from symbolic expressions generated in the following modules/tutorials:\n",
    "    * [BSSN/BSSN_constraints.py](../edit/BSSN/BSSN_constraints.py); [\\[**tutorial**\\]](Tutorial-BSSN_constraints.ipynb): Hamiltonian constraint in BSSN curvilinear basis/coordinates\n",
    "    * [BSSN/BSSN_RHSs.py](../edit/BSSN/BSSN_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb): Generates the right-hand sides for the BSSN evolution equations in singular, curvilinear coordinates\n",
    "    * [BSSN/BSSN_gauge_RHSs.py](../edit/BSSN/BSSN_gauge_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb): Generates the right-hand sides for the BSSN gauge evolution equations in singular, curvilinear coordinates\n",
    "\n",
    "\n",
    "## Introduction:\n",
    "Here we use NRPy+ to evolve initial data for a [simple polytrope TOV star](https://en.wikipedia.org/wiki/Tolman%E2%80%93Oppenheimer%E2%80%93Volkoff_equation), keeping the $T^{\\mu\\nu}$ source terms fixed. As the hydrodynamical fields that go into $T^{\\mu\\nu}$ are not updated, this is called the \"Hydro without Hydro\" test.\n",
    "\n",
    "The entire algorithm is outlined as follows, with links to the relevant NRPy+ tutorial notebooks listed at each step:\n",
    "\n",
    "1. Allocate memory for gridfunctions, including temporary storage for the Method of Lines time integration [(**NRPy+ tutorial on NRPy+ Method of Lines algorithm**)](Tutorial-Method_of_Lines-C_Code_Generation.ipynb).\n",
    "1. Set gridfunction values to initial data \n",
    "    * [**NRPy+ tutorial on TOV initial data**](Tutorial-ADM_Initial_Data-TOV.ipynb)\n",
    "    * [**NRPy+ tutorial on validating TOV initial data**](Tutorial-Start_to_Finish-BSSNCurvilinear-TOV_initial_data.ipynb).\n",
    "1. Next, integrate the initial data forward in time using the Method of Lines coupled to a Runge-Kutta explicit timestepping algorithm:\n",
    "    1. At the start of each iteration in time, output the Hamiltonian constraint violation \n",
    "        * [**NRPy+ tutorial on BSSN constraints**](Tutorial-BSSN_constraints.ipynb).\n",
    "    1. At each RK time substep, do the following:\n",
    "        1. Evaluate BSSN RHS expressions \n",
    "            * [**NRPy+ tutorial on BSSN right-hand sides**](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb)\n",
    "            * [**NRPy+ tutorial on BSSN gauge condition right-hand sides**](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb) \n",
    "            * [**NRPy+ tutorial on adding stress-energy source terms to BSSN RHSs**](Tutorial-BSSN_stress_energy_source_terms.ipynb).\n",
    "        1. Apply singular, curvilinear coordinate boundary conditions [*a la* the SENR/NRPy+ paper](https://arxiv.org/abs/1712.07658)\n",
    "            * [**NRPy+ tutorial on setting up singular, curvilinear boundary conditions**](Tutorial-Start_to_Finish-Curvilinear_BCs.ipynb)\n",
    "        1. Enforce constraint on conformal 3-metric: $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ \n",
    "            * [**NRPy+ tutorial on enforcing $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint**](Tutorial-BSSN_enforcing_determinant_gammabar_equals_gammahat_constraint.ipynb)\n",
    "1. Repeat above steps at two numerical resolutions to confirm convergence to zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='toc'></a>\n",
    "\n",
    "# Table of Contents\n",
    "$$\\label{toc}$$\n",
    "\n",
    "This notebook is organized as follows\n",
    "\n",
    "1. [Step 1](#initializenrpy): Set core NRPy+ parameters for numerical grids and reference metric\n",
    "1. [Step 2](#tov_id_setup): Set up TOV initial data and register C functions for reading \n",
    "    1. [Step 2.a](#tov_solve): Solve TOV equations to generate neutron star initial data\n",
    "    1. [Step 2.b](#adm_id_spacetime): Register C functions for interpolating TOV initial data onto our numerical grids, converting TOV metric quantities to BSSN, and constructing $T^{\\mu\\nu}$\n",
    "1. [Step 3](#ccodegen): Generate C code kernels for BSSN expressions, in parallel if possible\n",
    "    1. [Step 3.a](#rfm_ccodegen): Generate C code kernels for reference metric\n",
    "1. [Step 4](#cparams_rfm_and_domainsize): Set `free_parameters.h`; also output C codes needed for declaring and setting Cparameters\n",
    "1. [Step 5](#bc_functs): Set up boundary condition functions for chosen singular, curvilinear coordinate system\n",
    "1. [Step 6](#mainc): `Hydro_without_Hydro_Playground`: The C code `main()` function\n",
    "1. [Step 7](#compileexec): Compile generated C codes & perform the hydro-without-hydro evolution\n",
    "1. [Step 8](#visualize): Visualize the output!\n",
    "    1. [Step 8.a](#installdownload): Install `scipy` and download `ffmpeg` if they are not yet installed/downloaded\n",
    "    1. [Step 8.b](#genimages): Generate images for visualization animation\n",
    "    1. [Step 8.c](#genvideo): Generate visualization animation\n",
    "1. [Step 9](#convergence): Plot the numerical error at the end of the simulation, and confirm that it converges to zero with increasing numerical resolution (sampling)\n",
    "1. [Step 10](#latex_pdf_output): Output this notebook to $\\LaTeX$-formatted PDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='initializenrpy'></a>\n",
    "\n",
    "# Step 1: Set core NRPy+ parameters for numerical grids and reference metric \\[Back to [top](#toc)\\]\n",
    "$$\\label{initializenrpy}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:25.778737Z",
     "iopub.status.busy": "2021-09-23T22:08:25.774943Z",
     "iopub.status.idle": "2021-09-23T22:08:26.199113Z",
     "shell.execute_reply": "2021-09-23T22:08:26.198629Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step P1: Import needed NRPy+ core modules:\n",
    "from outputC import add_to_Cfunction_dict, outC_function_master_list  # NRPy+: Core C code output module\n",
    "import finite_difference as fin  # NRPy+: Finite difference C code generation module\n",
    "import NRPy_param_funcs as par   # NRPy+: Parameter interface\n",
    "import grid as gri               # NRPy+: Functions having to do with numerical grids\n",
    "import reference_metric as rfm   # NRPy+: Reference metric support\n",
    "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",
    "\n",
    "# Step P2: Create C code output directory:\n",
    "Ccodesrootdir = os.path.join(\"BSSN_Hydro_without_Hydro_Ccodes\")\n",
    "# First remove C code output directory if it exists\n",
    "# Courtesy https://stackoverflow.com/questions/303200/how-do-i-remove-delete-a-folder-that-is-not-empty\n",
    "shutil.rmtree(Ccodesrootdir, ignore_errors=True)\n",
    "# Then create a fresh directory\n",
    "cmd.mkdir(Ccodesrootdir)\n",
    "\n",
    "# Step 1.a: Enable SIMD-optimized code?\n",
    "#           I.e., generate BSSN and Ricci C code kernels using SIMD-vectorized\n",
    "#           compiler intrinsics, which *greatly improve the code's performance*,\n",
    "#           though at the expense of making the C-code kernels less\n",
    "#           human-readable.\n",
    "#           * Important note in case you wish to modify the BSSN/Ricci kernels\n",
    "#             here by adding expressions containing transcendental functions\n",
    "#             (e.g., certain scalar fields):\n",
    "#           Note that SIMD-based transcendental function intrinsics are not\n",
    "#           supported by the default installation of gcc or clang (you will\n",
    "#           need to use e.g., the SLEEF library from sleef.org, for this\n",
    "#           purpose). The Intel compiler suite does support these intrinsics\n",
    "#           however without the need for external libraries.\n",
    "enable_SIMD = True\n",
    "\n",
    "# Step 1.b: Enable reference metric precomputation.\n",
    "enable_rfm_precompute = True\n",
    "\n",
    "if enable_SIMD and not enable_rfm_precompute:\n",
    "    print(\"ERROR: SIMD does not currently handle transcendental functions,\\n\")\n",
    "    print(\"       like those found in rfmstruct (rfm_precompute).\\n\")\n",
    "    print(\"       Therefore, enable_SIMD==True and enable_rfm_precompute==False\\n\")\n",
    "    print(\"       is not supported.\\n\")\n",
    "    sys.exit(1)\n",
    "\n",
    "# Step 1.c: Enable \"FD functions\". In other words, all finite-difference stencils\n",
    "#         will be output as inlined static functions. This is essential for\n",
    "#         compiling highly complex FD kernels with using certain versions of GCC;\n",
    "#         GCC 10-ish will choke on BSSN FD kernels at high FD order, sometimes\n",
    "#         taking *hours* to compile. Unaffected GCC versions compile these kernels\n",
    "#         in seconds. FD functions do not slow the code performance, but do add\n",
    "#         another header file to the C source tree.\n",
    "# With gcc 7.5.0, enable_FD_functions=True decreases performance by 10%\n",
    "enable_FD_functions = False\n",
    "\n",
    "# Step 2: Set some core parameters, including CoordSystem MoL timestepping algorithm,\n",
    "#                                 FD order, floating point precision, and CFL factor:\n",
    "# Choices are: Spherical, SinhSpherical, SinhSphericalv2, Cylindrical, SinhCylindrical,\n",
    "#              SymTP, SinhSymTP\n",
    "CoordSystem     = \"Spherical\"\n",
    "par.set_parval_from_str(\"reference_metric::CoordSystem\", CoordSystem)\n",
    "rfm.reference_metric()\n",
    "\n",
    "# Step 2.a: Set outer boundary condition\n",
    "outer_bc_type = \"RADIATION_OUTER_BCS\"  # can be EXTRAPOLATION_OUTER_BCS or RADIATION_OUTER_BCS\n",
    "radiation_BC_FD_order = 2\n",
    "\n",
    "# Step 2.b: Set defaults for Coordinate system parameters.\n",
    "#           These are perhaps the most commonly adjusted parameters,\n",
    "#           so we enable modifications at this high level.\n",
    "\n",
    "# domain_size sets the default value for:\n",
    "#   * Spherical's params.RMAX\n",
    "#   * SinhSpherical*'s params.AMAX\n",
    "#   * Cartesians*'s -params.{x,y,z}min & .{x,y,z}max\n",
    "#   * Cylindrical's -params.ZMIN & .{Z,RHO}MAX\n",
    "#   * SinhCylindrical's params.AMPL{RHO,Z}\n",
    "#   * *SymTP's params.AMAX\n",
    "# domain_size     = 7.5 # SET BELOW BASED ON TOV STELLAR RADIUS\n",
    "\n",
    "# sinh_width sets the default value for:\n",
    "#   * SinhSpherical's params.SINHW\n",
    "#   * SinhCylindrical's params.SINHW{RHO,Z}\n",
    "#   * SinhSymTP's params.SINHWAA\n",
    "sinh_width      = 0.4 # If Sinh* coordinates chosen\n",
    "\n",
    "# sinhv2_const_dr sets the default value for:\n",
    "#   * SinhSphericalv2's params.const_dr\n",
    "#   * SinhCylindricalv2's params.const_d{rho,z}\n",
    "sinhv2_const_dr = 0.05 # If Sinh*v2 coordinates chosen\n",
    "\n",
    "# SymTP_bScale sets the default value for:\n",
    "#   * SinhSymTP's params.bScale\n",
    "SymTP_bScale    = 0.5 # If SymTP chosen\n",
    "\n",
    "# Step 2.c: Set the order of spatial and temporal derivatives;\n",
    "#           the core data type, and the CFL factor.\n",
    "# RK_method choices include: Euler, \"RK2 Heun\", \"RK2 MP\", \"RK2 Ralston\", RK3, \"RK3 Heun\", \"RK3 Ralston\",\n",
    "#              SSPRK3, RK4, DP5, DP5alt, CK5, DP6, L6, DP8\n",
    "RK_method = \"RK4\"\n",
    "FD_order  = 4            # Finite difference order: even numbers only, starting with 2. 12 is generally unstable\n",
    "REAL      = \"double\"     # Best to use double here.\n",
    "default_CFL_FACTOR= 0.5  # (GETS OVERWRITTEN IF SPECIFIED AT COMMAND LINE.)\n",
    "                         # In pure axisymmetry (symmetry_axes = 2 below) 1.0 works fine. Otherwise 0.5 or lower.\n",
    "\n",
    "# Set the lapse & shift evolution equations to be consistent with the original Hydro without Hydro paper.\n",
    "LapseCondition  = \"HarmonicSlicing\"\n",
    "ShiftCondition  = \"Frozen\"\n",
    "\n",
    "# Step 3: Polytropic EOS setup\n",
    "# For EOS_type, choose either \"SimplePolytrope\" or \"PiecewisePolytrope\"\n",
    "EOS_type = \"SimplePolytrope\"\n",
    "# If \"PiecewisePolytrope\" is chosen as EOS_type, you\n",
    "#   must also choose the name of the EOS, which can\n",
    "#   be any of the following:\n",
    "# 'PAL6', 'SLy', 'APR1', 'APR2', 'APR3', 'APR4',\n",
    "# 'FPS', 'WFF1', 'WFF2', 'WFF3', 'BBB2', 'BPAL12',\n",
    "# 'ENG', 'MPA1', 'MS1', 'MS2', 'MS1b', 'PS', 'GS1',\n",
    "# 'GS2', 'BGN1H1', 'GNH3', 'H1', 'H2', 'H3', 'H4',\n",
    "# 'H5', 'H6', 'H7', 'PCL2', 'ALF1', 'ALF2', 'ALF3',\n",
    "# 'ALF4'\n",
    "EOS_name = 'SLy' # <-- IGNORED IF EOS_type is not PiecewisePolytrope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:26.203895Z",
     "iopub.status.busy": "2021-09-23T22:08:26.203369Z",
     "iopub.status.idle": "2021-09-23T22:08:26.205606Z",
     "shell.execute_reply": "2021-09-23T22:08:26.205163Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step 5: Set the finite differencing order to FD_order (set above).\n",
    "par.set_parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\", FD_order)\n",
    "\n",
    "# Directory for reference_metric precomputation header files:\n",
    "rfm_precompute_Ccode_outdir = os.path.join(Ccodesrootdir, \"rfm_files/\")\n",
    "if enable_rfm_precompute:\n",
    "    cmd.mkdir(os.path.join(Ccodesrootdir, \"rfm_files/\"))\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_Ccode_outdir\", rfm_precompute_Ccode_outdir)\n",
    "\n",
    "# Step 6: Copy SIMD/SIMD_intrinsics.h to $Ccodesrootdir/SIMD/SIMD_intrinsics.h\n",
    "if enable_SIMD:\n",
    "    cmd.mkdir(os.path.join(Ccodesrootdir,\"SIMD\"))\n",
    "    shutil.copy(os.path.join(\"SIMD/\")+\"SIMD_intrinsics.h\",os.path.join(Ccodesrootdir,\"SIMD/\"))\n",
    "\n",
    "# Step 7: Set finite_difference::enable_FD_functions appropriately. Defaults to False\n",
    "if enable_FD_functions:\n",
    "    par.set_parval_from_str(\"finite_difference::enable_FD_functions\", enable_FD_functions)\n",
    "\n",
    "# Step 8: If enable_SIMD, then copy SIMD/SIMD_intrinsics.h to $Ccodesrootdir/SIMD/SIMD_intrinsics.h\n",
    "cmd.mkdir(os.path.join(Ccodesrootdir,\"SIMD\"))\n",
    "if enable_SIMD:\n",
    "    shutil.copy(os.path.join(\"SIMD\", \"SIMD_intrinsics.h\"), os.path.join(Ccodesrootdir, \"SIMD\"))\n",
    "\n",
    "# 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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 10: Generate Runge-Kutta-based (RK-based) timestepping code.\n",
    "#       As described above the Table of Contents, this is a 3-step process:\n",
    "#       10.A: Evaluate RHSs (RHS_string)\n",
    "#       10.B: Apply boundary conditions (post_RHS_string, pt 1)\n",
    "#       10.C: Enforce det(gammabar) = det(gammahat) constraint (post_RHS_string, pt 2)\n",
    "import MoLtimestepping.MoL as MoL\n",
    "# from MoLtimestepping.RK_Butcher_Table_Dictionary import Butcher_dict\n",
    "# RK_order  = Butcher_dict[RK_method][1]\n",
    "RHS_string      = \"\"\"\n",
    "Ricci_eval(params, rfmstruct, RK_INPUT_GFS, auxevol_gfs);\n",
    "rhs_eval(  params, rfmstruct, auxevol_gfs, RK_INPUT_GFS, RK_OUTPUT_GFS);\"\"\"\n",
    "RHS_string += \"\"\"\n",
    "if(params->outer_bc_type == RADIATION_OUTER_BCS)\n",
    "  apply_bcs_outerradiation_and_inner(params, bcstruct, griddata->xx,\n",
    "                                     gridfunctions_wavespeed,gridfunctions_f_infinity,\n",
    "                                     RK_INPUT_GFS, RK_OUTPUT_GFS);\"\"\"\n",
    "\n",
    "# Extrapolation BCs are applied to the evolved gridfunctions themselves after the MoL update\n",
    "post_RHS_string = \"\"\"if(params->outer_bc_type == EXTRAPOLATION_OUTER_BCS)\n",
    "  apply_bcs_outerextrap_and_inner(params, bcstruct, RK_OUTPUT_GFS);\n",
    "\"\"\"\n",
    "post_RHS_string += \"enforce_detgammahat_constraint(params, rfmstruct, RK_OUTPUT_GFS);\\n\"\n",
    "\n",
    "if not enable_rfm_precompute:\n",
    "    RHS_string = RHS_string.replace(\"rfmstruct\", \"xx\")\n",
    "    post_RHS_string = post_RHS_string.replace(\"rfmstruct\", \"xx\")\n",
    "\n",
    "MoL.register_C_functions_and_NRPy_basic_defines(RK_method,\n",
    "        RHS_string=RHS_string, post_RHS_string=post_RHS_string,\n",
    "        enable_rfm=enable_rfm_precompute, enable_curviBCs=True, enable_SIMD=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='tov_id_setup'></a>\n",
    "\n",
    "# Step 2: Set up TOV initial data and register C functions for reading  \\[Back to [top](#toc)\\]\n",
    "$$\\label{tov_id_setup}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='tov_solve'></a>\n",
    "\n",
    "## Step 2.a: Solve TOV equations to generate neutron star initial data \\[Back to [top](#toc)\\]\n",
    "$$\\label{tov_solve}$$\n",
    "\n",
    "As documented [in the TOV Initial Data NRPy+ Tutorial Module](Tutorial-TOV_Initial_Data.ipynb) ([older version here](Tutorial-GRMHD_UnitConversion.ipynb)), we will first set up TOV initial data, storing the densely-sampled result to file (***Courtesy Phil Chang***)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`scipy` provides the ODE integration routine used in our TOV solver, so we first make sure that it is installed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install scipy > /dev/null"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we call the [`TOV.TOV_Solver()` function](../edit/TOV/TOV_Solver.py) ([NRPy+ Tutorial module](Tutorial-ADM_Initial_Data-TOV.ipynb)) to set up the initial data, using the default parameters for initial data. This function outputs the solution to a file named `outputTOVpolytrope.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1256 1256 1256 1256 1256 1256\n",
      "Just generated a TOV star with\n",
      "* M        = 1.405030336771405e-01 ,\n",
      "* R_Schw   = 9.566044579232513e-01 ,\n",
      "* R_iso    = 8.100085557410308e-01 ,\n",
      "* M/R_Schw = 1.468768334847266e-01 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "##########################\n",
    "# Polytropic EOS example #\n",
    "##########################\n",
    "import TOV.Polytropic_EOSs as ppeos\n",
    "\n",
    "if EOS_type == \"SimplePolytrope\":\n",
    "    # Set neos = 1 (single polytrope)\n",
    "    neos = 1\n",
    "\n",
    "    # Set rho_poly_tab (not needed for a single polytrope)\n",
    "    rho_poly_tab = []\n",
    "\n",
    "    # Set Gamma_poly_tab\n",
    "    Gamma_poly_tab = [2.0]\n",
    "\n",
    "    # Set K_poly_tab0\n",
    "    K_poly_tab0 = 1. # ZACH NOTES: CHANGED FROM 100.\n",
    "\n",
    "    # Set the eos quantities\n",
    "    eos = ppeos.set_up_EOS_parameters__complete_set_of_input_variables(neos,rho_poly_tab,Gamma_poly_tab,K_poly_tab0)\n",
    "    rho_baryon_central = 0.129285\n",
    "elif EOS_type == \"PiecewisePolytrope\":\n",
    "    eos = ppeos.set_up_EOS_parameters__Read_et_al_input_variables(EOS_name)\n",
    "    rho_baryon_central=2.0\n",
    "else:\n",
    "    print(\"\"\"Error: unknown EOS_type. Valid types are 'SimplePolytrope' and 'PiecewisePolytrope' \"\"\")\n",
    "    sys.exit(1)\n",
    "\n",
    "import TOV.TOV_Solver as TOV\n",
    "TOV_Mass, R_Schw_TOV, R_iso_TOV = TOV.TOV_Solver(eos,\n",
    "                                              outfile=os.path.join(Ccodesrootdir, \"TOVdata.txt\"),\n",
    "                                              rho_baryon_central=rho_baryon_central,\n",
    "                                              return_M_RSchw_and_Riso = True,\n",
    "                                              verbose = True)\n",
    "\n",
    "# domain_size sets the default value for:\n",
    "#   * Spherical's params.RMAX\n",
    "#   * SinhSpherical*'s params.AMAX\n",
    "#   * Cartesians*'s -params.{x,y,z}min & .{x,y,z}max\n",
    "#   * Cylindrical's -params.ZMIN & .{Z,RHO}MAX\n",
    "#   * SinhCylindrical's params.AMPL{RHO,Z}\n",
    "#   * *SymTP's params.AMAX\n",
    "domain_size = 2.0 * R_iso_TOV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='adm_id_spacetime'></a>\n",
    "\n",
    "## Step 2.b: Register C functions for interpolating TOV initial data onto our numerical grids, converting TOV metric quantities to BSSN, and constructing $T^{\\mu\\nu}$ \\[Back to [top](#toc)\\]\n",
    "$$\\label{adm_id_spacetime}$$\n",
    "\n",
    "First we register all the C functions needed to read the TOV data file, interpolate the TOV solution to our numerical grid, and convert the TOV quantities to ADM variables and $T^{\\mu\\nu}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import TOV.TOV_Ccodegen_library as TOVCL  # NRPy+: TOV C codegen library\n",
    "TOVCL.add_to_Cfunction_dict_TOV_read_data_file_set_ID_persist(interp_stencil_size=12)\n",
    "TOVCL.add_to_Cfunction_dict_TOV_ID_function()\n",
    "TOVCL.add_to_Cfunction_dict_TOV_interpolate_1D()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='ccodegen'></a>\n",
    "\n",
    "# Step 3: Generate C code kernels for BSSN expressions, in parallel if possible \\[Back to [top](#toc)\\]\n",
    "$$\\label{ccodegen}$$\n",
    "\n",
    "In the following code cell, we create a list of Python functions, which each registers a single C code function in `outputC`'s `outC_function_dict` dictionary. These Python functions are defined in \n",
    "\n",
    "1. [`BSSN.Initial_Data_Reader__BSSN_Converter`](../edit/BSSN.Initial_Data_Reader__BSSN_Converter.py); ([\\[**tutorial**\\]](Tutorial-ADM_Initial_Data_Reader__BSSN_Converter.ipynb)), which registers the C function for our \"universal\" initial data reader/converter `initial_data_reader__convert_ADM_spherical_to_BSSN()`.\n",
    "    * This function first calls `TOV_ID_function()` to read the initial data from file. Spacetime data are given in terms of ADM quantities, and fluid quantity data are given in terms of the stress-energy tensor. Then the function converts the ADM quantities to BSSN in our desired reference metric, and performs the basis transform on the stress-energy tensor as well.\n",
    "1. the [`BSSN.BSSN_Ccodegen_library`](../edit/BSSN/BSSN_Ccodegen_library.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-C_codegen_library.ipynb), which contains Python functions for generating C code from symbolic expressions constructed within the following NRPy+ modules/tutorials:\n",
    "    1. [BSSN/BSSN_constraints](../edit/BSSN/BSSN_constraints.py); [\\[**tutorial**\\]](Tutorial-BSSN_constraints.ipynb): Hamiltonian constraint in BSSN curvilinear basis/coordinates\n",
    "    1. [BSSN/BSSN_RHSs](../edit/BSSN/BSSN_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb): Generates the right-hand sides for the BSSN evolution equations in singular, curvilinear coordinates\n",
    "    1. [BSSN/BSSN_gauge_RHSs](../edit/BSSN/BSSN_gauge_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb): Generates the right-hand sides for the BSSN gauge evolution equations in singular, curvilinear coordinates\n",
    "    1. [BSSN/Enforce_Detgammahat_Constraint](../edit/BSSN/Enforce_Detgammahat_Constraint.py); [**tutorial**](Tutorial-BSSN_enforcing_determinant_gammabar_equals_gammahat_constraint.ipynb): Generates symbolic expressions for enforcing the $\\det{\\bar{\\gamma}}=\\det{\\hat{\\gamma}}$ constraint\n",
    "\n",
    "\n",
    "Next, from within a `multiprocessing` environment, we then call all the Python C-code generation functions in this list in parallel (if `multiprocessing` is supported). This is quite useful, as these functions take several seconds to complete.\n",
    "\n",
    "Within each `multiprocessing` process, the current NRPy+ environment is cloned, and a new function is registered to the `outC_function_dict` dictionary. Thus when each process completes, it contains a unique NRPy+ environment, with only its function registered. We address this by saving each process' NRPy+ environment and sending it back in a common binary format known as a `pickle`, using NRPy+'s [`pickling`](../edit/pickling.py) module. The environments are combined in an unpickling such that all functions exist within the same `outC_function_dict` dictionary.\n",
    "\n",
    "To make the current environment fully consistent, we call `reference_metric.py` to register all its associated C functions (stored in globals) and contributions to `NRPy_basic_defines.h`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:26.232538Z",
     "iopub.status.busy": "2021-09-23T22:08:26.231967Z",
     "iopub.status.idle": "2021-09-23T22:08:41.510761Z",
     "shell.execute_reply": "2021-09-23T22:08:41.510225Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "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 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",
      "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",
      "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 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"
     ]
    }
   ],
   "source": [
    "# Step 2: Generate C code kernels for BSSN expressions, in parallel if possible;\n",
    "import BSSN.BSSN_Ccodegen_library as BCL\n",
    "# Step 2.a: Create a list of functions we wish to evaluate in parallel (if possible)\n",
    "# Create lists for all functions we wish to register\n",
    "codegen_funcs = []\n",
    "codegen_funcs.append(BCL.add_rhs_eval_to_Cfunction_dict)\n",
    "codegen_funcs.append(BCL.add_Ricci_eval_to_Cfunction_dict)\n",
    "codegen_funcs.append(BCL.add_BSSN_constraints_to_Cfunction_dict)\n",
    "codegen_funcs.append(BCL.add_enforce_detgammahat_constraint_to_Cfunction_dict)\n",
    "\n",
    "import BSSN.ADM_Initial_Data_Reader__BSSN_Converter as IDread\n",
    "codegen_funcs.append(IDread.add_to_Cfunction_dict_initial_data_reader__convert_ADM_Sph_or_Cart_to_BSSN)\n",
    "\n",
    "# Step 2.b: Define master functions for parallelization.\n",
    "#           Note that lambdifying this doesn't work in Python 3\n",
    "def master_func(arg):\n",
    "    if codegen_funcs[arg].__name__ == \"add_to_Cfunction_dict_initial_data_reader__convert_ADM_Sph_or_Cart_to_BSSN\":\n",
    "        ret = codegen_funcs[arg](addl_includes=None, rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                 input_Coord=\"Spherical\", include_T4UU=True)\n",
    "    else:\n",
    "        if enable_rfm_precompute:\n",
    "            # We use rfm_precompute for all BSSN functions:\n",
    "            par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"True\")\n",
    "            rfm.reference_metric()\n",
    "\n",
    "        if codegen_funcs[arg].__name__ == \"add_BSSN_constraints_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     enable_stress_energy_source_terms=True,\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"), output_H_only=True,\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, enable_SIMD=enable_SIMD,\n",
    "                                     OMP_pragma_on=OMP_pragma_on)\n",
    "        elif codegen_funcs[arg].__name__ == \"add_rhs_eval_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, enable_SIMD=enable_SIMD,\n",
    "                                     enable_stress_energy_source_terms=True,\n",
    "                                     OMP_pragma_on=OMP_pragma_on,\n",
    "                                     LapseCondition=LapseCondition, ShiftCondition=ShiftCondition)\n",
    "        elif codegen_funcs[arg].__name__ == \"add_Ricci_eval_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, enable_SIMD=enable_SIMD,\n",
    "                                     OMP_pragma_on=OMP_pragma_on)\n",
    "        elif codegen_funcs[arg].__name__ == \"add_enforce_detgammahat_constraint_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, OMP_pragma_on=OMP_pragma_on)\n",
    "        else:\n",
    "            print(\"ERROR: DID NOT RECOGNIZE FUNCTION \" + codegen_funcs[arg].__name__ + \"\\n\")\n",
    "            sys.exit(1)\n",
    "        if enable_rfm_precompute:\n",
    "            par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"False\")\n",
    "            rfm.ref_metric__hatted_quantities()\n",
    "    return ret\n",
    "\n",
    "\n",
    "NRPyEnvVars = []\n",
    "raised_exception = False\n",
    "try:\n",
    "    if os.name == 'nt':\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",
    "\n",
    "    # Step 2.e: Evaluate list of functions in parallel if possible;\n",
    "    #           otherwise fallback to serial evaluation:\n",
    "    pool = multiprocessing.Pool()\n",
    "    NRPyEnvVars.append(pool.map(master_func, range(len(codegen_funcs))))\n",
    "    pool.terminate()\n",
    "    pool.join()\n",
    "except:\n",
    "    print(\"FAILED PARALLEL CODEGEN!\")\n",
    "    NRPyEnvVars = [] # Reset, as pickling/unpickling unnecessary for serial codegen (see next line)\n",
    "\n",
    "    # Steps 2.d-e, alternate: As fallback, evaluate functions in serial.\n",
    "    #       This will happen on Android and Windows systems\n",
    "    for i, func in enumerate(codegen_funcs):\n",
    "        master_func(i)\n",
    "    raised_exception = True\n",
    "\n",
    "outCfunc_master_list = outC_function_master_list\n",
    "if not raised_exception:\n",
    "    outCfunc_master_list = unpickle_NRPy_env(NRPyEnvVars)\n",
    "    for el in outCfunc_master_list:\n",
    "        if el not in outC_function_master_list:  # in case there are duplicate funcs, which can happen\n",
    "            #                                      if finite_difference_functions = True\n",
    "            outC_function_master_list += [el]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='rfm_ccodegen'></a>\n",
    "\n",
    "## Step 3.a: Generate C code kernels for reference metric \\[Back to [top](#toc)\\]\n",
    "$$\\label{rfm_ccodegen}$$\n",
    "\n",
    "In the [reference_metric](../edit/reference_metric.py) NRPy+ module, `register_C_functions_and_NRPy_basic_defines()` registers the following C functions to `outC_Cfunction_dict`:\n",
    "\n",
    "1. `find_timestep()`: Finds the minimum spacing between adjacent gridpoints on our numerical grid $\\min(ds_i)$, and sets the timestep according to the [CFL](https://en.wikipedia.org/w/index.php?title=Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition&oldid=806430673) condition: $\\Delta t \\le \\frac{\\min(ds_i)}{c}$, where $c$ is the wavespeed, and $ds_i = h_i \\Delta x^i$ is the proper distance between neighboring gridpoints in the $i$th direction (in 3D, there are 3 directions), $h_i$ is the $i$th reference metric scale factor, and $\\Delta x^i$ is the uniform grid spacing in the $i$th direction.\n",
    "1. `xx_to_Cart()`: Input = uniformly sampled coordinate xx0,xx1,xx2 (e.g., r,theta,phi in Spherical coordinates). Output = Cartesian coordinate (x,y,z).\n",
    "1. `set_Nxx_dxx_invdx_params__and__xx()`: Sets `Nxx{0,1,2}`, `Nxx_plus_2NGHOSTS{0,1,2}`, `dxx{0,1,2}`, and `invdx{0,1,2}`; and defines `xx[3][]`.\n",
    "1. `Cart_to_xx_and_nearest_i0i1i2()`: Input = Cartesian coordinate (x,y,z). Output = uniformly sampled coordinate xx0,xx1,xx2 (e.g., r,theta,phi in Spherical coordinates), as well as corresponding grid index `i0,i1,i2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:41.574056Z",
     "iopub.status.busy": "2021-09-23T22:08:41.548577Z",
     "iopub.status.idle": "2021-09-23T22:08:41.938615Z",
     "shell.execute_reply": "2021-09-23T22:08:41.938185Z"
    }
   },
   "outputs": [],
   "source": [
    "# Generate & register C function set_Nxx_dxx_invdx_params__and__xx()\n",
    "# Generate & register C function xx_to_Cart() for\n",
    "#               (the mapping from xx->Cartesian) for the chosen\n",
    "#               CoordSystem:\n",
    "# Generate & register the find_timestep() function\n",
    "\n",
    "# Sets reference_metric globals: NRPy_basic_defines_str, rfm_struct__malloc, rfm_struct__define, rfm_struct__freemem\n",
    "if enable_rfm_precompute:\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_Ccode_outdir\", rfm_precompute_Ccode_outdir)\n",
    "    par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"True\")\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_to_Cfunctions_and_NRPy_basic_defines\", \"True\")\n",
    "    rfm.reference_metric()\n",
    "\n",
    "rfm.register_C_functions(enable_rfm_precompute=enable_rfm_precompute, use_unit_wavespeed_for_find_timestep=True)\n",
    "rfm.register_NRPy_basic_defines(enable_rfm_precompute=enable_rfm_precompute)\n",
    "\n",
    "if enable_rfm_precompute:\n",
    "    par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"False\")\n",
    "    rfm.ref_metric__hatted_quantities()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='cparams_rfm_and_domainsize'></a>\n",
    "\n",
    "# Step 4: Set `free_parameters.h`; also output C codes needed for declaring and setting Cparameters  \\[Back to [top](#toc)\\]\n",
    "$$\\label{cparams_rfm_and_domainsize}$$\n",
    "\n",
    "First we output `free_parameters.h`, which sets initial data parameters, as well as grid domain & reference metric parameters, applying `domain_size` and `sinh_width`/`SymTP_bScale` (if applicable) as set above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:41.942239Z",
     "iopub.status.busy": "2021-09-23T22:08:41.941715Z",
     "iopub.status.idle": "2021-09-23T22:08:41.943573Z",
     "shell.execute_reply": "2021-09-23T22:08:41.943985Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step 3.e.i: Set free_parameters.h\n",
    "outstr = r\"\"\"// Set free-parameter values.\n",
    "\n",
    "// Outer boundary condition choice:\n",
    "params.outer_bc_type = \"\"\"+outer_bc_type+r\"\"\";\n",
    "\n",
    "// Set the default CFL Factor. Can be overwritten at command line.\n",
    "REAL CFL_FACTOR = \"\"\"+str(default_CFL_FACTOR)+r\"\"\";\n",
    "\n",
    "// Set free-parameter values for BSSN evolution:\n",
    "//params.eta = 1.0;  // Frozen shift in hydro-without-hydro evolution\n",
    "\n",
    "// Part P0.d: Set TOV stellar parameters\n",
    "#define TOV_Mass  \"\"\"+str(TOV_Mass)+\"\"\"\n",
    "#define TOV_Riso  \"\"\"+str(R_iso_TOV)+\"\\n\"\n",
    "\n",
    "\n",
    "# Append to $Ccodesrootdir/free_parameters.h reference metric parameters based on generic\n",
    "#    domain_size,sinh_width,sinhv2_const_dr,SymTP_bScale,\n",
    "#    parameters set above.\n",
    "outstr += rfm.out_default_free_parameters_for_rfm(\"returnstring\",\n",
    "                                                  domain_size,sinh_width,sinhv2_const_dr,SymTP_bScale)\n",
    "with open(os.path.join(Ccodesrootdir,\"free_parameters.h\"),\"w\") as file:\n",
    "    file.write(outstr.replace(\"params.\", \"griddata.params.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='bc_functs'></a>\n",
    "\n",
    "# Step 5: Set up boundary condition functions for chosen singular, curvilinear coordinate system \\[Back to [top](#toc)\\]\n",
    "$$\\label{bc_functs}$$\n",
    "\n",
    "Next apply singular, curvilinear coordinate boundary conditions [as documented in the corresponding NRPy+ tutorial notebook](Tutorial-Start_to_Finish-Curvilinear_BCs.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:41.952190Z",
     "iopub.status.busy": "2021-09-23T22:08:41.951777Z",
     "iopub.status.idle": "2021-09-23T22:08:42.181582Z",
     "shell.execute_reply": "2021-09-23T22:08:42.181905Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evolved gridfunction \"aDD00\" has parity type 4.\n",
      "Evolved gridfunction \"aDD01\" has parity type 5.\n",
      "Evolved gridfunction \"aDD02\" has parity type 6.\n",
      "Evolved gridfunction \"aDD11\" has parity type 7.\n",
      "Evolved gridfunction \"aDD12\" has parity type 8.\n",
      "Evolved gridfunction \"aDD22\" has parity type 9.\n",
      "Evolved gridfunction \"alpha\" has parity type 0.\n",
      "Evolved gridfunction \"betU0\" has parity type 1.\n",
      "Evolved gridfunction \"betU1\" has parity type 2.\n",
      "Evolved gridfunction \"betU2\" has parity type 3.\n",
      "Evolved gridfunction \"cf\" has parity type 0.\n",
      "Evolved gridfunction \"hDD00\" has parity type 4.\n",
      "Evolved gridfunction \"hDD01\" has parity type 5.\n",
      "Evolved gridfunction \"hDD02\" has parity type 6.\n",
      "Evolved gridfunction \"hDD11\" has parity type 7.\n",
      "Evolved gridfunction \"hDD12\" has parity type 8.\n",
      "Evolved gridfunction \"hDD22\" has parity type 9.\n",
      "Evolved gridfunction \"lambdaU0\" has parity type 1.\n",
      "Evolved gridfunction \"lambdaU1\" has parity type 2.\n",
      "Evolved gridfunction \"lambdaU2\" has parity type 3.\n",
      "Evolved gridfunction \"trK\" has parity type 0.\n",
      "Evolved gridfunction \"vetU0\" has parity type 1.\n",
      "Evolved gridfunction \"vetU1\" has parity type 2.\n",
      "Evolved gridfunction \"vetU2\" has parity type 3.\n",
      "Auxiliary gridfunction \"H\" has parity type 0.\n",
      "AuxEvol gridfunction \"RbarDD00\" has parity type 4.\n",
      "AuxEvol gridfunction \"RbarDD01\" has parity type 5.\n",
      "AuxEvol gridfunction \"RbarDD02\" has parity type 6.\n",
      "AuxEvol gridfunction \"RbarDD11\" has parity type 7.\n",
      "AuxEvol gridfunction \"RbarDD12\" has parity type 8.\n",
      "AuxEvol gridfunction \"RbarDD22\" has parity type 9.\n",
      "AuxEvol gridfunction \"T4UU00\" has parity type 0.\n",
      "AuxEvol gridfunction \"T4UU01\" has parity type 1.\n",
      "AuxEvol gridfunction \"T4UU02\" has parity type 2.\n",
      "AuxEvol gridfunction \"T4UU03\" has parity type 3.\n",
      "AuxEvol gridfunction \"T4UU11\" has parity type 4.\n",
      "AuxEvol gridfunction \"T4UU12\" has parity type 5.\n",
      "AuxEvol gridfunction \"T4UU13\" has parity type 6.\n",
      "AuxEvol gridfunction \"T4UU22\" has parity type 7.\n",
      "AuxEvol gridfunction \"T4UU23\" has parity type 8.\n",
      "AuxEvol gridfunction \"T4UU33\" has parity type 9.\n"
     ]
    }
   ],
   "source": [
    "import CurviBoundaryConditions.CurviBoundaryConditions as CBC\n",
    "CBC.CurviBoundaryConditions_register_NRPy_basic_defines()\n",
    "CBC.CurviBoundaryConditions_register_C_functions(radiation_BC_FD_order=radiation_BC_FD_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='mainc'></a>\n",
    "\n",
    "# Step 6: The C code `main()` function for `Hydro_without_Hydro_Playground` \\[Back to [top](#toc)\\]\n",
    "$$\\label{mainc}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.191346Z",
     "iopub.status.busy": "2021-09-23T22:08:42.183557Z",
     "iopub.status.idle": "2021-09-23T22:08:42.193048Z",
     "shell.execute_reply": "2021-09-23T22:08:42.192711Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_main__Hydro_without_Hydro_Playground():\n",
    "    includes = [\"NRPy_basic_defines.h\", \"NRPy_function_prototypes.h\", \"time.h\"]\n",
    "    desc = \"\"\"// main() function:\n",
    "// Step 0: Read command-line input, set up grid structure, allocate memory for gridfunctions, set up coordinates\n",
    "// Step 1: Set up initial data to an exact solution\n",
    "// Step 2: Start the timer, for keeping track of how fast the simulation is progressing.\n",
    "// Step 3: Integrate the initial data forward in time using the chosen RK-like Method of\n",
    "//         Lines timestepping algorithm, and output periodic simulation diagnostics\n",
    "// Step 3.a: Output 2D data file periodically, for visualization\n",
    "// Step 3.b: Step forward one timestep (t -> t+dt) in time using\n",
    "//           chosen RK-like MoL timestepping algorithm\n",
    "// Step 3.c: If t=t_final, output conformal factor & Hamiltonian\n",
    "//           constraint violation to 2D data file\n",
    "// Step 3.d: Progress indicator printing to stderr\n",
    "// Step 4: Free all allocated memory\n",
    "\"\"\"\n",
    "    c_type = \"int\"\n",
    "    name = \"main\"\n",
    "    params = \"int argc, const char *argv[]\"\n",
    "    body = r\"\"\"  griddata_struct griddata;\n",
    "  set_Cparameters_to_default(&griddata.params);\n",
    "\n",
    "  // Step 0.a: Set free parameters, overwriting Cparameters defaults\n",
    "  //          by hand or with command-line input, as desired.\n",
    "#include \"free_parameters.h\"\n",
    "\n",
    "  // Step 0.b: Read command-line input, error out if nonconformant\n",
    "  if((argc != 4 && argc != 5) || atoi(argv[1]) < NGHOSTS || atoi(argv[2]) < NGHOSTS || atoi(argv[3]) < 2 /* FIXME; allow for axisymmetric sims */) {\n",
    "    fprintf(stderr,\"Error: Expected three command-line arguments: ./Hydro_without_Hydro_Playground Nx0 Nx1 Nx2,\\n\");\n",
    "    fprintf(stderr,\"where Nx[0,1,2] is the number of grid points in the 0, 1, and 2 directions.\\n\");\n",
    "    fprintf(stderr,\"Nx[] MUST BE larger than NGHOSTS (= %d)\\n\",NGHOSTS);\n",
    "    exit(1);\n",
    "  }\n",
    "  if(argc == 5) {\n",
    "    CFL_FACTOR = strtod(argv[4],NULL);\n",
    "    if(CFL_FACTOR > 0.5 && atoi(argv[3])!=2) {\n",
    "      fprintf(stderr,\"WARNING: CFL_FACTOR was set to %e, which is > 0.5.\\n\",CFL_FACTOR);\n",
    "      fprintf(stderr,\"         This will generally only be stable if the simulation is purely axisymmetric\\n\");\n",
    "      fprintf(stderr,\"         However, Nx2 was set to %d>2, which implies a non-axisymmetric simulation\\n\",atoi(argv[3]));\n",
    "    }\n",
    "  }\n",
    "  // Step 0.c: Set up numerical grid structure, first in space...\n",
    "  const int Nxx[3] = { atoi(argv[1]), atoi(argv[2]), atoi(argv[3]) };\n",
    "  if(Nxx[0]%2 != 0 || Nxx[1]%2 != 0 || Nxx[2]%2 != 0) {\n",
    "    fprintf(stderr,\"Error: Cannot guarantee a proper cell-centered grid if number of grid cells not set to even number.\\n\");\n",
    "    fprintf(stderr,\"       For example, in case of angular directions, proper symmetry zones will not exist.\\n\");\n",
    "    exit(1);\n",
    "  }\n",
    "\n",
    "  // Step 0.d: Uniform coordinate grids are stored to *xx[3]\n",
    "  // Step 0.d.i: Set bcstruct\n",
    "  {\n",
    "    int EigenCoord;\n",
    "    EigenCoord = 1;\n",
    "    // Step 0.d.ii: Call set_Nxx_dxx_invdx_params__and__xx(), which sets\n",
    "    //             params Nxx,Nxx_plus_2NGHOSTS,dxx,invdx, and xx[] for the\n",
    "    //             chosen Eigen-CoordSystem.\n",
    "    set_Nxx_dxx_invdx_params__and__xx(EigenCoord, Nxx, &griddata.params, griddata.xx);\n",
    "    // Step 0.e: Find ghostzone mappings; set up bcstruct\n",
    "    bcstruct_set_up(&griddata.params, griddata.xx, &griddata.bcstruct);\n",
    "    // Step 0.e.i: Free allocated space for xx[][] array\n",
    "    for(int i=0;i<3;i++) free(griddata.xx[i]);\n",
    "\n",
    "    // Step 0.f: Call set_Nxx_dxx_invdx_params__and__xx(), which sets\n",
    "    //          params Nxx,Nxx_plus_2NGHOSTS,dxx,invdx, and xx[] for the\n",
    "    //          chosen (non-Eigen) CoordSystem.\n",
    "    EigenCoord = 0;\n",
    "    set_Nxx_dxx_invdx_params__and__xx(EigenCoord, Nxx, &griddata.params, griddata.xx);\n",
    "  }\n",
    "\n",
    "  // Step 0.g: Time coordinate parameters\n",
    "  griddata.params.t_final =  1.8*TOV_Mass; /* Final time is set so that at t=t_final,\n",
    "                                            * data at the origin have not been corrupted\n",
    "                                            * by the approximate outer boundary condition */\n",
    "\n",
    "  // Step 0.h: Set timestep based on smallest proper distance between gridpoints and CFL factor\n",
    "  griddata.params.dt = find_timestep(&griddata.params, griddata.xx, CFL_FACTOR);\n",
    "  //fprintf(stderr,\"# Timestep set to = %e\\n\",(double)dt);\n",
    "  // Ntot = N_outputs * output_every_N -> output_every_N = Ntot/N_outputs; set N_outputs=800\n",
    "  int output_every_N = (int)((griddata.params.t_final/griddata.params.dt + 0.5) / 800.0);\n",
    "  if(output_every_N == 0) output_every_N = 1;\n",
    "\n",
    "  // Step 0.i: Error out if the number of auxiliary gridfunctions outnumber evolved gridfunctions.\n",
    "  //              This is a limitation of the RK method. You are always welcome to declare & allocate\n",
    "  //              additional gridfunctions by hand.\n",
    "  if(NUM_AUX_GFS > NUM_EVOL_GFS) {\n",
    "    fprintf(stderr,\"Error: NUM_AUX_GFS > NUM_EVOL_GFS. Either reduce the number of auxiliary gridfunctions,\\n\");\n",
    "    fprintf(stderr,\"       or allocate (malloc) by hand storage for *diagnostic_output_gfs. \\n\");\n",
    "    exit(1);\n",
    "  }\n",
    "\n",
    "  // Step 0.j: Declare struct for gridfunctions and allocate memory for y_n_gfs gridfunctions\n",
    "  MoL_malloc_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "\"\"\"\n",
    "    if enable_rfm_precompute:\n",
    "        body += \"\"\"\n",
    "  // Step 0.k: Set up precomputed reference metric arrays\n",
    "  // Step 0.k.i: Allocate space for precomputed reference metric arrays.\n",
    "  rfm_precompute_rfmstruct_malloc(&griddata.params, &griddata.rfmstruct);\n",
    "\n",
    "  // Step 0.k.ii: Define precomputed reference metric arrays.\n",
    "  rfm_precompute_rfmstruct_define(&griddata.params, griddata.xx, &griddata.rfmstruct);\"\"\"\n",
    "    body += r\"\"\"\n",
    "  // Step 0.l: Allocate memory for non-y_n_gfs gridfunctions\n",
    "  MoL_malloc_non_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "\n",
    "  // Step 0.m: Set up TOV initial data\n",
    "  ID_persist_struct ID_persist;\n",
    "  TOV_read_data_file_set_ID_persist(\"TOVdata.txt\", &ID_persist);\n",
    "\n",
    "  initial_data_reader__convert_ADM_Spherical_to_BSSN(&griddata, &ID_persist, TOV_ID_function);\n",
    "\n",
    "  // Step 0.n: Apply boundary conditions, as initial data\n",
    "  //          are sometimes ill-defined in ghost zones.\n",
    "  //          E.g., spherical initial data might not be\n",
    "  //          properly defined at points where r=-1.\n",
    "  apply_bcs_outerextrap_and_inner(&griddata.params, &griddata.bcstruct, griddata.gridfuncs.y_n_gfs);\n",
    "  enforce_detgammahat_constraint(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs);\n",
    "\n",
    "  // Step 1: Start the timer, for keeping track of how fast the simulation is progressing.\n",
    "#ifdef __linux__ // Use high-precision timer in Linux.\n",
    "  struct timespec start, end;\n",
    "  clock_gettime(CLOCK_REALTIME, &start);\n",
    "#else     // Resort to low-resolution, standards-compliant timer in non-Linux OSs\n",
    "  // http://www.cplusplus.com/reference/ctime/time/\n",
    "  time_t start_timer,end_timer;\n",
    "  time(&start_timer); // Resolution of one second...\n",
    "#endif\n",
    "\n",
    "  const int Nxx_plus_2NGHOSTS0 = griddata.params.Nxx_plus_2NGHOSTS0;\n",
    "  const int Nxx_plus_2NGHOSTS1 = griddata.params.Nxx_plus_2NGHOSTS1;\n",
    "  const int Nxx_plus_2NGHOSTS2 = griddata.params.Nxx_plus_2NGHOSTS2;\n",
    "\n",
    "  // Step 3: Integrate the initial data forward in time using the chosen RK-like Method of\n",
    "  //         Lines timestepping algorithm, and output periodic simulation diagnostics\n",
    "  while(griddata.params.time < griddata.params.t_final)\n",
    "    { // Main loop to progress forward in time.\n",
    "\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",
    "    }\n",
    "\n",
    "    // Step 3.b: Step forward one timestep (t -> t+dt) in time using\n",
    "    //           chosen RK-like MoL timestepping algorithm\n",
    "    MoL_step_forward_in_time(&griddata);\n",
    "\n",
    "    // 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",
    "    }\n",
    "    // Step 3.d: Progress indicator printing to stderr.\n",
    "    //      Note that we're at the end of an iteration, so n=0\n",
    "    //      indicates we are actually at the start of iteration 1.\n",
    "    if((griddata.params.n + 1) % 10 == 0 ||\n",
    "       (griddata.params.time > griddata.params.t_final + griddata.params.dt) ) {\n",
    "      // Step 3.d.i: Measure average time per iteration\n",
    "#ifdef __linux__ // Use high-precision timer in Linux.\n",
    "      clock_gettime(CLOCK_REALTIME, &end);\n",
    "      const long long unsigned int time_in_ns = 1000000000L * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;\n",
    "#else     // Resort to low-resolution, standards-compliant timer in non-Linux OSs\n",
    "      time(&end_timer); // Resolution of one second...\n",
    "      REAL time_in_ns = difftime(end_timer,start_timer)*1.0e9+0.5; // Round up to avoid divide-by-zero.\n",
    "#endif\n",
    "      const REAL s_per_iteration_avg = ((REAL)time_in_ns / (REAL)(griddata.params.n + 1)) / 1.0e9;\n",
    "      //  We are at the n+1st iteration now  ---------------------v        -------^\n",
    "      const int iterations_remaining = (int)(griddata.params.t_final/griddata.params.dt + 0.5) - (griddata.params.n + 1);\n",
    "      const REAL seconds_remaining = (int)(s_per_iteration_avg * (REAL)iterations_remaining);\n",
    "      const int time_remaining__hrs  = (int)(seconds_remaining / 3600.0);\n",
    "      const int time_remaining__mins = (int)(seconds_remaining / 60.0) % 60;\n",
    "      const int time_remaining__secs = (int)(seconds_remaining) - time_remaining__mins*60 - time_remaining__hrs*3600;\n",
    "      //const REAL num_RHS_pt_evals = (REAL)(Nxx[0]*Nxx[1]*Nxx[2]) * 4.0 * (REAL)(n+1); // 4 RHS evals per gridpoint for RK4\n",
    "      //const REAL RHS_pt_evals_per_sec = num_RHS_pt_evals / ((REAL)time_in_ns / 1.0e9);\n",
    "\n",
    "      // Step 3.d.ii: Output simulation progress to stderr\n",
    "      fprintf(stderr,\"%c[2K\", 27); // Clear the line\n",
    "      fprintf(stderr,\"It: %d t/M=%.2f dt/M=%.2e | log10H: %.1f | %.1f%%; ETA %dh%dm%ds | t/M/h %.2f\\r\",\n",
    "              (griddata.params.n), (double)((griddata.params.n)*griddata.params.dt/TOV_Mass), (double)griddata.params.dt/TOV_Mass,\n",
    "              (double)log10(fabs(griddata.gridfuncs.diagnostic_output_gfs[IDX4ptS(HGF,(int)(Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2*0.5))])),\n",
    "              (double)(100.0*(REAL)(griddata.params.n)/(REAL)(int)((griddata.params.t_final/griddata.params.dt + 0.5))),\n",
    "              time_remaining__hrs, time_remaining__mins, time_remaining__secs,\n",
    "              (double)(griddata.params.dt/TOV_Mass * 3600.0 / s_per_iteration_avg));\n",
    "      fflush(stderr); // Flush the stderr buffer\n",
    "    } // End progress indicator if(griddata.params.n % 10 == 0)\n",
    "  } // End main loop to progress forward in time.\n",
    "  fprintf(stderr,\"\\n\"); // Clear the final line of output from progress indicator.\n",
    "\n",
    "  // Step 4: Free all allocated memory\n",
    "\"\"\"\n",
    "    if enable_rfm_precompute:\n",
    "        body += \"  rfm_precompute_rfmstruct_freemem(&griddata.params, &griddata.rfmstruct);\\n\"\n",
    "    body += r\"\"\"\n",
    "  free(griddata.bcstruct.inner_bc_array);\n",
    "  for(int ng=0;ng<NGHOSTS*3;ng++) free(griddata.bcstruct.pure_outer_bc_array[ng]);\n",
    "  MoL_free_memory_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "  MoL_free_memory_non_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "  for(int i=0;i<3;i++) free(griddata.xx[i]);\n",
    "\n",
    "  return 0;\n",
    "\"\"\"\n",
    "    # As rfmstruct stores functions of xx, when rfm_precompute is disabled,\n",
    "    #   we always pass xx to a function instead of &rfmstruct.\n",
    "    if not enable_rfm_precompute:\n",
    "        body = body.replace(\"&rfmstruct\", \"xx\")\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body,\n",
    "        rel_path_to_Cparams=os.path.join(\".\"), enableCparameters=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='compileexec'></a>\n",
    "\n",
    "# Step 7: Compile generated C codes & perform the hydro-without-hydro evolution \\[Back to [top](#toc)\\]\n",
    "$$\\label{compileexec}$$\n",
    "\n",
    "First we register remaining C functions and contributions to `NRPy_basic_defines.h`, then we output `NRPy_basic_defines.h` and `NRPy_function_prototypes.h`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.198101Z",
     "iopub.status.busy": "2021-09-23T22:08:42.197578Z",
     "iopub.status.idle": "2021-09-23T22:08:42.199609Z",
     "shell.execute_reply": "2021-09-23T22:08:42.200020Z"
    }
   },
   "outputs": [],
   "source": [
    "add_to_Cfunction_dict_main__Hydro_without_Hydro_Playground()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.198101Z",
     "iopub.status.busy": "2021-09-23T22:08:42.197578Z",
     "iopub.status.idle": "2021-09-23T22:08:42.199609Z",
     "shell.execute_reply": "2021-09-23T22:08:42.200020Z"
    }
   },
   "outputs": [],
   "source": [
    "import outputC as outC\n",
    "outC.outputC_register_C_functions_and_NRPy_basic_defines()  # #define M_PI, etc.\n",
    "# Declare paramstruct, register set_Cparameters_to_default(),\n",
    "#   and output declare_Cparameters_struct.h and set_Cparameters[].h:\n",
    "outC.NRPy_param_funcs_register_C_functions_and_NRPy_basic_defines(os.path.join(Ccodesrootdir))\n",
    "par.register_NRPy_basic_defines()  # add `paramstruct params` to griddata struct.\n",
    "\n",
    "gri.register_C_functions_and_NRPy_basic_defines()  # #define IDX3S(), etc.\n",
    "fin.register_C_functions_and_NRPy_basic_defines(NGHOSTS_account_for_onezone_upwind=True,\n",
    "                                                enable_SIMD=enable_SIMD)  # #define NGHOSTS, and UPWIND() macro if SIMD disabled\n",
    "\n",
    "IDread.register_NRPy_basic_defines(ID_persist_struct_contents_str=TOVCL.ID_persist_str(), include_T4UU=True)\n",
    "\n",
    "# Output functions for computing all finite-difference stencils.\n",
    "#   Must be called after defining all functions depending on FD stencils.\n",
    "if enable_FD_functions:\n",
    "    fin.output_finite_difference_functions_h(path=Ccodesrootdir)\n",
    "\n",
    "# Call this last: Set up NRPy_basic_defines.h and NRPy_function_prototypes.h.\n",
    "outC.construct_NRPy_basic_defines_h(Ccodesrootdir, enable_SIMD=enable_SIMD)\n",
    "outC.construct_NRPy_function_prototypes_h(Ccodesrootdir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we output all the C codes in `outC_function_dict` to files in the directory `Ccodesrootdir`, generate a `Makefile`, and compile the project using a parallel `make` command. If the `make` command fails, a backup serial compilation script is run.\n",
    "\n",
    "To aid in the cross-platform-compatible (with Windows, MacOS, & Linux) compilation and execution, we make use of `cmdline_helper` [(**Tutorial**)](Tutorial-cmdline_helper.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.205118Z",
     "iopub.status.busy": "2021-09-23T22:08:42.204597Z",
     "iopub.status.idle": "2021-09-23T22:08:48.673486Z",
     "shell.execute_reply": "2021-09-23T22:08:48.673915Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(EXEC): Executing `make -j18`...\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",
      "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"
     ]
    }
   ],
   "source": [
    "import cmdline_helper as cmd\n",
    "cmd.new_C_compile(Ccodesrootdir, \"Hydro_without_Hydro_Playground\",\n",
    "                  uses_free_parameters_h=True, compiler_opt_option=\"fast\") # fastdebug or debug also supported\n",
    "\n",
    "# Change directory to Ccodesrootdir\n",
    "os.chdir(Ccodesrootdir)\n",
    "\n",
    "# Clean up existing output files\n",
    "cmd.delete_existing_files(\"out*.txt\")\n",
    "cmd.delete_existing_files(\"out*.png\")\n",
    "# Run executable with CFL_FACTOR = 1.0, which is allowed since\n",
    "#   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",
    "os.chdir(os.path.join(\"..\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='visualize'></a>\n",
    "\n",
    "# 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": [
    "<a id='installdownload'></a>\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`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:48.686286Z",
     "iopub.status.busy": "2021-09-23T22:08:48.685784Z",
     "iopub.status.idle": "2021-09-23T22:08:49.316627Z",
     "shell.execute_reply": "2021-09-23T22:08:49.316145Z"
    },
    "scrolled": false
   },
   "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": [
    "<a id='genimages'></a>\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 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": [
    "<a id='genvideo'></a>\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:52.931586Z",
     "iopub.status.busy": "2021-09-23T22:08:52.931027Z",
     "iopub.status.idle": "2021-09-23T22:08:52.933692Z",
     "shell.execute_reply": "2021-09-23T22:08:52.933338Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"480\" height=\"360\" controls>\n",
       "  <source src=\"BSSN_Hydro_without_Hydro_Ccodes/hydro_without_hydro.mp4\" type=\"video/mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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",
    "\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",
    "\n",
    "fig = plt.figure(frameon=False)\n",
    "ax = fig.add_axes([0, 0, 1, 1])\n",
    "ax.axis('off')\n",
    "\n",
    "myimages = []\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",
    "\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",
    "\n",
    "## VISUALIZATION ANIMATION, PART 3: Display movie as embedded HTML5 (see next cell) ##\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",
    "<video width=\"480\" height=\"360\" controls>\n",
    "  <source src=\\\"\"\"\"+os.path.join(Ccodesrootdir,\"hydro_without_hydro.mp4\")+\"\"\"\\\" type=\"video/mp4\">\n",
    "</video>\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='convergence'></a>\n",
    "\n",
    "# Step 9: Plot the numerical error at the end of the simulation, and confirm that it converges to zero with increasing numerical resolution (sampling) \\[Back to [top](#toc)\\]\n",
    "$$\\label{convergence}$$\n",
    "\n",
    "First we plot the log10-absolute value Hamiltonian constraint violation on the $x$-$z$ plane, near the neutron star. Notice the constraint violation is largest near the surface of the neutron star, where the fields are sharpest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:52.956531Z",
     "iopub.status.busy": "2021-09-23T22:08:52.956111Z",
     "iopub.status.idle": "2021-09-23T22:08:53.140079Z",
     "shell.execute_reply": "2021-09-23T22:08:53.139637Z"
    },
    "scrolled": false
   },
   "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": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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)"
   ]
  },
  {
   "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."
   ]
  },
  {
   "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"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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",
    "\n",
    "legend = ax.legend(loc='lower right', shadow=True, fontsize='x-large')\n",
    "legend.get_frame().set_facecolor('C1')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='latex_pdf_output'></a>\n",
    "\n",
    "# Step 10: Output this notebook to $\\LaTeX$-formatted PDF file \\[Back to [top](#toc)\\]\n",
    "$$\\label{latex_pdf_output}$$\n",
    "\n",
    "The following code cell converts this Jupyter notebook into a proper, clickable $\\LaTeX$-formatted PDF file. After the cell is successfully run, the generated PDF may be found in the root NRPy+ tutorial directory, with filename\n",
    "[Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.pdf](Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro.pdf) (Note that clicking on this link may not work; you may need to open the PDF file through another means.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:53.266009Z",
     "iopub.status.busy": "2021-09-23T22:08:53.265372Z",
     "iopub.status.idle": "2021-09-23T22:08:56.325817Z",
     "shell.execute_reply": "2021-09-23T22:08:56.325358Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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"
     ]
    }
   ],
   "source": [
    "import cmdline_helper as cmd    # NRPy+: Multi-platform Python command-line interface\n",
    "cmd.output_Jupyter_notebook_to_LaTeXed_PDF(\"Tutorial-Start_to_Finish-BSSNCurvilinear-Neutron_Star-Hydro_without_Hydro\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}